def setUpTestData(cls):
cls.current_academic_year = create_current_academic_year()
cls.next_academic_year = AcademicYearFactory(year=cls.current_academic_year.year + 1)
cls.person = CentralManagerFactory()
cls.person.user.user_permissions.add(Permission.objects.get(codename="change_educationgroup"))
cls.person.user.user_permissions.add(Permission.objects.get(codename="can_access_education_group"))
cls.education_group = EducationGroupFactory(end_year=cls.next_academic_year)
cls.education_group_year = TrainingFactory(academic_year=cls.current_academic_year,
education_group=cls.education_group)
cls.next_education_group_year = TrainingFactory(
academic_year=cls.next_academic_year,
education_group=cls.education_group,
management_entity=cls.education_group_year.management_entity
)
PersonEntityFactory(person=cls.person, entity=cls.education_group_year.management_entity)
cls.group_element_year = GroupElementYearFactory(
parent=cls.education_group_year,
child_branch__academic_year=cls.education_group_year.academic_year
)
cls.url = reverse(
"postpone_education_group",
kwargs={
"root_id": cls.next_education_group_year.pk,
"education_group_year_id": cls.next_education_group_year.pk,
}
)
cls.redirect_url = reverse("education_group_read",
args=[cls.next_education_group_year.pk, cls.next_education_group_year.pk])
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_is_central_manager_eligible(self):
central_manager = CentralManagerFactory()
for education_group_year in [self.common_bachelor, self.training]:
perm = GeneralInformationPerms(central_manager.user,
education_group_year)
self.assertTrue(perm._is_central_manager_eligible())
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=get_current_year() + 1)
cls.next_academic_year_1 = AcademicYearFactory(
year=cls.academic_year.year + 1)
cls.next_academic_year_2 = AcademicYearFactory(
year=cls.academic_year.year + 2)
cls.education_group_year = EducationGroupYearFactory(
academic_year=cls.academic_year,
education_group__end_year=cls.next_academic_year_2)
cls.education_group_year_child = EducationGroupYearFactory(
academic_year=cls.academic_year,
education_group__end_year=cls.next_academic_year_2)
cls.group_element_year = GroupElementYearFactory(
parent=cls.education_group_year,
child_branch=cls.education_group_year_child)
AuthorizedRelationshipFactory(
parent_type=cls.education_group_year.education_group_type,
child_type=cls.group_element_year.child_branch.
education_group_type,
)
cls.person = CentralManagerFactory()
cls.url = reverse("group_element_year_update",
kwargs={
"root_id": cls.education_group_year.id,
"education_group_year_id":
cls.education_group_year.id,
"group_element_year_id":
cls.group_element_year.id
})
cls.post_valid_data = {'action': 'edit'}
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)
cls.form_data = model_to_dict_fk(cls.training,
exclude=('secondary_domains', ))
cls.form_data.update({
'primary_language':
cls.form_data['primary_language_id'],
'administration_entity':
cls.entity_version.pk,
'management_entity':
cls.entity_version.pk
})
def setUpTestData(cls):
cls.user = UserFactory()
cls.person = CentralManagerFactory(
"can_access_learningunit", "can_edit_learningunit",
user=cls.user
)
person_entity = PersonEntityFactory(
person=cls.person,
entity=EntityVersionFactory().entity,
)
cls.academic_year = create_current_academic_year()
AcademicCalendarLearningUnitCentralEditionFactory(
data_year=cls.academic_year,
start_date=datetime.datetime(cls.academic_year.year - 6, 9, 15),
end_date=datetime.datetime(cls.academic_year.year + 1, 9, 14)
)
cls.luy = LearningUnitYearFullFactory(
academic_year=cls.academic_year,
internship_subtype=None,
acronym="EFAC1000",
learning_container_year__container_type=EXTERNAL,
learning_container_year__requirement_entity=person_entity.entity,
)
cls.data = get_valid_external_learning_unit_form_data(cls.academic_year, cls.person, cls.luy)
cls.url = reverse(update_learning_unit, args=[cls.luy.pk])
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)
self.academic_year = create_current_academic_year()
luy = LearningUnitYearFullFactory(academic_year=self.academic_year)
self.external = ExternalLearningUnitYearFactory(learning_unit_year=luy)
luy.learning_container_year.container_type = EXTERNAL
luy.learning_container_year.save()
EntityVersionFactory(entity=self.external.requesting_entity)
PersonEntityFactory(person=self.person,
entity=self.external.requesting_entity)
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 setUp(self):
self.current_academic_year = create_current_academic_year()
self.next_academic_year = AcademicYearFactory(year=self.current_academic_year.year + 1)
self.person = CentralManagerFactory()
self.person.user.user_permissions.add(Permission.objects.get(codename="change_educationgroup"))
self.person.user.user_permissions.add(Permission.objects.get(codename="can_access_education_group"))
self.client.force_login(self.person.user)
self.education_group = EducationGroupFactory(end_year=self.next_academic_year.year)
self.education_group_year = TrainingFactory(academic_year=self.current_academic_year,
education_group=self.education_group)
self.next_education_group_year = TrainingFactory(
academic_year=self.next_academic_year,
education_group=self.education_group,
management_entity=self.education_group_year.management_entity
)
PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity)
self.group_element_year = GroupElementYearFactory(parent=self.education_group_year)
self.url = reverse(
"postpone_education_group",
kwargs={
"root_id": self.next_education_group_year.pk,
"education_group_year_id": self.next_education_group_year.pk,
}
)
self.redirect_url = reverse("education_group_read",
args=[self.next_education_group_year.pk, self.next_education_group_year.pk])
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(current=True)
cls.education_group_year = EducationGroupYearFactory(
academic_year=cls.academic_year)
# Create contents of education group years [3 elements]
cls.group_element_year_1 = GroupElementYearFactory(
parent=cls.education_group_year,
child_branch__academic_year=cls.academic_year)
cls.group_element_year_2 = GroupElementYearFactory(
parent=cls.education_group_year,
child_branch__academic_year=cls.academic_year)
cls.group_element_year_3 = GroupElementYearFactory(
parent=cls.education_group_year,
child_branch__academic_year=cls.academic_year)
cls.person = CentralManagerFactory()
cls.person.user.user_permissions.add(
Permission.objects.get(codename="can_access_education_group"))
cls.url = reverse("education_groups_management")
cls.post_valid_data = {
"root_id": cls.education_group_year.id,
"element_id": cls.education_group_year.id,
"group_element_year_id": cls.group_element_year_3.id,
'action': 'up',
}
def setUpTestData(cls):
cls.user = UserFactory()
cls.person = CentralManagerFactory(user=cls.user)
cls.academic_year = create_current_academic_year()
cls.education_group_yr = EducationGroupYearFactory(
acronym='ARKE2A',
academic_year=cls.academic_year,
education_group_type=EducationGroupTypeFactory(
category=education_group_categories.TRAINING),
management_entity=EntityFactory())
cls.root_id = cls.education_group_yr.id
cls.country_be = CountryFactory()
cls.organization_address = OrganizationAddressFactory(
country=cls.country_be)
cls.organization = cls.organization_address.organization
cls.education_group_organization = EducationGroupOrganizationFactory(
organization=cls.organization,
education_group_year=cls.education_group_yr,
diploma=diploma_coorganization.UNIQUE,
all_students=True,
)
cls.organization_bis = OrganizationFactory()
cls.address = OrganizationAddressFactory(
organization=cls.organization_bis, is_main=True)
def test_is_eligible_case_user_is_central_manager(self, mock_is_central_eligible, mock_user_have_perm,
mock_super_is_eligible):
central_manager = CentralManagerFactory()
perm = AdmissionConditionPerms(central_manager.user, self.common_bachelor)
perm._is_eligible()
self.assertTrue(mock_super_is_eligible.called)
self.assertTrue(mock_is_central_eligible.called)
def test_return_true_if_is_central_manager(self):
person_entity = PersonEntityFactory(
entity=self.group_element_year.parent.management_entity,
person=CentralManagerFactory())
self.assertTrue(
can_update_group_element_year(person_entity.person.user,
self.group_element_year))
def test_li_edit_lu_year_person_is_not_linked_to_entity_in_charge_of_lu(
self):
a_person = CentralManagerFactory()
self.context['user'] = a_person.user
result = li_edit_lu(self.context, self.url_edit, "")
self.assertEqual(
result,
self._get_result_data_expected(
ID_LINK_EDIT_LU, MSG_ONLY_IF_YOUR_ARE_LINK_TO_ENTITY))
def test_return_true_if_is_central_manager(self):
central_manager = CentralManagerFactory(
'change_educationgroup', 'change_educationgroupcontent')
person_entity = PersonEntityFactory(
entity=self.group_element_year.parent.management_entity,
person=central_manager)
self.assertTrue(
can_update_group_element_year(person_entity.person.user,
self.group_element_year))
def test_return_true_if_child_is_learning_unit_and_user_is_central_manager(
self):
GroupElementYearChildLeafFactory(parent=self.group_element_year.parent)
person_entity = PersonEntityFactory(
entity=self.group_element_year.parent.management_entity,
person=CentralManagerFactory())
self.assertTrue(
can_update_group_element_year(person_entity.person.user,
self.group_element_year))
def setUp(self):
self.education_group_year = TrainingFactory()
self.person = CentralManagerFactory("delete_educationgroup", "change_educationgroup", "add_educationgroup")
PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity)
self.url = reverse('delete_education_group', args=[self.education_group_year.id, self.education_group_year.id])
self.client.force_login(user=self.person.user)
self.context = {
"person": self.person,
"education_group_year": self.education_group_year,
"request": RequestFactory().get("")
}
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory()
cls.education_group_year = EducationGroupYearFactory(academic_year=cls.academic_year)
cls.group_element_year = GroupElementYearFactory(parent=cls.education_group_year,
child_branch__academic_year=cls.academic_year)
cls.person = CentralManagerFactory()
cls.person.user.user_permissions.add(Permission.objects.get(codename="can_access_education_group"))
cls.url = reverse("group_element_year_delete", args=[
cls.education_group_year.id,
cls.education_group_year.id,
cls.group_element_year.id
])
def test_central_mgr_can_modify_end_year_by_proposal_n_year(self):
central_person = CentralManagerFactory()
lcy = LearningContainerYearFactory(
academic_year=self.current_academic_year,
container_type=learning_container_year_types.COURSE)
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.current_academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_unit=LearningUnitFactory(),
learning_container_year=lcy)
self.assertTrue(
can_modify_end_year_by_proposal(learning_unit_yr, central_person,
True))
def setUpTestData(cls):
cls.education_group_year = EducationGroupYearFactory()
cls.group_element_year = GroupElementYearFactory(parent=cls.education_group_year)
cls.person = CentralManagerFactory()
cls.url = reverse(
"group_element_year_management_comment",
kwargs={
"root_id": cls.education_group_year.id,
"education_group_year_id": cls.education_group_year.id,
"group_element_year_id": cls.group_element_year.id
}
)
cls.post_valid_data = {'action': 'edit'}
def test_when_external_learning_unit_is_not_co_graduation(
self, mock_is_person_linked_to_entity_in_charge_of_lu,
mock_is_learning_unit_year_in_state_to_be_modified,
mock_is_year_editable):
mock_is_person_linked_to_entity_in_charge_of_lu.return_value = True
mock_is_learning_unit_year_in_state_to_be_modified.return_value = True
mock_is_year_editable.return_value = True
a_person = CentralManagerFactory()
luy = LearningUnitYearFactory(academic_year=self.academic_yr)
ExternalLearningUnitYearFactory(learning_unit_year=luy,
co_graduation=False)
self.assertFalse(
perms.is_external_learning_unit_cograduation(luy, a_person, False))
def setUpTestData(cls):
academic_year = AcademicYearFactory(year=2020)
cls.education_group_year = TrainingFactory(academic_year=academic_year)
cls.person = CentralManagerFactory(
"delete_educationgroup",
"change_educationgroup",
"add_educationgroup",
"can_edit_education_group_administrative_data"
)
PersonEntityFactory(person=cls.person, entity=cls.education_group_year.management_entity)
cls.url = reverse('delete_education_group', args=[cls.education_group_year.id, cls.education_group_year.id])
cls.request = RequestFactory().get("")
def setUpTestData(cls):
cls.current_acy = create_current_academic_year()
cls.academic_years = GenerateAcademicYear(
cls.current_acy.year - LEARNING_UNIT_CREATION_SPAN_YEARS,
cls.current_acy.year +
LEARNING_UNIT_CREATION_SPAN_YEARS).academic_years
cls.academic_years[LEARNING_UNIT_CREATION_SPAN_YEARS] = cls.current_acy
cls.learning_unit_years = [
LearningUnitYearFactory(academic_year=acy)
for acy in cls.academic_years
]
cls.faculty_manager = FacultyManagerFactory()
cls.central_manager = CentralManagerFactory()
def setUpTestData(cls):
cls.education_group_year = EducationGroupYearFactory()
cls.group_element_year = GroupElementYearFactory(
parent=cls.education_group_year)
cls.person = CentralManagerFactory()
cls.person.user.user_permissions.add(
Permission.objects.get(codename="can_access_education_group"))
cls.url = reverse("education_groups_management")
cls.post_valid_data = {
"root_id": cls.education_group_year.id,
"element_id": cls.education_group_year.id,
"group_element_year_id": cls.group_element_year.id,
'action': 'detach',
}
def setUp(self):
self.learning_unit = LearningUnitFactory()
self.current_academic_year = create_current_academic_year()
self.next_academic_yr = AcademicYearFactory(
year=self.current_academic_year.year + 1)
self.lcy = LearningContainerYearFactory(
academic_year=self.current_academic_year,
container_type=learning_container_year_types.COURSE,
requirement_entity=EntityVersionFactory().entity)
self.central_manager = CentralManagerFactory()
self.luy = LearningUnitYearFactory(
learning_unit=self.learning_unit,
learning_container_year=self.lcy,
)
self.central_manager.linked_entities = [self.lcy.requirement_entity.id]
def test_can_modify_by_proposal_previous_n_year(self):
faculty_person = FacultyManagerFactory()
lcy = LearningContainerYearFactory(
academic_year=self.previous_academic_year,
container_type=learning_container_year_types.COURSE)
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.previous_academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_unit=LearningUnitFactory(),
learning_container_year=lcy)
self._modify_permission_assert(faculty_person, learning_unit_yr)
central_person = CentralManagerFactory()
self.assertFalse(
can_modify_by_proposal(learning_unit_yr, central_person, False))
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory()
cls.education_group_year = EducationGroupYearFactory(academic_year=cls.academic_year)
cls.group_element_year = GroupElementYearFactory(parent=cls.education_group_year,
child_branch__academic_year=cls.academic_year)
cls.person = CentralManagerFactory()
cls.person.user.user_permissions.add(Permission.objects.get(codename="can_access_education_group"))
cls.url = reverse(
"group_content",
kwargs={
"root_id": cls.education_group_year.id,
"education_group_year_id": cls.education_group_year.id
}
)
cls.post_valid_data = {'action': 'Generate pdf', 'language': LANGUAGE_CODE_EN}
def test_central_can_copy_into_future(self):
central_manager = CentralManagerFactory()
eg = EducationGroupFactory(end_year=AcademicYearFactory(
year=self.current_academic_year.year + 4))
egy = EducationGroupYearFactory(
education_group=eg,
academic_year__year=self.current_academic_year.year + 2)
GroupElementYearFactory(parent=egy,
child_branch__academic_year=egy.academic_year,
child_branch__education_group__end_year=None)
EducationGroupYearFactory(
education_group=eg,
academic_year__year=self.current_academic_year.year + 3)
self.postponer = PostponeContent(egy, central_manager)
self.assertIsNone(self.postponer.check_instance(central_manager))
def test_can_modify_by_proposal_n_year_plus_one(self):
faculty_person = FacultyManagerFactory()
lcy = LearningContainerYearFactory(
academic_year=self.next_academic_yr,
container_type=learning_container_year_types.COURSE)
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.next_academic_yr,
subtype=learning_unit_year_subtypes.FULL,
learning_unit=LearningUnitFactory(),
learning_container_year=lcy)
self.assertTrue(
can_modify_by_proposal(learning_unit_yr, faculty_person, True))
central_person = CentralManagerFactory()
self.assertTrue(
can_modify_by_proposal(learning_unit_yr, central_person, True))
def test_academic_year_range_creation_proposal_central_manager(self):
LanguageFactory(code="FR")
central_manager = CentralManagerFactory()
form = learning_unit_create_2.FullForm(
central_manager,
self.learning_unit_year.academic_year,
start_year=self.learning_unit_year.academic_year,
proposal_type=ProposalType.CREATION.name
)
self.assertCountEqual(
list(form.fields['academic_year'].queryset),
list(academic_year_mdl.find_academic_years(
start_year=self.current_academic_year.year,
end_year=self.current_academic_year.year + 6
))
)
def setUpTestData(cls):
# Common offer must exist
cls.academic_year = create_current_academic_year()
EducationGroupYearCommonFactory(academic_year=cls.academic_year)
cls.training = EducationGroupYearMasterFactory(
academic_year=cls.academic_year,
)
cls.publication_contact = EducationGroupPublicationContactFactory(
education_group_year=cls.training,
type=PublicationContactType.ACADEMIC_RESPONSIBLE.name
)
# Create a central manager and linked it to entity of training
cls.person = CentralManagerFactory("change_educationgroup", "can_access_education_group")
PersonEntityFactory(person=cls.person, entity=cls.training.management_entity)
