def test_post_training_removing_coorganization(self):
new_entity_version = MainEntityVersionFactory()
egy = TrainingFactory(
education_group_type__name=TrainingType.AGGREGATION.name,
management_entity=new_entity_version.entity,
administration_entity=new_entity_version.entity)
PersonEntityFactory(person=self.person,
entity=new_entity_version.entity)
address = OrganizationAddressFactory(
organization=OrganizationFactory(), is_main=True)
egy_organization = EducationGroupOrganizationFactory(
organization=OrganizationFactory(), education_group_year=egy)
diploma_choice = random.choice(DiplomaCoorganizationTypes.get_names())
data = {
'title': 'Cours au choix',
'education_group_type': egy.education_group_type.pk,
'acronym': 'CRSCHOIXDVLD',
'partial_acronym': 'LDVLD101R',
'management_entity': new_entity_version.pk,
'administration_entity': new_entity_version.pk,
'academic_year': egy.academic_year.pk,
'active': ACTIVE,
'schedule_type': DAILY,
"internship": internship_presence.NO,
"primary_language": LanguageFactory().pk,
"constraint_type": "",
"diploma_printing_title": "Diploma Title",
'form-TOTAL_FORMS': 1,
'form-INITIAL_FORMS': 1,
'form-0-country': address.country.pk,
'form-0-organization': egy_organization.organization.pk,
'form-0-diploma': diploma_choice,
'form-0-DELETE': 'on',
'form-0-id': egy_organization.pk
}
url = reverse(update_education_group, args=[egy.pk, egy.pk])
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 302)
egy.refresh_from_db()
coorganizations = egy.coorganizations
self.assertEqual(coorganizations.count(), 0)
class TestEducationGroupConstraintEndYearOn2M(TestCase):
@classmethod
def setUpTestData(cls):
cls.academic_year_2018 = AcademicYearFactory(year=2018)
cls.academic_year_2019 = AcademicYearFactory(year=cls.academic_year_2018.year + 1)
cls.academic_year_2020 = AcademicYearFactory(year=cls.academic_year_2018.year + 2)
def setUp(self):
# Create 2m pgrm structure as
# 2M
# |--FINALITY_LIST
# |--2MS
# |--2MD
self.master_120 = TrainingFactory(
academic_year=self.academic_year_2018,
education_group_type__name=TrainingType.PGRM_MASTER_120.name,
education_group__end_year=None
)
self.finality_group = GroupFactory(
academic_year=self.academic_year_2018,
education_group_type__name=GroupType.FINALITY_120_LIST_CHOICE.name,
education_group__end_year=None
)
GroupElementYearFactory(parent=self.master_120, child_branch=self.finality_group)
self.master_120_specialized = GroupFactory(
academic_year=self.academic_year_2018,
education_group_type__name=TrainingType.MASTER_MS_120.name,
education_group__end_year=None
)
GroupElementYearFactory(parent=self.finality_group, child_branch=self.master_120_specialized)
self.master_120_didactic = GroupFactory(
academic_year=self.academic_year_2018,
education_group_type__name=TrainingType.MASTER_MD_120.name,
education_group__end_year=self.academic_year_2019
)
GroupElementYearFactory(parent=self.finality_group, child_branch=self.master_120_didactic)
def test_check_end_year_constraints_case_2m_end_year_is_greater_or_equals_than_finalities(self):
"""
In this test, we ensure that a root 2M can have end date which are greater or equals than his finalities
"""
self.master_120_specialized.education_group.end_year = self.academic_year_2019
self.master_120_specialized.education_group.save()
self.master_120_specialized.refresh_from_db()
self.master_120.education_group._check_end_year_constraints_on_2m()
def test_check_end_year_constraints_case_2m_end_year_is_lower_than_finalities(self):
"""
In this test, we ensure that a root 2M CANNOT have end date which are lower than at least one
end year of his finalities
"""
# Set root 2M to 2019
self.master_120.education_group.end_year = self.academic_year_2019
self.master_120.education_group.save()
self.master_120.refresh_from_db()
with self.assertRaises(ValidationError):
self.master_120.education_group._check_end_year_constraints_on_2m()
def test_check_end_year_constraints_case_finality_end_year_greater_than_2m(self):
for edy in [self.master_120_didactic, self.master_120_specialized, self.master_120]:
edy.education_group.end_year = self.academic_year_2019
edy.education_group.save()
edy.education_group.refresh_from_db()
self.master_120_didactic.education_group._check_end_year_constraints_on_2m()
self.master_120_didactic.education_group.end_year = self.academic_year_2020
self.master_120_didactic.education_group.save()
self.master_120_didactic.education_group.refresh_from_db()
with self.assertRaises(ValidationError):
self.master_120_didactic.education_group._check_end_year_constraints_on_2m()
class TestUpdate(TestCase):
def setUp(self):
self.current_academic_year = create_current_academic_year()
self.start_date_ay_1 = self.current_academic_year.start_date.replace(
year=self.current_academic_year.year + 1)
self.end_date_ay_1 = self.current_academic_year.end_date.replace(
year=self.current_academic_year.year + 2)
self.previous_academic_year = AcademicYearFactory(
year=self.current_academic_year.year - 1)
academic_year_1 = AcademicYearFactory.build(
start_date=self.start_date_ay_1,
end_date=self.end_date_ay_1,
year=self.current_academic_year.year + 1)
academic_year_1.save()
self.start_date_ay_2 = self.current_academic_year.start_date.replace(
year=self.current_academic_year.year + 2)
self.end_date_ay_2 = self.current_academic_year.end_date.replace(
year=self.current_academic_year.year + 3)
academic_year_2 = AcademicYearFactory.build(
start_date=self.start_date_ay_2,
end_date=self.end_date_ay_2,
year=self.current_academic_year.year + 2)
academic_year_2.save()
self.education_group_year = GroupFactory()
EntityVersionFactory(
entity=self.education_group_year.management_entity,
start_date=self.education_group_year.academic_year.start_date)
EntityVersionFactory(
entity=self.education_group_year.administration_entity,
start_date=self.education_group_year.academic_year.start_date)
AuthorizedRelationshipFactory(
parent_type=self.education_group_year.education_group_type,
child_type=self.education_group_year.education_group_type)
self.url = reverse(update_education_group,
kwargs={
"root_id":
self.education_group_year.pk,
"education_group_year_id":
self.education_group_year.pk
})
self.person = CentralManagerFactory()
PersonEntityFactory(person=self.person,
entity=self.education_group_year.management_entity)
self.client.force_login(self.person.user)
permission = Permission.objects.get(codename='change_educationgroup')
self.person.user.user_permissions.add(permission)
self.perm_patcher = mock.patch(
"base.business.education_groups.perms._is_eligible_certificate_aims",
return_value=True)
self.mocked_perm = self.perm_patcher.start()
self.an_training_education_group_type = EducationGroupTypeFactory(
category=education_group_categories.TRAINING)
self.previous_training_education_group_year = TrainingFactory(
academic_year=self.previous_academic_year,
education_group_type=self.an_training_education_group_type,
education_group__start_year=1968)
EntityVersionFactory(
entity=self.previous_training_education_group_year.
management_entity,
start_date=self.previous_training_education_group_year.
academic_year.start_date)
EntityVersionFactory(
entity=self.previous_training_education_group_year.
administration_entity,
start_date=self.previous_training_education_group_year.
academic_year.start_date)
self.training_education_group_year = TrainingFactory(
academic_year=self.current_academic_year,
education_group_type=self.an_training_education_group_type,
education_group__start_year=1968)
self.training_education_group_year_1 = TrainingFactory(
academic_year=academic_year_1,
education_group_type=self.an_training_education_group_type,
education_group=self.training_education_group_year.education_group)
self.training_education_group_year_2 = TrainingFactory(
academic_year=academic_year_2,
education_group_type=self.an_training_education_group_type,
education_group=self.training_education_group_year.education_group)
AuthorizedRelationshipFactory(
parent_type=self.an_training_education_group_type,
child_type=self.an_training_education_group_type,
)
EntityVersionFactory(
entity=self.training_education_group_year.management_entity,
start_date=self.education_group_year.academic_year.start_date)
EntityVersionFactory(
entity=self.training_education_group_year.administration_entity,
start_date=self.education_group_year.academic_year.start_date)
self.training_url = reverse(update_education_group,
args=[
self.training_education_group_year.pk,
self.training_education_group_year.pk
])
PersonEntityFactory(
person=self.person,
entity=self.training_education_group_year.management_entity)
self.domains = [DomainFactory() for x in range(10)]
self.a_mini_training_education_group_type = EducationGroupTypeFactory(
category=education_group_categories.MINI_TRAINING)
self.mini_training_education_group_year = MiniTrainingFactory(
academic_year=self.current_academic_year,
education_group_type=self.a_mini_training_education_group_type)
self.mini_training_url = reverse(
update_education_group,
args=[
self.mini_training_education_group_year.pk,
self.mini_training_education_group_year.pk
])
PersonEntityFactory(
person=self.person,
entity=self.mini_training_education_group_year.management_entity)
EntityVersionFactory(
entity=self.mini_training_education_group_year.management_entity,
start_date=self.education_group_year.academic_year.start_date)
def tearDown(self):
self.perm_patcher.stop()
def test_login_required(self):
self.client.logout()
response = self.client.get(self.url)
self.assertRedirects(response, '/login/?next={}'.format(self.url))
def test_template_used(self):
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "education_group/update_groups.html")
def test_response_context(self):
response = self.client.get(self.url)
form_education_group_year = response.context[
"form_education_group_year"]
self.assertIsInstance(form_education_group_year, GroupYearModelForm)
def test_post(self):
new_entity_version = MainEntityVersionFactory()
PersonEntityFactory(person=self.person,
entity=new_entity_version.entity)
self.education_group_year.management_entity = new_entity_version.entity
self.education_group_year.save()
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 test_template_used_for_training(self):
response = self.client.get(self.training_url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response,
"education_group/update_trainings.html")
def test_template_used_for_certificate_edition(self):
faculty_managers_group = Group.objects.get(name='faculty_managers')
self.faculty_user = UserFactory()
self.faculty_user.groups.add(faculty_managers_group)
self.faculty_person = PersonFactory(user=self.faculty_user)
self.client.force_login(self.faculty_user)
permission = Permission.objects.get(codename='change_educationgroup')
self.faculty_user.user_permissions.add(permission)
response = self.client.get(
reverse(update_education_group,
args=[
self.previous_training_education_group_year.pk,
self.previous_training_education_group_year.pk
]))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(
response, "education_group/blocks/form/training_certificate.html")
certificate_aims = [
CertificateAimFactory(code=code) for code in range(100, 103)
]
response = self.client.post(
reverse(update_education_group,
args=[
self.previous_training_education_group_year.pk,
self.previous_training_education_group_year.pk
]),
data={'certificate_aims': str(certificate_aims[0].id)})
self.assertEqual(response.status_code, 302)
def test_post_training(self):
old_domain = DomainFactory()
EducationGroupYearDomainFactory(
education_group_year=self.training_education_group_year,
domain=old_domain)
new_entity_version = MainEntityVersionFactory()
PersonEntityFactory(person=self.person,
entity=new_entity_version.entity)
list_domains = [domain.pk for domain in self.domains]
isced_domain = DomainIscedFactory()
data = {
'title':
'Cours au choix',
'title_english':
'deaze',
'education_group_type':
self.an_training_education_group_type.pk,
'credits':
42,
'acronym':
'CRSCHOIXDVLD',
'partial_acronym':
'LDVLD101R',
'management_entity':
new_entity_version.pk,
'administration_entity':
new_entity_version.pk,
'main_teaching_campus':
"",
'academic_year':
self.training_education_group_year.academic_year.pk,
'secondary_domains': [
'|' + ('|'.join([str(domain.pk)
for domain in self.domains])) + '|'
],
'isced_domain':
isced_domain.pk,
'active':
ACTIVE,
'schedule_type':
DAILY,
"internship":
internship_presence.NO,
"primary_language":
LanguageFactory().pk,
"start_year":
2010,
"constraint_type":
"",
"diploma_printing_title":
"Diploma Title",
}
response = self.client.post(self.training_url, data=data)
self.assertEqual(response.status_code, 302)
self.training_education_group_year.refresh_from_db()
self.assertEqual(self.training_education_group_year.title,
'Cours au choix')
self.assertEqual(self.training_education_group_year.title_english,
'deaze')
self.assertEqual(self.training_education_group_year.credits, 42)
self.assertEqual(self.training_education_group_year.acronym,
'CRSCHOIXDVLD')
self.assertEqual(self.training_education_group_year.partial_acronym,
'LDVLD101R')
self.assertEqual(self.training_education_group_year.management_entity,
new_entity_version.entity)
self.assertEqual(
self.training_education_group_year.administration_entity,
new_entity_version.entity)
self.assertEqual(self.training_education_group_year.isced_domain,
isced_domain)
self.assertCountEqual(
list(
self.training_education_group_year.secondary_domains.
values_list('id', flat=True)), list_domains)
self.assertNotIn(old_domain,
self.education_group_year.secondary_domains.all())
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 test_post_training_with_end_year(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.an_training_education_group_type.pk,
'credits':
42,
'acronym':
'CRSCHOIXDVLD',
'partial_acronym':
'LDVLD101R',
'management_entity':
new_entity_version.pk,
'administration_entity':
new_entity_version.pk,
'main_teaching_campus':
"",
'academic_year':
self.training_education_group_year.academic_year.pk,
'secondary_domains': [
'|' + ('|'.join([str(domain.pk)
for domain in self.domains])) + '|'
],
'active':
ACTIVE,
'schedule_type':
DAILY,
"internship":
internship_presence.NO,
"primary_language":
LanguageFactory().pk,
"start_year":
2010,
"end_year":
2018,
"constraint_type":
"",
"diploma_printing_title":
"Diploma Title",
}
response = self.client.post(self.training_url, data=data)
messages = [m.message for m in get_messages(response.wsgi_request)]
self.assertEqual(
messages[1],
_("Education group year %(acronym)s (%(academic_year)s) successfuly deleted."
) % {
"acronym":
self.training_education_group_year_1.acronym,
"academic_year":
self.training_education_group_year_1.academic_year,
})
self.assertEqual(
messages[2],
_("Education group year %(acronym)s (%(academic_year)s) successfuly deleted."
) % {
"acronym":
self.training_education_group_year_2.acronym,
"academic_year":
self.training_education_group_year_2.academic_year,
})
class TestUpdate(TestCase):
def setUp(self):
self.current_academic_year = create_current_academic_year()
self.education_group_year = GroupFactory()
EntityVersionFactory(
entity=self.education_group_year.management_entity,
start_date=self.education_group_year.academic_year.start_date)
EntityVersionFactory(
entity=self.education_group_year.administration_entity,
start_date=self.education_group_year.academic_year.start_date)
AuthorizedRelationshipFactory(
parent_type=self.education_group_year.education_group_type,
child_type=self.education_group_year.education_group_type)
self.url = reverse(
update_education_group,
args=[self.education_group_year.pk, self.education_group_year.pk])
self.person = PersonFactory()
self.client.force_login(self.person.user)
permission = Permission.objects.get(codename='change_educationgroup')
self.person.user.user_permissions.add(permission)
self.perm_patcher = mock.patch(
"base.business.education_groups.perms.is_eligible_to_change_education_group",
return_value=True)
self.mocked_perm = self.perm_patcher.start()
self.an_training_education_group_type = EducationGroupTypeFactory(
category=education_group_categories.TRAINING)
self.training_education_group_year = TrainingFactory(
academic_year=self.current_academic_year,
education_group_type=self.an_training_education_group_type)
AuthorizedRelationshipFactory(
parent_type=self.an_training_education_group_type,
child_type=self.an_training_education_group_type,
)
EntityVersionFactory(
entity=self.training_education_group_year.management_entity,
start_date=self.education_group_year.academic_year.start_date)
EntityVersionFactory(
entity=self.training_education_group_year.administration_entity,
start_date=self.education_group_year.academic_year.start_date)
self.training_url = reverse(update_education_group,
args=[
self.training_education_group_year.pk,
self.training_education_group_year.pk
])
self.domains = [DomainFactory() for x in range(10)]
def tearDown(self):
self.perm_patcher.stop()
def test_login_required(self):
self.client.logout()
response = self.client.get(self.url)
self.assertRedirects(response, '/login/?next={}'.format(self.url))
def test_permission_required(self):
response = self.client.get(self.url)
self.mocked_perm.assert_called_once_with(self.person,
self.education_group_year,
raise_exception=True)
def test_template_used(self):
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "education_group/update_groups.html")
def test_response_context(self):
response = self.client.get(self.url)
form_education_group_year = response.context[
"form_education_group_year"]
self.assertIsInstance(form_education_group_year, GroupYearModelForm)
def test_post(self):
new_entity_version = MainEntityVersionFactory()
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 test_template_used_for_training(self):
response = self.client.get(self.training_url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response,
"education_group/update_trainings.html")
def test_post_training(self):
old_domain = DomainFactory()
EducationGroupYearDomainFactory(
education_group_year=self.training_education_group_year,
domain=old_domain)
new_entity_version = MainEntityVersionFactory()
list_domains = [domain.pk for domain in self.domains]
data = {
'title':
'Cours au choix',
'title_english':
'deaze',
'education_group_type':
self.an_training_education_group_type.pk,
'credits':
42,
'acronym':
'CRSCHOIXDVLD',
'partial_acronym':
'LDVLD101R',
'management_entity':
new_entity_version.pk,
'administration_entity':
new_entity_version.pk,
'main_teaching_campus':
"",
'academic_year':
self.training_education_group_year.academic_year.pk,
'secondary_domains': [
'|' + ('|'.join([str(domain.pk)
for domain in self.domains])) + '|'
],
'active':
ACTIVE,
'schedule_type':
DAILY,
"internship":
internship_presence.NO,
"primary_language":
LanguageFactory().pk,
"start_year":
2010,
"constraint_type":
"",
}
response = self.client.post(self.training_url, data=data)
self.assertEqual(response.status_code, 302)
self.training_education_group_year.refresh_from_db()
self.assertEqual(self.training_education_group_year.title,
'Cours au choix')
self.assertEqual(self.training_education_group_year.title_english,
'deaze')
self.assertEqual(self.training_education_group_year.credits, 42)
self.assertEqual(self.training_education_group_year.acronym,
'CRSCHOIXDVLD')
self.assertEqual(self.training_education_group_year.partial_acronym,
'LDVLD101R')
self.assertEqual(self.training_education_group_year.management_entity,
new_entity_version.entity)
self.assertEqual(
self.training_education_group_year.administration_entity,
new_entity_version.entity)
self.assertListEqual(
list(
self.training_education_group_year.secondary_domains.
values_list('id', flat=True)), list_domains)
self.assertNotIn(old_domain,
self.education_group_year.secondary_domains.all())
class TestPostponementEducationGroupYear(TestCase):
def setUp(self):
administration_entity_version = MainEntityVersionFactory()
management_entity_version = MainEntityVersionFactory()
self.education_group_year = TrainingFactory(
academic_year=create_current_academic_year(),
management_entity=management_entity_version.entity,
administration_entity=administration_entity_version.entity,
)
self.education_group_type = EducationGroupTypeFactory(
category=education_group_categories.TRAINING)
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': 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": "",
}
# Create user and attached it to management entity
person = PersonFactory()
PersonEntityFactory(person=person,
entity=self.education_group_year.management_entity)
self.user = person.user
def test_init(self):
# In case of creation
form = TrainingForm({},
user=self.user,
education_group_type=self.education_group_type)
self.assertFalse(form.dict_initial_egy)
# In case of update
form = TrainingForm({},
user=self.user,
instance=self.education_group_year)
dict_initial_egy = model_to_dict_fk(self.education_group_year,
exclude=form.field_to_exclude)
self.assertEqual(str(form.dict_initial_egy), str(dict_initial_egy))
def test_save_with_postponement(self):
# Create postponed egy
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(len(form.education_group_year_postponed), 6)
self.assertEqual(
EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group).
count(), 7)
self.assertEqual(len(form.warnings), 0)
# Update egys
self.education_group_year.refresh_from_db()
self.data["title"] = "Defence Against the Dark Arts"
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(
EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group).
count(), 7)
self.assertEqual(len(form.warnings), 0, form.warnings)
def test_save_with_postponement_error(self):
EducationGroupYearFactory(
academic_year=self.list_acs[4],
education_group=self.education_group_year.education_group,
duration=100)
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(len(form.education_group_year_postponed), 5)
egs = EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group)
self.assertEqual(egs.count(), 7)
self.assertGreater(len(form.warnings), 0)
def test_save_with_postponement_m2m(self):
domains = [
DomainFactory(name="Alchemy"),
DomainFactory(name="Muggle Studies")
]
self.data["secondary_domains"] = '|'.join(
[str(domain.pk) for domain in domains])
certificate_aims = [
CertificateAimFactory(code=code) for code in range(100, 103)
]
self.data["certificate_aims"] = [
str(aim.pk) for aim in certificate_aims
]
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(len(form.education_group_year_postponed), 6)
self.assertEqual(
EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group).
count(), 7)
last = EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group
).order_by('academic_year').last()
self.education_group_year.refresh_from_db()
self.assertEqual(self.education_group_year.secondary_domains.count(),
2)
self.assertEqual(last.secondary_domains.count(), 2)
self.assertEqual(last.certificate_aims.count(), 3)
self.assertEqual(len(form.warnings), 0)
# update with a conflict
dom3 = DomainFactory(name="Divination")
EducationGroupYearDomainFactory(domain=dom3, education_group_year=last)
domains = [
DomainFactory(name="Care of Magical Creatures"),
DomainFactory(name="Muggle Studies")
]
self.data["secondary_domains"] = '|'.join(
[str(domain.pk) for domain in domains])
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(len(form.education_group_year_postponed), 5)
self.assertEqual(
EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group).
count(), 7)
last.refresh_from_db()
self.education_group_year.refresh_from_db()
self.assertEqual(self.education_group_year.secondary_domains.count(),
2)
self.assertEqual(last.secondary_domains.count(), 3)
self.assertEqual(len(form.warnings), 1)
class TestPostponementEducationGroupYear(TestCase):
@classmethod
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 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_init(self):
# In case of creation
form = TrainingForm({},
user=self.user,
education_group_type=self.education_group_type)
self.assertFalse(form.dict_initial_egy)
self.assertEqual(form.initial_dicts,
{'educationgrouporganization_set': {}})
# In case of update
coorg = EducationGroupOrganizationFactory(
organization=OrganizationFactory(),
education_group_year=self.education_group_year)
form = TrainingForm({},
user=self.user,
instance=self.education_group_year)
dict_initial_egy = model_to_dict_fk(self.education_group_year,
exclude=form.field_to_exclude)
self.assertEqual(str(form.dict_initial_egy), str(dict_initial_egy))
initial_dict_coorg = model_to_dict_fk(
self.education_group_year.coorganizations.first(),
exclude=FIELD_TO_EXCLUDE_IN_SET)
self.assertEqual(
form.initial_dicts, {
'educationgrouporganization_set': {
coorg.organization.id: initial_dict_coorg
}
})
def test_save_with_postponement(self):
# Create postponed egy
self._create_postponed_egys()
# Update egys
self.education_group_year.refresh_from_db()
self.assertEqual(
self.education_group_year.educationgrouporganization_set.all().
count(), 0)
EducationGroupOrganizationFactory(
organization=OrganizationFactory(),
education_group_year=self.education_group_year)
self.assertEqual(
self.education_group_year.educationgrouporganization_set.all().
count(), 1)
self.data["title"] = "Defence Against the Dark Arts"
self._postpone_coorganization_and_check()
def test_save_with_postponement_error(self):
EducationGroupYearFactory(
academic_year=self.list_acs[4],
education_group=self.education_group_year.education_group,
duration=100)
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(len(form.education_group_year_postponed), 5)
egs = EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group)
self.assertEqual(egs.count(), 7)
self.assertGreater(len(form.warnings), 0)
def test_save_with_postponement_sets_inconsistents(self):
# create postponed egy's
self._create_postponed_egys()
# update with inconsistant EducationGroupOrganization (organization present in the future not in present)
self.education_group_year.refresh_from_db()
unconsistent_egy = EducationGroupYear.objects.get(
education_group=self.education_group_year.education_group,
academic_year=self.list_acs[4])
EducationGroupOrganizationFactory(
organization=OrganizationFactory(),
education_group_year=unconsistent_egy)
EducationGroupOrganizationFactory(
organization=OrganizationFactory(),
education_group_year=self.education_group_year)
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertGreater(len(form.warnings), 0)
self.assertEqual(form.warnings, [
_("Consistency error in %(academic_year)s : %(error)s") % {
'academic_year': unconsistent_egy.academic_year,
'error': EducationGroupOrganization._meta.verbose_name.title()
}
])
def test_save_with_postponement_coorganization_inconsistant(self):
# create postponed egy's
self._create_postponed_egys()
# update with a coorganization to postpone
self.education_group_year.refresh_from_db()
good_organization = EducationGroupOrganizationFactory(
organization=OrganizationFactory(),
education_group_year=self.education_group_year)
self._postpone_coorganization_and_check()
# update with unconsistant EducationGroupOrganization (field different from a year to another one)
self.education_group_year.refresh_from_db()
unconsistent_egy = EducationGroupYear.objects.get(
education_group=self.education_group_year.education_group,
academic_year=self.list_acs[4])
unconsistent_orga = EducationGroupOrganization.objects.get(
education_group_year=unconsistent_egy)
unconsistent_orga.all_students = not good_organization.all_students
unconsistent_orga.save()
# have to invalidate cache
del self.education_group_year.coorganizations
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(len(form.warnings), 1)
error_msg = _("%(col_name)s has been already modified.") % {
"col_name":
_(
EducationGroupOrganization._meta.get_field(
'all_students').verbose_name).title(),
}
self.assertEqual(form.warnings, [
_("Consistency error in %(academic_year)s with %(model)s: %(error)s"
) %
{
'academic_year': unconsistent_egy.academic_year,
'model': EducationGroupOrganization._meta.verbose_name.title(),
'error': error_msg
}
])
def _postpone_coorganization_and_check(self):
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(len(form.warnings), 0, form.warnings)
all_egys = EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group)
self.assertEqual(all_egys.count(), 7)
for egy in all_egys:
self.assertEqual(egy.educationgrouporganization_set.all().count(),
1)
def _create_postponed_egys(self):
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(len(form.education_group_year_postponed), 6)
self.assertEqual(len(form.warnings), 0)
self.assertEqual(
EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group).
count(), 7)
def test_save_with_postponement_m2m(self):
domains = [
DomainFactory(name="Alchemy"),
DomainFactory(name="Muggle Studies")
]
self.data["secondary_domains"] = '|'.join(
[str(domain.pk) for domain in domains])
certificate_aims = [
CertificateAimFactory(code=100, section=1),
CertificateAimFactory(code=101, section=2)
]
self.data["certificate_aims"] = [
str(aim.pk) for aim in certificate_aims
]
self._create_postponed_egys()
last = EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group
).order_by('academic_year').last()
self.education_group_year.refresh_from_db()
self.assertEqual(self.education_group_year.secondary_domains.count(),
2)
self.assertEqual(last.secondary_domains.count(), 2)
self.assertEqual(last.certificate_aims.count(), len(certificate_aims))
# update with a conflict
dom3 = DomainFactory(name="Divination")
EducationGroupYearDomainFactory(domain=dom3, education_group_year=last)
domains = [
DomainFactory(name="Care of Magical Creatures"),
DomainFactory(name="Muggle Studies")
]
self.data["secondary_domains"] = '|'.join(
[str(domain.pk) for domain in domains])
form = TrainingForm(self.data,
instance=self.education_group_year,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(len(form.education_group_year_postponed), 5)
self.assertEqual(
EducationGroupYear.objects.filter(
education_group=self.education_group_year.education_group).
count(), 7)
last.refresh_from_db()
self.education_group_year.refresh_from_db()
self.assertEqual(self.education_group_year.secondary_domains.count(),
2)
self.assertEqual(last.secondary_domains.count(), 3)
self.assertEqual(len(form.warnings), 1)