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)