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): self.user = UserFactory() self.user.user_permissions.add( Permission.objects.get(codename="can_access_learningunit")) self.user.user_permissions.add( Permission.objects.get(codename="can_edit_learningunit")) self.person = CentralManagerFactory(user=self.user) self.client.force_login(self.user) person_entity = PersonEntityFactory( person=self.person, entity=EntityVersionFactory().entity, ) self.academic_year = create_current_academic_year() luy = LearningUnitYearFullFactory( academic_year=self.academic_year, internship_subtype=None, acronym="EFAC0000", learning_container_year__container_type=EXTERNAL, learning_container_year__requirement_entity=person_entity.entity, ) self.external = ExternalLearningUnitYearFactory(learning_unit_year=luy) self.data = get_valid_external_learning_unit_form_data( self.academic_year, self.person, self.external.learning_unit_year) self.url = reverse(update_learning_unit, args=[self.external.learning_unit_year.pk])
def test_is_central_manager_eligible(self): central_manager = CentralManagerFactory() for education_group_year in [self.common_bachelor, self.training]: perm = GeneralInformationPerms(central_manager.user, education_group_year) self.assertTrue(perm._is_central_manager_eligible())
def setUpTestData(cls): cls.academic_year = AcademicYearFactory(year=get_current_year() + 1) cls.next_academic_year_1 = AcademicYearFactory( year=cls.academic_year.year + 1) cls.next_academic_year_2 = AcademicYearFactory( year=cls.academic_year.year + 2) cls.education_group_year = EducationGroupYearFactory( academic_year=cls.academic_year, education_group__end_year=cls.next_academic_year_2) cls.education_group_year_child = EducationGroupYearFactory( academic_year=cls.academic_year, education_group__end_year=cls.next_academic_year_2) cls.group_element_year = GroupElementYearFactory( parent=cls.education_group_year, child_branch=cls.education_group_year_child) AuthorizedRelationshipFactory( parent_type=cls.education_group_year.education_group_type, child_type=cls.group_element_year.child_branch. education_group_type, ) cls.person = CentralManagerFactory() cls.url = reverse("group_element_year_update", kwargs={ "root_id": cls.education_group_year.id, "education_group_year_id": cls.education_group_year.id, "group_element_year_id": cls.group_element_year.id }) cls.post_valid_data = {'action': 'edit'}
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 setUpTestData(cls): cls.user = UserFactory() cls.person = CentralManagerFactory( "can_access_learningunit", "can_edit_learningunit", user=cls.user ) person_entity = PersonEntityFactory( person=cls.person, entity=EntityVersionFactory().entity, ) cls.academic_year = create_current_academic_year() AcademicCalendarLearningUnitCentralEditionFactory( data_year=cls.academic_year, start_date=datetime.datetime(cls.academic_year.year - 6, 9, 15), end_date=datetime.datetime(cls.academic_year.year + 1, 9, 14) ) cls.luy = LearningUnitYearFullFactory( academic_year=cls.academic_year, internship_subtype=None, acronym="EFAC1000", learning_container_year__container_type=EXTERNAL, learning_container_year__requirement_entity=person_entity.entity, ) cls.data = get_valid_external_learning_unit_form_data(cls.academic_year, cls.person, cls.luy) cls.url = reverse(update_learning_unit, args=[cls.luy.pk])
def setUp(self): self.user = UserFactory() self.user.user_permissions.add( Permission.objects.get(codename="can_access_learningunit")) self.user.user_permissions.add( Permission.objects.get(codename="can_edit_learningunit")) self.person = CentralManagerFactory(user=self.user) self.client.force_login(self.user) self.academic_year = create_current_academic_year() luy = LearningUnitYearFullFactory(academic_year=self.academic_year) self.external = ExternalLearningUnitYearFactory(learning_unit_year=luy) luy.learning_container_year.container_type = EXTERNAL luy.learning_container_year.save() EntityVersionFactory(entity=self.external.requesting_entity) PersonEntityFactory(person=self.person, entity=self.external.requesting_entity) self.data = get_valid_external_learning_unit_form_data( self.academic_year, self.person, self.external.learning_unit_year) self.url = reverse(update_learning_unit, args=[self.external.learning_unit_year.pk])
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 = AcademicYearFactory(current=True) cls.education_group_year = EducationGroupYearFactory( academic_year=cls.academic_year) # Create contents of education group years [3 elements] cls.group_element_year_1 = GroupElementYearFactory( parent=cls.education_group_year, child_branch__academic_year=cls.academic_year) cls.group_element_year_2 = GroupElementYearFactory( parent=cls.education_group_year, child_branch__academic_year=cls.academic_year) cls.group_element_year_3 = GroupElementYearFactory( parent=cls.education_group_year, child_branch__academic_year=cls.academic_year) cls.person = CentralManagerFactory() cls.person.user.user_permissions.add( Permission.objects.get(codename="can_access_education_group")) cls.url = reverse("education_groups_management") cls.post_valid_data = { "root_id": cls.education_group_year.id, "element_id": cls.education_group_year.id, "group_element_year_id": cls.group_element_year_3.id, 'action': 'up', }
def setUpTestData(cls): cls.user = UserFactory() cls.person = CentralManagerFactory(user=cls.user) cls.academic_year = create_current_academic_year() cls.education_group_yr = EducationGroupYearFactory( acronym='ARKE2A', academic_year=cls.academic_year, education_group_type=EducationGroupTypeFactory( category=education_group_categories.TRAINING), management_entity=EntityFactory()) cls.root_id = cls.education_group_yr.id cls.country_be = CountryFactory() cls.organization_address = OrganizationAddressFactory( country=cls.country_be) cls.organization = cls.organization_address.organization cls.education_group_organization = EducationGroupOrganizationFactory( organization=cls.organization, education_group_year=cls.education_group_yr, diploma=diploma_coorganization.UNIQUE, all_students=True, ) cls.organization_bis = OrganizationFactory() cls.address = OrganizationAddressFactory( organization=cls.organization_bis, is_main=True)
def test_is_eligible_case_user_is_central_manager(self, mock_is_central_eligible, mock_user_have_perm, mock_super_is_eligible): central_manager = CentralManagerFactory() perm = AdmissionConditionPerms(central_manager.user, self.common_bachelor) perm._is_eligible() self.assertTrue(mock_super_is_eligible.called) self.assertTrue(mock_is_central_eligible.called)
def test_return_true_if_is_central_manager(self): person_entity = PersonEntityFactory( entity=self.group_element_year.parent.management_entity, person=CentralManagerFactory()) self.assertTrue( can_update_group_element_year(person_entity.person.user, self.group_element_year))
def test_li_edit_lu_year_person_is_not_linked_to_entity_in_charge_of_lu( self): a_person = CentralManagerFactory() self.context['user'] = a_person.user result = li_edit_lu(self.context, self.url_edit, "") self.assertEqual( result, self._get_result_data_expected( ID_LINK_EDIT_LU, MSG_ONLY_IF_YOUR_ARE_LINK_TO_ENTITY))
def test_return_true_if_is_central_manager(self): central_manager = CentralManagerFactory( 'change_educationgroup', 'change_educationgroupcontent') person_entity = PersonEntityFactory( entity=self.group_element_year.parent.management_entity, person=central_manager) self.assertTrue( can_update_group_element_year(person_entity.person.user, self.group_element_year))
def test_return_true_if_child_is_learning_unit_and_user_is_central_manager( self): GroupElementYearChildLeafFactory(parent=self.group_element_year.parent) person_entity = PersonEntityFactory( entity=self.group_element_year.parent.management_entity, person=CentralManagerFactory()) self.assertTrue( can_update_group_element_year(person_entity.person.user, self.group_element_year))
def setUp(self): self.education_group_year = TrainingFactory() self.person = CentralManagerFactory("delete_educationgroup", "change_educationgroup", "add_educationgroup") PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity) self.url = reverse('delete_education_group', args=[self.education_group_year.id, self.education_group_year.id]) self.client.force_login(user=self.person.user) self.context = { "person": self.person, "education_group_year": self.education_group_year, "request": RequestFactory().get("") }
def setUpTestData(cls): cls.academic_year = AcademicYearFactory() cls.education_group_year = EducationGroupYearFactory(academic_year=cls.academic_year) cls.group_element_year = GroupElementYearFactory(parent=cls.education_group_year, child_branch__academic_year=cls.academic_year) cls.person = CentralManagerFactory() cls.person.user.user_permissions.add(Permission.objects.get(codename="can_access_education_group")) cls.url = reverse("group_element_year_delete", args=[ cls.education_group_year.id, cls.education_group_year.id, cls.group_element_year.id ])
def test_central_mgr_can_modify_end_year_by_proposal_n_year(self): central_person = CentralManagerFactory() lcy = LearningContainerYearFactory( academic_year=self.current_academic_year, container_type=learning_container_year_types.COURSE) learning_unit_yr = LearningUnitYearFactory( academic_year=self.current_academic_year, subtype=learning_unit_year_subtypes.FULL, learning_unit=LearningUnitFactory(), learning_container_year=lcy) self.assertTrue( can_modify_end_year_by_proposal(learning_unit_yr, central_person, True))
def setUpTestData(cls): cls.education_group_year = EducationGroupYearFactory() cls.group_element_year = GroupElementYearFactory(parent=cls.education_group_year) cls.person = CentralManagerFactory() cls.url = reverse( "group_element_year_management_comment", kwargs={ "root_id": cls.education_group_year.id, "education_group_year_id": cls.education_group_year.id, "group_element_year_id": cls.group_element_year.id } ) cls.post_valid_data = {'action': 'edit'}
def test_when_external_learning_unit_is_not_co_graduation( self, mock_is_person_linked_to_entity_in_charge_of_lu, mock_is_learning_unit_year_in_state_to_be_modified, mock_is_year_editable): mock_is_person_linked_to_entity_in_charge_of_lu.return_value = True mock_is_learning_unit_year_in_state_to_be_modified.return_value = True mock_is_year_editable.return_value = True a_person = CentralManagerFactory() luy = LearningUnitYearFactory(academic_year=self.academic_yr) ExternalLearningUnitYearFactory(learning_unit_year=luy, co_graduation=False) self.assertFalse( perms.is_external_learning_unit_cograduation(luy, a_person, False))
def setUpTestData(cls): academic_year = AcademicYearFactory(year=2020) cls.education_group_year = TrainingFactory(academic_year=academic_year) cls.person = CentralManagerFactory( "delete_educationgroup", "change_educationgroup", "add_educationgroup", "can_edit_education_group_administrative_data" ) PersonEntityFactory(person=cls.person, entity=cls.education_group_year.management_entity) cls.url = reverse('delete_education_group', args=[cls.education_group_year.id, cls.education_group_year.id]) cls.request = RequestFactory().get("")
def setUpTestData(cls): cls.current_acy = create_current_academic_year() cls.academic_years = GenerateAcademicYear( cls.current_acy.year - LEARNING_UNIT_CREATION_SPAN_YEARS, cls.current_acy.year + LEARNING_UNIT_CREATION_SPAN_YEARS).academic_years cls.academic_years[LEARNING_UNIT_CREATION_SPAN_YEARS] = cls.current_acy cls.learning_unit_years = [ LearningUnitYearFactory(academic_year=acy) for acy in cls.academic_years ] cls.faculty_manager = FacultyManagerFactory() cls.central_manager = CentralManagerFactory()
def setUpTestData(cls): cls.education_group_year = EducationGroupYearFactory() cls.group_element_year = GroupElementYearFactory( parent=cls.education_group_year) cls.person = CentralManagerFactory() cls.person.user.user_permissions.add( Permission.objects.get(codename="can_access_education_group")) cls.url = reverse("education_groups_management") cls.post_valid_data = { "root_id": cls.education_group_year.id, "element_id": cls.education_group_year.id, "group_element_year_id": cls.group_element_year.id, 'action': 'detach', }
def setUp(self): self.learning_unit = LearningUnitFactory() self.current_academic_year = create_current_academic_year() self.next_academic_yr = AcademicYearFactory( year=self.current_academic_year.year + 1) self.lcy = LearningContainerYearFactory( academic_year=self.current_academic_year, container_type=learning_container_year_types.COURSE, requirement_entity=EntityVersionFactory().entity) self.central_manager = CentralManagerFactory() self.luy = LearningUnitYearFactory( learning_unit=self.learning_unit, learning_container_year=self.lcy, ) self.central_manager.linked_entities = [self.lcy.requirement_entity.id]
def test_can_modify_by_proposal_previous_n_year(self): faculty_person = FacultyManagerFactory() lcy = LearningContainerYearFactory( academic_year=self.previous_academic_year, container_type=learning_container_year_types.COURSE) learning_unit_yr = LearningUnitYearFactory( academic_year=self.previous_academic_year, subtype=learning_unit_year_subtypes.FULL, learning_unit=LearningUnitFactory(), learning_container_year=lcy) self._modify_permission_assert(faculty_person, learning_unit_yr) central_person = CentralManagerFactory() self.assertFalse( can_modify_by_proposal(learning_unit_yr, central_person, False))
def setUpTestData(cls): cls.academic_year = AcademicYearFactory() cls.education_group_year = EducationGroupYearFactory(academic_year=cls.academic_year) cls.group_element_year = GroupElementYearFactory(parent=cls.education_group_year, child_branch__academic_year=cls.academic_year) cls.person = CentralManagerFactory() cls.person.user.user_permissions.add(Permission.objects.get(codename="can_access_education_group")) cls.url = reverse( "group_content", kwargs={ "root_id": cls.education_group_year.id, "education_group_year_id": cls.education_group_year.id } ) cls.post_valid_data = {'action': 'Generate pdf', 'language': LANGUAGE_CODE_EN}
def test_central_can_copy_into_future(self): central_manager = CentralManagerFactory() eg = EducationGroupFactory(end_year=AcademicYearFactory( year=self.current_academic_year.year + 4)) egy = EducationGroupYearFactory( education_group=eg, academic_year__year=self.current_academic_year.year + 2) GroupElementYearFactory(parent=egy, child_branch__academic_year=egy.academic_year, child_branch__education_group__end_year=None) EducationGroupYearFactory( education_group=eg, academic_year__year=self.current_academic_year.year + 3) self.postponer = PostponeContent(egy, central_manager) self.assertIsNone(self.postponer.check_instance(central_manager))
def test_can_modify_by_proposal_n_year_plus_one(self): faculty_person = FacultyManagerFactory() lcy = LearningContainerYearFactory( academic_year=self.next_academic_yr, container_type=learning_container_year_types.COURSE) learning_unit_yr = LearningUnitYearFactory( academic_year=self.next_academic_yr, subtype=learning_unit_year_subtypes.FULL, learning_unit=LearningUnitFactory(), learning_container_year=lcy) self.assertTrue( can_modify_by_proposal(learning_unit_yr, faculty_person, True)) central_person = CentralManagerFactory() self.assertTrue( can_modify_by_proposal(learning_unit_yr, central_person, True))
def test_academic_year_range_creation_proposal_central_manager(self): LanguageFactory(code="FR") central_manager = CentralManagerFactory() form = learning_unit_create_2.FullForm( central_manager, self.learning_unit_year.academic_year, start_year=self.learning_unit_year.academic_year, proposal_type=ProposalType.CREATION.name ) self.assertCountEqual( list(form.fields['academic_year'].queryset), list(academic_year_mdl.find_academic_years( start_year=self.current_academic_year.year, end_year=self.current_academic_year.year + 6 )) )
def setUpTestData(cls): # Common offer must exist cls.academic_year = create_current_academic_year() EducationGroupYearCommonFactory(academic_year=cls.academic_year) cls.training = EducationGroupYearMasterFactory( academic_year=cls.academic_year, ) cls.publication_contact = EducationGroupPublicationContactFactory( education_group_year=cls.training, type=PublicationContactType.ACADEMIC_RESPONSIBLE.name ) # Create a central manager and linked it to entity of training cls.person = CentralManagerFactory("change_educationgroup", "can_access_education_group") PersonEntityFactory(person=cls.person, entity=cls.training.management_entity)