def setUp(self): current_ac = create_current_academic_year() self.education_group1 = EducationGroupFactory() self.education_group2 = EducationGroupFactory() self.education_group_year1 = EducationGroupYearFactory( education_group=self.education_group1, academic_year=current_ac, ) self.education_group_year2 = EducationGroupYearFactory( education_group=self.education_group2, academic_year=current_ac, ) self.person = PersonWithPermissionsFactory("delete_educationgroup") PersonEntityFactory(person=self.person, entity=self.education_group_year1.management_entity) PersonEntityFactory(person=self.person, entity=self.education_group_year2.management_entity) self.url = reverse('delete_education_group', args=[self.education_group_year1.id, self.education_group_year1.education_group.id]) self.url2 = reverse('delete_education_group', args=[self.education_group_year2.id, self.education_group_year2.education_group.id]) self.client.force_login(user=self.person.user) self.academic_calendar = AcademicCalendarFactory( reference=EDUCATION_GROUP_EDITION, start_date=timezone.now(), end_date=timezone.now() + timedelta(weeks=+1), academic_year=current_ac, )
def setUp(self): today = datetime.date.today() self.faculty_user = factory_user.UserFactory() self.faculty_user.groups.add( Group.objects.get(name=FACULTY_MANAGER_GROUP)) self.faculty_person = factory_person.PersonFactory( user=self.faculty_user) self.faculty_user.user_permissions.add( Permission.objects.get(codename='can_propose_learningunit')) self.faculty_user.user_permissions.add( Permission.objects.get(codename='can_create_learningunit')) self.super_user = factory_user.SuperUserFactory() self.person = factory_person.PersonFactory(user=self.super_user) self.academic_years = GenerateAcademicYear(get_current_year(), get_current_year() + 7).academic_years self.current_academic_year = self.academic_years[0] self.next_academic_year = self.academic_years[1] self.language = LanguageFactory(code='FR') self.organization = organization_factory.OrganizationFactory( type=organization_type.MAIN) self.campus = campus_factory.CampusFactory( organization=self.organization, is_administration=True) self.entity = EntityFactory(organization=self.organization) self.entity_version = EntityVersionFactory( entity=self.entity, entity_type=entity_type.FACULTY, start_date=today.replace(year=1900), end_date=None) PersonEntityFactory(person=self.faculty_person, entity=self.entity) PersonEntityFactory(person=self.person, entity=self.entity)
def setUp(self): self.language_fr = LanguageFactory(code="FR") self.language_en = LanguageFactory(code="EN") self.user = UserFactory() self.person = PersonFactory(user=self.user) self.person_entity = PersonEntityFactory(person=self.person) self.academic_year = create_current_academic_year() self.learning_unit_year = LearningUnitYearFactory( academic_year=self.academic_year, subtype=learning_unit_year_subtypes.FULL, learning_container_year__requirement_entity=self.person_entity.entity, ) self.client.force_login(self.user) self.achievement_fr = LearningAchievementFactory( language=self.language_fr, learning_unit_year=self.learning_unit_year, order=0 ) self.achievement_en = LearningAchievementFactory( language=self.language_en, learning_unit_year=self.learning_unit_year, order=0, code_name=self.achievement_fr.code_name ) self.reverse_learning_unit_yr = reverse('learning_unit', args=[self.learning_unit_year.id]) flag, created = Flag.objects.get_or_create(name='learning_achievement_update') flag.users.add(self.user) self.request_factory = RequestFactory()
def test_find_attached_faculty_entities_version_filtered_by_person(self): person = PersonFactory() entity_attached = EntityFactory(organization=self.organization) entity_version_attached = EntityVersionFactory(entity=entity_attached, entity_type="FACULTY") entity_not_attached = EntityFactory(organization=self.organization) EntityVersionFactory(entity=entity_not_attached, entity_type="SECTOR") entity_ilv = EntityFactory(organization=self.organization) entity_version_ilv = EntityVersionFactory(entity=entity_ilv, acronym="ILV") entity_parent = EntityFactory(organization=self.organization) entity_version_parent = EntityVersionFactory(entity=entity_parent, entity_type='FACULTY') EntityVersionFactory(parent=entity_parent) PersonEntityFactory(person=person, entity=entity_attached) PersonEntityFactory(person=person, entity=entity_ilv) PersonEntityFactory(person=person, entity=entity_parent) entity_list = list( person.find_attached_faculty_entities_version( acronym_exceptions=['ILV'])) self.assertTrue(entity_list) self.assertEqual(len(entity_list), 3) self.assertIn(entity_version_attached, entity_list) self.assertIn(entity_version_ilv, entity_list) self.assertIn(entity_version_parent, entity_list)
def setUpTestData(cls): today = datetime.date.today() FacultyManagerGroupFactory() cls.faculty_user = factory_user.UserFactory() cls.faculty_person = FacultyManagerFactory('can_propose_learningunit', 'can_create_learningunit', user=cls.faculty_user) cls.super_user = factory_user.SuperUserFactory() cls.person = factory_person.CentralManagerFactory(user=cls.super_user) start_year = AcademicYearFactory(year=get_current_year()) end_year = AcademicYearFactory(year=get_current_year() + 7) cls.academic_years = GenerateAcademicYear(start_year, end_year).academic_years cls.current_academic_year = cls.academic_years[0] cls.next_academic_year = cls.academic_years[1] generate_creation_or_end_date_proposal_calendars(cls.academic_years) cls.language = LanguageFactory(code='FR') cls.organization = organization_factory.OrganizationFactory( type=organization_type.MAIN) cls.campus = campus_factory.CampusFactory( organization=cls.organization, is_administration=True) cls.entity = EntityFactory(organization=cls.organization) cls.entity_version = EntityVersionFactory( entity=cls.entity, entity_type=entity_type.FACULTY, start_date=today.replace(year=1900), end_date=None) PersonEntityFactory(person=cls.faculty_person, entity=cls.entity) PersonEntityFactory(person=cls.person, entity=cls.entity)
def test_find_entities_by_person_with_multiple_person_entity_no_duplicate(self): person = PersonFactory() PersonEntityFactory(person=person, entity=self.sst_entity, with_child=True) PersonEntityFactory(person=person, entity=self.agro_entity, with_child=False) entities = person_entity.find_entities_by_person(person) self.assertIsInstance(entities, list) self.assertEqual(len(entities), 3)
def setUp(self): current_ac = create_current_academic_year() next_ac = AcademicYearFactory(year=current_ac.year + 1) self.education_group = EducationGroupFactory() self.education_group_year = EducationGroupYearFactory( education_group=self.education_group, academic_year=next_ac) self.education_group_year2 = EducationGroupYearFactory( education_group=self.education_group, academic_year=next_ac) self.person = PersonFactory() PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity) PersonEntityFactory( person=self.person, entity=self.education_group_year2.management_entity) self.url = reverse('delete_education_group', args=[ self.education_group_year.id, self.education_group_year.education_group.id ]) self.person.user.user_permissions.add( Permission.objects.get(codename="delete_educationgroup")) self.client.force_login(user=self.person.user) self.academic_calendar = AcademicCalendarFactory( reference=EDUCATION_GROUP_EDITION, start_date=timezone.now(), end_date=timezone.now() + timedelta(weeks=+1), academic_year=current_ac, )
def setUp(self): self.luy = LearningUnitYearFakerFactory(learning_container_year__academic_year=self.current_academic_year, learning_container_year__container_type=COURSE, subtype=FULL) self.entity_container_year = EntityContainerYearFactory( learning_container_year=self.luy.learning_container_year, type=entity_container_year_link_type.REQUIREMENT_ENTITY) self.person_entity = PersonEntityFactory(person=self.person, entity=self.entity_container_year.entity)
def setUp(self): requirement_entity = EntityFactory() self.luy = LearningUnitYearFakerFactory( learning_container_year__academic_year=self.current_academic_year, learning_container_year__container_type=COURSE, subtype=FULL, learning_container_year__requirement_entity=requirement_entity) self.person_entity = PersonEntityFactory(person=self.person, entity=requirement_entity)
def test_find_entities_by_person_with_multiple_person_entity(self): person = PersonFactory() PersonEntityFactory(person=person, entity=self.sst_entity, with_child=True) PersonEntityFactory(person=person, entity=self.ssh_entity, with_child=False) entities = person.linked_entities self.assertIsInstance(entities, set) self.assertEqual(len(entities), 4)
def test_filter_by_attached_entities(self): person = PersonFactory() PersonEntityFactory(person=person, entity=self.sst_entity, with_child=True) PersonEntityFactory(person=person, entity=self.agro_entity, with_child=False) person_2 = PersonFactory() PersonEntityFactory(person=person_2, entity=self.ssh_entity, with_child=True) queryset = PersonEntity.objects.all() list_filtered = list(person_entity_filter.filter_by_attached_entities(person, queryset)) self.assertEqual(len(list_filtered), 2) list_filtered = list(person_entity_filter.filter_by_attached_entities(person_2, queryset)) self.assertEqual(len(list_filtered), 1)
def setUpTestData(cls): person_entity = PersonEntityFactory() cls.user = person_entity.person.user cls.entity = person_entity.entity cls.user.groups.add(Group.objects.get(name=FACULTY_MANAGER_GROUP)) cls.user_not_faculty_manager = PersonEntityFactory( entity=cls.entity).person.user cls.user_with_no_person = UserFactory() cls.entity_not_linked_to = EntityFactory()
def test_is_eligible_for_cancel_of_proposal_wrong_state(self): generated_container = GenerateContainer( start_year=self.academic_yr.year, end_year=self.academic_yr.year) generated_container_first_year = generated_container.generated_container_years[ 0] an_requirement_entity = generated_container_first_year.requirement_entity_container_year.entity luy = generated_container_first_year.learning_unit_year_full a_person = self.create_person_with_permission_and_group( FACULTY_MANAGER_GROUP, 'can_propose_learningunit') a_proposal = ProposalLearningUnitFactory( learning_unit_year=luy, type=proposal_type.ProposalType.MODIFICATION.name, state=proposal_state.ProposalState.CENTRAL.name, initial_data={ "entities": { entity_container_year_link_type.REQUIREMENT_ENTITY: an_requirement_entity.id, } }) PersonEntityFactory(person=a_person, entity=an_requirement_entity) self.assertFalse( perms.is_eligible_for_cancel_of_proposal(a_proposal, a_person))
def test_show_and_edit_coorganization(self): user = UserFactory() person = PersonFactory(user=user) user.user_permissions.add( Permission.objects.get(codename="can_access_education_group")) person.user.user_permissions.add( Permission.objects.get(codename='change_educationgroup')) training_not_2m = EducationGroupYearFactory( education_group_type__category=TRAINING, education_group_type__name=TrainingType.CAPAES.name) PersonEntityFactory(person=person, entity=training_not_2m.management_entity) url = reverse("education_group_read", args=[training_not_2m.pk, training_not_2m.pk]) self.client.force_login(user) response = self.client.get(url) self.assertTrue(response.context['show_coorganization']) self.assertFalse(response.context['can_change_coorganization']) user.groups.add(Group.objects.get(name=CENTRAL_MANAGER_GROUP)) response = self.client.get(url) self.assertTrue(response.context['show_coorganization']) self.assertTrue(response.context['can_change_coorganization'])
def setUp(self): self.current_academic_year = create_current_academic_year() self.generated_ac_years = GenerateAcademicYear( self.current_academic_year.year + 1, self.current_academic_year.year + 10) # Creation of a LearingContainerYear and all related models - FOR 6 years self.learn_unit_structure = GenerateContainer( self.current_academic_year.year, self.current_academic_year.year + 6) # Build in Generated Container [first index = start Generate Container ] self.generated_container_year = self.learn_unit_structure.generated_container_years[ 0] # Update All full learning unit year acronym LearningUnitYear.objects.filter(learning_unit=self.learn_unit_structure.learning_unit_full)\ .update(acronym=FULL_ACRONYM) # Update All partim learning unit year acronym LearningUnitYear.objects.filter(learning_unit=self.learn_unit_structure.learning_unit_partim) \ .update(acronym=FULL_ACRONYM + SUBDIVISION_ACRONYM) self.learning_unit_year_full = LearningUnitYear.objects.get( learning_unit=self.learn_unit_structure.learning_unit_full, academic_year=self.current_academic_year) self.learning_unit_year_partim = LearningUnitYear.objects.get( learning_unit=self.learn_unit_structure.learning_unit_partim, academic_year=self.current_academic_year) self.person = PersonFactory() for entity in self.learn_unit_structure.entities: PersonEntityFactory(person=self.person, entity=entity)
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 setUp(self): self.academic_year = create_current_academic_year() self.learning_unit_year = LearningUnitYearFactory( academic_year=self.academic_year, subtype=learning_unit_year_subtypes.FULL) self.language_fr = LanguageFactory(code="FR") self.language_en = LanguageFactory(code="EN") 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_create_learningunit")) self.person = PersonFactory(user=self.user) self.a_superuser = SuperUserFactory() self.client.force_login(self.a_superuser) self.superperson = PersonFactory(user=self.a_superuser) self.person_entity = PersonEntityFactory(person=self.superperson) EntityContainerYearFactory( learning_container_year=self.learning_unit_year. learning_container_year, entity=self.person_entity.entity, type=entity_container_year_link_type.REQUIREMENT_ENTITY)
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 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 setUpTestData(cls): now = datetime.datetime.now() cls.academic_year = create_current_academic_year() cls.previous_academic_year = GenerateAcademicYear( cls.academic_year.year - 1, cls.academic_year.year - 1).academic_years[0] AcademicCalendarFactory( academic_year=cls.previous_academic_year, start_date=now - datetime.timedelta(days=5), end_date=now + datetime.timedelta(days=15), reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION) cls.requirement_entity_version = EntityVersionFactory( entity__organization__type=organization_type.MAIN, start_date=now, end_date=datetime.datetime(now.year + 1, 9, 15), entity_type=entity_type.INSTITUTE) cls.learning_unit_year = LearningUnitYearFactory( acronym="LBIR1100", academic_year=cls.academic_year, learning_container_year__academic_year=cls.academic_year, learning_container_year__acronym="LBIR1100", learning_container_year__requirement_entity=cls. requirement_entity_version.entity) cls.url = reverse('learning_units_summary') cls.faculty_person = FacultyManagerFactory( 'can_access_learningunit', 'can_edit_learningunit_pedagogy') PersonEntityFactory(person=cls.faculty_person, entity=cls.requirement_entity_version.entity)
def test_post(self): new_entity_version = MainEntityVersionFactory() PersonEntityFactory(person=self.person, entity=new_entity_version.entity) data = { 'title': 'Cours au choix', 'title_english': 'deaze', 'education_group_type': self.education_group_year.education_group_type.id, 'credits': 42, 'acronym': 'CRSCHOIXDVLD', 'partial_acronym': 'LDVLD101R', 'management_entity': new_entity_version.pk, 'main_teaching_campus': "", 'academic_year': self.education_group_year.academic_year.pk, "constraint_type": "", } response = self.client.post(self.url, data=data) self.assertEqual(response.status_code, 302) self.education_group_year.refresh_from_db() self.assertEqual(self.education_group_year.title, 'Cours au choix') self.assertEqual(self.education_group_year.title_english, 'deaze') self.assertEqual(self.education_group_year.credits, 42) self.assertEqual(self.education_group_year.acronym, 'CRSCHOIXDVLD') self.assertEqual(self.education_group_year.partial_acronym, 'LDVLD101R') self.assertEqual(self.education_group_year.management_entity, new_entity_version.entity)
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.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_raise_permission_denied_if_person_is_faculty_manager_and_period_closed(self): CloseAcademicCalendarFactory(reference=EDUCATION_GROUP_EDITION, academic_year=self.previous_acy) person_entity = PersonEntityFactory(entity=self.group_element_year.parent.management_entity, person=FacultyManagerFactory()) with self.assertRaises(PermissionDenied): can_update_group_element_year(person_entity.person.user, self.group_element_year)
def setUp(self): self.academic_years = GenerateAcademicYear( start_year=get_current_year(), end_year=get_current_year() + 10) self.generate_container = GenerateContainer( start_year=get_current_year(), end_year=get_current_year() + 10) self.generated_container_year = self.generate_container.generated_container_years[ 0] self.container_year = self.generated_container_year.learning_container_year self.learning_unit_year = self.generated_container_year.learning_unit_year_full self.learning_unit_year_partim = self.generated_container_year.learning_unit_year_partim self.person = PersonFactory() edit_learning_unit_permission = Permission.objects.get( codename="can_edit_learningunit") self.person.user.user_permissions.add(edit_learning_unit_permission) self.url = reverse('learning_unit_volumes_management', kwargs={ 'learning_unit_year_id': self.learning_unit_year.id, 'form_type': 'full' }) self.client.force_login(self.person.user) self.user = self.person.user PersonEntityFactory(entity=self.generate_container.entities[0], person=self.person)
def setUpTestData(cls, **kwargs): cls.education_group_type = kwargs.pop('education_group_type') cls.campus = CampusFactory(organization__type=organization_type.MAIN) cls.academic_year = AcademicYearFactory() new_entity_version = MainEntityVersionFactory() cls.form_data = { "acronym": "ACRO4569", "partial_acronym": "PACR8974", "education_group_type": cls.education_group_type.id, "title": "Test data", "main_teaching_campus": cls.campus.id, "academic_year": cls.academic_year.id, "management_entity": new_entity_version.pk, "remark": "This is a test!!" } cls.parent_education_group_year = EducationGroupYearFactory( academic_year=cls.academic_year) # Append version to management/administration entity cls.entity_version = EntityVersionFactory( entity=cls.parent_education_group_year.management_entity) if cls.education_group_type.category == TRAINING: EntityVersionFactory( entity=cls.parent_education_group_year.administration_entity) # Create user and attached it to management entity person = PersonFactory() PersonEntityFactory( person=person, entity=cls.parent_education_group_year.management_entity) cls.user = person.user
def test_cannot_delete_learning_unit_year_with_administrative_manager_role( self): manager = AdministrativeManagerFactory() entity_version = EntityVersionFactory(entity_type=entity_type.FACULTY, acronym="SST", start_date=datetime.date( year=1990, month=1, day=1), end_date=None) PersonEntityFactory(person=manager, entity=entity_version.entity, with_child=True) # Cannot remove FULL COURSE self.assertFalse( base.business.learning_units.perms. is_eligible_to_delete_learning_unit_year(self.luy1, manager)) # Can remove PARTIM COURSE self.luy1.subtype = learning_unit_year_subtypes.PARTIM self.luy1.save() self.assertFalse( base.business.learning_units.perms. is_eligible_to_delete_learning_unit_year(self.luy1, manager)) self.luy1.subtype = learning_unit_year_subtypes.FULL self.luy1.save()
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 test_cannot_delete_learning_unit_year_with_administrative_manager_role(self): manager = AdministrativeManagerFactory() entity_version = EntityVersionFactory(entity_type=entity_type.FACULTY, acronym="SST", start_date=datetime.date(year=1990, month=1, day=1), end_date=None) PersonEntityFactory(person=manager, entity=entity_version.entity, with_child=True) # Creation UE learning_unit = LearningUnitFactory() l_containeryear = LearningContainerYearFactory(academic_year=self.academic_year, container_type=learning_container_year_types.COURSE, requirement_entity=entity_version.entity) learning_unit_year = LearningUnitYearFactory(learning_unit=learning_unit, academic_year=self.academic_year, learning_container_year=l_containeryear, subtype=learning_unit_year_subtypes.FULL) # Cannot remove FULL COURSE self.assertFalse( base.business.learning_units.perms.is_eligible_to_delete_learning_unit_year( learning_unit_year, manager ) ) # Can remove PARTIM COURSE learning_unit_year.subtype = learning_unit_year_subtypes.PARTIM learning_unit_year.save() self.assertFalse( base.business.learning_units.perms.is_eligible_to_delete_learning_unit_year( learning_unit_year, manager ) )
def setUpTestData(cls): cls.current_academic_year = create_current_academic_year() cls.proposal = ProposalLearningUnitFactory( state=proposal_state.ProposalState.ACCEPTED.name, learning_unit_year__subtype=learning_unit_year_subtypes.FULL, learning_unit_year__academic_year=cls.current_academic_year, learning_unit_year__learning_container_year__academic_year=cls. current_academic_year) cls.learning_unit_year = cls.proposal.learning_unit_year cls.person = PersonFactory() cls.person.user.user_permissions.add( Permission.objects.get(codename="can_access_learningunit")) cls.person.user.user_permissions.add( Permission.objects.get( codename="can_consolidate_learningunit_proposal")) person_entity = PersonEntityFactory( person=cls.person, entity=EntityContainerYearFactory( learning_container_year=cls.learning_unit_year. learning_container_year, type=entity_container_year_link_type.REQUIREMENT_ENTITY).entity ) EntityVersionFactory(entity=person_entity.entity) cls.url = reverse("learning_unit_consolidate_proposal") cls.post_data = {"learning_unit_year_id": cls.learning_unit_year.id}