def setUpTestData(cls): cls.country_1 = CountryFactory(name="country_1", iso_code="C1") cls.country_2 = CountryFactory(name="country_2", iso_code="C2") cls.country_3 = CountryFactory(name="country_3", iso_code="C3") cls.academic_year_1 = AcademicYearFactory(year=2040) cls.academic_year_2 = AcademicYearFactory(current=True) cls.academic_year_3 = AcademicYearFactory(year=2041) cls.financing_1 = FinancingFactory( type__name="financing_1", academic_year=cls.academic_year_1, ) cls.financing_2 = FinancingFactory( type__name="financing_2", academic_year=cls.academic_year_1, ) cls.financing_3 = FinancingFactory( type__name="financing_3", academic_year=cls.academic_year_3, ) cls.financing_1.countries.set([cls.country_1, cls.country_2]) cls.financing_2.countries.set([cls.country_3]) cls.user = UserFactory() cls.user_adri = UserFactory() entity_version = EntityVersionFactory(acronym='ADRI') PartnershipEntityManagerFactory(entity=entity_version.entity, person__user=cls.user_adri) cls.url = reverse('partnerships:financings:export', kwargs={'year': cls.academic_year_1.year}) cls.url_empty = reverse('partnerships:financings:export')
def setUpTestData(cls): # User creation cls.user = UserFactory() cls.user_adri = UserFactory() entity_version = EntityVersionFactory(acronym='ADRI') PartnershipEntityManagerFactory(entity=entity_version.entity, person__user=cls.user_adri) cls.user_gf = UserFactory() entity_manager = PartnershipEntityManagerFactory(person__user=cls.user_gf) EntityVersionFactory(entity=entity_manager.entity) cls.user_other_gf = UserFactory() PartnershipEntityManagerFactory(person__user=cls.user_other_gf, entity=entity_manager.entity) # Partnership creation cls.date_ok = date.today() + timedelta(days=365) date_ko = date.today() - timedelta(days=365) cls.partnership = PartnershipFactory() PartnershipAgreementFactory(partnership=cls.partnership) cls.partnership_gf = PartnershipFactory( author=cls.user_gf.person, ucl_entity=entity_manager.entity, ) PartnershipAgreementFactory(partnership=cls.partnership_gf) cls.partnership_out_of_date = PartnershipFactory( author=cls.user_gf.person, ucl_entity=entity_manager.entity, ) PartnershipAgreementFactory(partnership=cls.partnership_out_of_date) # Misc cls.url = reverse('partnerships:agreements:delete', kwargs={ 'partnership_pk': cls.partnership.pk, 'pk': cls.partnership.agreements.all()[0].pk })
def setUpTestData(cls): # User creation cls.user = UserFactory() cls.user_adri = UserFactory() entity_version = EntityVersionFactory(acronym='ADRI') PartnershipEntityManagerFactory(entity=entity_version.entity, person__user=cls.user_adri) cls.user_gf = UserFactory() entity_manager = PartnershipEntityManagerFactory( person__user=cls.user_gf) EntityVersionFactory(entity=entity_manager.entity) cls.user_other_gf = UserFactory() PartnershipEntityManagerFactory(person__user=cls.user_other_gf, entity=entity_manager.entity) # Partnership creation contact = ContactFactory() cls.partnership = PartnershipFactory(contacts=[contact]) cls.url = resolve_url( 'partnerships:contacts:delete', partnership_pk=cls.partnership.pk, pk=contact.pk, ) contact = ContactFactory() cls.partnership_gf = PartnershipFactory( author=cls.user_gf.person, ucl_entity=entity_manager.entity, contacts=[contact], ) cls.gf_url = resolve_url( 'partnerships:contacts:delete', partnership_pk=cls.partnership_gf.pk, pk=contact.pk, )
def setUpTestData(cls): faculty = EntityFactory() other_faculty = EntityFactory() third_faculty = EntityFactory() EntityVersionFactory(entity_type="FACULTY", entity=faculty) EntityVersionFactory(entity_type="FACULTY", entity=other_faculty) EntityVersionFactory(entity_type="FACULTY", entity=third_faculty) # Users cls.lambda_user = UserFactory() cls.adri_user = UserFactory() entity_version = EntityVersionFactory(acronym="ADRI") PartnershipEntityManagerFactory(entity=entity_version.entity, person__user=cls.adri_user) cls.gf_user = UserFactory() PartnershipEntityManagerFactory(person__user=cls.gf_user, entity=faculty) cls.other_gf_user = UserFactory() PartnershipEntityManagerFactory(person__user=cls.other_gf_user, entity=other_faculty) cls.ucl_management_entity = UCLManagementEntityFactory(entity=faculty) cls.ucl_management_entity_linked = UCLManagementEntityFactory( entity=third_faculty, ) PartnershipFactory(ucl_entity=third_faculty) cls.url = reverse('partnerships:ucl_management_entities:delete', kwargs={"pk": cls.ucl_management_entity.pk}) cls.linked_url = reverse( 'partnerships:ucl_management_entities:delete', kwargs={"pk": cls.ucl_management_entity_linked.pk}, ) cls.template_name = 'partnerships/ucl_management_entities/uclmanagemententity_delete.html'
def setUp(self): self.permissions = [PermissionFactory() for _ in range(10)] FieldReferenceFactory( content_type=ContentType.objects.get(app_label="base", model="educationgroupyear"), field_name="main_teaching_campus", context=TRAINING_DAILY_MANAGEMENT, permissions=self.permissions, ) FieldReferenceFactory( content_type=ContentType.objects.get(app_label="base", model="educationgroupyear"), field_name="partial_acronym", context="", permissions=self.permissions, ) self.user_with_perm = UserFactory() self.user_with_perm.user_permissions.add(self.permissions[2]) self.user_without_perm = UserFactory() self.user_without_perm.user_permissions.add(PermissionFactory()) self.education_group_type = EducationGroupTypeFactory( category=education_group_categories.TRAINING)
def test_save_with_postponement(self): # Create postponed egy 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), 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=UserFactory()) 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 setUpTestData(cls): # User creation cls.user = PartnershipEntityManagerFactory().person.user cls.user_adri = UserFactory() root = EntityVersionFactory(parent=None).entity entity_version = EntityVersionFactory(acronym='ADRI', parent=root) PartnershipEntityManagerFactory(entity=entity_version.entity, person__user=cls.user_adri) cls.user_gf = UserFactory() entity_manager = PartnershipEntityManagerFactory(person__user=cls.user_gf) EntityVersionFactory(entity=entity_manager.entity, parent=root) cls.user_other_gf = UserFactory() PartnershipEntityManagerFactory(person__user=cls.user_other_gf, entity=entity_manager.entity) # Partnership creation cls.date_ok = date.today() + timedelta(days=365) cls.partnership = PartnershipFactory() cls.partnership_gf = PartnershipFactory( author=cls.user_gf.person, ucl_entity=entity_manager.entity, ) # Misc cls.url = reverse('partnerships:agreements:create', kwargs={'partnership_pk': cls.partnership.pk}) cls.data = { 'start_academic_year': AcademicYearFactory(year=cls.date_ok.year).pk, 'end_academic_year': AcademicYearFactory(year=cls.date_ok.year + 1).pk, 'status': AgreementStatus.WAITING.name, 'comment': 'test', 'media-name': 'test', 'media-description': 'test', 'media-url': 'http://example.com', 'media-visibility': MediaVisibility.PUBLIC.name, }
def setUpTestData(cls): # User creation cls.user = UserFactory() cls.user_adri = UserFactory() entity_version = EntityVersionFactory(acronym='ADRI') PartnershipEntityManagerFactory(entity=entity_version.entity, person__user=cls.user_adri) cls.user_gf = UserFactory() entity_manager = PartnershipEntityManagerFactory( person__user=cls.user_gf) cls.user_other_gf = UserFactory() PartnershipEntityManagerFactory(person__user=cls.user_other_gf, entity=entity_manager.entity) # Partner creation cls.partner = PartnerFactory() cls.partner_gf = PartnerFactory(author=cls.user_gf.person) # Misc cls.contact_type = ContactType.objects.create(value='foobar') cls.country = CountryFactory() cls.media = MediaFactory() cls.partner.medias.add(cls.media) cls.url = reverse('partnerships:partners:medias:update', kwargs={ 'partner_pk': cls.partner.pk, 'pk': cls.media.pk })
def setUpTestData(cls): cls.user_without_notifications = UserFactory() cls.user_with_notifications = UserFactory() cls.unread_notifications = [NotificationFactory(recipient=cls.user_with_notifications) for _ in range(5)] cls.read_notifications = [NotificationFactory(recipient=cls.user_with_notifications, unread=False) for _ in range(3)] cls.all_notifications = cls.unread_notifications + cls.read_notifications
def setUpTestData(cls): cls.filename_1 = tempfile.mkstemp(suffix='.csv')[1] cls.filename_2 = tempfile.mkstemp(suffix='.csv')[1] cls.filename_3 = tempfile.mkstemp(suffix='.badext')[1] cls.country_1 = CountryFactory(name='country_1', iso_code='C1') cls.country_2 = CountryFactory(name='country_2', iso_code='C2') cls.country_3 = CountryFactory(name='country_3', iso_code='C3') cls.country_4 = CountryFactory(name='country_4', iso_code='C4') FundingSourceFactory(name='Source1') FundingSourceFactory(name='Source2') FundingProgramFactory(name='ProgramA') FundingProgramFactory(name='ProgramB') FundingProgramFactory(name='ProgramC') with open(cls.filename_1, 'w') as f: f.write('country_name;country;name;url;program;source\n') f.write( '{0.name};{0.iso_code};foo;http://foo.com;ProgramB;Source2\n'. format(cls.country_1)) f.write( '{0.name};{0.iso_code};bar;http://bar.com;ProgramC;Source2\n'. format(cls.country_2)) f.write( '{0.name};{0.iso_code};foo;http://foo.com;ProgramA;Source1\n'. format(cls.country_3)) # bad country f.write('FOO;ZZ;baz;http://baz.com;ProgramD;Source1\n') # bad program f.write( '{0.name};{0.iso_code};foo;http://foo.com;bad program;Source1\n' .format(cls.country_3)) # bad url f.write( '{0.name};{0.iso_code};foo;badurl;ProgramA;Source1\n'.format( cls.country_3)) # no name f.write('{0.name};{0.iso_code};;badurl;ProgramA;Source1\n'.format( cls.country_2)) with open(cls.filename_2, 'w') as f: f.write('country_name;country;name;url;program;source\n') f.write( '{0.name};{0.iso_code};foo;http://foobis.com;ProgramA;Source1\n' .format(cls.country_4)) with open(cls.filename_3, 'w') as f: f.writelines(['foo', 'bar']) cls.user = UserFactory() cls.user_adri = UserFactory() entity_version = EntityVersionFactory(acronym='ADRI') PartnershipEntityManagerFactory(entity=entity_version.entity, person__user=cls.user_adri) cls.academic_year = AcademicYearFactory() cls.url = reverse('partnerships:financings:import')
class PermsViewAcademicActorCase(TestCase): def setUp(self): self.user = UserFactory() def test_has_no_perms(self): self.assertFalse(view_academicactors(self.user)) def test_has_valid_perms(self): self.user.user_permissions.add( Permission.objects.get(codename="view_programmanager")) self.user.refresh_from_db() self.assertTrue(view_academicactors(self.user))
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 setUp(self): self.current_academic_year = create_current_academic_year() self.person = PersonFactory() self.education_group_year_1 = EducationGroupYearFactory() self.education_group_year_2 = EducationGroupYearFactory() self.education_group_year_3 = EducationGroupYearFactory() self.learning_unit_year_1 = LearningUnitYearFactory() self.learning_component_year_1 = LearningComponentYearFactory( learning_container_year=self.learning_unit_year_1. learning_container_year, hourly_volume_partial_q1=10, hourly_volume_partial_q2=10) self.learning_component_year_2 = LearningComponentYearFactory( learning_container_year=self.learning_unit_year_1. learning_container_year, hourly_volume_partial_q1=10, hourly_volume_partial_q2=10) self.learning_unit_component_1 = LearningUnitComponentFactory( learning_component_year=self.learning_component_year_1, learning_unit_year=self.learning_unit_year_1) self.learning_unit_component_2 = LearningUnitComponentFactory( learning_component_year=self.learning_component_year_2, learning_unit_year=self.learning_unit_year_1) self.learning_unit_year_without_container = LearningUnitYearFactory( learning_container_year=None) self.group_element_year_1 = GroupElementYearFactory( parent=self.education_group_year_1, child_branch=self.education_group_year_2) self.group_element_year_2 = GroupElementYearFactory( parent=self.education_group_year_1, child_branch=None, child_leaf=self.learning_unit_year_1) self.group_element_year_3 = GroupElementYearFactory( parent=self.education_group_year_1, child_branch=self.education_group_year_3) self.group_element_year_without_container = GroupElementYearFactory( parent=self.education_group_year_1, child_branch=None, child_leaf=self.learning_unit_year_without_container) self.user = UserFactory() self.person = PersonFactory(user=self.user) self.user.user_permissions.add( Permission.objects.get(codename="can_access_education_group")) self.url = reverse("education_group_content", args=[ self.education_group_year_1.id, self.education_group_year_1.id, ]) self.client.force_login(self.user)
def test_show_and_edit_coorganization(self): user = UserFactory() person = PersonFactory(user=user) user.user_permissions.add( Permission.objects.get(codename="can_access_education_group")) person.user.user_permissions.add( Permission.objects.get(codename='change_educationgroup')) training_not_2m = EducationGroupYearFactory( education_group_type__category=TRAINING, education_group_type__name=TrainingType.CAPAES.name) PersonEntityFactory(person=person, entity=training_not_2m.management_entity) url = reverse("education_group_read", args=[training_not_2m.pk, training_not_2m.pk]) self.client.force_login(user) response = self.client.get(url) self.assertTrue(response.context['show_coorganization']) self.assertFalse(response.context['can_change_coorganization']) user.groups.add(Group.objects.get(name=CENTRAL_MANAGER_GROUP)) response = self.client.get(url) self.assertTrue(response.context['show_coorganization']) self.assertTrue(response.context['can_change_coorganization'])
def setUp(self): self.user = UserFactory() self.global_ids = ['12348', '565656', '5888'] self.url = reverse('recompute_attribution_portal') self.client = APIClient() self.client.force_authenticate(user=self.user)
def setUp(self): self.academic_year = create_current_academic_year() self.learning_unit_year = LearningUnitYearFactory( academic_year=self.academic_year, subtype=learning_unit_year_subtypes.FULL) self.language_fr = LanguageFactory(code="FR") self.language_en = LanguageFactory(code="EN") self.user = UserFactory() self.user.user_permissions.add( Permission.objects.get(codename="can_access_learningunit")) self.user.user_permissions.add( Permission.objects.get(codename="can_create_learningunit")) self.person = PersonFactory(user=self.user) self.a_superuser = SuperUserFactory() self.client.force_login(self.a_superuser) self.superperson = PersonFactory(user=self.a_superuser) self.person_entity = PersonEntityFactory(person=self.superperson) EntityContainerYearFactory( learning_container_year=self.learning_unit_year. learning_container_year, entity=self.person_entity.entity, type=entity_container_year_link_type.REQUIREMENT_ENTITY)
def setUp(self): self.user = UserFactory() generatorContainer = GenerateContainer(datetime.date.today().year, datetime.date.today().year) self.partim = generatorContainer.generated_container_years[ 0].learning_unit_year_partim self.learning_unit_year_1 = generatorContainer.generated_container_years[ 0].learning_unit_year_full self.entity_1 = generatorContainer.entities[0] self.entity_version_1 = EntityVersionFactory(entity=self.entity_1, acronym="AGRO") self.entity_2 = generatorContainer.entities[0] self.entity_version_2 = EntityVersionFactory(entity=self.entity_2, acronym="DRT") self.learning_unit_year_1.entities = { REQUIREMENT_ENTITY: self.entity_version_1, ALLOCATION_ENTITY: self.entity_version_1, ADDITIONAL_REQUIREMENT_ENTITY_1: self.entity_version_2 } self.academic_year = self.learning_unit_year_1.academic_year self.proposal = ProposalLearningUnitFactory( learning_unit_year=self.learning_unit_year_1, initial_data={"learning_unit": { "faculty_remark": "First remark" }})
def setUpTestData(cls): cls.academic_year = create_current_academic_year() cls.learning_unit = LearningUnitFactory(start_year__year=1900) cls.l_container_year = LearningContainerYearFactory(acronym="LBIR1212", academic_year=cls.academic_year) cls.user = UserFactory()
def setUpTestData(cls): cls.user = UserFactory() cls.url = reverse('reference_api_v1:country-list') CountryFactory(iso_code='BE') CountryFactory(iso_code='FR') CountryFactory(iso_code='UK')
def setUpTestData(cls): cls.permission = HasAdmissionAccess() cls.user = UserFactory() person_information = ContinuingEducationPersonFactory( person=PersonFactory(user=cls.user) ) cls.admission = AdmissionFactory(person_information=person_information)
def test_hasadmissionaccess_return_false_if_not_owner_of_admission(self): other_user = UserFactory() request = APIRequestFactory(user=other_user) request.user = other_user self.assertFalse( self.permission.has_object_permission(request, None, self.admission) )
def setUpTestData(cls): cls.user = UserFactory() CentralManagerGroupFactory() cls.person = PersonFactory(user=cls.user) cls.user.user_permissions.add( Permission.objects.get(codename="can_access_education_group")) cls.academic_year = AcademicYearFactory(current=True)
def setUpTestData(cls): cls.user_adri = UserFactory() entity_version = EntityVersionFactory(acronym='ADRI') PartnershipEntityManagerFactory( entity=entity_version.entity, person__user=cls.user_adri, scopes=[PartnershipType.GENERAL.name] ) # Partnership creation cls.partnership = PartnershipFactory( partnership_type=PartnershipType.GENERAL.name, ) # Misc cls.url = reverse('partnerships:agreements:create', kwargs={ 'partnership_pk': cls.partnership.pk, }) cls.years = AcademicYearFactory.produce_in_future(quantity=3) cls.data = { 'start_date': date.today(), 'end_date': date.today() + timedelta(days=365), 'status': AgreementStatus.WAITING.name, 'comment': 'test', 'media-name': 'test', 'media-description': 'test', 'media-file': ContentFile(b'hello world', 'something.pdf'), 'media-visibility': MediaVisibility.PUBLIC.name, }
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 setUpTestData(cls): cls.user = UserFactory() CountryFactory(iso_code='NL') cls.person = ContinuingEducationPersonFactory() cls.address = AddressFactory() cls.academic_year = AcademicYearFactory(year=2018) cls.education_group = EducationGroupFactory() EducationGroupYearFactory( education_group=cls.education_group, academic_year=cls.academic_year ) cls.formation = ContinuingEducationTrainingFactory( education_group=cls.education_group ) cls.admission = AdmissionFactory( person_information=cls.person, address=cls.address, state=DRAFT, formation=cls.formation ) cls.url = reverse('continuing_education_api_v1:registration-list', kwargs={'uuid': cls.person.uuid}) for state in [VALIDATED, ACCEPTED, REGISTRATION_SUBMITTED]: cls.education_group = EducationGroupFactory() EducationGroupYearFactory(education_group=cls.education_group) AdmissionFactory( person_information=cls.person, state=state, formation=ContinuingEducationTrainingFactory( education_group=cls.education_group ) )
def setUp(self): self.user = UserFactory() self.user.user_permissions.add( Permission.objects.get(codename="can_access_learningunit")) self.user.user_permissions.add( Permission.objects.get(codename="can_edit_learningunit")) self.person = CentralManagerFactory(user=self.user) self.client.force_login(self.user) person_entity = PersonEntityFactory( person=self.person, entity=EntityVersionFactory().entity, ) self.academic_year = create_current_academic_year() luy = LearningUnitYearFullFactory( academic_year=self.academic_year, internship_subtype=None, acronym="EFAC0000", learning_container_year__container_type=EXTERNAL, learning_container_year__requirement_entity=person_entity.entity, ) self.external = ExternalLearningUnitYearFactory(learning_unit_year=luy) self.data = get_valid_external_learning_unit_form_data( self.academic_year, self.person, self.external.learning_unit_year) self.url = reverse(update_learning_unit, args=[self.external.learning_unit_year.pk])
def test_change_language(self): user = UserFactory() user.save() create_person_with_user(user) person.change_language(user, "en") a_person = person.find_by_user(user) self.assertEqual(a_person.language, "en")
def setUpTestData(cls): today = datetime.date.today() academic_year = AcademicYearFactory( start_date=today, end_date=today.replace(year=today.year + 1), year=today.year) cls.education_group_parent = EducationGroupYearFactory( acronym="Parent", academic_year=academic_year) cls.education_group_child_1 = EducationGroupYearFactory( acronym="Child_1", academic_year=academic_year) cls.education_group_child_2 = EducationGroupYearFactory( acronym="Child_2", academic_year=academic_year) GroupElementYearFactory(parent=cls.education_group_parent, child_branch=cls.education_group_child_1) GroupElementYearFactory(parent=cls.education_group_parent, child_branch=cls.education_group_child_2) cls.education_group_language_parent = \ EducationGroupLanguageFactory(education_group_year=cls.education_group_parent) cls.education_group_language_child_1 = \ EducationGroupLanguageFactory(education_group_year=cls.education_group_child_1) cls.user = UserFactory() cls.user.user_permissions.add( Permission.objects.get(codename="can_access_education_group")) cls.url = reverse("education_group_read", args=[cls.education_group_child_1.id])
def test_can_user_edit_administrative_data_no_permission(self): """Without permission/group, we cannot access to administrative data ==> Refused""" user_without_perm = UserFactory() PersonFactory(user=user_without_perm) self.assertFalse( can_user_edit_administrative_data(user_without_perm, self.education_group_year))
def setUpTestData(cls): academic_year = AcademicYearFactory() type_training = EducationGroupTypeFactory( category=education_group_categories.TRAINING) cls.education_group_parent = EducationGroupYearFactory( acronym="Parent", academic_year=academic_year, education_group_type=type_training) cls.education_group_child = EducationGroupYearFactory( acronym="Child_1", academic_year=academic_year, education_group_type=type_training) GroupElementYearFactory(parent=cls.education_group_parent, child_branch=cls.education_group_child) cls.cms_label_for_child = TranslatedTextFactory( text_label=TextLabelFactory(entity=entity_name.OFFER_YEAR), reference=cls.education_group_child.id) cls.user = UserFactory() cls.user.user_permissions.add( Permission.objects.get(codename="can_access_education_group")) cls.url = reverse("education_group_general_informations", args=[cls.education_group_child.id])