class LearningUnitFullFormContextMixin(TestCase): """This mixin is used in this test file in order to setup an environment for testing FULL FORM""" def setUp(self): self.initial_language = LanguageFactory(code='FR') self.initial_campus = CampusFactory( name='Louvain-la-Neuve', organization__type=organization_type.MAIN) self.current_academic_year = create_current_academic_year() self.person = PersonFactory() self.post_data = get_valid_form_data(self.current_academic_year, person=self.person) # Creation of a LearningContainerYear and all related models self.learn_unit_structure = GenerateContainer( self.current_academic_year.year, self.current_academic_year.year) self.learning_unit_year = LearningUnitYear.objects.get( learning_unit=self.learn_unit_structure.learning_unit_full, academic_year=self.current_academic_year) self.acs = GenerateAcademicYear( start_year=self.current_academic_year.year - 3, end_year=self.current_academic_year.year + 7).academic_years del self.acs[3] for ac in self.acs: LearningUnitYearFactory( academic_year=ac, learning_unit=self.learning_unit_year.learning_unit) self.acs.insert(3, self.current_academic_year)
def test_can_be_updated_by_faculty_manager(self): previous_academic_years = GenerateAcademicYear( start_year=self.academic_year.year - 3, end_year=self.academic_year.year - 1).academic_years next_academic_years = GenerateAcademicYear( start_year=self.academic_year.year + 1, end_year=self.academic_year.year + 3).academic_years previous_luys = [ LearningUnitYearFactory( academic_year=ac, learning_unit=self.learning_unit_year.learning_unit) for ac in previous_academic_years ] next_luys = [ LearningUnitYearFactory( academic_year=ac, learning_unit=self.learning_unit_year.learning_unit) for ac in next_academic_years ] for luy in previous_luys: self.assertFalse(luy.can_update_by_faculty_manager()) self.assertTrue( self.learning_unit_year.can_update_by_faculty_manager()) self.assertTrue(next_luys[0].can_update_by_faculty_manager()) self.assertTrue(next_luys[1].can_update_by_faculty_manager()) self.assertFalse(next_luys[2].can_update_by_faculty_manager())
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) self.parent_education_group_year = EducationGroupYearFactory( academic_year=self.current_academic_year) self.test_categories = [ education_group_categories.GROUP, education_group_categories.TRAINING, education_group_categories.MINI_TRAINING, ] self.education_group_types = [ EducationGroupTypeFactory(category=category) for category in self.test_categories ] self.organization = OrganizationFactory(type=organization_type.MAIN) self.entity = EntityFactory(organization=self.organization) self.entity_version = EntityVersionFactory(entity=self.entity, entity_type=FACULTY, start_date=datetime.now()) self.language = LanguageFactory() self.person = PersonFactory() PersonEntityFactory(person=self.person, entity=self.entity) self.client.force_login(self.person.user) self.perm_patcher = mock.patch( "base.business.education_groups.perms._is_eligible_to_add_education_group", return_value=True) self.mocked_perm = self.perm_patcher.start()
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 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 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 setUp(self): today = datetime.date.today() self.academic_years = GenerateAcademicYear(start_year=today.year+1, end_year=today.year+7) self.a_superuser = SuperUserFactory() self.person = PersonFactory(user=self.a_superuser) self.client.force_login(self.a_superuser)
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 setUpTestData(cls): starting_year = AcademicYearFactory(year=YEAR_LIMIT_LUE_MODIFICATION) end_year = AcademicYearFactory(year=YEAR_LIMIT_LUE_MODIFICATION + 6) cls.academic_years = GenerateAcademicYear(starting_year, end_year).academic_years cls.academic_year = cls.academic_years[1] cls.language = LanguageFactory(code='FR')
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 self.learn_unit_structure = GenerateContainer( self.current_academic_year.year, self.current_academic_year.year) # Build in Generated Container [first index = start Generate Container ] self.generated_container_year = self.learn_unit_structure.generated_container_years[ 0] # Update Full learning unit year 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_full.acronym = FULL_ACRONYM self.learning_unit_year_full.learning_container_year.acronym = FULL_ACRONYM self.learning_unit_year_full.learning_container_year.save() self.learning_unit_year_full.save() # Update Partim learning unit year acronym self.learning_unit_year_partim = LearningUnitYear.objects.get( learning_unit=self.learn_unit_structure.learning_unit_partim, academic_year=self.current_academic_year, learning_container_year=self.learning_unit_year_full. learning_container_year) self.learning_unit_year_partim.acronym = FULL_ACRONYM + SUBDIVISION_ACRONYM self.learning_unit_year_partim.save()
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 setUpTestData(cls): cls.person = PersonFactory() cls.user = cls.person.user cls.tutor = TutorFactory(person=cls.person) cls.current_ac_year = create_current_academic_year() ac_year_in_future = GenerateAcademicYear( start_year=cls.current_ac_year.year + 1, end_year=cls.current_ac_year.year + 5) cls.academic_calendar = AcademicCalendarFactory( academic_year=cls.current_ac_year, reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION) # Create multiple attribution in different academic years for ac_year in [cls.current_ac_year ] + ac_year_in_future.academic_years: learning_container_year = LearningContainerYearFactory( academic_year=ac_year) learning_unit_year = LearningUnitYearFactory( summary_locked=False, academic_year=ac_year, learning_container_year=learning_container_year) AttributionFactory( tutor=cls.tutor, summary_responsible=True, learning_unit_year=learning_unit_year, ) cls.url = reverse(list_my_attributions_summary_editable)
def setUp(self): 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): self.person = PersonFactory() starting_year = YEAR_LIMIT_LUE_MODIFICATION self.academic_years = GenerateAcademicYear( starting_year, starting_year + 6).academic_years self.academic_year = self.academic_years[1] self.language = LanguageFactory(code='FR')
def test_apply_learning_unit_year_postponement(self): """ Postpone to N+6 in Learning Unit Admin """ current_year = get_current_year() academic_years = GenerateAcademicYear(current_year, current_year + 6) lu = LearningUnitFactory(end_year=None) LearningUnitYearFactory(academic_year=academic_years[0], learning_unit=lu) postpone_url = reverse('admin:base_learningunit_changelist') self.client.force_login(SuperUserFactory()) response = self.client.post( postpone_url, data={ 'action': 'apply_learning_unit_year_postponement', '_selected_action': [lu.pk] }) msg = [m.message for m in get_messages(response.wsgi_request)] self.assertEqual( msg[0], ngettext( "%(count)d learning unit has been postponed with success", "%(count)d learning units have been postponed with success", 6) % {'count': 6})
def test_apply_education_group_year_postponement(self): """ Postpone to N+6 in Education Group Admin """ current_year = get_current_year() academic_years = GenerateAcademicYear(current_year, current_year + 6) eg = EducationGroupFactory(end_year=None) EducationGroupYearFactory(academic_year=academic_years[0], education_group=eg) postpone_url = reverse('admin:base_educationgroup_changelist') self.client.force_login(SuperUserFactory()) response = self.client.post( postpone_url, data={ 'action': 'apply_education_group_year_postponement', '_selected_action': [eg.pk] }) msg = [m.message for m in get_messages(response.wsgi_request)] self.assertEqual( msg[0], ngettext( "%(count)d education group has been postponed with success.", "%(count)d education groups have been postponed with success.", 6) % {'count': 6})
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.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) # Generate data for XLS export cls.learning_unit_year_with_mandatory_teaching_materials = 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) TeachingMaterialFactory( learning_unit_year=cls. learning_unit_year_with_mandatory_teaching_materials, title="Magic wand", mandatory=True, ) TeachingMaterialFactory( learning_unit_year=cls. learning_unit_year_with_mandatory_teaching_materials, title="Broomsticks", mandatory=False, ) cls.learning_unit_year_without_mandatory_teaching_materials = LearningUnitYearFactory( acronym="LDROI1600", academic_year=cls.academic_year, learning_container_year__academic_year=cls.academic_year, learning_container_year__acronym="LDROI1600", learning_container_year__requirement_entity=cls. requirement_entity_version.entity) TeachingMaterialFactory( learning_unit_year=cls. learning_unit_year_without_mandatory_teaching_materials, title="cauldron", mandatory=False, )
def setUpTestData(cls): # Create several academic year cls.current_academic_year = create_current_academic_year() start_year = AcademicYearFactory(year=cls.current_academic_year.year + 1) end_year = AcademicYearFactory(year=cls.current_academic_year.year + 10) cls.generated_ac_years = GenerateAcademicYear(start_year, end_year)
def setUpTestData(cls): cls.current_academic_year = create_current_academic_year() start_year = AcademicYearFactory(year=cls.current_academic_year.year + 1) end_year = AcademicYearFactory(year=cls.current_academic_year.year + 10) cls.generated_ac_years = GenerateAcademicYear(start_year, end_year) FacultyManagerGroupFactory()
def setUp(self): self.start_year = 2010 self.end_year = 2020 self.generated_ac_years = GenerateAcademicYear(self.start_year, self.end_year) self.generated_container = GenerateContainer(self.start_year, self.end_year) self.first_learning_unit_year = self.generated_container.generated_container_years[0].learning_unit_year_full self.learning_unit_with_context = get_with_context( learning_container_year_id=self.first_learning_unit_year.learning_container_year)[0]
def setUpTestData(cls): cls.current_academic_year = create_current_academic_year() cls.generated_ac_years = GenerateAcademicYear( cls.current_academic_year.year + 1, cls.current_academic_year.year + 10) cls.parent_education_group_year = EducationGroupYearFactory( academic_year=cls.current_academic_year) cls.test_categories = [ education_group_categories.GROUP, education_group_categories.TRAINING, education_group_categories.MINI_TRAINING, ] cls.education_group_types = [ EducationGroupTypeFactory(category=category) for category in cls.test_categories ] cls.urls_without_parent_by_category = { education_group_type.category: reverse("new_education_group", kwargs={ "category": education_group_type.category, "education_group_type_pk": education_group_type.pk, }) for education_group_type in cls.education_group_types } cls.urls_with_parent_by_category = { education_group_type.category: reverse("new_education_group", kwargs={ "category": education_group_type.category, "education_group_type_pk": education_group_type.pk, "root_id": cls.parent_education_group_year.id, "parent_id": cls.parent_education_group_year.id, }) for education_group_type in cls.education_group_types } cls.expected_templates_by_category = { education_group_categories.GROUP: "education_group/create_groups.html", education_group_categories.TRAINING: "education_group/create_trainings.html", education_group_categories.MINI_TRAINING: "education_group/create_mini_trainings.html", } cls.organization = OrganizationFactory(type=organization_type.MAIN) cls.entity = EntityFactory(organization=cls.organization) cls.entity_version = EntityVersionFactory(entity=cls.entity, entity_type=FACULTY, start_date=datetime.now()) cls.language = LanguageFactory() cls.person = PersonFactory() PersonEntityFactory(person=cls.person, entity=cls.entity)
def setUpTestData(cls): cls.current_acy = create_current_academic_year() start_year = AcademicYearFactory(year=cls.current_acy.year - LEARNING_UNIT_CREATION_SPAN_YEARS) end_year = AcademicYearFactory(year=cls.current_acy.year + LEARNING_UNIT_CREATION_SPAN_YEARS) cls.generated_ac_years = GenerateAcademicYear(start_year, end_year) cls.academic_years = GenerateAcademicYear(start_year, end_year).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 ] generate_learning_unit_edition_calendars(cls.academic_years) cls.faculty_manager = FacultyManagerFactory() cls.central_manager = CentralManagerFactory() cls.faculty_manager_for_ue = UEFacultyManagerFactory()
def setUpTestData(cls): today = datetime.date.today() start_year = AcademicYearFactory(year=today.year + 1) end_year = AcademicYearFactory(year=today.year + 7) cls.academic_years = GenerateAcademicYear(start_year=start_year, end_year=end_year) cls.a_superuser = SuperUserFactory() cls.person = PersonFactory(user=cls.a_superuser) cls.url = reverse('check_acronym', kwargs={'subtype': FULL})
def setUp(self): self.initial_language = LanguageFactory(code='FR') self.initial_campus = CampusFactory(name='Louvain-la-Neuve', organization__type=organization_type.MAIN) self.current_academic_year = create_current_academic_year() self.person = PersonFactory() self.post_data = get_valid_form_data(self.current_academic_year, person=self.person) # Creation of a LearningContainerYear and all related models self.learn_unit_structure = GenerateContainer(self.current_academic_year.year, self.current_academic_year.year) self.learning_unit_year = LearningUnitYear.objects.get( learning_unit=self.learn_unit_structure.learning_unit_full, academic_year=self.current_academic_year ) self.acs = GenerateAcademicYear( start_year=self.current_academic_year.year - 3, end_year=self.current_academic_year.year + 7).academic_years del self.acs[3] for ac in self.acs: LearningUnitYearFactory(academic_year=ac, learning_unit=self.learning_unit_year.learning_unit) self.acs.insert(3, self.current_academic_year)
def setUpTestData(cls): cls.initial_language = LanguageFactory(code='FR') cls.initial_campus = CampusFactory(name='Louvain-la-Neuve', organization__type=organization_type.MAIN) cls.current_academic_year = create_current_academic_year() # Creation of a LearningContainerYear and all related models cls.learn_unit_structure = GenerateContainer(cls.current_academic_year, cls.current_academic_year) start_year = AcademicYearFactory(year=cls.current_academic_year.year - 3) end_year = AcademicYearFactory(year=cls.current_academic_year.year + 7) cls.acs = GenerateAcademicYear(start_year=start_year, end_year=end_year).academic_years
def setUpTestData(cls): start_year = AcademicYearFactory(year=get_current_year()) end_year = AcademicYearFactory(year=get_current_year() + 40) cls.list_acs = GenerateAcademicYear(start_year, end_year).academic_years # Create user and attached it to management entity cls.person = PersonFactory() cls.user = cls.person.user cls.management_entity_version = MainEntityVersionFactory() cls.education_group_type = EducationGroupTypeFactory( category=education_group_categories.TRAINING, name=education_group_types.TrainingType.BACHELOR)
def setUpTestData(cls): cls.start_year = AcademicYearFactory(year=2010) cls.end_year = AcademicYearFactory(year=2020) cls.generated_ac_years = GenerateAcademicYear(cls.start_year, cls.end_year) cls.generated_container = GenerateContainer(cls.start_year, cls.end_year) cls.first_learning_unit_year = cls.generated_container.generated_container_years[ 0].learning_unit_year_full cls.learning_unit_with_context = get_with_context( learning_container_year_id=cls.first_learning_unit_year. learning_container_year)[0]
def setUpTestData(cls): current_year = datetime.date.today().year start_year = AcademicYearFactory(year=current_year - 2) end_year = AcademicYearFactory(year=current_year + 2) cls.academic_years = GenerateAcademicYear(start_year, end_year).academic_years ExternalLearningUnitYearFactory( learning_unit_year__academic_year=cls.academic_years[0], learning_unit_year__learning_container_year__container_type= learning_container_year_types.EXTERNAL, mobility=True, co_graduation=False, )
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_create_learningunit")) self.user.user_permissions.add(Permission.objects.get(codename="add_externallearningunityear")) self.person = PersonFactory(user=self.user) self.client.force_login(self.user) starting_year = YEAR_LIMIT_LUE_MODIFICATION self.academic_years = GenerateAcademicYear(starting_year, starting_year + 1).academic_years self.academic_year = self.academic_years[1] self.language = LanguageFactory(code='FR') self.data = get_valid_external_learning_unit_form_data(self.academic_year, self.person) self.url = reverse(get_external_learning_unit_creation_form, args=[self.academic_year.pk])
def test_is_learning_unit_year_in_state_to_be_modified(self): luy = LearningUnitYearFactory(acronym="LDROI1004", specific_title="Juridic law courses", academic_year=self.academic_yr, subtype=learning_unit_year_subtypes.FULL) start_year = AcademicYearFactory(year=self.academic_yr.year - 3) end_year = AcademicYearFactory(year=self.academic_yr.year - 1) previous_academic_years = GenerateAcademicYear( start_year=start_year, end_year=end_year).academic_years next_academic_years = GenerateAcademicYear( start_year=self.academic_yr_1, end_year=self.academic_yr_6).academic_years previous_luys = [ LearningUnitYearFactory(academic_year=ac, learning_unit=luy.learning_unit) for ac in previous_academic_years ] next_luys = [ LearningUnitYearFactory(academic_year=ac, learning_unit=luy.learning_unit) for ac in next_academic_years ] learning_units_can_be_modified = [luy, next_luys[0], next_luys[1]] for luy in learning_units_can_be_modified: with self.subTest(luy=luy): self.assertTrue( perms._is_learning_unit_year_in_state_to_be_modified( luy, self.person_fac, False)) learning_units_cannot_be_modified = previous_luys + [ next_luys[2], next_luys[3], next_luys[4] ] for luy in learning_units_cannot_be_modified: with self.subTest(luy=luy): self.assertFalse( perms._is_learning_unit_year_in_state_to_be_modified( luy, self.person_fac, False))