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_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 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 _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_init(self): # In case of creation form = TrainingForm({}, user=UserFactory(), education_group_type=self.education_group_type) self.assertFalse(hasattr(form, "dict_initial_egy")) # In case of update form = TrainingForm({}, user=UserFactory(), instance=self.education_group_year) dict_initial_egy = _model_to_dict(self.education_group_year, exclude=form.field_to_exclude) self.assertEqual(str(form.dict_initial_egy), str(dict_initial_egy))
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_ensure_show_diploma_tab_is_hidden(self): """ This test ensure that the show diploma property is False if all fields contains in tab are disabled """ form = TrainingForm( {}, user=self.user_without_perm, education_group_type=self.education_group_type, context=TRAINING_DAILY_MANAGEMENT, ) for field_name_in_diploma in form.diploma_tab_fields: form.forms[ forms.ModelForm].fields[field_name_in_diploma].disabled = True self.assertFalse(form.show_diploma_tab())
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 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)
def test_ensure_diploma_tab_fields_property(self): form = TrainingForm( {}, user=self.user_with_perm, education_group_type=self.education_group_type, context=TRAINING_DAILY_MANAGEMENT, ) expected_fields = [ 'joint_diploma', 'diploma_printing_title', 'professional_title', 'section', 'certificate_aims' ] self.assertEqual(form.diploma_tab_fields, expected_fields)
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 test_init_case_user_without_perms(self): """ In this test, we ensure that field present in FieldReference and user don't have permission is disabled ==> [main_teaching_campus] For field which are not present in FieldReference (same context), the field is not disabled by default ==> [partial_acronym] """ form = TrainingForm( {}, user=self.user_without_perm, education_group_type=self.education_group_type, context=TRAINING_DAILY_MANAGEMENT, ) self.assertTrue(form.forms[forms.ModelForm].fields["main_teaching_campus"].disabled) self.assertFalse(form.forms[forms.ModelForm].fields["partial_acronym"].disabled)
def create_education_group(request, category=None, parent_id=None): parent = get_object_or_404(EducationGroupYear, id=parent_id) if parent_id is not None else None forms_by_category = { education_group_categories.GROUP: GroupForm(request.POST or None, parent=parent), education_group_categories.TRAINING: TrainingForm(request.POST or None, parent=parent), education_group_categories.MINI_TRAINING: MiniTrainingForm(request.POST or None, parent=parent), } form_education_group_year = forms_by_category.get(category) if form_education_group_year.is_valid(): education_group_year = form_education_group_year.save() parent_id = parent.pk if parent else education_group_year.pk success_msg = create_success_message_for_creation_education_group_year( parent_id, education_group_year) display_success_messages(request, success_msg, extra_tags='safe') url = reverse("education_group_read", args=[parent_id, education_group_year.pk]) return redirect(url) 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", } return layout.render( request, templates_by_category.get(category), { "form_education_group_year": form_education_group_year.forms[forms.ModelForm], "form_education_group": form_education_group_year.forms[EducationGroupModelForm], "parent": parent })
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] }