def test_main_programmanager_update(self): offer_year1 = OfferYearFactory(academic_year=self.academic_year_current) offer_year2 = OfferYearFactory(academic_year=self.academic_year_current) pgm1 = ProgramManagerFactory(person=self.person, offer_year=offer_year1, is_main=False) pgm2 = ProgramManagerFactory(person=self.person, offer_year=offer_year2, is_main=False) self.client.post( reverse('update_main_person', args=[self.person.pk]) + "?offer_year={},{}".format( offer_year1.pk, offer_year2.pk ), data={'is_main': 'true'} ) pgm1.refresh_from_db() pgm2.refresh_from_db() self.assertTrue(pgm1.is_main) self.assertTrue(pgm2.is_main) self.client.post( reverse('update_main', args=[pgm1.pk]) + "?offer_year={},{}".format( offer_year1.pk, offer_year2.pk ), data={'is_main': 'false'} ) pgm1.refresh_from_db() pgm2.refresh_from_db() self.assertFalse(pgm1.is_main) self.assertTrue(pgm2.is_main)
def setUp(self): self.user = User.objects.create_user(username='******', password='******') self.person = PersonFactory(user=self.user) add_permission(self.user, "can_access_scoreencoding") self.client.force_login(self.user) # Set user as program manager of two offer academic_year = _get_academic_year(2017) self.offer_year_bio2ma = OfferYearFactory(acronym="BIO2MA", title="Master en Biologie", academic_year=academic_year) self.offer_year_bio2bac = OfferYearFactory( acronym="BIO2BAC", title="Bachelier en Biologie", academic_year=academic_year) ProgramManagerFactory(offer_year=self.offer_year_bio2ma, person=self.person) ProgramManagerFactory(offer_year=self.offer_year_bio2bac, person=self.person) # Create an score submission event - with an session exam academic_calendar = AcademicCalendarFactory( title="Submission of score encoding - 1", academic_year=academic_year, start_date=academic_year.start_date, end_date=academic_year.end_date, reference=academic_calendar_type.SCORES_EXAM_SUBMISSION) academic_calendar.save() self.session_exam_calendar = SessionExamCalendarFactory( academic_calendar=academic_calendar, number_session=number_session.ONE) # Offer : BIO2MA - 2 Learning unit with exam self.offer_year_calendar_bio2ma = OfferYearCalendarFactory( offer_year=self.offer_year_bio2ma, academic_calendar=academic_calendar) self.learning_unit_year = LearningUnitYearFactory( academic_year=academic_year) self.learning_unit_year_2 = LearningUnitYearFactory( academic_year=academic_year) self.first_session_exam = test_session_exam.create_session_exam( number_session.ONE, self.learning_unit_year, self.offer_year_bio2ma) self.first_session_exam_2 = test_session_exam.create_session_exam( number_session.ONE, self.learning_unit_year_2, self.offer_year_bio2ma) # Offer: BIO2BAC - 1 learning unit with exam self.offer_year_calendar_bio2bac = OfferYearCalendarFactory( offer_year=self.offer_year_bio2ma, academic_calendar=academic_calendar) self.learning_unit_year_3 = LearningUnitYearFactory( academic_year=academic_year) self.first_session_exam_3 = test_session_exam.create_session_exam( number_session.ONE, self.learning_unit_year_3, self.offer_year_bio2bac) self._create_context_exam_enrollment()
def test_return_sorted_managers(self): ProgramManagerFactory(offer_year=self.offer_year, person=PersonFactory(first_name="Yannick", last_name="Leblanc")) ProgramManagerFactory(offer_year=self.offer_year, person=PersonFactory(first_name="Yannick", last_name="Ferreira")) ProgramManagerFactory(offer_year=self.offer_year, person=PersonFactory(first_name="Laura", last_name="Ferreira")) ProgramManagerFactory(offer_year=self.offer_year, person=PersonFactory(first_name="Bob", last_name="Uncle")) ProgramManagerFactory(offer_year=self.offer_year, person=PersonFactory(first_name="Laura", last_name="Dupont")) managers = program_manager.find_by_offer_year(self.offer_year) self.assertEquals(managers[0].person.last_name, "Dupont") self.assertEquals(managers[1].person.last_name, "Ferreira") self.assertEquals(managers[1].person.first_name, "Laura") self.assertEquals(managers[2].person.last_name, "Ferreira") self.assertEquals(managers[2].person.first_name, "Yannick") self.assertEquals(managers[3].person.last_name, "Leblanc") self.assertEquals(managers[4].person.last_name, "Uncle")
def test_filter_by_person(self): an_offer_type = OfferTypeFactory() offer_year1 = OfferYearFactory( academic_year=self.academic_year_current, entity_management=self.structure_parent1, offer_type=an_offer_type) offer_year2 = OfferYearFactory( academic_year=self.academic_year_current, entity_management=self.structure_child1, offer_type=an_offer_type) ProgramManagerFactory(person=self.person, offer_year=offer_year1) ProgramManagerFactory(person=self.person, offer_year=offer_year2) offer_year_results = pgm_manager_administration._filter_by_person( self.person, [self.structure_parent1, self.structure_child1], self.academic_year_current, an_offer_type) self.assertCountEqual(offer_year_results, [offer_year1, offer_year2]) offer_year_results = pgm_manager_administration._filter_by_person( self.person, [self.structure_parent1], self.academic_year_current, an_offer_type) self.assertCountEqual(offer_year_results, [offer_year1]) offer_year_results = pgm_manager_administration._filter_by_person( self.person, [], self.academic_year_current, an_offer_type) self.assertCountEqual(offer_year_results, [offer_year1, offer_year2]) an_other_offer_type = OfferTypeFactory() offer_year_results = pgm_manager_administration._filter_by_person( self.person, [self.structure_parent1], self.academic_year_current, an_other_offer_type) self.assertCountEqual(offer_year_results, [])
def test_managed_programs(self): offer_year_1 = OfferYearFactory() offer_year_2 = OfferYearFactory() ProgramManagerFactory(person=self.person_with_user, offer_year=offer_year_1) ProgramManagerFactory(person=self.person_with_user, offer_year=offer_year_2) managed_programs = self.person_with_user.get_managed_programs() self.assertTrue(len(managed_programs) == 2) self.assertTrue(offer_year_1 in managed_programs) self.assertTrue(offer_year_2 in managed_programs)
def test_list_pgm_manager(self): offer_year1 = OfferYearFactory(academic_year=self.academic_year_current) offer_year2 = OfferYearFactory(academic_year=self.academic_year_current) pgm1 = ProgramManagerFactory(person=self.person, offer_year=offer_year1) pgm2 = ProgramManagerFactory(person=self.person, offer_year=offer_year2) response = self.client.get( reverse('manager_list'), data={'offer_year': [offer_year1.pk, offer_year2.pk]} ) self.assertEqual( response.context['by_person'], {self.person: [pgm1, pgm2]} )
def setUp(self): self.request_factory = RequestFactory() academic_year = _get_academic_year(year=2017) academic_calendar = AcademicCalendarFactory( title="Submission of score encoding - 1", start_date=academic_year.start_date, end_date=academic_year.end_date, academic_year=academic_year, reference=academic_calendar_type.SCORES_EXAM_SUBMISSION) SessionExamCalendarFactory(academic_calendar=academic_calendar, number_session=number_session.ONE) self.learning_unit_year = LearningUnitYearFactory( academic_year=academic_year) self.offer_year = test_offer_year.create_offer_year( 'SINF1BA', 'Bachelor in informatica', academic_year) self.session_exam = test_session_exam.create_session_exam( number_session.ONE, self.learning_unit_year, self.offer_year) # Create enrollment related self.enrollments = [] for index in range(0, 2): offer_year = OfferYearFactory(academic_year=academic_year) OfferYearCalendarFactory(academic_calendar=academic_calendar, offer_year=offer_year) offer_enrollment = test_offer_enrollment.create_offer_enrollment( StudentFactory(), offer_year) learning_unit_enrollment = test_learning_unit_enrollment.create_learning_unit_enrollment( offer_enrollment=offer_enrollment, learning_unit_year=self.learning_unit_year) exam_enrollment = test_exam_enrollment.create_exam_enrollment( self.session_exam, learning_unit_enrollment) self.enrollments.append(exam_enrollment) self.tutor = TutorFactory() test_attribution.create_attribution( tutor=self.tutor, learning_unit_year=self.learning_unit_year) add_permission(self.tutor.person.user, "can_access_scoreencoding") offer_year = self.enrollments[ 0].learning_unit_enrollment.offer_enrollment.offer_year self.program_manager_1 = ProgramManagerFactory(offer_year=offer_year) add_permission(self.program_manager_1.person.user, "can_access_scoreencoding") offer_year = self.enrollments[ 1].learning_unit_enrollment.offer_enrollment.offer_year self.program_manager_2 = ProgramManagerFactory(offer_year=offer_year) add_permission(self.program_manager_2.person.user, "can_access_scoreencoding")
def test_pgm_manager_queried_by_academic_year(self): a_management_entity = StructureFactory() offer_year_previous_year = OfferYearFactory(academic_year=self.academic_year_previous, entity_management=a_management_entity) offer_year_current_year = OfferYearFactory(academic_year=self.academic_year_current, entity_management=a_management_entity) person_previous_year = PersonFactory() person_current_year = PersonFactory() ProgramManagerFactory(person=person_previous_year, offer_year=offer_year_previous_year) ProgramManagerFactory(person=person_current_year, offer_year=offer_year_current_year) self.assertEqual(len(pgm_manager_administration._get_entity_program_managers([{'root': a_management_entity}], self.academic_year_current)), 1)
def setUp(self): self.person = PersonFactory() self.permission = Permission.objects.get( codename='can_edit_education_group_administrative_data') self.person.user.user_permissions.add(self.permission) self.education_group_year = EducationGroupYearFactory() self.program_manager = ProgramManagerFactory( person=self.person, education_group=self.education_group_year.education_group) self.url = reverse('education_group_edit_administrative', args=[self.education_group_year.id]) self.client.force_login(self.person.user)
def setUpTestData(cls): group = ProgramManagerGroupFactory() group.permissions.add( Permission.objects.get(codename='view_scoresresponsible')) group.permissions.add( Permission.objects.get(codename='change_scoresresponsible')) cls.academic_year = create_current_academic_year() # FIXME: Old structure model [To remove] cls.structure = structure.StructureFactory() entities_hierarchy = create_entities_hierarchy() cls.root_entity = entities_hierarchy.get('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.root_entity, ) cls.education_group_year = EducationGroupYearFactory( academic_year=cls.academic_year, administration_entity=cls.root_entity) cls.program_manager = ProgramManagerFactory( education_group=cls.education_group_year.education_group) cls.program_manager.person.user.groups.add(group) offer_enrollment = OfferEnrollmentFactory( education_group_year=cls.education_group_year) LearningUnitEnrollmentFactory( offer_enrollment=offer_enrollment, learning_unit_year=cls.learning_unit_year)
def create_test_pgm_manager(self): egy = EducationGroupYearFactory(academic_year__current=True) offer_year = OfferYearFactory(academic_year=egy.academic_year, acronym=egy.acronym) return ProgramManagerFactory(offer_year=offer_year, education_group=egy.education_group, person=self.person_foo)
def test_case_with_existing_program_manager(self): pgm_mgr = ProgramManagerFactory(offer_year=self.offer_year) self.assertQuerysetEqual(program_manager.find_by_offer_year( self.offer_year), [pgm_mgr], transform=lambda rec: rec) self.assertEqual( len(program_manager.find_by_offer_year(self.offer_year)), 1)
def test_offer_read(self, mock_program_manager, mock_render, mock_decorators): mock_decorators.login_required = lambda x: x mock_decorators.permission_required = lambda *args, **kwargs: lambda func: func today = datetime.date.today() academic_year = AcademicYearFactory(start_date=today, end_date=today.replace(year=today.year + 1), year=today.year) offer_year = OfferYearFactory(academic_year=academic_year) academic_calendar = AcademicCalendarFactory(academic_year=academic_year) offer_year_calendar = OfferYearCalendarFactory(offer_year=offer_year, academic_calendar=academic_calendar) ProgramManagerFactory(offer_year=offer_year) request = mock.Mock(method='GET') from base.views.offer import offer_read offer_read(request, offer_year_calendar.id) self.assertTrue(mock_render.called) request, template, context = mock_render.call_args[0] self.assertEqual(template, 'offer/tab_identification.html')
def setUp(self): Group.objects.get_or_create(name="tutors") Group.objects.get_or_create(name="program_managers") self.request_factory = RequestFactory() data = generate_exam_enrollments(2017, with_different_offer=True) self.academic_year = data["academic_year"] self.session_exam_calendar = data["session_exam_calendar"] self.learning_unit_year = data["learning_unit_year"] self.enrollments = data["exam_enrollments"] self.attribution = data["attribution"] self.offer_years = data["offer_years"] self.tutor = self.attribution.tutor add_permission(self.tutor.person.user, "can_access_scoreencoding") self.program_managers = [ ProgramManagerFactory(offer_year=self.offer_years[i]) for i in range(0, 2) ] [ add_permission(self.program_managers[i].person.user, "can_access_scoreencoding") for i in range(0, 2) ] # Mock academic_year / session_exam_calendar in order to be decouple test from system time self.mock_academic_year( current_academic_year=self.academic_year, starting_academic_year=self.academic_year, ) self.mock_session_exam_calendar( current_session_exam=self.session_exam_calendar)
def setUp(self): self.program_manager_1 = ProgramManagerFactory() # Add permission user = self.program_manager_1.person.user permission = Permission.objects.get(name='Can access student') user.user_permissions.add(permission) self.students_db = [StudentFactory() for i in range(10)]
def test_remove_pgm_manager_from_two_pgm(self): self.client.force_login(self.user) offer_year1 = OfferYearFactory( academic_year=self.academic_year_current) offer_year2 = OfferYearFactory( academic_year=self.academic_year_current) ProgramManagerFactory(person=self.person, offer_year=offer_year1) ProgramManagerFactory(person=self.person, offer_year=offer_year2) managers_count_before = len( program_manager.ProgramManager.objects.all()) pgm_manager_administration.remove_program_mgr_from_offers( [offer_year1, offer_year2], self.person) managers_count_after = len( program_manager.ProgramManager.objects.all()) self.assertEqual(managers_count_after, managers_count_before - 2)
def setUpTestData(cls): cls.program_manager = ProgramManagerFactory( person=PersonWithPermissionsFactory("can_access_student") ) cls.students_db = StudentFactory.create_batch(10) cls.url = reverse("students")
def test_find_by_education_group(self): self.assertIsNone(program_manager.find_by_education_group(None)) an_education_group = EducationGroupFactory() a_program_manager = ProgramManagerFactory( education_group=an_education_group) self.assertEquals( list(program_manager.find_by_education_group(an_education_group)), [a_program_manager])
def test_find_by_person_exclude_offer_list(self): a_person = PersonFactory(first_name="Yannick", last_name="Leblanc") previous_academic_year = AcademicYearFactory( year=datetime.datetime.now().year - 1) offer_yr_previous = OfferYearFactory( academic_year=previous_academic_year) ProgramManagerFactory(offer_year=offer_yr_previous, person=a_person) offer_yr1 = OfferYearFactory(academic_year=self.academic_year) offer_yr2 = OfferYearFactory(academic_year=self.academic_year) ProgramManagerFactory(offer_year=offer_yr1, person=a_person) ProgramManagerFactory(offer_year=offer_yr2, person=a_person) self.assertEquals( len( program_manager.find_by_person_exclude_offer_list( a_person, [offer_yr1], self.academic_year)), 1)
def test_is_program_manager_of_education_group(self): user = UserFactory(username="******") an_education_group = EducationGroupFactory() ProgramManagerFactory(education_group=an_education_group, person=PersonFactory(user=user)) self.assertTrue( program_manager.is_program_manager( user=user, education_group=an_education_group))
def test_is_already_program_manager(self): offer_year1 = OfferYearFactory( academic_year=self.academic_year_current, entity_management=self.structure_parent1) ProgramManagerFactory(person=self.person, offer_year=offer_year1) self.assertTrue( pgm_manager_administration.is_already_program_manager( self.person, offer_year1))
def setUpTestData(cls): cls.program_manager = ProgramManagerFactory( person=PersonWithPermissionsFactory("can_access_student") ) cls.student_m = StudentFactory(person=PersonFactory(last_name='Durant', first_name='Thomas', gender='M')) cls.student_f = StudentFactory(person=PersonFactory(last_name='Durant', first_name='Alice', gender='F')) cls.url = reverse("students")
def test_find_program_manager_by_entity_administration_fac(self): a_management_entity = StructureFactory() offer_yr = OfferYearFactory(academic_year=self.academic_year, entity_management=a_management_entity) ProgramManagerFactory(offer_year=offer_yr, person=PersonFactory()) self.assertEquals( len( program_manager.find_by_management_entity( [a_management_entity], self.academic_year)), 1)
def test_can_user_edit_administartive_data_group_central_manager_no_entity_linked_but_program_manager(self): """ With permission + Group central manager + Linked to the parent entity (with_child FALSE) + IS program manager ==> Allowed """ _add_to_group(self.user, CENTRAL_MANAGER_GROUP) PersonEntityFactory(person=self.person, entity=self.root_entity, with_child=False) ProgramManagerFactory(person=self.person, education_group=self.education_group_year.education_group) self.assertTrue(can_user_edit_administrative_data(self.user, self.education_group_year))
def test_remove_pgm_manager(self): offer_year1 = OfferYearFactory(academic_year=self.academic_year_current) offer_year2 = OfferYearFactory(academic_year=self.academic_year_current) pgm1 = ProgramManagerFactory(person=self.person, offer_year=offer_year1) pgm2 = ProgramManagerFactory(person=self.person, offer_year=offer_year2) response = self.client.get( reverse('delete_manager', args=[pgm1.pk]) + "?offer_year={},{}".format( offer_year1.pk, offer_year2.pk ) ) self.assertEqual(response.context['other_programs'].get(), pgm2) self.client.post( reverse('delete_manager', args=[pgm1.pk]) + "?offer_year={},{}".format(offer_year1.pk, offer_year2.pk) ) self.assertFalse(ProgramManager.objects.filter(pk=pgm1.pk).exists()) self.assertTrue(ProgramManager.objects.filter(pk=pgm2.pk).exists())
def test_can_user_edit_administrative_data_with_permission_and_pgrm_manager( self): """With permission and program manager of education group ==> Allowed""" ProgramManagerFactory( person=self.person, education_group=self.education_group_year.education_group) self.assertTrue( can_user_edit_administrative_data(self.user, self.education_group_year))
def test__get_all_offer_years_grouped_by_person(self): offer_year1 = OfferYearFactory( academic_year=self.academic_year_current, entity_management=self.structure_parent1) offer_year2 = OfferYearFactory( academic_year=self.academic_year_current, entity_management=self.structure_parent1) person1 = PersonFactory(last_name='AAA') person2 = PersonFactory(last_name='BBB') ProgramManagerFactory(person=person1, offer_year=offer_year1) ProgramManagerFactory(person=person2, offer_year=offer_year1) ProgramManagerFactory(person=person2, offer_year=offer_year2) data = pgm_manager_administration._get_all_offer_years_grouped_by_person( [person1.id, person2.id]) self.assertEqual(len(data), 2) self.assertEqual(len(data[person1.id]), 1) self.assertEqual(len(data[person2.id]), 2)
def setUpClass(cls): super().setUpClass() cls.training = TrainingFactory(academic_year__year=2018) cls.program_manager = ProgramManagerFactory(education_group=cls.training.education_group) cls.context = { 'person': cls.program_manager.person, 'root': cls.training, 'education_group_year': cls.training, } cls.url = reverse('update_education_group', args=[cls.training.pk, cls.training.pk]) cls.request = RequestFactory().get("")
def test_delete_manager(self): offer_year1 = OfferYearFactory( academic_year=self.academic_year_current, entity_management=self.structure_parent1) ProgramManagerFactory(person=self.person, offer_year=offer_year1) self.client.force_login(self.user) a_person = PersonFactory(user=self.user) EntityManagerFactory(person=a_person) url = reverse('delete_manager') response = self.client.get(url + "?person=%s&pgms=%s" % (self.person.id, offer_year1.id)) self.assertEqual(response.status_code, 204)
def setUp(self): self.academic_year = AcademicYearFactory( year=datetime.date.today().year) self.academic_calendar = AcademicCalendarFactory.build( title="Submission of score encoding - 1", start_date=self.academic_year.start_date, end_date=self.academic_year.end_date, academic_year=self.academic_year, reference=academic_calendar_type.SCORES_EXAM_SUBMISSION) self.academic_calendar.save(functions=[]) SessionExamCalendarFactory(academic_calendar=self.academic_calendar, number_session=number_session.ONE) # Offer year CHIM1BA self.offer_year = OfferYearFactory(acronym="CHIM1BA", academic_year=self.academic_year) self.learning_unit_year = LearningUnitYearFactory( acronym="LBIR1210", academic_year=self.academic_year) self._create_context_exam_enrollments(self.learning_unit_year, self.offer_year, 10, 3) self.learning_unit_year_2 = LearningUnitYearFactory( acronym="LBIR1211", academic_year=self.academic_year) self._create_context_exam_enrollments(self.learning_unit_year_2, self.offer_year, 5) # Offer year DIR2BA self.offer_year_2 = OfferYearFactory(acronym="DIR2BA", academic_year=self.academic_year) self._create_context_exam_enrollments(self.learning_unit_year, self.offer_year_2, 8, 5) self.program_manager = ProgramManagerFactory( offer_year=self.offer_year) ProgramManagerFactory(offer_year=self.offer_year_2, person=self.program_manager.person) # Tutor [Tom Dupont] have an attribution to LBIR1210 person = PersonFactory(last_name="Dupont", first_name="Thierry") self.tutor = TutorFactory(person=person) test_attribution.create_attribution( tutor=self.tutor, learning_unit_year=self.learning_unit_year, score_responsible=True)
def test_add_program_managers(self): offer_year1 = OfferYearFactory( academic_year=self.academic_year_current, entity_management=self.structure_parent1) offer_year2 = OfferYearFactory( academic_year=self.academic_year_current, entity_management=self.structure_parent1) ProgramManagerFactory(person=self.person, offer_year=offer_year1) self.assertEqual( len( pgm_manager_administration.add_program_managers( [offer_year1, offer_year2], self.person)), 1)