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)
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 setUp(self):
self.super_user = SuperUserFactory()
self.url = reverse("certificate_aim_autocomplete")
self.certificate_aim = CertificateAimFactory(
code=1234,
section=5,
description="description",
)
def _generate_certificate_aims_with_wrong_order(self):
# Numbers below are used only to ensure records are saved in wrong order (there's no other meaning)
for section in range(4, 2, -1):
code_range = section * 11
for code in range(code_range, code_range - 2, -1):
EducationGroupCertificateAimFactory(
education_group_year=self.education_group_child,
certificate_aim=CertificateAimFactory(code=code,
section=section),
)
def test_clean_certificate_aims(self):
administration_entity_version = MainEntityVersionFactory(end_date=None)
management_entity_version = MainEntityVersionFactory(end_date=None)
person = PersonFactory()
PersonEntityFactory(person=person,
entity=management_entity_version.entity)
user = person.user
user.groups.add(self.central_manager)
parent_education_group_year = TrainingFactory(
academic_year=self.academic_year,
education_group_type=self.education_group_type,
management_entity=management_entity_version.entity,
administration_entity=administration_entity_version.entity,
)
AuthorizedRelationshipFactory(
parent_type=parent_education_group_year.education_group_type,
child_type=self.education_group_type,
)
cert = [
CertificateAimFactory(code=code, section=2)
for code in range(100, 102)
]
for i in range(0, len(cert)):
with self.subTest(i=i):
cert_for_form = [str(cert[j].pk) for j in range(0, i + 1)]
form = self.form_class(
data={
'acronym': "EEDY2020",
'partial_acronym': 'EEDY2020F',
'title': "Test",
'internship': 'OPTIONAL',
'primary_language': LanguageFactory().pk,
'active': 'ACTIVE',
'schedule_type': 'DAILY',
'administration_entity':
administration_entity_version.pk,
'management_entity': management_entity_version.pk,
'diploma_printing_title': 'Diplome en test',
'certificate_aims': cert_for_form,
},
parent=parent_education_group_year,
education_group_type=parent_education_group_year.
education_group_type,
user=user,
)
if i == 0:
self.assertTrue(form.is_valid())
else:
self.assertFalse(form.is_valid())
def setUpTestData(cls):
super().setUpTestData()
cls.current_academic_year = AcademicYearFactory(current=True)
cls.generated_ac_years = AcademicYearFactory.produce(
base_year=cls.current_academic_year.year,
number_past=0,
number_future=7)
cls.entity_version = MainEntityVersionFactory(
entity_type=entity_type.SECTOR)
cls.central_manager = CentralManagerFactory()
PersonEntityFactory(person=cls.central_manager,
entity=cls.entity_version.entity)
cls.training = TrainingFactory(
management_entity=cls.entity_version.entity,
administration_entity=cls.entity_version.entity,
academic_year=cls.current_academic_year)
# Save the training instance will create N+6 data...
form_data = model_to_dict_fk(cls.training,
exclude=('secondary_domains', ))
form_data.update({
'primary_language': form_data['primary_language_id'],
'administration_entity': cls.entity_version.pk,
'management_entity': cls.entity_version.pk
})
training_form = TrainingForm(form_data,
instance=cls.training,
user=cls.central_manager.user)
training_form.is_valid()
training_form.save()
cls.certificate_aim_type_2 = CertificateAimFactory(section=2, code=200)
cls.certificate_aim_type_4 = CertificateAimFactory(section=4, code=400)
cls.form_data = {
'certificate_aims':
[cls.certificate_aim_type_2.pk, cls.certificate_aim_type_4.pk]
}
def test_save_case_consistency_raised_because_property_different_in_future(
self):
"""
This test ensure that the consistency check is raised an exception because certificate aims
is different in future
"""
# Update in future
training_in_future = self.qs_training_futures.last()
certificate_aim_type_9 = CertificateAimFactory(section=9, code=900)
form = CertificateAimsForm(
{'certificate_aims': [certificate_aim_type_9]},
instance=training_in_future)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertFalse(form.warnings, form.warnings)
# Update current training...
form = CertificateAimsForm(self.form_data, instance=self.training)
self.assertTrue(form.is_valid(), form.errors)
form.save()
error_expected = _("%(col_name)s has been already modified.") % {
"col_name":
_(
EducationGroupYear._meta.get_field(
'certificate_aims').verbose_name).title(),
}
warnings_expected = [
_("Consistency error in %(academic_year)s with %(model)s: %(error)s"
) % {
'academic_year': training_in_future.academic_year,
'model': EducationGroupYear._meta.verbose_name.title(),
'error': error_expected
}
]
self.assertEqual(form.warnings, warnings_expected, form.warnings)
edgy_postponed_expected = list(
self.qs_training_futures.exclude(
pk=training_in_future.pk).order_by('academic_year__year'))
self.assertEqual(form.education_group_year_postponed,
edgy_postponed_expected)
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)
self._assert_redirects_to_modal_to_update_certificate_aims(
self.previous_training_education_group_year)
self._assert_redirects_to_modal_to_update_certificate_aims(
self.training_education_group_year)
certificate_aims = [
CertificateAimFactory(code=code) for code in range(100, 103)
]
first_certificate_aim = certificate_aims[0].id
self._assert_post_to_modal_to_update_certificate_aims(
first_certificate_aim, self.previous_training_education_group_year)
self._assert_post_to_modal_to_update_certificate_aims(
first_certificate_aim, self.training_education_group_year)
def setUpTestData(cls):
cls.certificate_aim = CertificateAimFactory(
section=9,
code=987,
description="Description of the certificate aim")
def setUp(self):
self.certificate_aim = CertificateAimFactory(
section=9,
code=987,
description="Description of the certificate aim")