def test_order_find_related_tutors_somebody(self):
# Create tutor - Dupont Tom
tutor_five = TutorFactory(
person=PersonFactory(last_name='Dupont', first_name='Tom'))
test_attribution.create_attribution(
tutor=tutor_five, learning_unit_year=self.learning_unit_year)
# Create tutor - Dupont Albert
tutor_third = TutorFactory(
person=PersonFactory(last_name='Dupont', first_name='Albert'))
test_attribution.create_attribution(
tutor=tutor_third, learning_unit_year=self.learning_unit_year)
# Create tutor - Armand Zoe
tutor_second = TutorFactory(
person=PersonFactory(last_name='Armand', first_name='Zoe'))
test_attribution.create_attribution(
tutor=tutor_second, learning_unit_year=self.learning_unit_year_2)
# Create tutor - SOMEBODY_GID [Specific case: Must be at top of list - Global_id: 99999998]
tutor_first = TutorFactory(
person=PersonFactory(last_name='SOMEBODY_GID',
first_name='SOMEBODY_GID',
global_id='99999998'))
test_attribution.create_attribution(
tutor=tutor_first, learning_unit_year=self.learning_unit_year_2)
tutors = list(
score_encoding_progress.find_related_tutors(
self.program_manager.person.user, self.academic_year,
number_session.ONE))
self.assertEqual(len(tutors), 5)
self.assertEqual(tutors[0], tutor_first) #SOMEBODY_GID
self.assertEqual(tutors[1], tutor_second) #Armand Zoe
self.assertEqual(tutors[2], tutor_third) #Dupont Albert
self.assertEqual(tutors[3],
self.tutor) #Dupont Thierry [ Set in setUp fct ]
self.assertEqual(tutors[4], tutor_five) #Dupont Tom
def setUp(self):
Group.objects.get_or_create(name='tutors')
self.person = PersonFactory()
self.tutor = TutorFactory(person=self.person)
attribution_permission = Permission.objects.get(
codename='can_access_attribution')
self.person.user.user_permissions.add(attribution_permission)
today = datetime.datetime.today()
self.academic_year = AcademicYearFactory(
year=today.year,
start_date=today - datetime.timedelta(days=5),
end_date=today + datetime.timedelta(days=5))
self.learning_unit_year = LearningUnitYearFactory(
academic_year=self.academic_year)
self.learning_unit_year.learning_container_year = LearningContainerYearFactory(
academic_year=self.learning_unit_year.academic_year,
in_charge=True)
self.learning_unit_year.save()
self.attribution = AttributionFactory(
function=function.CO_HOLDER,
learning_unit_year=self.learning_unit_year,
tutor=self.tutor,
external_id=ATTRIBUTION_EXTERNAL_ID)
self.url = reverse('attribution_home')
self.client.force_login(self.person.user)
def setUp(self):
today = date.today()
self.academic_year = AcademicYearFactory(year=today.year, start_date=today)
# Creation Container / UE and components related
self.l_container = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1210",
in_charge=True)
_create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
acronym="LBIR1210",subtype=learning_unit_year_subtypes.FULL)
_create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
acronym="LBIR1210A", subtype=learning_unit_year_subtypes.PARTIM)
_create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
acronym="LBIR1210B", subtype=learning_unit_year_subtypes.PARTIM)
# Creation Tutors
self.tutor_1 = TutorFactory(person=PersonFactory(first_name="Tom", last_name="Dupont", global_id='00012345'))
self.tutor_2 = TutorFactory(person=PersonFactory(first_name="Paul", last_name="Durant", global_id='08923545'))
# Creation Attribution and Attributions Charges - Tutor 1 - Holder
attribution_tutor_1 = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_1,
function=function.HOLDER)
_create_attribution_charge(self.academic_year, attribution_tutor_1, "LBIR1210", Decimal(15.5), Decimal(10))
_create_attribution_charge(self.academic_year, attribution_tutor_1, "LBIR1210A", None, Decimal(5))
# Creation Attribution and Attributions Charges - Tutor 2 - Co-holder
attribution_tutor_2 = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_2,
function=function.CO_HOLDER)
_create_attribution_charge(self.academic_year, attribution_tutor_2, "LBIR1210B", Decimal(7.5))
def setUp(self):
self.user = UserFactory()
self.person = PersonFactory(first_name="James",
last_name="Dupont",
user=self.user)
self.tutor = TutorFactory(person=self.person)
TutorFactory() # Create fake Tutor
TutorFactory() # Create fake Tutor
class CheckPaperSheetTest(TestCase):
def setUp(self):
a_person = PersonFactory(global_id=GLOBAL_ID)
tutors_group = Group.objects.create(name='tutors')
permission = Permission.objects.get(codename="is_tutor")
tutors_group.permissions.add(permission)
a_person.user.groups.add(tutors_group)
self.tutor = TutorFactory(person=a_person)
self.url = reverse('check_papersheet', args=[GLOBAL_ID])
self.client.force_login(a_person.user)
def test_when_no_tutor(self):
self.tutor.delete()
response = self.client.get(self.url, follow=True)
self.assertEqual(response.status_code, ACCESS_DENIED)
def test_when_request_is_post(self):
response = self.client.post(self.url, data={}, follow=True)
self.assertEqual(response.status_code, METHOD_NOT_ALLOWED)
def test_when_request_is_not_ajax(self):
response = self.client.get(self.url, data={}, follow=True)
self.assertEqual(response.status_code, ACCESS_DENIED)
def test_when_no_corresponding_person(self):
self.url = reverse('check_papersheet', args=["01010101"])
response = self.client.get(self.url, follow=True)
self.assertEqual(response.status_code, ACCESS_DENIED)
@modify_settings(INSTALLED_APPS={'remove': 'assessments'})
def test_when_app_not_installed(self):
response = self.client.get(self.url,
data={},
follow=True,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.status_code, METHOD_NOT_ALLOWED)
def test_when_no_corresponding_papersheet(self):
response = self.client.get(self.url,
data={},
follow=True,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.status_code, FILE_NOT_FOUND)
def test_when_papersheet_is_present(self):
ScoreEncodingFactory(global_id=GLOBAL_ID)
response = self.client.get(self.url,
data={},
follow=True,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.status_code, OK)
def test_find_related_tutors(self):
# Create tutors
test_attribution.create_attribution(tutor=TutorFactory(), learning_unit_year=self.learning_unit_year)
test_attribution.create_attribution(tutor=TutorFactory(), learning_unit_year=self.learning_unit_year)
test_attribution.create_attribution(tutor=TutorFactory(), learning_unit_year=self.learning_unit_year_2)
test_attribution.create_attribution(tutor=TutorFactory(), learning_unit_year=self.learning_unit_year_2)
tutors = list(score_encoding_progress.find_related_tutors(self.program_manager.person.user, self.academic_year,
number_session.ONE))
self.assertEqual(len(tutors), 5)
def setUp(self):
a_person = PersonFactory(global_id=GLOBAL_ID)
tutors_group = Group.objects.create(name='tutors')
permission = Permission.objects.get(codename="is_tutor")
tutors_group.permissions.add(permission)
a_person.user.groups.add(tutors_group)
self.tutor = TutorFactory(person=a_person)
self.url = reverse('check_papersheet', args=[GLOBAL_ID])
self.client.force_login(a_person.user)
def setUpTestData(cls):
cls.education_group_year = EducationGroupYearFactory()
cls.child_leaves = GroupElementYearChildLeafFactory.create_batch(
2, parent=cls.education_group_year, is_mandatory=True)
for node, acronym in zip(
cls.child_leaves,
["LCORS124" + str(i) for i in range(0, len(cls.child_leaves))]):
node.child_leaf.acronym = acronym
node.child_leaf.save()
cls.luy_children = [child.child_leaf for child in cls.child_leaves]
cls.workbook_contains = \
EducationGroupYearLearningUnitsContainedToExcel(cls.education_group_year, CustomXlsForm({}))._to_workbook()
cls.sheet_contains = cls.workbook_contains.worksheets[0]
generator_container = GenerateContainer(
cls.education_group_year.academic_year,
cls.education_group_year.academic_year)
cls.luy = generator_container.generated_container_years[
0].learning_unit_year_full
cls.lecturing_component = LecturingLearningComponentYearFactory(
learning_unit_year=cls.luy)
cls.practical_component = PracticalLearningComponentYearFactory(
learning_unit_year=cls.luy)
cls.person_1 = PersonFactory(last_name='Dupont',
first_name="Marcel",
email="*****@*****.**")
cls.person_2 = PersonFactory(last_name='Marseillais',
first_name="Pol",
email="*****@*****.**")
cls.tutor_1 = TutorFactory(person=cls.person_1)
cls.tutor_2 = TutorFactory(person=cls.person_2)
cls.attribution_1 = AttributionNewFactory(
tutor=cls.tutor_1,
learning_container_year=cls.luy.learning_container_year)
cls.charge_lecturing = AttributionChargeNewFactory(
attribution=cls.attribution_1,
learning_component_year=cls.lecturing_component)
cls.charge_practical = AttributionChargeNewFactory(
attribution=cls.attribution_1,
learning_component_year=cls.practical_component)
cls.attribution_2 = AttributionNewFactory(
tutor=cls.tutor_2,
learning_container_year=cls.luy.learning_container_year)
cls.charge_lecturing = AttributionChargeNewFactory(
attribution=cls.attribution_2,
learning_component_year=cls.lecturing_component)
cls.charge_practical = AttributionChargeNewFactory(
attribution=cls.attribution_2,
learning_component_year=cls.practical_component)
cls.gey = GroupElementYearChildLeafFactory(child_leaf=cls.luy)
def setUpTestData(cls):
cls.user = UserFactory()
cls.person = PersonFactory(first_name="James",
last_name="Dupont",
user=cls.user)
cls.tutor = TutorFactory(person=cls.person)
TutorFactory() # Create fake Tutor
TutorFactory() # Create fake Tutor
cls.learning_unit_year = LearningUnitYearFactory()
cls.attribution = test_attribution.create_attribution(
tutor=cls.tutor,
learning_unit_year=cls.learning_unit_year,
score_responsible=False)
def setUp(self):
today = date.today()
self.academic_year = AcademicYearFactory(year=today.year, start_date=today)
self.l_container_1 = LearningContainerYearFactory(in_charge=True)
self.tutor_1 = TutorFactory(person=PersonFactory(global_id='00012345'))
self.tutor_2 = TutorFactory(person=PersonFactory(global_id=''))
self.tutor_3 = TutorFactory(person=PersonFactory(global_id=None))
self.tutor_application_1 = TutorApplicationFactory(tutor=self.tutor_1,
learning_container_year=self.l_container_1)
self.tutor_application_2 = TutorApplicationFactory(tutor=self.tutor_2,
learning_container_year=self.l_container_1)
self.tutor_application_3 = TutorApplicationFactory(tutor=self.tutor_3,
learning_container_year=self.l_container_1)
def setUp(self):
self.user = UserFactory()
self.person = PersonFactory(first_name="James",
last_name="Dupont",
user=self.user)
self.tutor = TutorFactory(person=self.person)
TutorFactory() # Create fake Tutor
TutorFactory() # Create fake Tutor
self.learning_unit_year = LearningUnitYearFactory()
self.attribution = test_attribution.create_attribution(
tutor=self.tutor,
learning_unit_year=self.learning_unit_year,
score_responsible=False,
summary_responsible=True)
def test_get_scores_encoding_progress_with_tutors_and_score_responsible(self):
# Create tutors
test_attribution.create_attribution(tutor=TutorFactory(), learning_unit_year=self.learning_unit_year)
test_attribution.create_attribution(tutor=TutorFactory(), learning_unit_year=self.learning_unit_year)
progress_list = score_encoding_progress.get_scores_encoding_progress(
user=self.program_manager.person.user,
offer_year_id=self.offer_year_2,
number_session=number_session.ONE,
academic_year=self.academic_year
)
progress_list = score_encoding_progress.append_related_tutors_and_score_responsibles(progress_list)
self.assertEqual(len(progress_list), 1)
self.assertEqual(len(progress_list[0].tutors), 3)
self.assertEqual(len(progress_list[0].score_responsibles), 1)
def test_learning_units_summary_list(self, mock_render):
request_factory = RequestFactory()
now = datetime.datetime.now()
EntityVersionFactory(entity=self.an_entity,
start_date=now,
end_date=datetime.datetime(now.year + 1, 9, 15),
entity_type='INSTITUTE')
request = request_factory.get(
self.url, data={'academic_year_id': starting_academic_year().id})
request.user = self.faculty_user
lu = self._create_learning_unit_year_for_entity(self.an_entity)
person_lu = PersonFactory()
tutor_lu_1 = TutorFactory(person=person_lu)
self.attribution_lu = AttributionFactory(learning_unit_year=lu,
tutor=tutor_lu_1,
summary_responsible=True)
self._create_entity_calendar(self.an_entity)
self.client.force_login(self.faculty_user)
learning_units_summary_list(request)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_units.html')
self.assertEqual(context['search_type'], SUMMARY_LIST)
self.assertEqual(len(context['learning_units_with_errors']), 1)
self.assertTrue(context['is_faculty_manager'])
def setUpTestData(cls):
group = EntityManagerGroupFactory()
group.permissions.add(
Permission.objects.get(codename='view_scoresresponsible'))
group.permissions.add(
Permission.objects.get(codename='change_scoresresponsible'))
cls.tutor = TutorFactory()
cls.user = cls.tutor.person.user
cls.academic_year = AcademicYearFactory(current=True)
# FIXME: Old structure model [To remove]
cls.structure = structure.StructureFactory()
cls.structure_children = structure.StructureFactory(
part_of=cls.structure)
# New structure model
entities_hierarchy = create_entities_hierarchy()
cls.root_entity = entities_hierarchy.get('root_entity')
cls.child_one_entity = entities_hierarchy.get('child_one_entity')
cls.child_two_entity = entities_hierarchy.get('child_two_entity')
cls.learning_unit_yr_req_entity_acronym = entities_hierarchy.get(
'child_one_entity_version').acronym
cls.root_entity_acronym = entities_hierarchy.get(
'root_entity_version').acronym
cls.entity_manager = EntityManagerFactory(
person=cls.tutor.person,
structure=cls.structure,
entity=cls.root_entity,
)
cls.learning_unit_year = LearningUnitYearFactory(
academic_year=cls.academic_year,
acronym="LBIR1210",
structure=cls.structure,
learning_container_year__academic_year=cls.academic_year,
learning_container_year__acronym="LBIR1210",
learning_container_year__requirement_entity=cls.child_one_entity,
)
cls.learning_unit_year_children = LearningUnitYearFactory(
academic_year=cls.academic_year,
acronym="LBIR1211",
structure=cls.structure_children,
learning_container_year__academic_year=cls.academic_year,
learning_container_year__acronym="LBIR1211",
learning_container_year__requirement_entity=cls.child_two_entity,
)
cls.attribution = AttributionFactory(
tutor=cls.tutor,
learning_unit_year=cls.learning_unit_year,
score_responsible=True)
cls.attribution_children = AttributionFactory(
tutor=cls.tutor,
learning_unit_year=cls.learning_unit_year_children,
score_responsible=True)
cls.url = reverse('scores_responsible_list')
cls.user.groups.add(group)
def setUpTestData(cls):
cls.person = PersonFactory()
cls.user = cls.person.user
cls.tutor = TutorFactory(person=cls.person)
cls.current_ac_year = create_current_academic_year()
ac_year_in_future = GenerateAcademicYear(
start_year=cls.current_ac_year.year + 1,
end_year=cls.current_ac_year.year + 5)
cls.academic_calendar = AcademicCalendarFactory(
academic_year=cls.current_ac_year,
reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION)
# Create multiple attribution in different academic years
for ac_year in [cls.current_ac_year
] + ac_year_in_future.academic_years:
learning_container_year = LearningContainerYearFactory(
academic_year=ac_year)
learning_unit_year = LearningUnitYearFactory(
summary_locked=False,
academic_year=ac_year,
learning_container_year=learning_container_year)
AttributionFactory(
tutor=cls.tutor,
summary_responsible=True,
learning_unit_year=learning_unit_year,
)
cls.url = reverse(list_my_attributions_summary_editable)
def setUp(self):
# Create academic year
self.academic_year = AcademicYearFactory(year=2017)
# Create several learning container year - 2017
self.lbir1200_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1200")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lbir1200_2017)
self.lbir1250_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1250")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lbir1250_2017)
self.lbir1300_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1300")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lbir1300_2017)
self.lagro1200_2017 = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LAGRO1200")
LearningUnitYearFactory(academic_year=self.academic_year, learning_container_year=self.lagro1200_2017)
# Create several learning container year - 2016
self.academic_year_2016 = AcademicYearFactory(year=2016)
self.lbir1200_2016 = LearningContainerYearFactory(academic_year=self.academic_year_2016, acronym="LBIR1200")
LearningUnitYearFactory(academic_year=self.academic_year_2016, learning_container_year=self.lbir1200_2016)
self.lbir1250_2016 = LearningContainerYearFactory(academic_year=self.academic_year_2016, acronym="LBIR1250")
LearningUnitYearFactory(academic_year=self.academic_year_2016, learning_container_year=self.lbir1250_2016)
# Creation Person/Tutor
Group.objects.create(name="tutors")
person = PersonFactory(global_id="98363454")
self.tutor = TutorFactory(person=person)
applications = [
_get_application_example(self.lbir1200_2017, '3.5', '35.6'), # Application 2017
_get_application_example(self.lbir1300_2017, '7.5', '25'), # Application 2017
_get_application_example(self.lbir1200_2016, '2', '30'), # Application 2016
]
self.attribution = AttributionNewFactory(global_id=person.global_id,
attributions=_get_attributions_default(),
applications=applications)
def setUp(self):
self.tutor = TutorFactory()
self.academic_year = AcademicYearFactory(year=timezone.now().year)
self.learning_unit_year = LearningUnitYearFactory(
acronym="LDROI1004",
title="Juridic law courses",
academic_year=self.academic_year)
def test_learning_units_summary_list(self):
now = datetime.datetime.now()
EntityVersionFactory(entity=self.an_entity,
start_date=now,
end_date=datetime.datetime(now.year + 1, 9, 15),
entity_type='INSTITUTE')
lu = self._create_learning_unit_year_for_entity(
self.an_entity, "LBIR1100")
person_lu = PersonFactory()
tutor_lu_1 = TutorFactory(person=person_lu)
self.attribution_lu = AttributionFactory(learning_unit_year=lu,
tutor=tutor_lu_1,
summary_responsible=True)
self._create_entity_calendar(self.an_entity)
self.client.force_login(self.faculty_user)
response = self.client.get(
self.url, data={'academic_year_id': starting_academic_year().id})
self.assertTemplateUsed(response, 'learning_units.html')
context = response.context
self.assertEqual(context['search_type'], SUMMARY_LIST)
self.assertEqual(context['learning_units_count'], 1)
self.assertTrue(context['is_faculty_manager'])
def setUp(self):
self.person = PersonFactory()
self.tutor = TutorFactory(person=self.person)
self.learning_container_year = LearningContainerYearFactory()
self.attribution_new = AttributionNewFactory(learning_container_year=self.learning_container_year,
start_year=2018, end_year=2020, tutor=self.tutor,
score_responsible=True)
def test_when_trying_to_access_other_tutor_students_list(self):
an_other_tutor = TutorFactory()
an_other_tutor.person.user.user_permissions.add(
Permission.objects.get(codename="can_access_attribution"))
self.client.force_login(an_other_tutor.person.user)
today = datetime.datetime.today()
an_academic_year = AcademicYearFactory(
year=today.year,
start_date=today - datetime.timedelta(days=5),
end_date=today + datetime.timedelta(days=5))
a_learning_unit_year = LearningUnitYearFactory(
academic_year=an_academic_year)
AttributionFactory(learning_unit_year=a_learning_unit_year,
tutor=self.tutor)
key = '{}{}'.format(LEARNING_UNIT_ACRONYM_ID,
a_learning_unit_year.acronym)
response = self.client.post(self.url, data={key: ""})
self.assertEqual(response.status_code, OK)
self.assertTemplateUsed(response, 'list/students_exam.html')
self.assertEqual(response.context['person'], an_other_tutor.person)
self.assertEqual(response.context['my_learning_units'], [])
self.assertEqual(response.context['msg_error'], _('No data found'))
def test_when_valid_post_request(self):
self.__add_faculty_administrator_permission()
Group.objects.create(name='tutors')
TutorFactory(person=self.a_person)
response = self.client.post(self.url, {'global_id': GLOBAL_ID})
self.assertEqual(response.status_code, OK)
self.assertTemplateUsed(response, 'scores_sheets.html')
def setUpTestData(cls):
cls.person = PersonFactory()
cls.user = cls.person.user
cls.tutor = TutorFactory(person=cls.person)
cls.current_ac_year = create_current_academic_year()
ac_year_in_past = AcademicYearFactory.produce_in_past(
cls.current_ac_year.year)
cls.ac_year_in_future = AcademicYearFactory.produce_in_future(
cls.current_ac_year.year)
cls.academic_calendar = OpenAcademicCalendarFactory(
academic_year=cls.current_ac_year,
data_year=cls.current_ac_year,
reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION)
requirement_entity = EntityVersionFactory().entity
# Create multiple attribution in different academic years
for ac_year in ac_year_in_past + [cls.current_ac_year
] + cls.ac_year_in_future:
learning_container_year = LearningContainerYearFactory(
academic_year=ac_year, requirement_entity=requirement_entity)
learning_unit_year = LearningUnitYearFactory(
summary_locked=False,
academic_year=ac_year,
learning_container_year=learning_container_year)
AttributionFactory(
tutor=cls.tutor,
summary_responsible=True,
learning_unit_year=learning_unit_year,
)
cls.url = reverse(list_my_attributions_summary_editable)
def setUp(self):
Group.objects.create(name="tutors")
self.tutor = TutorFactory()
self.tutor.person.user.user_permissions.add(Permission.objects.get(codename="can_access_attribution"))
self.url = reverse('produce_xls_students', args=['01234567'])
self.client.force_login(self.tutor.person.user)
def setUp(self):
self.academic_year = AcademicYearFactory(year=2017)
external_id = tutor_application_epc.LEARNING_CONTAINER_YEAR_PREFIX_EXTERNAL_ID + '35654987_2017'
self.lbir1200 = LearningUnitYearFactory(
academic_year=self.academic_year,
acronym="LBIR1200",
learning_container_year__academic_year=self.academic_year,
learning_container_year__acronym="LBIR1200",
learning_container_year__external_id=external_id)
self.lagro2630 = LearningUnitYearFactory(
academic_year=self.academic_year,
acronym="LAGRO2630",
learning_container_year__academic_year=self.academic_year,
learning_container_year__acronym="LAGRO2630",
)
# Creation Person/Tutor
Group.objects.create(name="tutors")
person = PersonFactory(global_id="98363454")
external_id = tutor_application_epc.TUTOR_PREFIX_EXTERNAL_ID + '2089590559'
self.tutor = TutorFactory(external_id=external_id, person=person)
# Create two tutor applications
applications = [
_get_application_example(self.lbir1200, '30.5', '40.5'),
_get_application_example(self.lagro2630, '12.5', '0')
]
self.attribution = AttributionNewFactory(global_id=person.global_id,
applications=applications)
def setUp(self):
self.tutor = TutorFactory()
self.academic_year = create_current_academic_year()
self.learning_unit_year = LearningUnitYearFactory(acronym="LDROI1004",
specific_title="Juridic law courses",
academic_year=self.academic_year,
subtype=learning_unit_year_subtypes.FULL)
def setUp(self):
today = datetime.datetime.today()
twenty_days = datetime.timedelta(days=20)
#Take same academic year as the one in the associated xls file
an_academic_year = AcademicYearFactory(year=2017)
a_learning_unit_year = LearningUnitYearFakerFactory(
academic_year=an_academic_year, acronym=LEARNING_UNIT_ACRONYM)
tutor = TutorFactory()
an_academic_calendar = AcademicCalendarFactory(
academic_year=an_academic_year,
start_date=today - twenty_days,
end_date=today + twenty_days,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
SessionExamCalendarFactory(number_session=number_session.ONE,
academic_calendar=an_academic_calendar)
AttributionFactory(learning_unit_year=a_learning_unit_year,
tutor=tutor)
a_session_exam = SessionExamFactory(
number_session=number_session.ONE,
learning_unit_year=a_learning_unit_year)
self.person_student_1 = PersonFactory(email=EMAIL_1)
person_student_2 = PersonFactory(email=EMAIL_2)
student_1 = StudentFactory(registration_id=REGISTRATION_ID_1,
person=self.person_student_1)
student_2 = StudentFactory(registration_id=REGISTRATION_ID_2,
person=person_student_2)
an_offer_year = OfferYearFactory(academic_year=an_academic_year,
acronym=OFFER_ACRONYM)
offer_enrollment_1 = OfferEnrollmentFactory(offer_year=an_offer_year,
student=student_1)
offer_enrollment_2 = OfferEnrollmentFactory(offer_year=an_offer_year,
student=student_2)
learning_unit_enrollment_1 = LearningUnitEnrollmentFactory(
learning_unit_year=a_learning_unit_year,
offer_enrollment=offer_enrollment_1)
learning_unit_enrollment_2 = LearningUnitEnrollmentFactory(
learning_unit_year=a_learning_unit_year,
offer_enrollment=offer_enrollment_2)
ExamEnrollmentFactory(
session_exam=a_session_exam,
learning_unit_enrollment=learning_unit_enrollment_1)
ExamEnrollmentFactory(
session_exam=a_session_exam,
learning_unit_enrollment=learning_unit_enrollment_2)
user = tutor.person.user
self.client = Client()
self.client.force_login(user=user)
self.url = reverse(
'upload_encoding',
kwargs={'learning_unit_year_id': a_learning_unit_year.id})
def setUpTestData(cls):
cls.settings = SettingsFactory()
cls.current_academic_year = AcademicYearFactory(current=True)
cls.tutor = TutorFactory()
cls.get_url = reverse("form_part3_edit")
cls.post_url = reverse("form_part3_save")
def setUp(self):
for _ in range(10):
user = UserFactory()
person = PersonFactory(user=user)
TutorFactory(person=person)
user.groups.clear()
self.site = AdminSite()
def setUpTestData(cls):
cls.tutor = TutorFactory()
cls.attribution = AttributionFactory(tutor=cls.tutor,
summary_responsible=True)
cls.url = reverse("tutor_edit_educational_information",
args=[cls.attribution.learning_unit_year.id])
cls.tutor.person.user.user_permissions.add(
Permission.objects.get(codename='can_edit_learningunit_pedagogy'))
def _create_attribution(learning_unit_year, person, is_score_responsible=False):
PersonAddressFactory(person=person, label='PROFESSIONAL', city="Louvain-la-neuve")
PersonAddressFactory(person=person, label='PRIVATE', city="Bruxelles")
return AttributionFactory(
learning_unit_year=learning_unit_year,
tutor=TutorFactory(person=person),
score_responsible=is_score_responsible
)
