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 )