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_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_adviser_can_manage_dissertation(self):
manager = AdviserManagerFactory()
manager2 = AdviserManagerFactory()
a_person_teacher = PersonFactory.create(first_name='Pierre', last_name='Dupont')
a_person_teacher2 = PersonFactory.create(first_name='Marco', last_name='Millet')
teacher = AdviserTeacherFactory(person=a_person_teacher)
teacher2 = AdviserTeacherFactory(person=a_person_teacher2)
a_person_student = PersonFactory.create(last_name="Durant", user=None)
student = StudentFactory.create(person=a_person_student)
offer_year_start = OfferYearFactory(academic_year=self.academic_year1, acronym="test_offer2")
offer_year_start2 = OfferYearFactory(acronym="test_offer3", academic_year=offer_year_start.academic_year)
offer = offer_year_start.offer
offer2 = offer_year_start2.offer
FacultyAdviserFactory(adviser=manager, offer=offer)
create_faculty_adviser(manager, offer)
create_faculty_adviser(manager2, offer2)
proposition_dissertation = PropositionDissertationFactory(author=teacher,
creator=a_person_teacher,
title='Proposition1')
dissertation = DissertationFactory(author=student,
title='Dissertation 2017',
offer_year_start=offer_year_start,
proposition_dissertation=proposition_dissertation,
status='DIR_SUBMIT',
active=True,
dissertation_role__adviser=teacher,
dissertation_role__status='PROMOTEUR')
self.assertEqual(adviser_can_manage(dissertation, manager), True)
self.assertEqual(adviser_can_manage(dissertation, manager2), False)
self.assertEqual(adviser_can_manage(dissertation, teacher), False)
def setUp(self):
self.maxDiff = None
self.manager = AdviserManagerFactory()
a_person_teacher = PersonFactory.create(
first_name='Pierre',
last_name='Dupont',
email='*****@*****.**')
self.teacher = AdviserTeacherFactory(person=a_person_teacher)
a_person_teacher2 = PersonFactory.create(
first_name='Marco',
last_name='Millet',
email='*****@*****.**')
self.teacher2 = AdviserTeacherFactory(person=a_person_teacher2)
self.teacher3 = AdviserTeacherFactory()
self.teacher4 = AdviserTeacherFactory()
a_person_student = PersonFactory.create(
last_name="Durant",
user=None,
email='*****@*****.**')
self.student = StudentFactory.create(person=a_person_student)
self.offer1 = OfferFactory(title="test_offer1")
self.offer2 = OfferFactory(title="test_offer2")
self.academic_year1 = AcademicYearFactory()
self.academic_year2 = AcademicYearFactory(
year=self.academic_year1.year - 1)
self.offer_year_start1 = OfferYearFactory(
acronym="test_offer1",
offer=self.offer1,
academic_year=self.academic_year1)
self.offer_year_start2 = OfferYearFactory(
acronym="test_offer2",
offer=self.offer2,
academic_year=self.academic_year1)
self.offer_proposition1 = OfferPropositionFactory(
offer=self.offer1,
global_email_to_commission=True,
evaluation_first_year=True)
self.offer_proposition2 = OfferPropositionFactory(
offer=self.offer2, global_email_to_commission=False)
self.proposition_dissertation = PropositionDissertationFactory(
author=self.teacher,
creator=a_person_teacher,
title='Proposition 1212121')
FacultyAdviserFactory(adviser=self.manager, offer=self.offer1)
self.dissertation1 = DissertationFactory(
author=self.student,
title='Dissertation_test_email',
offer_year_start=self.offer_year_start1,
proposition_dissertation=self.proposition_dissertation,
status='DIR_SUBMIT',
active=True,
dissertation_role__adviser=self.teacher,
dissertation_role__status='PROMOTEUR')
DissertationRoleFactory(adviser=self.teacher2,
status='CO_PROMOTEUR',
dissertation=self.dissertation1)
DissertationRoleFactory(adviser=self.teacher3,
status='READER',
dissertation=self.dissertation1)
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 setUpTestData(cls):
cls.person = PersonFactory()
cls.offer_year_without_equivalent_education_group_year = OfferYearFactory(
corresponding_education_group_year=None)
acronym = "Acronym"
cls.education_group_year = EducationGroupYearFactory(acronym=acronym)
cls.offer_year = OfferYearFactory(
acronym=acronym,
corresponding_education_group_year=cls.education_group_year)
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)
self.client.post(
reverse("create_manager_person") + "?offer_year={},{}".format(offer_year1.pk, offer_year2.pk),
data={'person': self.person.pk}
)
self.assertEqual(ProgramManager.objects.filter(person=self.person).count(), 2)
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 test_add_pgm_manager_to_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)
list_offer_id = [offer_year1, offer_year2]
pgm_manager_administration.add_program_managers(
list_offer_id, self.person)
managers = program_manager.find_by_offer_year_list(
[offer_year1, offer_year2])
self.assertEqual(len(managers), 2)
def setUp(self):
academic_year = AcademicYearFactory()
self.education_group_type_training = EducationGroupTypeFactory(
category=education_group_categories.TRAINING)
self.education_group_type_minitraining = EducationGroupTypeFactory(
category=education_group_categories.MINI_TRAINING)
self.education_group_type_group = EducationGroupTypeFactory(
category=education_group_categories.GROUP)
self.education_group_year_1 = EducationGroupYearFactory(
academic_year=academic_year,
education_group_type=self.education_group_type_training)
self.education_group_year_2 = EducationGroupYearFactory(
academic_year=academic_year,
education_group_type=self.education_group_type_minitraining)
self.education_group_year_3 = EducationGroupYearFactory(
academic_year=academic_year,
education_group_type=self.education_group_type_training)
self.education_group_year_4 = EducationGroupYearFactory(
academic_year=academic_year,
education_group_type=self.education_group_type_group)
self.education_group_year_5 = EducationGroupYearFactory(
academic_year=academic_year,
education_group_type=self.education_group_type_group)
self.offer_year_2 = OfferYearFactory(academic_year=academic_year)
self.offer_year_domain = OfferYearDomainFactory(
offer_year=self.offer_year_2,
education_group_year=self.education_group_year_2)
self.offer_year_entity_admin = OfferYearEntityFactory(
offer_year=self.offer_year_2,
education_group_year=self.education_group_year_2,
type=offer_year_entity_type.ENTITY_ADMINISTRATION)
self.entity_version_admin = EntityVersionFactory(
entity=self.offer_year_entity_admin.entity, parent=None)
self.offer_year_3 = OfferYearFactory(academic_year=academic_year)
self.offer_year_entity_management = OfferYearEntityFactory(
offer_year=self.offer_year_3,
education_group_year=self.education_group_year_3,
type=offer_year_entity_type.ENTITY_MANAGEMENT)
self.entity_version_management = EntityVersionFactory(
entity=self.offer_year_entity_management.entity, parent=None)
self.group_element_year_4 = GroupElementYearFactory(
parent=self.education_group_year_3,
child_branch=self.education_group_year_1)
self.group_element_year_5 = GroupElementYearFactory(
parent=self.education_group_year_3,
child_branch=self.education_group_year_1)
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)
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 test_offer_year_queried_by_academic_year(self):
an_entity_management = StructureFactory()
OfferYearFactory(academic_year=self.academic_year_previous, entity_management=an_entity_management)
OfferYearFactory(academic_year=self.academic_year_current, entity_management=an_entity_management)
OfferYearFactory(academic_year=self.academic_year_current, entity_management=an_entity_management)
self.assertEqual(len(pgm_manager_administration._get_programs(self.academic_year_current,
[an_entity_management],
None,
None)), 2)
self.assertEqual(len(pgm_manager_administration._get_programs(self.academic_year_previous,
[an_entity_management],
None,
None)), 1)
def setUp(self):
self.maxDiff = None
self.manager = AdviserManagerFactory()
a_person_teacher = PersonFactory.create(first_name='Pierre', last_name='Dupont')
self.teacher = AdviserTeacherFactory(person=a_person_teacher)
a_person_teacher2 = PersonFactory.create(first_name='Marco', last_name='Millet')
self.teacher2 = AdviserTeacherFactory(person=a_person_teacher2)
a_person_student = PersonFactory.create(last_name="Durant", user=None)
student = StudentFactory.create(person=a_person_student)
self.offer1 = OfferFactory(title="test_offer1")
self.offer2 = OfferFactory(title="test_offer2")
self.academic_year1 = AcademicYearFactory()
self.academic_year2 = AcademicYearFactory(year=self.academic_year1.year-1)
self.offer_year_start1 = OfferYearFactory(acronym="test_offer1", offer=self.offer1,
academic_year=self.academic_year1)
offer_year_start2 = OfferYearFactory(academic_year=self.academic_year2, acronym="test_offer2", offer=self.offer1)
self.offer_proposition1 = OfferPropositionFactory(offer=self.offer1)
self.offer_proposition2 = OfferPropositionFactory(offer=self.offer2)
FacultyAdviserFactory(adviser=self.manager, offer=self.offer1)
self.manager2 = AdviserManagerFactory()
FacultyAdviserFactory(adviser=self.manager, offer=self.offer2)
roles = ['PROMOTEUR', 'CO_PROMOTEUR', 'READER', 'PROMOTEUR', 'ACCOMPANIST', 'PRESIDENT']
status = ['DRAFT', 'COM_SUBMIT', 'EVA_SUBMIT', 'TO_RECEIVE', 'DIR_SUBMIT', 'DIR_SUBMIT']
self.dissertations_list = list()
for x in range(0, 6):
proposition_dissertation = PropositionDissertationFactory(author=self.teacher,
creator=a_person_teacher,
title='Proposition {}'.format(x)
)
PropositionOfferFactory(proposition_dissertation=proposition_dissertation,
offer_proposition=self.offer_proposition1)
self.dissertations_list.append(DissertationFactory(author=student,
title='Dissertation {}'.format(x),
offer_year_start=self.offer_year_start1,
proposition_dissertation=proposition_dissertation,
status=status[x],
active=True,
dissertation_role__adviser=self.teacher,
dissertation_role__status=roles[x]
))
self.dissertation_1 = DissertationFactory\
(author=student,
title='Dissertation 2017',
offer_year_start=self.offer_year_start1,
proposition_dissertation=proposition_dissertation,
status='COM_SUBMIT',
active=True,
dissertation_role__adviser=self.teacher2,
dissertation_role__status='PROMOTEUR')
def test_add_offer_program_manager(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.assertFalse(
pgm_manager_administration.add_offer_program_manager(
offer_year1, self.person))
self.assertTrue(
pgm_manager_administration.add_offer_program_manager(
offer_year2, self.person))
def test_with_end_date_inferior_to_offer_year_calendar_end_date(self):
an_academic_calendar = AcademicCalendarFactory(
academic_year=self.an_academic_year)
an_offer_year = OfferYearFactory(academic_year=self.an_academic_year)
an_offer_year_calendar = OfferYearCalendarFactory(
academic_calendar=an_academic_calendar, offer_year=an_offer_year)
form = AcademicCalendarForm(data={
"academic_year":
self.an_academic_year.pk,
"title":
"New title",
"start_date":
an_academic_calendar.start_date,
"end_date":
an_offer_year_calendar.end_date - datetime.timedelta(days=2)
},
instance=an_academic_calendar)
self.assertFalse(form.is_valid())
date_format = str(_('date_format'))
self.assertEqual(
form.errors['end_date'],
_("The closure's date of '%s' of the academic calendar can't be "
"lower than %s (end date of '%s' of the program '%s')") %
(an_academic_calendar.title,
an_offer_year_calendar.end_date.strftime(date_format),
an_academic_calendar.title,
an_offer_year_calendar.offer_year.acronym))
def setUp(self):
today = datetime.date.today()
self.academic_year = AcademicYearFactory(start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
self.offer_year = OfferYearFactory(academic_year=self.academic_year)
self.COMMON_CONTEXT_KEYS = ['offer_year', 'countries', 'is_program_manager', 'entity_versions']
def setUp(self):
self.academic_year = AcademicYearFactory()
self.offer_year = OfferYearFactory(academic_year=self.academic_year)
self.learning_unit_year = LearningUnitYearFactory(academic_year=self.academic_year, acronym="LBIR1100",
decimal_scores=False)
# Create tutor and score responsible
_create_attribution(self.learning_unit_year, person=PersonFactory(last_name='Alibra', first_name='Paul'))
_create_attribution(self.learning_unit_year, person=PersonFactory(last_name='Durant', first_name='Thomas'),
is_score_responsible=True)
_create_attribution(self.learning_unit_year, person=PersonFactory(last_name='Lobradi', first_name='Pierre'))
self.session_exam = SessionExamFactory(number_session=1, learning_unit_year=self.learning_unit_year)
# Create three students and enrol them to learning unit year
self.student_1 = StudentFactory(person=PersonFactory(last_name='Dupont', first_name='Jacques'))
self.student_2 = StudentFactory(person=PersonFactory(last_name='Dupont', first_name='Axel'))
self.student_3 = StudentFactory(person=PersonFactory(last_name='Armand', first_name='Zoe'))
for student in (self.student_1, self.student_2, self.student_3):
offer_enrollment = OfferEnrollmentFactory(offer_year=self.offer_year, student=student)
lu_enrolmment = LearningUnitEnrollmentFactory(
offer_enrollment=offer_enrollment,
learning_unit_year=self.learning_unit_year
)
ExamEnrollmentFactory(learning_unit_enrollment=lu_enrolmment, session_exam=self.session_exam)
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_is_not_already_program_manager(self):
offer_year1 = OfferYearFactory(
academic_year=self.academic_year_current,
entity_management=self.structure_parent1)
self.assertFalse(
pgm_manager_administration.is_already_program_manager(
self.person, offer_year1))
def test_with_end_date_inferior_to_offer_year_calendar_end_date(self):
an_academic_calendar = AcademicCalendarFactory(
academic_year=self.an_academic_year)
an_offer_year = OfferYearFactory(academic_year=self.an_academic_year)
an_offer_year_calendar = OfferYearCalendarFactory(
academic_calendar=an_academic_calendar, offer_year=an_offer_year)
form = AcademicCalendarForm(data={
"academic_year":
self.an_academic_year.pk,
"title":
"New title",
"start_date":
an_academic_calendar.start_date,
"end_date":
an_offer_year_calendar.end_date - datetime.timedelta(days=2)
},
instance=an_academic_calendar)
self.assertFalse(form.is_valid())
date_format = str(_('date_format'))
self.assertEqual(
form.errors['end_date'], "%s." %
(_('academic_calendar_offer_year_calendar_end_date_error') %
(an_academic_calendar.title,
an_offer_year_calendar.end_date.strftime(date_format),
an_academic_calendar.title,
an_offer_year_calendar.offer_year.acronym)))
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 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 test_find_by_offer_year(self):
tmp_student = StudentFactory()
tmp_offer_year = OfferYearFactory()
OfferEnrollmentFactory.create(offer_year=tmp_offer_year, student=tmp_student)
db_student = list(student.find_by_offer_year([tmp_offer_year][0]))[0]
self.assertIsNotNone(db_student)
self.assertEqual(db_student, tmp_student)
def setUp(self):
today = datetime.datetime.today()
twenty_days = datetime.timedelta(days=20)
#Take same academic year as the one in the associated xls file
an_academic_year = AcademicYearFactory(year=2017)
a_learning_unit_year = LearningUnitYearFakerFactory(
academic_year=an_academic_year, acronym=LEARNING_UNIT_ACRONYM)
tutor = TutorFactory()
an_academic_calendar = AcademicCalendarFactory(
academic_year=an_academic_year,
start_date=today - twenty_days,
end_date=today + twenty_days,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
SessionExamCalendarFactory(number_session=number_session.ONE,
academic_calendar=an_academic_calendar)
AttributionFactory(learning_unit_year=a_learning_unit_year,
tutor=tutor)
a_session_exam = SessionExamFactory(
number_session=number_session.ONE,
learning_unit_year=a_learning_unit_year)
self.person_student_1 = PersonFactory(email=EMAIL_1)
person_student_2 = PersonFactory(email=EMAIL_2)
student_1 = StudentFactory(registration_id=REGISTRATION_ID_1,
person=self.person_student_1)
student_2 = StudentFactory(registration_id=REGISTRATION_ID_2,
person=person_student_2)
an_offer_year = OfferYearFactory(academic_year=an_academic_year,
acronym=OFFER_ACRONYM)
offer_enrollment_1 = OfferEnrollmentFactory(offer_year=an_offer_year,
student=student_1)
offer_enrollment_2 = OfferEnrollmentFactory(offer_year=an_offer_year,
student=student_2)
learning_unit_enrollment_1 = LearningUnitEnrollmentFactory(
learning_unit_year=a_learning_unit_year,
offer_enrollment=offer_enrollment_1)
learning_unit_enrollment_2 = LearningUnitEnrollmentFactory(
learning_unit_year=a_learning_unit_year,
offer_enrollment=offer_enrollment_2)
ExamEnrollmentFactory(
session_exam=a_session_exam,
learning_unit_enrollment=learning_unit_enrollment_1)
ExamEnrollmentFactory(
session_exam=a_session_exam,
learning_unit_enrollment=learning_unit_enrollment_2)
user = tutor.person.user
self.client = Client()
self.client.force_login(user=user)
self.url = reverse(
'upload_encoding',
kwargs={'learning_unit_year_id': a_learning_unit_year.id})
def build_old_offer_yr_calendar(self):
self.previous_academic_year = AcademicYearFactory(start_date=today.replace(year=today.year - 3),
end_date=today.replace(year=today.year - 2),
year=today.year - 3)
an_previous_academic_calendar = AcademicCalendarFactory(academic_year=self.previous_academic_year)
self.a_previous_offer_year = OfferYearFactory(academic_year=self.previous_academic_year)
self.a_previous_offer_yr_calendar = OfferYearCalendarFactory(academic_calendar=an_previous_academic_calendar,
offer_year=self.a_previous_offer_year)
def build_current_offer_yr_calendar(self):
self.current_academic_year = AcademicYearFactory(start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
an_academic_calendar = AcademicCalendarFactory(academic_year=self.current_academic_year)
self.a_current_offer_year = OfferYearFactory(academic_year=self.current_academic_year)
self.a_current_offer_yr_calendar = OfferYearCalendarFactory(academic_calendar=an_academic_calendar,
offer_year=self.a_current_offer_year)
def test_find_by_offers_year(self):
student1 = StudentFactory.create()
offer_year1 = OfferYearFactory()
OfferEnrollmentFactory(student=student1, offer_year=offer_year1)
result = list(offer_enrollment.find_by_offers_years([offer_year1]))
self.assertEqual(result[0].student, student1)
self.assertEqual(result[0].offer_year, offer_year1)
self.assertEqual(len(result), 1)
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)
