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=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)
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 _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, user=request.user, instance=education_group_year) coorganization_formset = None if show_coorganization(education_group_year): coorganization_formset = OrganizationFormset( data=request.POST or None, form_kwargs={ 'education_group_year': education_group_year, 'user': request.user }, queryset=education_group_year.coorganizations) if form_education_group_year.is_valid( ) and coorganization_formset.is_valid(): coorganization_formset.save() return _common_success_redirect(request, form_education_group_year, root) else: if form_education_group_year.is_valid(): return _common_success_redirect(request, form_education_group_year, root) return 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], "form_coorganization": coorganization_formset, "form_hops": form_education_group_year.hops_form, "show_coorganization": show_coorganization(education_group_year), 'can_change_coorganization': perms.is_eligible_to_change_coorganization( person=request.user.person, education_group=education_group_year, ) })
def _update_training(request, education_group_year, root, groupelementyear_formset): # 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, user=request.user, instance=education_group_year) coorganization_formset = None forms_valid = all([ form_education_group_year.is_valid(), groupelementyear_formset.is_valid() ]) if has_coorganization(education_group_year): coorganization_formset = OrganizationFormset( data=request.POST or None, form_kwargs={ 'education_group_year': education_group_year, 'user': request.user }, queryset=education_group_year.coorganizations) forms_valid = forms_valid and coorganization_formset.is_valid() if request.method == 'POST': if forms_valid: if has_coorganization(education_group_year): coorganization_formset.save() return _common_success_redirect(request, form_education_group_year, root, groupelementyear_formset) else: show_error_message_for_form_invalid(request) return 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], "form_coorganization": coorganization_formset, "form_hops": form_education_group_year.hops_form, "show_coorganization": has_coorganization(education_group_year), "show_diploma_tab": form_education_group_year.show_diploma_tab(), 'can_change_coorganization': perms.is_eligible_to_change_coorganization( person=request.user.person, education_group=education_group_year, ), 'group_element_years': groupelementyear_formset, "is_finality_types": education_group_year.is_finality })
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_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 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 _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] })
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)