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(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_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 _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 _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 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 test_save_with_postponement_error(self):
EducationGroupYearFactory(
academic_year=self.list_acs[4],
education_group=self.education_group_year.education_group)
form = TrainingForm(self.data,
instance=self.education_group_year,
user=UserFactory())
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)
self.assertEqual(len(form.warnings), 15)
def test_save_with_postponement_certificate_aims_inconsistant(self):
"""
This test ensure that the we haven't an error if the certificate aims is inconsistant in future because
certificate aims is managed by program_manager (This form is only accessible on Central/Faculty manager)
"""
# Save the training instance will create N+6 data...
form = TrainingForm(self.form_data,
instance=self.training,
user=self.central_manager.user)
self.assertTrue(form.is_valid(), form.errors)
form.save()
# Add certificate aims in future...
training_future = EducationGroupYear.objects.filter(
education_group=self.training.education_group,
academic_year__year=self.training.academic_year.year + 2).get()
certificate_aims_in_future = EducationGroupCertificateAimFactory(
education_group_year=training_future)
# Re-save and ensure that there are not consitency errors and the modification is correctly postponed
form = TrainingForm(
{
**self.form_data, "title": "Modification du titre"
},
instance=self.training,
user=self.central_manager.user,
)
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertFalse(form.warnings, form.warnings)
training_future.refresh_from_db()
self.assertEqual(training_future.title, "Modification du titre")
# Ensure that certificate aims has not be modified during postponement
self.assertTrue(
EducationGroupCertificateAim.objects.filter(
pk=certificate_aims_in_future.pk).exists())
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 _update_training(request, education_group_year, root):
# TODO :: IMPORTANT :: Fix urls patterns to get the GroupElementYear_id and the root_id in the url path !
# TODO :: IMPORTANT :: Need to update form to filter on list of parents, not only on the first direct parent
form_education_group_year = TrainingForm(request.POST or None,
instance=education_group_year)
if form_education_group_year.is_valid():
return _common_success_redirect(request,
form_education_group_year.save(), root)
return layout.render(
request, "education_group/update_trainings.html", {
"education_group_year":
education_group_year,
"form_education_group_year":
form_education_group_year.forms[forms.ModelForm],
"form_education_group":
form_education_group_year.forms[EducationGroupModelForm]
})