def setUpTestData(cls): cls.current_academic_year = create_current_academic_year() cls.next_academic_year = AcademicYearFactory(year=cls.current_academic_year.year + 1) cls.person = CentralManagerFactory() cls.person.user.user_permissions.add(Permission.objects.get(codename="change_educationgroup")) cls.person.user.user_permissions.add(Permission.objects.get(codename="can_access_education_group")) cls.education_group = EducationGroupFactory(end_year=cls.next_academic_year) cls.education_group_year = TrainingFactory(academic_year=cls.current_academic_year, education_group=cls.education_group) cls.next_education_group_year = TrainingFactory( academic_year=cls.next_academic_year, education_group=cls.education_group, management_entity=cls.education_group_year.management_entity ) PersonEntityFactory(person=cls.person, entity=cls.education_group_year.management_entity) cls.group_element_year = GroupElementYearFactory( parent=cls.education_group_year, child_branch__academic_year=cls.education_group_year.academic_year ) cls.url = reverse( "postpone_education_group", kwargs={ "root_id": cls.next_education_group_year.pk, "education_group_year_id": cls.next_education_group_year.pk, } ) cls.redirect_url = reverse("education_group_read", args=[cls.next_education_group_year.pk, cls.next_education_group_year.pk])
def setUp(self): # Create 2m pgrm structure as # 2M # |--FINALITY_LIST # |--2MS # |--2MD self.master_120 = TrainingFactory( academic_year=self.academic_year_2018, education_group_type__name=TrainingType.PGRM_MASTER_120.name, education_group__end_year=None ) self.finality_group = GroupFactory( academic_year=self.academic_year_2018, education_group_type__name=GroupType.FINALITY_120_LIST_CHOICE.name, education_group__end_year=None ) GroupElementYearFactory(parent=self.master_120, child_branch=self.finality_group) self.master_120_specialized = GroupFactory( academic_year=self.academic_year_2018, education_group_type__name=TrainingType.MASTER_MS_120.name, education_group__end_year=None ) GroupElementYearFactory(parent=self.finality_group, child_branch=self.master_120_specialized) self.master_120_didactic = GroupFactory( academic_year=self.academic_year_2018, education_group_type__name=TrainingType.MASTER_MD_120.name, education_group__end_year=self.academic_year_2019 ) GroupElementYearFactory(parent=self.finality_group, child_branch=self.master_120_didactic)
def setUp(self): self.current_academic_year = create_current_academic_year() self.next_academic_year = AcademicYearFactory(year=self.current_academic_year.year + 1) self.person = CentralManagerFactory() self.person.user.user_permissions.add(Permission.objects.get(codename="change_educationgroup")) self.person.user.user_permissions.add(Permission.objects.get(codename="can_access_education_group")) self.client.force_login(self.person.user) self.education_group = EducationGroupFactory(end_year=self.next_academic_year.year) self.education_group_year = TrainingFactory(academic_year=self.current_academic_year, education_group=self.education_group) self.next_education_group_year = TrainingFactory( academic_year=self.next_academic_year, education_group=self.education_group, management_entity=self.education_group_year.management_entity ) PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity) self.group_element_year = GroupElementYearFactory(parent=self.education_group_year) self.url = reverse( "postpone_education_group", kwargs={ "root_id": self.next_education_group_year.pk, "education_group_year_id": self.next_education_group_year.pk, } ) self.redirect_url = reverse("education_group_read", args=[self.next_education_group_year.pk, self.next_education_group_year.pk])
def setUpTestData(cls): cls.academic_year_2017 = AcademicYearFactory(year=2017) cls.academic_year_2018 = AcademicYearFactory(year=2018) cls.academic_year_2019 = AcademicYearFactory(year=2019) cls.academic_year_2020 = AcademicYearFactory(year=2020) cls.academic_year_2021 = AcademicYearFactory(year=2021) cls.master_120 = TrainingFactory( education_group_type__name=TrainingType.PGRM_MASTER_120.name, academic_year=cls.academic_year_2018, education_group__end_year=cls.academic_year_2020 ) cls.finality_group = GroupFactory( education_group_type__name=GroupType.FINALITY_120_LIST_CHOICE.name, academic_year=cls.academic_year_2018, education_group__end_year=cls.academic_year_2020 ) GroupElementYearFactory(parent=cls.master_120, child_branch=cls.finality_group) cls.master_120_specialized = TrainingFactory( education_group_type__name=TrainingType.MASTER_MS_120.name, academic_year=cls.academic_year_2018, education_group__end_year=cls.academic_year_2020 ) GroupElementYearFactory(parent=cls.finality_group, child_branch=cls.master_120_specialized)
def setUp(self): self.data = { 'title': 'Métamorphose', 'title_english': 'Transfiguration', 'education_group_type': self.education_group_type.pk, 'credits': 42, 'acronym': 'CRSCHOIXDVLD', 'partial_acronym': 'LDVLD101R', 'management_entity': self.management_entity_version.pk, 'administration_entity': MainEntityVersionFactory().pk, 'main_teaching_campus': "", 'academic_year': create_current_academic_year().pk, 'active': ACTIVE, 'schedule_type': DAILY, "internship": internship_presence.NO, "primary_language": LanguageFactory().pk, "start_year": 2010, "constraint_type": "", "diploma_printing_title": 'Diploma title' } self.administration_entity_version = MainEntityVersionFactory() self.education_group_year = TrainingFactory( academic_year=create_current_academic_year(), education_group_type__name=education_group_types.TrainingType. BACHELOR, management_entity=self.management_entity_version.entity, administration_entity=self.administration_entity_version.entity, ) PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity)
def test_bulk_publish(self, mock_publish): training_1 = TrainingFactory() training_2 = TrainingFactory() result = _bulk_publish([training_1, training_2]) self.assertIsInstance(result, list) self.assertListEqual(result, [True, True])
def setUp(self): self.education_group_year = TrainingFactory( academic_year=create_current_academic_year()) self.education_group_type = EducationGroupTypeFactory( category=education_group_categories.TRAINING) EntityVersionFactory( entity=self.education_group_year.administration_entity) EntityVersionFactory( entity=self.education_group_year.management_entity) self.list_acs = GenerateAcademicYear(get_current_year(), get_current_year() + 40).academic_years self.data = { 'title': 'Métamorphose', 'title_english': 'Transfiguration', 'education_group_type': self.education_group_type.pk, 'credits': 42, 'acronym': 'CRSCHOIXDVLD', 'partial_acronym': 'LDVLD101R', 'management_entity': MainEntityVersionFactory().pk, 'administration_entity': MainEntityVersionFactory().pk, 'main_teaching_campus': "", 'academic_year': create_current_academic_year().pk, 'active': ACTIVE, 'schedule_type': DAILY, "internship": internship_presence.NO, "primary_language": LanguageFactory().pk, "start_year": 2010, "constraint_type": "", }
def test_delete_case_remove_mandatory_structure_case_reused_item_which_are_mandatory( self): """ In this test, we ensure that the mandatory elem is not removed if it is reused in another structure """ education_group_year = TrainingFactory( academic_year=self.academic_year) child_mandatory = GroupFactory( academic_year=self.academic_year, education_group_type__name=GroupType.COMMON_CORE.name) AuthorizedRelationshipFactory( parent_type=education_group_year.education_group_type, child_type=child_mandatory.education_group_type, min_count_authorized=1, ) link_parent_child = GroupElementYearFactory( parent=education_group_year, child_branch=child_mandatory) # Create another training another_training = TrainingFactory(academic_year=self.academic_year) GroupElementYearFactory(parent=another_training, child_branch=child_mandatory) delete.start(education_group_year) with self.assertRaises(EducationGroupYear.DoesNotExist): EducationGroupYear.objects.get(pk=education_group_year.pk) with self.assertRaises(GroupElementYear.DoesNotExist): GroupElementYear.objects.get(pk=link_parent_child.pk) self.assertEqual(child_mandatory, EducationGroupYear.objects.get(pk=child_mandatory.pk))
def test_is_current_academic_year_in_range_of_editable_education_group_year_case_in_range(self): """This test ensure that we modify OF which lower than N+1""" training_n1 = TrainingFactory(academic_year__year=self.current_academic_year.year + 1) training = TrainingFactory(academic_year=self.current_academic_year) for education_group_year in [training_n1, training]: perm = CommonEducationGroupStrategyPerms(self.person.user, education_group_year) self.assertTrue(perm._is_current_academic_year_in_range_of_editable_education_group_year())
def setUpTestData(cls): cls.user = UserFactory() cls.url = reverse('education_group_api_v1:training-list') cls.academic_year = AcademicYearFactory(year=2018) TrainingFactory(acronym='BIR1BA', partial_acronym='LBIR1000I', academic_year=cls.academic_year) TrainingFactory(acronym='AGRO1BA', partial_acronym='LAGRO2111C', academic_year=cls.academic_year) TrainingFactory(acronym='MED12M', partial_acronym='LMED12MA', academic_year=cls.academic_year)
def setUp(self): self.current_academic_year = create_current_academic_year() self.education_group_year = GroupFactory() EntityVersionFactory( entity=self.education_group_year.management_entity, start_date=self.education_group_year.academic_year.start_date) EntityVersionFactory( entity=self.education_group_year.administration_entity, start_date=self.education_group_year.academic_year.start_date) AuthorizedRelationshipFactory( parent_type=self.education_group_year.education_group_type, child_type=self.education_group_year.education_group_type) self.url = reverse( update_education_group, args=[self.education_group_year.pk, self.education_group_year.pk]) self.person = PersonFactory() self.client.force_login(self.person.user) permission = Permission.objects.get(codename='change_educationgroup') self.person.user.user_permissions.add(permission) self.perm_patcher = mock.patch( "base.business.education_groups.perms.is_eligible_to_change_education_group", return_value=True) self.mocked_perm = self.perm_patcher.start() self.an_training_education_group_type = EducationGroupTypeFactory( category=education_group_categories.TRAINING) self.training_education_group_year = TrainingFactory( academic_year=self.current_academic_year, education_group_type=self.an_training_education_group_type) AuthorizedRelationshipFactory( parent_type=self.an_training_education_group_type, child_type=self.an_training_education_group_type, ) EntityVersionFactory( entity=self.training_education_group_year.management_entity, start_date=self.education_group_year.academic_year.start_date) EntityVersionFactory( entity=self.training_education_group_year.administration_entity, start_date=self.education_group_year.academic_year.start_date) self.training_url = reverse(update_education_group, args=[ self.training_education_group_year.pk, self.training_education_group_year.pk ]) self.domains = [DomainFactory() for x in range(10)]
def setUpTestData(cls): """ DROI2M |--Common Core |-- Learning unit year |--Finality list choice |-- DROI2MS/IU |--Common core """ cls.academic_year = AcademicYearFactory(year=2018) cls.training = TrainingFactory( acronym='DROI2M', partial_acronym='LBROI200M', academic_year=cls.academic_year, education_group_type__name=TrainingType.PGRM_MASTER_120.name) cls.common_core = GroupFactory( education_group_type__name=GroupType.COMMON_CORE.name, academic_year=cls.academic_year) GroupElementYearFactory(parent=cls.training, child_branch=cls.common_core, child_leaf=None) cls.learning_unit_year = LearningUnitYearFactory( academic_year=cls.academic_year, learning_container_year__academic_year=cls.academic_year) GroupElementYearFactory(parent=cls.common_core, child_branch=None, child_leaf=cls.learning_unit_year) cls.finality_list_choice = GroupFactory( education_group_type__name=GroupType.FINALITY_120_LIST_CHOICE.name, academic_year=cls.academic_year) GroupElementYearFactory(parent=cls.training, child_branch=cls.finality_list_choice, child_leaf=None) cls.training_ms = TrainingFactory( acronym='DROI2MS/IU', partial_acronym='LIURE200S', academic_year=cls.academic_year, education_group_type__name=TrainingType.MASTER_MS_120) GroupElementYearFactory(parent=cls.finality_list_choice, child_branch=cls.training_ms, child_leaf=None) cls.common_core_ms = GroupFactory( education_group_type__name=GroupType.COMMON_CORE.name, academic_year=cls.academic_year) GroupElementYearFactory(parent=cls.training_ms, child_branch=cls.common_core_ms, child_leaf=None) cls.person = PersonFactory() url_kwargs = { 'acronym': cls.training.acronym, 'year': cls.training.academic_year.year } cls.url = reverse('education_group_api_v1:' + TrainingTreeView.name, kwargs=url_kwargs)
def test_is_lower_than_limit_edg_year_case_greater(self): """This test ensure that we modify OF which greater or equal than limit year""" training_limit_year = TrainingFactory( academic_year__year=settings.YEAR_LIMIT_EDG_MODIFICATION + 1) training_greater = TrainingFactory( academic_year__year=settings.YEAR_LIMIT_EDG_MODIFICATION) for education_group_year in [training_limit_year, training_greater]: with self.subTest(msg=education_group_year): perm = CommonEducationGroupStrategyPerms( self.person.user, education_group_year) self.assertFalse(perm._is_lower_than_limit_edg_year())
def test_raise_validation_acronym_invalid(self): random_acronym = string_generator() external_ids = [ 'osis.education_group_type_2M180', 'osis.education_group_type_2M1', 'osis.education_group_type_3DP' ] for ext_id in external_ids: with self.subTest(type=ext_id): e = TrainingFactory(acronym=random_acronym, academic_year=self.current_acy, education_group_type__external_id=ext_id) with self.assertRaises(ValidationError): e.clean_acronym()
def setUp(self): self.current_academic_year = create_current_academic_year() self.next_academic_year = AcademicYearFactory(year=self.current_academic_year.year + 1) self.education_group = EducationGroupFactory(end_year=self.next_academic_year.year) self.current_education_group_year = TrainingFactory(education_group=self.education_group, academic_year=self.current_academic_year) self.current_group_element_year = GroupElementYearFactory(parent=self.current_education_group_year) self.next_education_group_year = TrainingFactory(education_group=self.education_group, academic_year=self.next_academic_year)
def setUp(self): current_ac = create_current_academic_year() self.education_group_year = TrainingFactory(academic_year=current_ac) self.person = FacultyManagerFactory("delete_educationgroup", "change_educationgroup", "add_educationgroup") PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity) # Create an academic calendar in order to check permission [Faculty can modify when period is opened] self.academic_calendar = AcademicCalendarFactory( reference=EDUCATION_GROUP_EDITION, start_date=timezone.now(), end_date=timezone.now() + timedelta(weeks=+1), academic_year=current_ac, ) self.client.force_login(user=self.person.user) self.url = reverse( 'delete_education_group', args=[self.education_group_year.id, self.education_group_year.id]) self.context = { "person": self.person, "root": self.education_group_year, "education_group_year": self.education_group_year, "request": RequestFactory().get("") }
def setUpTestData(cls): cls.academic_year = AcademicYearFactory() cls.master_120 = TrainingFactory( education_group_type__name=TrainingType.PGRM_MASTER_120.name, academic_year=cls.academic_year) cls.option_in_parent = MiniTrainingFactory( acronym="OPT1", education_group_type__name=MiniTrainingType.OPTION.name, academic_year=cls.academic_year) cls.master_120_link_option = GroupElementYearFactory( parent=cls.master_120, child_branch=cls.option_in_parent) # Create finality structure cls.finality_group = GroupFactory( education_group_type__name=GroupType.FINALITY_120_LIST_CHOICE.name, academic_year=cls.academic_year) GroupElementYearFactory(parent=cls.master_120, child_branch=cls.finality_group) cls.master_120_specialized = GroupFactory( education_group_type__name=TrainingType.MASTER_MS_120.name, academic_year=cls.academic_year) GroupElementYearFactory(parent=cls.finality_group, child_branch=cls.master_120_specialized)
def test_do_not_duplicate_11BA(self): TrainingFactory(education_group_type__name=TrainingType.BACHELOR.name, acronym="OSIS11BA") postponement = EducationGroupAutomaticPostponementToN6() self.assertQuerysetEqual(postponement.queryset, [])
def test_permission_denied_when_learning_unit_not_contained_in_training(self): other_education_group_year = TrainingFactory(academic_year=self.academic_year) url = reverse("learning_unit_prerequisite_update", args=[other_education_group_year.id, self.learning_unit_year_child.id]) response = self.client.get(url) self.assertEqual(response.status_code, HttpResponseForbidden.status_code)
def test_is_eligible_case_raising_exception(self, mock_is_eligible): person = PersonWithPermissionsFactory() perm = CommonEducationGroupStrategyPerms(person.user, TrainingFactory()) with self.assertRaises(PermissionDenied): perm.is_eligible(raise_exception=True)
def setUpTestData(cls): """ BIR1BA |--Common Core |-- Learning Unit Year """ cls.academic_year = AcademicYearFactory(year=2018) cls.training = TrainingFactory(acronym='BIR1BA', partial_acronym='LBIR1000I', academic_year=cls.academic_year) cls.common_core = GroupFactory( education_group_type__name=GroupType.COMMON_CORE.name, academic_year=cls.academic_year) GroupElementYearFactory(parent=cls.training, child_branch=cls.common_core, child_leaf=None) cls.learning_unit_year = LearningUnitYearFactory( academic_year=cls.academic_year, learning_container_year__academic_year=cls.academic_year) GroupElementYearFactory(parent=cls.common_core, child_branch=None, child_leaf=cls.learning_unit_year) cls.person = PersonFactory() url_kwargs = { 'acronym': cls.learning_unit_year.acronym, 'year': cls.learning_unit_year.academic_year.year } cls.url = reverse('learning_unit_api_v1:' + EducationGroupRootsList.name, kwargs=url_kwargs)
def setUpTestData(cls): cls.academic_year = AcademicYearFactory() cls.education_group_year_root = TrainingFactory(academic_year=cls.academic_year) cls.education_group_year_childs = [MiniTrainingFactory(academic_year=cls.academic_year) for _ in range(0, 3)] cls.group_element_years_root_to_child = [ GroupElementYearFactory(parent=cls.education_group_year_root, child_leaf=None, child_branch=cls.education_group_year_childs[i]) for i in range(0, len(cls.education_group_year_childs)) ] cls.group_element_years_child_0 = [ GroupElementYearFactory(parent=cls.education_group_year_childs[0], child_leaf=LearningUnitYearFakerFactory( learning_container_year__academic_year=cls.academic_year), child_branch=None) for i in range(0, 2) ] cls.group_element_years_child_2 = [ GroupElementYearFactory(parent=cls.education_group_year_childs[2], child_leaf=LearningUnitYearFakerFactory( learning_container_year__academic_year=cls.academic_year), child_branch=None) for i in range(0, 4) ] cls.all_learning_units_acronym = [ gey.child_leaf.acronym for gey in itertools.chain(cls.group_element_years_child_0, cls.group_element_years_child_2) ]
def test_have_contents_case_have_contents_because_mandatory_structure_is_present_multiple_times( self): """ In this test, we ensure that we have two elements of one type which are mandatory in the basic structure. ==> We must consider as it have contents """ education_group_year = TrainingFactory( academic_year=self.academic_year) subgroup_1 = GroupFactory( academic_year=self.academic_year, education_group_type__name=GroupType.SUB_GROUP.name) GroupElementYearFactory(parent=education_group_year, child_branch=subgroup_1) subgroup_2 = GroupFactory( academic_year=self.academic_year, education_group_type=subgroup_1.education_group_type, ) GroupElementYearFactory(parent=education_group_year, child_branch=subgroup_2) AuthorizedRelationshipFactory( parent_type=education_group_year.education_group_type, child_type=subgroup_1.education_group_type, min_count_authorized=1, ) self.assertTrue( delete._have_contents_which_are_not_mandatory( education_group_year))
def test_training_template_used(self): training = TrainingFactory() url = reverse("education_group_read", args=[training.pk, training.pk]) expected_template = "education_group/identification_training_details.html" response = self.client.get(url) self.assertTemplateUsed(response, expected_template)
def setUpTestData(cls): super().setUpTestData() cls.current_academic_year = AcademicYearFactory(current=True) cls.generated_ac_years = AcademicYearFactory.produce( base_year=cls.current_academic_year.year, number_past=0, number_future=7) cls.entity_version = MainEntityVersionFactory( entity_type=entity_type.SECTOR) cls.central_manager = CentralManagerFactory() PersonEntityFactory(person=cls.central_manager, entity=cls.entity_version.entity) cls.training = TrainingFactory( management_entity=cls.entity_version.entity, administration_entity=cls.entity_version.entity, academic_year=cls.current_academic_year) cls.form_data = model_to_dict_fk(cls.training, exclude=('secondary_domains', )) cls.form_data.update({ 'primary_language': cls.form_data['primary_language_id'], 'administration_entity': cls.entity_version.pk, 'management_entity': cls.entity_version.pk })
def test_ensure_is_eligible_case_permission_denied( self, mock_linked_to_management, mock_is_current_in_range): perm = CommonEducationGroupStrategyPerms(self.person.user, TrainingFactory()) with self.assertRaises(PermissionDenied): perm._is_eligible()
def setUpTestData(cls): cls.root = TrainingFactory( academic_year__current=True, education_group_type=EducationGroupTypeFactory( name=education_group_types.TrainingType.MASTER_MA_120.name)) cls.children_level_0 = GroupElementYearFactory.create_batch( 1, parent=cls.root, child_branch__education_group_type__group=True, child_branch__academic_year=cls.root.academic_year) cls.children_level_1 = GroupElementYearFactory.create_batch( 3, parent=cls.children_level_0[0].child_branch, child_branch__education_group_type__group=True, child_branch__academic_year=cls.root.academic_year) cls.children_level_2 = GroupElementYearFactory.create_batch( 1, parent=cls.children_level_1[0].child_branch, child_branch__education_group_type__group=True, child_branch__academic_year=cls.root.academic_year) cls.lu_children_level_2 = GroupElementYearChildLeafFactory.create_batch( 2, parent=cls.children_level_1[1].child_branch, child_leaf__academic_year=cls.root.academic_year) cls.lu_children_level_3 = GroupElementYearChildLeafFactory.create_batch( 2, parent=cls.children_level_2[0].child_branch, child_leaf__academic_year=cls.root.academic_year)
def setUpTestData(cls): cls.academic_year = AcademicYearFactory() cls.parent = TrainingFactory( academic_year=cls.academic_year, education_group_type__learning_unit_child_allowed=True) cls.child_leaf = LearningUnitYearFactory() cls.child_branch = MiniTrainingFactory(academic_year=cls.academic_year)
def test_delete_case_no_mandatory_structure(self): education_group_year = TrainingFactory( academic_year=self.academic_year) delete.start(education_group_year) with self.assertRaises(EducationGroupYear.DoesNotExist): EducationGroupYear.objects.get(pk=education_group_year.pk)
def test_have_contents_case_no_contents_which_because_mandatory_structure( self): """ In this test, we ensure that all of his children are mandatory groups and they are empty. It must be consider as empty """ education_group_year = TrainingFactory( academic_year=self.academic_year) for education_group_type in [ GroupType.COMMON_CORE.name, GroupType.FINALITY_120_LIST_CHOICE.name ]: child = GroupFactory( academic_year=self.academic_year, education_group_type__name=education_group_type) AuthorizedRelationshipFactory( parent_type=education_group_year.education_group_type, child_type=child.education_group_type, min_count_authorized=1, ) GroupElementYearFactory(parent=education_group_year, child_branch=child) self.assertFalse( delete._have_contents_which_are_not_mandatory( education_group_year))