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])
