def test_main_programmanager_update(self):
offer_year1 = OfferYearFactory(academic_year=self.academic_year_current)
offer_year2 = OfferYearFactory(academic_year=self.academic_year_current)
pgm1 = ProgramManagerFactory(person=self.person, offer_year=offer_year1, is_main=False)
pgm2 = ProgramManagerFactory(person=self.person, offer_year=offer_year2, is_main=False)
self.client.post(
reverse('update_main_person', args=[self.person.pk]) + "?offer_year={},{}".format(
offer_year1.pk,
offer_year2.pk
), data={'is_main': 'true'}
)
pgm1.refresh_from_db()
pgm2.refresh_from_db()
self.assertTrue(pgm1.is_main)
self.assertTrue(pgm2.is_main)
self.client.post(
reverse('update_main', args=[pgm1.pk]) + "?offer_year={},{}".format(
offer_year1.pk,
offer_year2.pk
), data={'is_main': 'false'}
)
pgm1.refresh_from_db()
pgm2.refresh_from_db()
self.assertFalse(pgm1.is_main)
self.assertTrue(pgm2.is_main)
def setUp(self):
self.user = User.objects.create_user(username='******',
password='******')
self.person = PersonFactory(user=self.user)
add_permission(self.user, "can_access_scoreencoding")
self.client.force_login(self.user)
# Set user as program manager of two offer
academic_year = _get_academic_year(2017)
self.offer_year_bio2ma = OfferYearFactory(acronym="BIO2MA",
title="Master en Biologie",
academic_year=academic_year)
self.offer_year_bio2bac = OfferYearFactory(
acronym="BIO2BAC",
title="Bachelier en Biologie",
academic_year=academic_year)
ProgramManagerFactory(offer_year=self.offer_year_bio2ma,
person=self.person)
ProgramManagerFactory(offer_year=self.offer_year_bio2bac,
person=self.person)
# Create an score submission event - with an session exam
academic_calendar = AcademicCalendarFactory(
title="Submission of score encoding - 1",
academic_year=academic_year,
start_date=academic_year.start_date,
end_date=academic_year.end_date,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
academic_calendar.save()
self.session_exam_calendar = SessionExamCalendarFactory(
academic_calendar=academic_calendar,
number_session=number_session.ONE)
# Offer : BIO2MA - 2 Learning unit with exam
self.offer_year_calendar_bio2ma = OfferYearCalendarFactory(
offer_year=self.offer_year_bio2ma,
academic_calendar=academic_calendar)
self.learning_unit_year = LearningUnitYearFactory(
academic_year=academic_year)
self.learning_unit_year_2 = LearningUnitYearFactory(
academic_year=academic_year)
self.first_session_exam = test_session_exam.create_session_exam(
number_session.ONE, self.learning_unit_year,
self.offer_year_bio2ma)
self.first_session_exam_2 = test_session_exam.create_session_exam(
number_session.ONE, self.learning_unit_year_2,
self.offer_year_bio2ma)
# Offer: BIO2BAC - 1 learning unit with exam
self.offer_year_calendar_bio2bac = OfferYearCalendarFactory(
offer_year=self.offer_year_bio2ma,
academic_calendar=academic_calendar)
self.learning_unit_year_3 = LearningUnitYearFactory(
academic_year=academic_year)
self.first_session_exam_3 = test_session_exam.create_session_exam(
number_session.ONE, self.learning_unit_year_3,
self.offer_year_bio2bac)
self._create_context_exam_enrollment()
def test_return_sorted_managers(self):
ProgramManagerFactory(offer_year=self.offer_year,
person=PersonFactory(first_name="Yannick",
last_name="Leblanc"))
ProgramManagerFactory(offer_year=self.offer_year,
person=PersonFactory(first_name="Yannick",
last_name="Ferreira"))
ProgramManagerFactory(offer_year=self.offer_year,
person=PersonFactory(first_name="Laura",
last_name="Ferreira"))
ProgramManagerFactory(offer_year=self.offer_year,
person=PersonFactory(first_name="Bob",
last_name="Uncle"))
ProgramManagerFactory(offer_year=self.offer_year,
person=PersonFactory(first_name="Laura",
last_name="Dupont"))
managers = program_manager.find_by_offer_year(self.offer_year)
self.assertEquals(managers[0].person.last_name, "Dupont")
self.assertEquals(managers[1].person.last_name, "Ferreira")
self.assertEquals(managers[1].person.first_name, "Laura")
self.assertEquals(managers[2].person.last_name, "Ferreira")
self.assertEquals(managers[2].person.first_name, "Yannick")
self.assertEquals(managers[3].person.last_name, "Leblanc")
self.assertEquals(managers[4].person.last_name, "Uncle")
def test_filter_by_person(self):
an_offer_type = OfferTypeFactory()
offer_year1 = OfferYearFactory(
academic_year=self.academic_year_current,
entity_management=self.structure_parent1,
offer_type=an_offer_type)
offer_year2 = OfferYearFactory(
academic_year=self.academic_year_current,
entity_management=self.structure_child1,
offer_type=an_offer_type)
ProgramManagerFactory(person=self.person, offer_year=offer_year1)
ProgramManagerFactory(person=self.person, offer_year=offer_year2)
offer_year_results = pgm_manager_administration._filter_by_person(
self.person, [self.structure_parent1, self.structure_child1],
self.academic_year_current, an_offer_type)
self.assertCountEqual(offer_year_results, [offer_year1, offer_year2])
offer_year_results = pgm_manager_administration._filter_by_person(
self.person, [self.structure_parent1], self.academic_year_current,
an_offer_type)
self.assertCountEqual(offer_year_results, [offer_year1])
offer_year_results = pgm_manager_administration._filter_by_person(
self.person, [], self.academic_year_current, an_offer_type)
self.assertCountEqual(offer_year_results, [offer_year1, offer_year2])
an_other_offer_type = OfferTypeFactory()
offer_year_results = pgm_manager_administration._filter_by_person(
self.person, [self.structure_parent1], self.academic_year_current,
an_other_offer_type)
self.assertCountEqual(offer_year_results, [])
def test_managed_programs(self):
offer_year_1 = OfferYearFactory()
offer_year_2 = OfferYearFactory()
ProgramManagerFactory(person=self.person_with_user, offer_year=offer_year_1)
ProgramManagerFactory(person=self.person_with_user, offer_year=offer_year_2)
managed_programs = self.person_with_user.get_managed_programs()
self.assertTrue(len(managed_programs) == 2)
self.assertTrue(offer_year_1 in managed_programs)
self.assertTrue(offer_year_2 in managed_programs)
def test_list_pgm_manager(self):
offer_year1 = OfferYearFactory(academic_year=self.academic_year_current)
offer_year2 = OfferYearFactory(academic_year=self.academic_year_current)
pgm1 = ProgramManagerFactory(person=self.person, offer_year=offer_year1)
pgm2 = ProgramManagerFactory(person=self.person, offer_year=offer_year2)
response = self.client.get(
reverse('manager_list'), data={'offer_year': [offer_year1.pk, offer_year2.pk]}
)
self.assertEqual(
response.context['by_person'], {self.person: [pgm1, pgm2]}
)
def setUp(self):
self.request_factory = RequestFactory()
academic_year = _get_academic_year(year=2017)
academic_calendar = AcademicCalendarFactory(
title="Submission of score encoding - 1",
start_date=academic_year.start_date,
end_date=academic_year.end_date,
academic_year=academic_year,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
SessionExamCalendarFactory(academic_calendar=academic_calendar,
number_session=number_session.ONE)
self.learning_unit_year = LearningUnitYearFactory(
academic_year=academic_year)
self.offer_year = test_offer_year.create_offer_year(
'SINF1BA', 'Bachelor in informatica', academic_year)
self.session_exam = test_session_exam.create_session_exam(
number_session.ONE, self.learning_unit_year, self.offer_year)
# Create enrollment related
self.enrollments = []
for index in range(0, 2):
offer_year = OfferYearFactory(academic_year=academic_year)
OfferYearCalendarFactory(academic_calendar=academic_calendar,
offer_year=offer_year)
offer_enrollment = test_offer_enrollment.create_offer_enrollment(
StudentFactory(), offer_year)
learning_unit_enrollment = test_learning_unit_enrollment.create_learning_unit_enrollment(
offer_enrollment=offer_enrollment,
learning_unit_year=self.learning_unit_year)
exam_enrollment = test_exam_enrollment.create_exam_enrollment(
self.session_exam, learning_unit_enrollment)
self.enrollments.append(exam_enrollment)
self.tutor = TutorFactory()
test_attribution.create_attribution(
tutor=self.tutor, learning_unit_year=self.learning_unit_year)
add_permission(self.tutor.person.user, "can_access_scoreencoding")
offer_year = self.enrollments[
0].learning_unit_enrollment.offer_enrollment.offer_year
self.program_manager_1 = ProgramManagerFactory(offer_year=offer_year)
add_permission(self.program_manager_1.person.user,
"can_access_scoreencoding")
offer_year = self.enrollments[
1].learning_unit_enrollment.offer_enrollment.offer_year
self.program_manager_2 = ProgramManagerFactory(offer_year=offer_year)
add_permission(self.program_manager_2.person.user,
"can_access_scoreencoding")
def test_pgm_manager_queried_by_academic_year(self):
a_management_entity = StructureFactory()
offer_year_previous_year = OfferYearFactory(academic_year=self.academic_year_previous,
entity_management=a_management_entity)
offer_year_current_year = OfferYearFactory(academic_year=self.academic_year_current,
entity_management=a_management_entity)
person_previous_year = PersonFactory()
person_current_year = PersonFactory()
ProgramManagerFactory(person=person_previous_year, offer_year=offer_year_previous_year)
ProgramManagerFactory(person=person_current_year, offer_year=offer_year_current_year)
self.assertEqual(len(pgm_manager_administration._get_entity_program_managers([{'root': a_management_entity}],
self.academic_year_current)), 1)
def setUp(self):
self.person = PersonFactory()
self.permission = Permission.objects.get(
codename='can_edit_education_group_administrative_data')
self.person.user.user_permissions.add(self.permission)
self.education_group_year = EducationGroupYearFactory()
self.program_manager = ProgramManagerFactory(
person=self.person,
education_group=self.education_group_year.education_group)
self.url = reverse('education_group_edit_administrative',
args=[self.education_group_year.id])
self.client.force_login(self.person.user)
def setUpTestData(cls):
group = ProgramManagerGroupFactory()
group.permissions.add(
Permission.objects.get(codename='view_scoresresponsible'))
group.permissions.add(
Permission.objects.get(codename='change_scoresresponsible'))
cls.academic_year = create_current_academic_year()
# FIXME: Old structure model [To remove]
cls.structure = structure.StructureFactory()
entities_hierarchy = create_entities_hierarchy()
cls.root_entity = entities_hierarchy.get('root_entity')
cls.learning_unit_year = LearningUnitYearFactory(
academic_year=cls.academic_year,
acronym="LBIR1210",
structure=cls.structure,
learning_container_year__academic_year=cls.academic_year,
learning_container_year__acronym="LBIR1210",
learning_container_year__requirement_entity=cls.root_entity,
)
cls.education_group_year = EducationGroupYearFactory(
academic_year=cls.academic_year,
administration_entity=cls.root_entity)
cls.program_manager = ProgramManagerFactory(
education_group=cls.education_group_year.education_group)
cls.program_manager.person.user.groups.add(group)
offer_enrollment = OfferEnrollmentFactory(
education_group_year=cls.education_group_year)
LearningUnitEnrollmentFactory(
offer_enrollment=offer_enrollment,
learning_unit_year=cls.learning_unit_year)
def create_test_pgm_manager(self):
egy = EducationGroupYearFactory(academic_year__current=True)
offer_year = OfferYearFactory(academic_year=egy.academic_year,
acronym=egy.acronym)
return ProgramManagerFactory(offer_year=offer_year,
education_group=egy.education_group,
person=self.person_foo)
def test_case_with_existing_program_manager(self):
pgm_mgr = ProgramManagerFactory(offer_year=self.offer_year)
self.assertQuerysetEqual(program_manager.find_by_offer_year(
self.offer_year), [pgm_mgr],
transform=lambda rec: rec)
self.assertEqual(
len(program_manager.find_by_offer_year(self.offer_year)), 1)
def test_offer_read(self,
mock_program_manager,
mock_render,
mock_decorators):
mock_decorators.login_required = lambda x: x
mock_decorators.permission_required = lambda *args, **kwargs: lambda func: func
today = datetime.date.today()
academic_year = AcademicYearFactory(start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
offer_year = OfferYearFactory(academic_year=academic_year)
academic_calendar = AcademicCalendarFactory(academic_year=academic_year)
offer_year_calendar = OfferYearCalendarFactory(offer_year=offer_year,
academic_calendar=academic_calendar)
ProgramManagerFactory(offer_year=offer_year)
request = mock.Mock(method='GET')
from base.views.offer import offer_read
offer_read(request, offer_year_calendar.id)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'offer/tab_identification.html')
def setUp(self):
Group.objects.get_or_create(name="tutors")
Group.objects.get_or_create(name="program_managers")
self.request_factory = RequestFactory()
data = generate_exam_enrollments(2017, with_different_offer=True)
self.academic_year = data["academic_year"]
self.session_exam_calendar = data["session_exam_calendar"]
self.learning_unit_year = data["learning_unit_year"]
self.enrollments = data["exam_enrollments"]
self.attribution = data["attribution"]
self.offer_years = data["offer_years"]
self.tutor = self.attribution.tutor
add_permission(self.tutor.person.user, "can_access_scoreencoding")
self.program_managers = [
ProgramManagerFactory(offer_year=self.offer_years[i])
for i in range(0, 2)
]
[
add_permission(self.program_managers[i].person.user,
"can_access_scoreencoding") for i in range(0, 2)
]
# Mock academic_year / session_exam_calendar in order to be decouple test from system time
self.mock_academic_year(
current_academic_year=self.academic_year,
starting_academic_year=self.academic_year,
)
self.mock_session_exam_calendar(
current_session_exam=self.session_exam_calendar)
def setUp(self):
self.program_manager_1 = ProgramManagerFactory()
# Add permission
user = self.program_manager_1.person.user
permission = Permission.objects.get(name='Can access student')
user.user_permissions.add(permission)
self.students_db = [StudentFactory() for i in range(10)]
def test_remove_pgm_manager_from_two_pgm(self):
self.client.force_login(self.user)
offer_year1 = OfferYearFactory(
academic_year=self.academic_year_current)
offer_year2 = OfferYearFactory(
academic_year=self.academic_year_current)
ProgramManagerFactory(person=self.person, offer_year=offer_year1)
ProgramManagerFactory(person=self.person, offer_year=offer_year2)
managers_count_before = len(
program_manager.ProgramManager.objects.all())
pgm_manager_administration.remove_program_mgr_from_offers(
[offer_year1, offer_year2], self.person)
managers_count_after = len(
program_manager.ProgramManager.objects.all())
self.assertEqual(managers_count_after, managers_count_before - 2)
def setUpTestData(cls):
cls.program_manager = ProgramManagerFactory(
person=PersonWithPermissionsFactory("can_access_student")
)
cls.students_db = StudentFactory.create_batch(10)
cls.url = reverse("students")
def test_find_by_education_group(self):
self.assertIsNone(program_manager.find_by_education_group(None))
an_education_group = EducationGroupFactory()
a_program_manager = ProgramManagerFactory(
education_group=an_education_group)
self.assertEquals(
list(program_manager.find_by_education_group(an_education_group)),
[a_program_manager])
def test_find_by_person_exclude_offer_list(self):
a_person = PersonFactory(first_name="Yannick", last_name="Leblanc")
previous_academic_year = AcademicYearFactory(
year=datetime.datetime.now().year - 1)
offer_yr_previous = OfferYearFactory(
academic_year=previous_academic_year)
ProgramManagerFactory(offer_year=offer_yr_previous, person=a_person)
offer_yr1 = OfferYearFactory(academic_year=self.academic_year)
offer_yr2 = OfferYearFactory(academic_year=self.academic_year)
ProgramManagerFactory(offer_year=offer_yr1, person=a_person)
ProgramManagerFactory(offer_year=offer_yr2, person=a_person)
self.assertEquals(
len(
program_manager.find_by_person_exclude_offer_list(
a_person, [offer_yr1], self.academic_year)), 1)
def test_is_program_manager_of_education_group(self):
user = UserFactory(username="******")
an_education_group = EducationGroupFactory()
ProgramManagerFactory(education_group=an_education_group,
person=PersonFactory(user=user))
self.assertTrue(
program_manager.is_program_manager(
user=user, education_group=an_education_group))
def test_is_already_program_manager(self):
offer_year1 = OfferYearFactory(
academic_year=self.academic_year_current,
entity_management=self.structure_parent1)
ProgramManagerFactory(person=self.person, offer_year=offer_year1)
self.assertTrue(
pgm_manager_administration.is_already_program_manager(
self.person, offer_year1))
def setUpTestData(cls):
cls.program_manager = ProgramManagerFactory(
person=PersonWithPermissionsFactory("can_access_student")
)
cls.student_m = StudentFactory(person=PersonFactory(last_name='Durant', first_name='Thomas', gender='M'))
cls.student_f = StudentFactory(person=PersonFactory(last_name='Durant', first_name='Alice', gender='F'))
cls.url = reverse("students")
def test_find_program_manager_by_entity_administration_fac(self):
a_management_entity = StructureFactory()
offer_yr = OfferYearFactory(academic_year=self.academic_year,
entity_management=a_management_entity)
ProgramManagerFactory(offer_year=offer_yr, person=PersonFactory())
self.assertEquals(
len(
program_manager.find_by_management_entity(
[a_management_entity], self.academic_year)), 1)
def test_can_user_edit_administartive_data_group_central_manager_no_entity_linked_but_program_manager(self):
"""
With permission + Group central manager + Linked to the parent entity (with_child FALSE) + IS
program manager ==> Allowed
"""
_add_to_group(self.user, CENTRAL_MANAGER_GROUP)
PersonEntityFactory(person=self.person, entity=self.root_entity, with_child=False)
ProgramManagerFactory(person=self.person, education_group=self.education_group_year.education_group)
self.assertTrue(can_user_edit_administrative_data(self.user, self.education_group_year))
def test_remove_pgm_manager(self):
offer_year1 = OfferYearFactory(academic_year=self.academic_year_current)
offer_year2 = OfferYearFactory(academic_year=self.academic_year_current)
pgm1 = ProgramManagerFactory(person=self.person, offer_year=offer_year1)
pgm2 = ProgramManagerFactory(person=self.person, offer_year=offer_year2)
response = self.client.get(
reverse('delete_manager', args=[pgm1.pk]) + "?offer_year={},{}".format(
offer_year1.pk,
offer_year2.pk
)
)
self.assertEqual(response.context['other_programs'].get(), pgm2)
self.client.post(
reverse('delete_manager', args=[pgm1.pk]) + "?offer_year={},{}".format(offer_year1.pk, offer_year2.pk)
)
self.assertFalse(ProgramManager.objects.filter(pk=pgm1.pk).exists())
self.assertTrue(ProgramManager.objects.filter(pk=pgm2.pk).exists())
def test_can_user_edit_administrative_data_with_permission_and_pgrm_manager(
self):
"""With permission and program manager of education group ==> Allowed"""
ProgramManagerFactory(
person=self.person,
education_group=self.education_group_year.education_group)
self.assertTrue(
can_user_edit_administrative_data(self.user,
self.education_group_year))
def test__get_all_offer_years_grouped_by_person(self):
offer_year1 = OfferYearFactory(
academic_year=self.academic_year_current,
entity_management=self.structure_parent1)
offer_year2 = OfferYearFactory(
academic_year=self.academic_year_current,
entity_management=self.structure_parent1)
person1 = PersonFactory(last_name='AAA')
person2 = PersonFactory(last_name='BBB')
ProgramManagerFactory(person=person1, offer_year=offer_year1)
ProgramManagerFactory(person=person2, offer_year=offer_year1)
ProgramManagerFactory(person=person2, offer_year=offer_year2)
data = pgm_manager_administration._get_all_offer_years_grouped_by_person(
[person1.id, person2.id])
self.assertEqual(len(data), 2)
self.assertEqual(len(data[person1.id]), 1)
self.assertEqual(len(data[person2.id]), 2)
def setUpClass(cls):
super().setUpClass()
cls.training = TrainingFactory(academic_year__year=2018)
cls.program_manager = ProgramManagerFactory(education_group=cls.training.education_group)
cls.context = {
'person': cls.program_manager.person,
'root': cls.training,
'education_group_year': cls.training,
}
cls.url = reverse('update_education_group', args=[cls.training.pk, cls.training.pk])
cls.request = RequestFactory().get("")
def test_delete_manager(self):
offer_year1 = OfferYearFactory(
academic_year=self.academic_year_current,
entity_management=self.structure_parent1)
ProgramManagerFactory(person=self.person, offer_year=offer_year1)
self.client.force_login(self.user)
a_person = PersonFactory(user=self.user)
EntityManagerFactory(person=a_person)
url = reverse('delete_manager')
response = self.client.get(url + "?person=%s&pgms=%s" %
(self.person.id, offer_year1.id))
self.assertEqual(response.status_code, 204)
def setUp(self):
self.academic_year = AcademicYearFactory(
year=datetime.date.today().year)
self.academic_calendar = AcademicCalendarFactory.build(
title="Submission of score encoding - 1",
start_date=self.academic_year.start_date,
end_date=self.academic_year.end_date,
academic_year=self.academic_year,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
self.academic_calendar.save(functions=[])
SessionExamCalendarFactory(academic_calendar=self.academic_calendar,
number_session=number_session.ONE)
# Offer year CHIM1BA
self.offer_year = OfferYearFactory(acronym="CHIM1BA",
academic_year=self.academic_year)
self.learning_unit_year = LearningUnitYearFactory(
acronym="LBIR1210", academic_year=self.academic_year)
self._create_context_exam_enrollments(self.learning_unit_year,
self.offer_year, 10, 3)
self.learning_unit_year_2 = LearningUnitYearFactory(
acronym="LBIR1211", academic_year=self.academic_year)
self._create_context_exam_enrollments(self.learning_unit_year_2,
self.offer_year, 5)
# Offer year DIR2BA
self.offer_year_2 = OfferYearFactory(acronym="DIR2BA",
academic_year=self.academic_year)
self._create_context_exam_enrollments(self.learning_unit_year,
self.offer_year_2, 8, 5)
self.program_manager = ProgramManagerFactory(
offer_year=self.offer_year)
ProgramManagerFactory(offer_year=self.offer_year_2,
person=self.program_manager.person)
# Tutor [Tom Dupont] have an attribution to LBIR1210
person = PersonFactory(last_name="Dupont", first_name="Thierry")
self.tutor = TutorFactory(person=person)
test_attribution.create_attribution(
tutor=self.tutor,
learning_unit_year=self.learning_unit_year,
score_responsible=True)
def test_add_program_managers(self):
offer_year1 = OfferYearFactory(
academic_year=self.academic_year_current,
entity_management=self.structure_parent1)
offer_year2 = OfferYearFactory(
academic_year=self.academic_year_current,
entity_management=self.structure_parent1)
ProgramManagerFactory(person=self.person, offer_year=offer_year1)
self.assertEqual(
len(
pgm_manager_administration.add_program_managers(
[offer_year1, offer_year2], self.person)), 1)
