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))
