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 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 setUpTestData(cls):
cls.language_fr = LanguageFactory(code="FR")
cls.language_en = LanguageFactory(code="EN")
cls.user = UserFactory()
flag, created = Flag.objects.get_or_create(name='learning_achievement_update')
flag.users.add(cls.user)
cls.person = PersonWithPermissionsFactory("can_access_learningunit", "can_create_learningunit", user=cls.user)
cls.person_entity = PersonEntityFactory(person=cls.person)
EntityVersionFactory(entity=cls.person_entity.entity)
cls.academic_years = AcademicYearFactory.produce_in_future(quantity=5)
cls.max_la_number = 2*len(cls.academic_years)
cls.learning_unit = LearningUnitFactory(start_year=cls.academic_years[0], end_year=cls.academic_years[-1])
cls.learning_container = LearningContainerFactory()
cls.learning_unit_years = [LearningUnitYearFactory(
academic_year=academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_container_year=LearningContainerYearFactory(
academic_year=academic_year,
learning_container=cls.learning_container,
requirement_entity=cls.person_entity.entity
),
learning_unit=cls.learning_unit,
acronym="TEST0000"
) for academic_year in cls.academic_years]
cls.learning_component_years = [LearningComponentYearFactory(
learning_unit_year=luy,
) for luy in cls.learning_unit_years]
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_CODE_LANGUAGE)
self.language_en = LanguageFactory(code=EN_CODE_LANGUAGE)
def setUp(self):
current_academic_year = create_current_academic_year()
generated_container = GenerateContainer(start_year=current_academic_year.year,
end_year=current_academic_year.year)
generated_container_first_year = generated_container.generated_container_years[0]
self.luy = generated_container_first_year.learning_unit_year_full
self.language_fr = LanguageFactory(code='FR')
self.language_en = LanguageFactory(code='EN')
def setUpTestData(cls):
cls.academic_year = create_current_academic_year()
cls.learning_unit_year = LearningUnitYearFactory(
academic_year=cls.academic_year,
subtype=learning_unit_year_subtypes.FULL)
cls.language_fr = LanguageFactory(code=FR_CODE_LANGUAGE)
cls.language_en = LanguageFactory(code=EN_CODE_LANGUAGE)
def setUpTestData(cls):
cls.language_fr = LanguageFactory(code="FR")
cls.language_en = LanguageFactory(code="EN")
cls.learning_unit_year = LearningUnitYearFactory(
academic_year=create_current_academic_year())
cls.learning_achievement = LearningAchievementFactory(
learning_unit_year=cls.learning_unit_year,
language=cls.language_fr,
code_name='TEST',
)
def setUpTestData(cls):
cls.person = PersonFactory()
starting_year = AcademicYearFactory(year=YEAR_LIMIT_LUE_MODIFICATION)
end_year = AcademicYearFactory(year=YEAR_LIMIT_LUE_MODIFICATION + 6)
academic_years = GenerateAcademicYear(starting_year,
end_year).academic_years
cls.academic_year = academic_years[1]
cls.language = LanguageFactory(code='FR')
organization = OrganizationFactory(type=organization_type.MAIN)
cls.campus = CampusFactory(organization=organization)
cls.language = LanguageFactory(code='FR')
cls.container_year = LearningContainerYearFactory(
academic_year=cls.academic_year, container_type=EXTERNAL)
cls.learning_unit = LearningUnitFactory(start_year=cls.academic_year)
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.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.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_year = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 1),
end_date=today.replace(year=today.year + 2),
year=today.year + 1)
super(AcademicYear, self.academic_year).save()
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.SCHOOL,
start_date=today - datetime.timedelta(days=1),
end_date=today.replace(year=today.year + 1))
PersonEntityFactory(person=self.faculty_person, entity=self.entity)
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):
cls._create_luy()
cls._set_entities()
cls._create_cms_data()
cls.teaching_material = TeachingMaterialFactory(
learning_unit_year=cls.l_unit_yr_1,
title='Teaching material title')
cls.learning_unit_achievement_fr = LearningAchievementFactory(
learning_unit_year=cls.l_unit_yr_1,
language=LanguageFactory(code='FR'))
cls.learning_unit_achievement_en = LearningAchievementFactory(
learning_unit_year=cls.l_unit_yr_1,
language=LanguageFactory(code='EN'))
cls.entity_requirement = EntityVersion.objects.filter(entity=OuterRef(
'learning_container_year__requirement_entity'), ).current(
OuterRef('academic_year__start_date')).values('acronym')[:1]
def test_check_postponement_conflict_learning_unit_year_case_language_diff(
self):
# Copy the same learning unit year + change academic year, language
another_learning_unit_year = _build_copy(self.learning_unit_year)
another_learning_unit_year.academic_year = self.next_academic_year
another_learning_unit_year.language = LanguageFactory(code='FR',
name='French')
another_learning_unit_year.save()
error_list = business_edition._check_postponement_conflict_on_learning_unit_year(
self.learning_unit_year, another_learning_unit_year)
self.assertIsInstance(error_list, list)
self.assertEqual(len(error_list), 1)
generic_error = "The value of field '%(field)s' is different between year %(year)s - %(value)s " \
"and year %(next_year)s - %(next_value)s"
# Error : Language diff
error_language = _(generic_error) % {
'field': _('language'),
'year': self.learning_container_year.academic_year,
'value': getattr(self.learning_unit_year, 'language'),
'next_year': another_learning_unit_year.academic_year,
'next_value': getattr(another_learning_unit_year, 'language')
}
self.assertIn(error_language, error_list)
def setUp(self):
self.academic_year = create_current_academic_year()
self.next_academic_year = AcademicYearFactory(year=self.academic_year.year + 1)
self.learning_container_year = LearningContainerYearFactory(academic_year=self.academic_year,
common_title='common title',
language=LanguageFactory(code='EN', name='English'),
campus=CampusFactory(name='MIT'))
self.learning_unit_year = _create_learning_unit_year_with_components(self.learning_container_year,
create_lecturing_component=True,
create_pratical_component=True)
an_entity = EntityFactory()
self.entity_version = EntityVersionFactory(entity=an_entity, parent=None, end_date=None, acronym="DRT")
self.allocation_entity = _create_entity_container_with_entity_components(
self.learning_unit_year,
entity_container_year_link_type.ALLOCATION_ENTITY,
an_entity
)
self.requirement_entity = _create_entity_container_with_entity_components(
self.learning_unit_year,
entity_container_year_link_type.REQUIREMENT_ENTITY,
an_entity,
repartition_lecturing=30,
repartition_practical_exercises=10
)
self.add_requirement_entity_1 = _create_entity_container_with_entity_components(
self.learning_unit_year,
entity_container_year_link_type.ADDITIONAL_REQUIREMENT_ENTITY_1,
an_entity,
repartition_lecturing=10,
repartition_practical_exercises=5
)
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 _create_learning_unit_year_with_components(l_container,
create_lecturing_component=True,
create_pratical_component=True):
language = LanguageFactory(code='EN', name='English')
a_learning_unit_year = LearningUnitYearFactory(
learning_container_year=l_container,
acronym=l_container.acronym,
academic_year=l_container.academic_year,
status=True,
language=language,
campus=CampusFactory(name='MIT'))
if create_lecturing_component:
a_component = LearningComponentYearFactory(
learning_container_year=l_container,
type=learning_component_year_type.LECTURING,
planned_classes=1)
LearningUnitComponentFactory(learning_unit_year=a_learning_unit_year,
learning_component_year=a_component)
if create_pratical_component:
a_component = LearningComponentYearFactory(
learning_container_year=l_container,
type=learning_component_year_type.PRACTICAL_EXERCISES,
planned_classes=1)
LearningUnitComponentFactory(learning_unit_year=a_learning_unit_year,
learning_component_year=a_component)
return a_learning_unit_year
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 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 test_post_mini_training(self):
old_domain = DomainFactory()
EducationGroupYearDomainFactory(
education_group_year=self.mini_training_education_group_year,
domain=old_domain)
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.a_mini_training_education_group_type.pk,
'credits':
42,
'acronym':
'CRSCHOIXDVLD',
'partial_acronym':
'LDVLD101R',
'management_entity':
new_entity_version.pk,
'main_teaching_campus':
"",
'academic_year':
self.mini_training_education_group_year.academic_year.pk,
'active':
ACTIVE,
'schedule_type':
DAILY,
"primary_language":
LanguageFactory().pk,
"start_year":
2010,
"constraint_type":
"",
"diploma_printing_title":
"Diploma Title",
}
response = self.client.post(self.mini_training_url, data=data)
self.assertEqual(response.status_code,
HttpResponseRedirect.status_code)
self.mini_training_education_group_year.refresh_from_db()
self.assertEqual(self.mini_training_education_group_year.title,
'Cours au choix')
self.assertEqual(self.mini_training_education_group_year.title_english,
'deaze')
self.assertEqual(self.mini_training_education_group_year.credits, 42)
self.assertEqual(self.mini_training_education_group_year.acronym,
'CRSCHOIXDVLD')
self.assertEqual(
self.mini_training_education_group_year.partial_acronym,
'LDVLD101R')
self.assertEqual(
self.mini_training_education_group_year.management_entity,
new_entity_version.entity)
def get_valid_external_learning_unit_form_data(academic_year, person, learning_unit_year=None):
entities = create_entities_hierarchy()
PersonEntityFactory(person=person, entity=entities['root_entity'], with_child=True)
requesting_entity = entities['child_one_entity_version']
organization = OrganizationFactory(type=organization_type.MAIN)
campus = CampusFactory(organization=organization)
language = LanguageFactory(code='FR')
if not learning_unit_year:
container_year = LearningContainerYearFactory(academic_year=academic_year)
learning_unit_year = LearningUnitYearFactory.build(
acronym='EOSIS1111',
academic_year=academic_year,
learning_container_year=container_year,
subtype=learning_unit_year_subtypes.FULL,
campus=campus,
language=language
)
return {
# Learning unit year data model form
'acronym_0': learning_unit_year.acronym[0],
'acronym_1': learning_unit_year.acronym[1:],
'acronym_2': "A",
'academic_year': learning_unit_year.academic_year.id,
'specific_title': learning_unit_year.specific_title,
'specific_title_english': learning_unit_year.specific_title_english,
'credits': learning_unit_year.credits,
'status': learning_unit_year.status,
'campus': learning_unit_year.campus.id,
'language': learning_unit_year.language.pk,
'periodicity': learning_unit_year.periodicity,
# Learning unit data model form
'faculty_remark': learning_unit_year.learning_unit.faculty_remark,
# Learning container year data model form
'common_title': learning_unit_year.learning_container_year.common_title,
'common_title_english': learning_unit_year.learning_container_year.common_title_english,
'is_vacant': learning_unit_year.learning_container_year.is_vacant,
# External learning unit model form
'requirement_entity': requesting_entity.id,
'allocation_entity': requesting_entity.id,
'external_acronym': 'Gorzyne',
'external_credits': '5',
# Learning component year data model form
'component-TOTAL_FORMS': '2',
'component-INITIAL_FORMS': '0',
'component-MAX_NUM_FORMS': '2',
'component-0-hourly_volume_total_annual': 20,
'component-0-hourly_volume_partial_q1': 10,
'component-0-hourly_volume_partial_q2': 10,
'component-0-planned_classes': 1,
'component-1-hourly_volume_total_annual': 20,
'component-1-hourly_volume_partial_q1': 10,
'component-1-hourly_volume_partial_q2': 10,
'component-1-planned_classes': 1,
}
def setUp(self):
academic_year = AcademicYearFactory()
self.education_group_year = EducationGroupYearFactory(academic_year=academic_year)
self.language = LanguageFactory()
self.education_group_language_1 = EducationGroupLanguageFactory(education_group_year=self.education_group_year,
language=self.language)
self.education_group_language_2 = EducationGroupLanguageFactory(education_group_year=self.education_group_year,
language=self.language)
def setUp(self):
self.person = PersonFactory()
an_organization = OrganizationFactory(type=organization_type.MAIN)
current_academic_year = create_current_academic_year()
learning_container_year = LearningContainerYearFactory(
academic_year=current_academic_year,
container_type=learning_container_year_types.COURSE,
campus=CampusFactory(organization=an_organization,
is_administration=True))
self.learning_unit_year = LearningUnitYearFakerFactory(
credits=5,
subtype=learning_unit_year_subtypes.FULL,
academic_year=current_academic_year,
learning_container_year=learning_container_year)
self.entity_container_year = EntityContainerYearFactory(
learning_container_year=self.learning_unit_year.
learning_container_year,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
today = datetime.date.today()
an_entity = EntityFactory(organization=an_organization)
self.entity_version = EntityVersionFactory(
entity=an_entity,
entity_type=entity_type.SCHOOL,
start_date=today,
end_date=today.replace(year=today.year + 1))
self.language = LanguageFactory(code="EN")
self.campus = CampusFactory(
name="OSIS Campus",
organization=OrganizationFactory(type=organization_type.MAIN),
is_administration=True)
self.form_data = {
"academic_year": self.learning_unit_year.academic_year.id,
"first_letter": "L",
"acronym": "OSIS1245",
"common_title": "New common title",
"common_title_english": "New common title english",
"specific_title": "New title",
"specific_title_english": "New title english",
"container_type":
self.learning_unit_year.learning_container_year.container_type,
"internship_subtype": "",
"credits": "4",
"periodicity": learning_unit_periodicity.BIENNIAL_ODD,
"status": False,
"language": self.language.pk,
"quadrimester": learning_unit_year_quadrimesters.Q1,
"campus": self.campus.id,
"requirement_entity": self.entity_version.id,
"allocation_entity": self.entity_version.id,
"entity": self.entity_version.id,
"folder_id": "1",
"state": proposal_state.ProposalState.CENTRAL.name
}
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.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 setUp(self):
self.person = PersonFactory()
self.academic_year = create_current_academic_year()
self.language = LanguageFactory(code='FR')
organization = OrganizationFactory(type=organization_type.MAIN)
campus = CampusFactory(organization=organization)
language = LanguageFactory(code='FR')
container_year = LearningContainerYearFactory(academic_year=self.academic_year, container_type=EXTERNAL)
self.learning_unit = LearningUnitFactory(start_year=self.academic_year.year)
self.learning_unit_year = LearningUnitYearFactory(
acronym='EOSIS1111',
academic_year=self.academic_year,
learning_unit=self.learning_unit,
learning_container_year=container_year,
subtype=learning_unit_year_subtypes.FULL,
campus=campus,
language=language,
internship_subtype=None
)
def setUpTestData(cls):
academic_year = AcademicYearFactory()
cls.education_group_year = EducationGroupYearFactory(
academic_year=academic_year)
cls.language = LanguageFactory()
cls.education_group_language_1 = EducationGroupLanguageFactory(
education_group_year=cls.education_group_year,
language=cls.language)
cls.education_group_language_2 = EducationGroupLanguageFactory(
education_group_year=cls.education_group_year,
language=cls.language)
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="can_propose_learningunit"))
self.person = PersonFactory(user=self.user)
self.client.force_login(self.user)
self.academic_year = create_current_academic_year()
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 setUpTestData(cls):
cls.language_fr = LanguageFactory(code="FR")
cls.language_en = LanguageFactory(code="EN")
cls.user = UserFactory()
cls.person = PersonWithPermissionsFactory("can_access_learningunit", "can_create_learningunit", user=cls.user)
cls.a_superuser = SuperUserFactory()
cls.superperson = PersonFactory(user=cls.a_superuser)
cls.person_entity = PersonEntityFactory(person=cls.superperson)
cls.academic_year = create_current_academic_year()
AcademicYearFactory.produce_in_future(quantity=2)
cls.luy = LearningUnitYearFactory(
academic_year=cls.academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_container_year__requirement_entity=cls.person_entity.entity,
)
cls.future_luy = LearningUnitYearFactory(
academic_year=cls.academic_year.next(),
learning_unit=cls.luy.learning_unit,
)