def test_faculty_manager_is_not_eligible_to_add_training(self):
result = _is_eligible_to_add_education_group_with_category(
FacultyManagerFactory(),
random.choice([EducationGroupYearFactory(), None]),
Categories.TRAINING,
raise_exception=False)
self.assertFalse(result)
def test_is_faculty_manager_eligible(self):
faculty_manager = FacultyManagerFactory()
for education_group_year in [self.training, self.common_bachelor]:
perm = GeneralInformationPerms(faculty_manager.user,
education_group_year)
self.assertTrue(perm._is_faculty_manager_eligible())
def setUpTestData(cls):
today = datetime.date.today()
FacultyManagerGroupFactory()
cls.faculty_user = factory_user.UserFactory()
cls.faculty_person = FacultyManagerFactory('can_propose_learningunit',
'can_create_learningunit',
user=cls.faculty_user)
cls.super_user = factory_user.SuperUserFactory()
cls.person = factory_person.CentralManagerFactory(user=cls.super_user)
start_year = AcademicYearFactory(year=get_current_year())
end_year = AcademicYearFactory(year=get_current_year() + 7)
cls.academic_years = GenerateAcademicYear(start_year,
end_year).academic_years
cls.current_academic_year = cls.academic_years[0]
cls.next_academic_year = cls.academic_years[1]
generate_creation_or_end_date_proposal_calendars(cls.academic_years)
cls.language = LanguageFactory(code='FR')
cls.organization = organization_factory.OrganizationFactory(
type=organization_type.MAIN)
cls.campus = campus_factory.CampusFactory(
organization=cls.organization, is_administration=True)
cls.entity = EntityFactory(organization=cls.organization)
cls.entity_version = EntityVersionFactory(
entity=cls.entity,
entity_type=entity_type.FACULTY,
start_date=today.replace(year=1900),
end_date=None)
PersonEntityFactory(person=cls.faculty_person, entity=cls.entity)
PersonEntityFactory(person=cls.person, entity=cls.entity)
def test_li_edit_lu_year_non_editable_for_faculty_manager(self):
faculty_manager = FacultyManagerFactory()
self.context["learning_unit_year"] = self.previous_learning_unit_year
self.context["user"] = faculty_manager.user
result = li_edit_lu(self.context, self.url_edit, "")
self.assertEqual(
result, {
'load_modal':
False,
'id_li':
ID_LINK_EDIT_LU,
'url':
"#",
'title':
"{}. {}".format(
"You can't modify learning unit under year : %(year)d" %
{"year": settings.YEAR_LIMIT_LUE_MODIFICATION},
"Modifications should be made in EPC for year %(year)d" % {
"year":
self.previous_learning_unit_year.academic_year.year
}),
'class_li':
DISABLED,
'text':
"",
'data_target':
""
})
def test_learning_unit_with_faculty_manager_when_cannot_edit_end_date(
self):
learning_container_year = LearningContainerYearFactory(
academic_year=self.current_academic_year,
container_type=learning_container_year_types.COURSE,
requirement_entity=EntityFactory(),
)
learning_unit_year = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=learning_container_year,
subtype=learning_unit_year_subtypes.FULL)
EntityVersionFactory(entity=learning_container_year.requirement_entity)
learning_unit_year.learning_unit.end_year = None
learning_unit_year.learning_unit.save()
managers = [
FacultyManagerFactory('can_access_learningunit'),
]
for manager in managers:
PersonEntityFactory(
entity=learning_container_year.requirement_entity,
person=manager)
url = reverse("learning_unit", args=[learning_unit_year.id])
self.client.force_login(manager.user)
response = self.client.get(url)
self.assertEqual(response.context["can_edit_date"], False)
def setUpTestData(cls):
cls.person_fac = FacultyManagerFactory()
cls.academic_yr = create_current_academic_year()
cls.academic_yr_1 = AcademicYearFactory.build(
year=cls.academic_yr.year + 1)
super(AcademicYear, cls.academic_yr_1).save()
cls.academic_yr_2 = AcademicYearFactory.build(
year=cls.academic_yr.year + 2)
super(AcademicYear, cls.academic_yr_2).save()
cls.academic_yr_6 = AcademicYearFactory.build(
year=cls.academic_yr.year + 6)
super(AcademicYear, cls.academic_yr_6).save()
previous_academic_yr = AcademicYearFactory.build(
year=cls.academic_yr.year - 1)
super(AcademicYear, previous_academic_yr).save()
cls.lunit_container_yr = LearningContainerYearFactory(
academic_year=cls.academic_yr)
cls.luy = LearningUnitYearFactory(
academic_year=cls.academic_yr,
learning_container_year=cls.lunit_container_yr,
subtype=FULL,
learning_unit=LearningUnitFactory(
start_year=create_past_academic_year(),
end_year=cls.academic_yr))
academic_years = [
cls.academic_yr, cls.academic_yr_1, cls.academic_yr_2
]
generate_learning_unit_edition_calendars(academic_years)
def setUpTestData(cls):
now = datetime.datetime.now()
cls.academic_year = create_current_academic_year()
cls.previous_academic_year = GenerateAcademicYear(
cls.academic_year.year - 1,
cls.academic_year.year - 1).academic_years[0]
AcademicCalendarFactory(
academic_year=cls.previous_academic_year,
start_date=now - datetime.timedelta(days=5),
end_date=now + datetime.timedelta(days=15),
reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION)
cls.requirement_entity_version = EntityVersionFactory(
entity__organization__type=organization_type.MAIN,
start_date=now,
end_date=datetime.datetime(now.year + 1, 9, 15),
entity_type=entity_type.INSTITUTE)
cls.learning_unit_year = LearningUnitYearFactory(
acronym="LBIR1100",
academic_year=cls.academic_year,
learning_container_year__academic_year=cls.academic_year,
learning_container_year__acronym="LBIR1100",
learning_container_year__requirement_entity=cls.
requirement_entity_version.entity)
cls.url = reverse('learning_units_summary')
cls.faculty_person = FacultyManagerFactory(
'can_access_learningunit', 'can_edit_learningunit_pedagogy')
PersonEntityFactory(person=cls.faculty_person,
entity=cls.requirement_entity_version.entity)
def test_raise_permission_denied_if_person_is_faculty_manager_and_period_closed(self):
CloseAcademicCalendarFactory(reference=EDUCATION_GROUP_EDITION, academic_year=self.previous_acy)
person_entity = PersonEntityFactory(entity=self.group_element_year.parent.management_entity,
person=FacultyManagerFactory())
with self.assertRaises(PermissionDenied):
can_update_group_element_year(person_entity.person.user, self.group_element_year)
def setUp(self):
current_ac = create_current_academic_year()
self.education_group_year = TrainingFactory(academic_year=current_ac)
self.person = FacultyManagerFactory("delete_educationgroup",
"change_educationgroup",
"add_educationgroup")
PersonEntityFactory(person=self.person,
entity=self.education_group_year.management_entity)
# Create an academic calendar in order to check permission [Faculty can modify when period is opened]
self.academic_calendar = AcademicCalendarFactory(
reference=EDUCATION_GROUP_EDITION,
start_date=timezone.now(),
end_date=timezone.now() + timedelta(weeks=+1),
academic_year=current_ac,
)
self.client.force_login(user=self.person.user)
self.url = reverse(
'delete_education_group',
args=[self.education_group_year.id, self.education_group_year.id])
self.context = {
"person": self.person,
"root": self.education_group_year,
"education_group_year": self.education_group_year,
"request": RequestFactory().get("")
}
def setUpTestData(cls):
now = datetime.datetime.now()
cls.academic_year = create_current_academic_year()
cls.previous_academic_year = GenerateAcademicYear(
cls.academic_year.year - 1,
cls.academic_year.year - 1).academic_years[0]
AcademicCalendarFactory(
academic_year=cls.previous_academic_year,
start_date=now - datetime.timedelta(days=5),
end_date=now + datetime.timedelta(days=15),
reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION)
cls.requirement_entity_version = EntityVersionFactory(
entity__organization__type=organization_type.MAIN,
start_date=now,
end_date=datetime.datetime(now.year + 1, 9, 15),
entity_type=entity_type.INSTITUTE)
cls.url = reverse('learning_units_summary')
cls.faculty_person = FacultyManagerFactory(
'can_access_learningunit', 'can_edit_learningunit_pedagogy')
PersonEntityFactory(person=cls.faculty_person,
entity=cls.requirement_entity_version.entity)
# Generate data for XLS export
cls.learning_unit_year_with_mandatory_teaching_materials = LearningUnitYearFactory(
acronym="LBIR1100",
academic_year=cls.academic_year,
learning_container_year__academic_year=cls.academic_year,
learning_container_year__acronym="LBIR1100",
learning_container_year__requirement_entity=cls.
requirement_entity_version.entity)
TeachingMaterialFactory(
learning_unit_year=cls.
learning_unit_year_with_mandatory_teaching_materials,
title="Magic wand",
mandatory=True,
)
TeachingMaterialFactory(
learning_unit_year=cls.
learning_unit_year_with_mandatory_teaching_materials,
title="Broomsticks",
mandatory=False,
)
cls.learning_unit_year_without_mandatory_teaching_materials = LearningUnitYearFactory(
acronym="LDROI1600",
academic_year=cls.academic_year,
learning_container_year__academic_year=cls.academic_year,
learning_container_year__acronym="LDROI1600",
learning_container_year__requirement_entity=cls.
requirement_entity_version.entity)
TeachingMaterialFactory(
learning_unit_year=cls.
learning_unit_year_without_mandatory_teaching_materials,
title="cauldron",
mandatory=False,
)
def test_faculty_manager_is_eligible_to_add_groups_in_tree_of_offer_of_its_entity(
self):
result = _is_eligible_to_add_education_group_with_category(
FacultyManagerFactory(),
EducationGroupYearFactory(),
Categories.GROUP,
raise_exception=False)
self.assertTrue(result)
def test_faculty_manager_is_not_eligible_to_add_groups_in_search_page(
self):
result = _is_eligible_to_add_education_group_with_category(
FacultyManagerFactory(),
None,
Categories.GROUP,
raise_exception=False)
self.assertFalse(result)
def test_is_eligible_case_user_is_faculty_manager(self, mock_is_faculty_eligible, mock_user_have_perm,
mock_super_is_eligible):
faculty_manager = FacultyManagerFactory()
perm = AdmissionConditionPerms(faculty_manager.user, self.common_bachelor)
perm._is_eligible()
self.assertTrue(mock_super_is_eligible.called)
self.assertTrue(mock_is_faculty_eligible.called)
def test_is_eligible_to_modify_by_proposal(self, mock_perm):
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.next_academic_yr,
subtype=learning_unit_year_subtypes.FULL,
learning_container_year=self.lcy)
person_faculty_manager = FacultyManagerFactory()
self.assertTrue(
is_eligible_to_modify_by_proposal(learning_unit_yr,
person_faculty_manager, True))
def test_li_edit_date_person_test_is_eligible_to_modify_end_date_based_on_container_type(
self):
lu = LearningUnitFactory(existing_proposal_in_epc=False)
learning_unit_year_without_proposal = LearningUnitYearFactory(
academic_year=self.academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_unit=lu,
learning_container_year=self.lcy)
person_faculty_manager = FacultyManagerFactory()
PersonEntityFactory(person=person_faculty_manager,
entity=self.entity_container_yr.entity)
self.context['user'] = person_faculty_manager.user
self.context[
'learning_unit_year'] = learning_unit_year_without_proposal
result = li_edit_date_lu(self.context, self.url_edit, "")
self.assertEqual(
result,
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
MSG_NO_ELIGIBLE_TO_MODIFY_END_DATE))
# allowed if _is_person_central_manager or
# _is_learning_unit_year_a_partim or
# negation(_is_container_type_course_dissertation_or_internship),
# test 1st condition true
self.context['user'] = self.central_manager_person.user
result = li_edit_date_lu(self.context, self.url_edit, "")
self.assertEqual(
result,
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
url=self.url_edit))
# test 2nd condition true
self.context['user'] = person_faculty_manager.user
learning_unit_year_without_proposal.subtype = learning_unit_year_subtypes.PARTIM
learning_unit_year_without_proposal.save()
self.context[
'learning_unit_year'] = learning_unit_year_without_proposal
self.assertEqual(
li_edit_date_lu(self.context, self.url_edit, ""),
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
url=self.url_edit))
# test 3rd condition true
learning_unit_year_without_proposal.learning_container_year.container_type = learning_container_year_types.OTHER_COLLECTIVE
learning_unit_year_without_proposal.learning_container_year.save()
learning_unit_year_without_proposal.subtype = learning_unit_year_subtypes.FULL
learning_unit_year_without_proposal.save()
self.context[
'learning_unit_year'] = learning_unit_year_without_proposal
self.assertEqual(
li_edit_date_lu(self.context, self.url_edit, ""),
self._get_result_data_expected(ID_LINK_EDIT_DATE_LU,
url=self.url_edit))
def setUpTestData(cls):
cls.current_academic_year = create_current_academic_year()
cls.faculty_person = FacultyManagerFactory()
cls.learning_unit_year = LearningUnitYearFactory(
academic_year=cls.current_academic_year,
learning_container_year__academic_year=cls.current_academic_year,
subtype=FULL
)
cls.url = reverse('learning_unit_pedagogy_toggle_summary_locked',
kwargs={'learning_unit_year_id': cls.learning_unit_year.pk})
def test_is_faculty_manager_case_cannot_modify_data_in_past(self):
previous_year = self.current_academic_year.year - 1
training_in_past = TrainingFactory(academic_year__year=previous_year)
common_in_past = EducationGroupYearCommonBachelorFactory(academic_year__year=previous_year)
faculty_manager = FacultyManagerFactory()
for education_group_year in [training_in_past, common_in_past]:
perm = AdmissionConditionPerms(faculty_manager.user, education_group_year)
with self.assertRaises(PermissionDenied):
perm._is_faculty_manager_eligible()
def test_faculty_mgr_can_not_modify_end_year_by_proposal_n_year(self):
faculty_person = FacultyManagerFactory()
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._assert_no_permission_end_year(faculty_person, learning_unit_yr)
def step_impl(context: Context):
context.user = FacultyManagerFactory(
user__username="******",
user__first_name="Keyser",
user__last_name="Söze",
user__password="******").user
page = LoginPage(driver=context.browser,
base_url=context.get_url('/login/')).open()
page.login("usual_suspect", 'Roger_Verbal_Kint')
context.test.assertEqual(context.browser.current_url, context.get_url('/'))
def test_not_is_eligible_to_modify_by_proposal(self, mock_perm):
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.current_academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_container_year=self.lcy)
person_faculty_manager = FacultyManagerFactory()
with self.assertRaises(PermissionDenied) as perm_ex:
is_eligible_to_modify_by_proposal(learning_unit_yr,
person_faculty_manager, True)
self.assertEqual('{}'.format(perm_ex.exception),
MSG_NOT_ELIGIBLE_TO_PUT_IN_PROPOSAL_ON_THIS_YEAR)
def setUpTestData(cls):
cls.current_acy, cls.previous_acy = AcademicYearFactory.produce_in_past(
from_year=2019, quantity=2)
cls.group_element_year = GroupElementYearFactory(
parent=TrainingFactory(academic_year=cls.current_acy),
child_branch=MiniTrainingFactory(academic_year=cls.current_acy),
)
cls.faculty_manager = FacultyManagerFactory()
cls.faculty_manager.user.user_permissions.add(
Permission.objects.get(codename="change_educationgroup"))
PersonEntityFactory(
entity=cls.group_element_year.parent.management_entity,
person=cls.faculty_manager)
def test_is_eligible_to_modify_end_year_by_proposal(self, mock_perm):
lu = LearningUnitFactory(existing_proposal_in_epc=False)
learning_unit_yr = LearningUnitYearFactory(
academic_year=self.next_academic_yr,
subtype=learning_unit_year_subtypes.FULL,
learning_unit=lu,
learning_container_year=self.lcy)
ProposalLearningUnitFactory(learning_unit_year=learning_unit_yr)
person_faculty_manager = FacultyManagerFactory()
self.assertTrue(
is_eligible_to_modify_end_year_by_proposal(learning_unit_yr,
person_faculty_manager,
True))
def test_li_edit_proposal_as_faculty_manager(self):
person_faculty_manager = FacultyManagerFactory()
self.context['user'] = person_faculty_manager.user
self.context['proposal'] = self.proposal
self.context['learning_unit_year'] = self.proposal.learning_unit_year
result = li_edit_proposal(self.context, self.url_edit, "")
self.assertEqual(
result,
self._get_result_data_expected_for_proposal(
'link_proposal_edit', MSG_CAN_EDIT_PROPOSAL_NO_LINK_TO_ENTITY,
DISABLED))
faculty_manager_person = FacultyManagerFactory()
PersonEntityFactory(person=faculty_manager_person,
entity=self.requirement_entity)
self.context['user'] = faculty_manager_person.user
self.context['person'] = faculty_manager_person
self.proposal.state = ProposalState.CENTRAL.name
self.proposal.save()
self.context['proposal'] = self.proposal
result = li_edit_proposal(self.context, self.url_edit, "")
self.assertEqual(
result,
self._get_result_data_expected_for_proposal(
'link_proposal_edit', MSG_NOT_PROPOSAL_STATE_FACULTY,
DISABLED))
self.proposal.state = ProposalState.FACULTY.name
self.proposal.save()
self.context['proposal'] = self.proposal
result = li_edit_proposal(self.context, self.url_edit, "")
self.assertEqual(
result,
self._get_result_data_expected_for_proposal(
'link_proposal_edit', MSG_NOT_ELIGIBLE_TO_EDIT_PROPOSAL,
DISABLED))
def setUpTestData(cls):
cls.current_acy, cls.previous_acy = AcademicYearFactory.produce_in_past(
from_year=2019, quantity=2)
cls.group_element_year = GroupElementYearFactory(
parent=TrainingFactory(academic_year=cls.current_acy),
child_branch=MiniTrainingFactory(
academic_year=cls.current_acy,
education_group_type__name=MiniTrainingType.DEEPENING.name),
)
cls.faculty_manager = FacultyManagerFactory(
'change_educationgroup', 'change_educationgroupcontent')
PersonEntityFactory(
entity=cls.group_element_year.parent.management_entity,
person=cls.faculty_manager)
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 test_can_modify_by_proposal_n_year(self):
faculty_person = FacultyManagerFactory()
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._modify_permission_assert(faculty_person, learning_unit_yr)
central_person = CentralManagerFactory()
self.assertTrue(
can_modify_by_proposal(learning_unit_yr, central_person, True))
def test_raise_permission_denied_when_minor_or_major_list_choice_and_person_is_faculty_manager(self):
OpenAcademicCalendarFactory(reference=EDUCATION_GROUP_EDITION, academic_year=self.previous_acy)
egys = [
GroupFactory(education_group_type__name=GroupType.MINOR_LIST_CHOICE.name, academic_year=self.current_acy),
GroupFactory(education_group_type__name=GroupType.MAJOR_LIST_CHOICE.name, academic_year=self.current_acy)
]
person_entity = PersonEntityFactory(entity=self.group_element_year.parent.management_entity,
person=FacultyManagerFactory())
for egy in egys:
with self.subTest(type=egy.education_group_type):
with self.assertRaises(PermissionDenied):
group_element_year = GroupElementYearFactory(parent=self.group_element_year.parent,
child_branch=egy)
can_update_group_element_year(person_entity.person.user, group_element_year)
def test_faculty_cannot_copy_into_future(self):
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)
EducationGroupYearFactory(
education_group=eg,
academic_year__year=self.current_academic_year.year + 3)
with self.assertRaises(
NotPostponeError,
msg=
_('You are not allowed to postpone this training in the future.'
)):
self.postponer = PostponeContent(egy, FacultyManagerFactory())
def test_academic_year_range_creation_proposal_faculty_manager(self):
LanguageFactory(code="FR")
faculty_manager = FacultyManagerFactory()
form = learning_unit_create_2.FullForm(
faculty_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 + 1,
end_year=self.current_academic_year.year + 6
))
)
def setUpTestData(cls):
academic_year = AcademicYearFactory(year=2020)
cls.education_group_year = TrainingFactory(academic_year=academic_year)
cls.person = FacultyManagerFactory("delete_educationgroup", "change_educationgroup", "add_educationgroup")
PersonEntityFactory(person=cls.person, entity=cls.education_group_year.management_entity)
# Create an academic calendar in order to check permission [Faculty can modify when period is opened]
cls.academic_calendar = AcademicCalendarFactory(
reference=EDUCATION_GROUP_EDITION,
start_date=timezone.now(),
end_date=timezone.now() + timedelta(weeks=+1),
academic_year=academic_year,
data_year=academic_year,
)
cls.url = reverse('delete_education_group', args=[cls.education_group_year.id, cls.education_group_year.id])