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()
class OfferYearCalendarsAttributesValidation(TestCase):
def setUp(self):
self.academic_year = AcademicYearFactory(
year=YEAR_CALENDAR,
start_date=datetime.date(YEAR_CALENDAR, 9, 1),
end_date=datetime.date(YEAR_CALENDAR + 1, 10, 30))
self.academic_calendar = AcademicCalendarFactory(
academic_year=self.academic_year,
start_date=datetime.date(YEAR_CALENDAR, 9, 1),
end_date=datetime.date(YEAR_CALENDAR + 1, 10, 30))
self.offer_year = OfferYearFactory(academic_year=self.academic_year)
def test_end_date_lower_than_start_date(self):
self.offer_year_calendar = OfferYearCalendarFactory(
offer_year=self.offer_year,
academic_calendar=self.academic_calendar)
self.offer_year_calendar.start_date = datetime.date(
YEAR_CALENDAR, 9, 1)
self.offer_year_calendar.end_date = datetime.date(YEAR_CALENDAR, 8, 1)
with self.assertRaises(ValidationError):
self.offer_year_calendar.save()
def test_compute_deadline_is_called_case_offer_year_calendar_save(self):
with mock.patch.object(compute_scores_encodings_deadlines,
'send') as mock_method:
OfferYearCalendarFactory()
self.assertTrue(mock_method.called)
def _create_administrative_data(self):
# Course enrollment event
self.offer_yr_cal_course_enrollment = OfferYearCalendarFactory(
academic_calendar__academic_year=self.academic_year,
academic_calendar__reference=academic_calendar_type.
COURSE_ENROLLMENT,
education_group_year=self.education_group_year_1,
start_date=datetime.datetime(2017, 9, 11, hour=4),
end_date=datetime.datetime(2017, 9, 22, hour=6))
# Score submission event (session 1)
self.offer_yr_cal_score_exam_submission_1 = OfferYearCalendarFactory(
academic_calendar__academic_year=self.academic_year,
academic_calendar__reference=academic_calendar_type.
SCORES_EXAM_SUBMISSION,
education_group_year=self.education_group_year_1,
start_date=datetime.datetime(2017, 5, 11, hour=4),
end_date=datetime.datetime(2017, 5, 22, hour=6))
SessionExamCalendarFactory(
academic_calendar=self.offer_yr_cal_score_exam_submission_1.
academic_calendar,
number_session=1)
# Score submission event (session 2)
self.offer_yr_cal_score_exam_submission_2 = OfferYearCalendarFactory(
academic_calendar__academic_year=self.academic_year,
academic_calendar__reference=academic_calendar_type.
SCORES_EXAM_SUBMISSION,
education_group_year=self.education_group_year_1,
start_date=datetime.datetime(2017, 9, 1, hour=4))
SessionExamCalendarFactory(
academic_calendar=self.offer_yr_cal_score_exam_submission_2.
academic_calendar,
number_session=2)
def test_get_oyc_by_reference_when_education_group_year_is_null(self):
ac_cal = AcademicCalendarFactory(reference=academic_calendar_type.DELIBERATION)
SessionExamCalendarFactory(academic_calendar=ac_cal)
OfferYearCalendarFactory(academic_calendar=ac_cal, education_group_year=None)
off_year_cal_expected = OfferYearCalendarFactory(academic_calendar=ac_cal, education_group_year=None)
oyc = scores_encodings_deadline._get_oyc_by_reference(off_year_cal_expected,
academic_calendar_type.DELIBERATION)
self.assertEqual(oyc, off_year_cal_expected)
def test_end_date_lower_than_start_date(self):
self.offer_year_calendar = OfferYearCalendarFactory(
offer_year=self.offer_year,
academic_calendar=self.academic_calendar)
self.offer_year_calendar.start_date = datetime.date(
YEAR_CALENDAR, 9, 1)
self.offer_year_calendar.end_date = datetime.date(YEAR_CALENDAR, 8, 1)
with self.assertRaises(ValidationError):
self.offer_year_calendar.save()
def test_case_deliberation_date_is_set(self):
delibe_date = datetime.datetime(self.current_academic_yr.year+1, 6, 10)
offer_year_cal = OfferYearCalendarFactory(academic_calendar=self.academic_calendar,
offer_year=self.offer_yr,
start_date=delibe_date,
end_date=delibe_date)
self.assertEqual(session_exam_calendar.find_deliberation_date(number_session.ONE, offer_year_cal.offer_year), delibe_date)
def test_get_sessions_dates(self):
from base.views.education_group import get_sessions_dates
from base.tests.factories.session_exam_calendar import SessionExamCalendarFactory
from base.tests.factories.academic_calendar import AcademicCalendarFactory
from base.tests.factories.education_group_year import EducationGroupYearFactory
from base.tests.factories.offer_year_calendar import OfferYearCalendarFactory
sessions_quantity = 3
an_academic_year = AcademicYearFactory()
academic_calendar = AcademicCalendarFactory.build(
academic_year=an_academic_year)
academic_calendar.save(functions=[])
education_group_year = EducationGroupYearFactory(
academic_year=an_academic_year)
session_exam_calendars = [
SessionExamCalendarFactory(number_session=session,
academic_calendar=academic_calendar)
for session in range(1, sessions_quantity + 1)
]
offer_year_calendar = OfferYearCalendarFactory(
academic_calendar=academic_calendar,
education_group_year=education_group_year)
self.assertEquals(
get_sessions_dates(academic_calendar.reference,
education_group_year), {
'session{}'.format(s): offer_year_calendar
for s in range(1, sessions_quantity + 1)
})
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_get_sessions_dates(self):
from base.views.education_group import get_sessions_dates
from base.tests.factories.session_exam_calendar import SessionExamCalendarFactory
from base.tests.factories.academic_calendar import AcademicCalendarFactory
from base.tests.factories.education_group_year import EducationGroupYearFactory
from base.tests.factories.offer_year_calendar import OfferYearCalendarFactory
sessions_quantity = 3
an_academic_year = AcademicYearFactory()
academic_calendars = [
AcademicCalendarFactory(
academic_year=an_academic_year,
reference=academic_calendar_type.DELIBERATION)
for _ in range(sessions_quantity)
]
education_group_year = EducationGroupYearFactory(
academic_year=an_academic_year)
for session, academic_calendar in enumerate(academic_calendars):
SessionExamCalendarFactory(number_session=session + 1,
academic_calendar=academic_calendar)
offer_year_calendars = [
OfferYearCalendarFactory(academic_calendar=academic_calendar,
education_group_year=education_group_year)
for academic_calendar in academic_calendars
]
self.assertEquals(
get_sessions_dates(academic_calendars[0].reference,
education_group_year),
{
'session{}'.format(s + 1): offer_year_calendar
for s, offer_year_calendar in enumerate(offer_year_calendars)
})
def _create_context_exam_enrollments(self,
learning_unit_year,
offer_year,
nb_enrollment=10,
nb_filled=None):
counter_filled = nb_filled if (
nb_filled and nb_filled <= nb_enrollment) else nb_enrollment
session_exam = SessionExamFactory(
number_session=number_session.ONE,
learning_unit_year=learning_unit_year)
OfferYearCalendarFactory(academic_calendar=self.academic_calendar,
offer_year=offer_year)
for index in range(0, nb_enrollment):
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=learning_unit_year)
exam_enrollment = test_exam_enrollment.create_exam_enrollment(
session_exam, learning_unit_enrollment)
if counter_filled:
exam_enrollment.score_final = randint(0, 20)
exam_enrollment.save()
counter_filled -= 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 _create_tutor_scores_submission_end_date(self, end_date):
return OfferYearCalendarFactory(
academic_calendar=self.ac_score_exam_submission,
offer_year=self.off_year,
start_date=self.academic_calendar_deliberation.start_date,
end_date=end_date,
education_group_year=self.education_group_year)
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 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 test_case_only_global_scores_encoding_end_date_is_set(self):
self.offer_year_calendar_deliberation.delete()
OfferYearCalendarFactory(academic_calendar=self.ac_score_exam_submission, start_date=None, end_date=None,
offer_year=self.off_year)
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline,
self.ac_score_exam_submission.end_date)
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline_tutor_computed,
self.ac_score_exam_submission.end_date)
def test_get_oyc_by_reference_when_no_matching_result(self):
ac_cal = AcademicCalendarFactory(
reference=academic_calendar_type.DELIBERATION)
SessionExamCalendarFactory(academic_calendar=ac_cal)
off_year_cal = OfferYearCalendarFactory(academic_calendar=ac_cal)
oyc = scores_encodings_deadline._get_oyc_by_reference(
off_year_cal, academic_calendar_type.COURSE_ENROLLMENT)
self.assertIsNone(oyc)
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_case_deliberation_date_is_not_set(self):
global_date = self.academic_calendar.start_date
delibe_date = None
OfferYearCalendarFactory(academic_calendar=self.academic_calendar,
offer_year=self.offer_yr,
start_date=delibe_date,
end_date=delibe_date)
result_delibe_date = session_exam_calendar.find_deliberation_date(number_session.ONE, self.offer_yr)
self.assertNotEqual(result_delibe_date, global_date)
self.assertIsNone(result_delibe_date)
def test_taking_correct_number_session(self):
offer_year_cal = OfferYearCalendarFactory(
academic_calendar=self.academic_calendar, offer_year=self.offer_yr)
self.assertEqual(
session_exam_calendar.find_deliberation_date(
number_session.ONE, offer_year_cal.offer_year),
datetime.datetime(self.current_academic_yr.year + 1, 1, 1))
self.assertIsNone(
session_exam_calendar.find_deliberation_date(
number_session.TWO, offer_year_cal.offer_year))
def _load_initial_data_of_type_deliberation(self, academic_year):
self.academic_calendar_deliberation = AcademicCalendarFactory(
academic_year=academic_year,
reference=academic_calendar_type.DELIBERATION,
start_date=academic_year.start_date,
end_date=academic_year.end_date,
)
SessionExamCalendarFactory(
academic_calendar=self.academic_calendar_deliberation,
number_session=self.nb_session,
)
self.offer_year_calendar_deliberation = OfferYearCalendarFactory(
academic_calendar=self.academic_calendar_deliberation,
offer_year=self.off_year,
start_date=self.academic_calendar_deliberation.start_date,
end_date=self.academic_calendar_deliberation.end_date,
education_group_year=self.education_group_year)
def test_offer_year_calendar_read(self, mock_program_manager):
offer_year = OfferYearCalendarFactory()
mock_program_manager.is_program_manager.return_value = True
response = self.client.get(
reverse('offer_year_calendar_read', args=[offer_year.id]))
self.assertTemplateUsed(response, 'offer_year_calendar.html')
self.assertEqual(response.context['offer_year_calendar'], offer_year)
self.assertEqual(response.context['is_programme_manager'],
mock_program_manager.is_program_manager())
def test_find_deliberation_date_offer_year_cals(self):
SessionExamCalendarFactory(academic_calendar=self.academic_calendar_4,
number_session=number_session.ONE)
offer_yr = OfferYearFactory(academic_year=self.current_academic_yr)
global_date = self.academic_calendar_4.start_date
delibe_date = datetime.date(self.current_academic_yr.year + 1, 6, 10)
offer_year_cal = OfferYearCalendarFactory(
academic_calendar=self.academic_calendar_4,
offer_year=offer_yr,
start_date=delibe_date,
end_date=delibe_date)
self.assertEqual(
session_exam_calendar.find_deliberation_date(
number_session.ONE, offer_yr), delibe_date)
offer_year_cal.start_date = offer_year_cal.end_date = None
offer_year_cal.save()
self.assertEqual(
session_exam_calendar.find_deliberation_date(
number_session.ONE, offer_yr), global_date)
def test_cannot_access_any_offer_pages_if_not_program_manager(self):
offer_year = OfferYearCalendarFactory()
person = PersonFactory()
self.client.force_login(person.user)
pages = [('offers_search', None), ('offers', None),
('offer_score_encoding_tab', offer_year.pk)]
for page, arg in pages:
url = reverse(page, args=[arg]) if arg else reverse(page)
response = self.client.get(url)
self.assertEqual(response.status_code,
HttpResponseForbidden.status_code)
self.assertTemplateUsed(response, 'access_denied.html')
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_find_deliberation_date(self):
SessionExamCalendarFactory(academic_calendar=self.academic_calendar_4,
number_session=number_session.ONE)
offer_yr = OfferYearFactory(academic_year=self.current_academic_yr)
offer_year_cal = OfferYearCalendarFactory(
academic_calendar=self.academic_calendar_4, offer_year=offer_yr)
self.assertEqual(
session_exam_calendar.find_deliberation_date(
number_session.ONE, offer_year_cal.offer_year),
datetime.date(self.current_academic_yr.year + 1, 1, 1))
self.assertIsNone(
session_exam_calendar.find_deliberation_date(
number_session.TWO, offer_year_cal.offer_year))
def setUp(self):
self.offer_year_calendar_deliberation = OfferYearCalendarFactory(
academic_calendar=self.academic_calendar_deliberation,
offer_year=self.off_year,
start_date=self.academic_calendar_deliberation.start_date,
end_date=self.academic_calendar_deliberation.end_date,
education_group_year=self.education_group_year
)
off_enrol = OfferEnrollmentFactory(offer_year=self.offer_year_calendar_deliberation.offer_year)
self.sess_exam_dealine = SessionExamDeadlineFactory(offer_enrollment=off_enrol, deliberation_date=None,
deadline=scores_encodings_deadline._one_day_before(
self.academic_calendar_deliberation.end_date),
deadline_tutor=0,
number_session=self.nb_session)
self.ac_score_exam_submission = AcademicCalendarFactory(
academic_year=self.academic_year,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION,
start_date=self.academic_year.start_date,
end_date=self.academic_year.end_date,
)
SessionExamCalendarFactory(
academic_calendar=self.ac_score_exam_submission,
number_session=self.nb_session
)
def test_compute_deadline_tutor_by_offer_year(self):
"""
In this test, we will check if the tutor day delta [deadline is correctly computed]
"""
self.offer_year_calendar_deliberation.end_date = self.offer_year_calendar_deliberation.end_date + timedelta(
days=10)
self.offer_year_calendar_deliberation.save()
correct_deadlines = [0 for _ in SessionExamDeadline.objects.all()]
OfferYearCalendarFactory(
academic_calendar=self.ac_score_exam_submission,
education_group_year=self.offer_year_calendar_deliberation.education_group_year,
offer_year=self.offer_year_calendar_deliberation.offer_year
)
new_deadlines_tutors = [i.deadline_tutor for i in SessionExamDeadline.objects.all()]
self.assertListEqual(new_deadlines_tutors, correct_deadlines)
def setUp(self):
self.academic_year = AcademicYearFactory(year=2007)
self.academic_calendars = [
AcademicCalendarFactory(reference=i[0], academic_year=self.academic_year)
for i in academic_calendar_type.CALENDAR_TYPES
]
self.education_group_year = EducationGroupYearFactory(academic_year=self.academic_year)
self.offer_year = [
OfferYearCalendarFactory(education_group_year=self.education_group_year, academic_calendar=ac)
for ac in self.academic_calendars
]
self.session_exam_calendars = [
SessionExamCalendarFactory(number_session=1, academic_calendar=ac) for ac in self.academic_calendars
]
def test_offer_read(self, mock_program_manager):
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)
response = self.client.get(reverse('offer_read', args=[offer_year.pk]))
self.assertTemplateUsed(response, 'offer/tab_identification.html')
def _load_initial_data_of_type_deliberation(self, academic_year):
self.academic_calendar_deliberation = AcademicCalendarFactory(
academic_year=academic_year,
reference=academic_calendar_type.DELIBERATION,
start_date=academic_year.start_date,
end_date=academic_year.end_date,
)
SessionExamCalendarFactory(
academic_calendar=self.academic_calendar_deliberation,
number_session=self.nb_session,
)
self.offer_year_calendar_deliberation = OfferYearCalendarFactory(
academic_calendar=self.academic_calendar_deliberation,
offer_year=self.off_year,
start_date=self.academic_calendar_deliberation.start_date,
end_date=self.academic_calendar_deliberation.end_date,
education_group_year=self.education_group_year
)
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=2007)
cls.academic_calendars = [
AcademicCalendarFactory(reference=i[0],
academic_year=cls.academic_year)
for i in academic_calendar_type.CALENDAR_TYPES
]
cls.education_group_year = EducationGroupYearFactory(
academic_year=cls.academic_year)
cls.offer_year = [
OfferYearCalendarFactory(
education_group_year=cls.education_group_year,
academic_calendar=ac) for ac in cls.academic_calendars
]
cls.session_exam_calendars = [
SessionExamCalendarFactory(number_session=1, academic_calendar=ac)
for ac in cls.academic_calendars
]
class ComputeScoresEncodingsDeadlinesTest(TestCase):
def setUp(self):
self.nb_session = number_session.ONE
current_year = datetime.now().year
current_date = datetime(year=current_year, month=9, day=1, hour=12)
academic_year = AcademicYearFactory(year=current_year,
start_date=current_date,
end_date=current_date + timedelta(days=365))
self.off_year = OfferYearFactory()
self.education_group_year = EducationGroupYearFactory()
self._load_initial_data_of_type_deliberation(academic_year)
self._load_initial_data_of_type_scores_exam_submission(academic_year)
self._load_one_student_session_exam_deadline()
def _load_initial_data_of_type_deliberation(self, academic_year):
self.academic_calendar_deliberation = AcademicCalendarFactory(
academic_year=academic_year,
reference=academic_calendar_type.DELIBERATION,
start_date=academic_year.start_date,
end_date=academic_year.end_date,
)
SessionExamCalendarFactory(
academic_calendar=self.academic_calendar_deliberation,
number_session=self.nb_session,
)
self.offer_year_calendar_deliberation = OfferYearCalendarFactory(
academic_calendar=self.academic_calendar_deliberation,
offer_year=self.off_year,
start_date=self.academic_calendar_deliberation.start_date,
end_date=self.academic_calendar_deliberation.end_date,
education_group_year=self.education_group_year
)
def _load_initial_data_of_type_scores_exam_submission(self, academic_year):
self.ac_score_exam_submission = AcademicCalendarFactory(
academic_year=academic_year,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION,
start_date=academic_year.start_date,
end_date=academic_year.end_date,
)
SessionExamCalendarFactory(
academic_calendar=self.ac_score_exam_submission,
number_session=self.nb_session
)
def _load_one_student_session_exam_deadline(self):
off_enrol = OfferEnrollmentFactory(offer_year=self.offer_year_calendar_deliberation.offer_year)
self.sess_exam_dealine = SessionExamDeadlineFactory(offer_enrollment=off_enrol, deliberation_date=None,
deadline=scores_encodings_deadline._one_day_before(self.academic_calendar_deliberation.end_date),
deadline_tutor=0,
number_session=self.nb_session)
def _create_tutor_scores_submission_end_date(self, end_date):
return OfferYearCalendarFactory(
academic_calendar=self.ac_score_exam_submission,
offer_year=self.off_year,
start_date=self.academic_calendar_deliberation.start_date,
end_date=end_date,
education_group_year=self.education_group_year
)
def _get_persistent_session_exam_deadline(self):
return SessionExamDeadline.objects.get(pk=self.sess_exam_dealine.id)
def _change_student_deliberation_date(self, new_end_date):
self.sess_exam_dealine.deliberation_date = new_end_date
self.sess_exam_dealine.save()
def _assert_date_equal(self, date1, date2):
self.assertEqual(scores_encodings_deadline._get_date_instance(date1),
scores_encodings_deadline._get_date_instance(date2))
def test_compute_deadline_wrong_reference(self):
self.offer_year_calendar_deliberation.academic_calendar.reference = academic_calendar_type.COURSE_ENROLLMENT
old_deadline = self.sess_exam_dealine.deadline
self.offer_year_calendar_deliberation.save()
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline, old_deadline)
def test_compute_deadline_tutor_by_offer_year(self):
"""
In this test, we will check if the tutor day delta [deadline is correctly computed]
"""
self.offer_year_calendar_deliberation.end_date = self.offer_year_calendar_deliberation.end_date + timedelta(
days=10)
self.offer_year_calendar_deliberation.save()
correct_deadlines = [0 for _ in SessionExamDeadline.objects.all()]
OfferYearCalendarFactory(
academic_calendar=self.ac_score_exam_submission,
education_group_year=self.offer_year_calendar_deliberation.education_group_year,
offer_year=self.offer_year_calendar_deliberation.offer_year
)
new_deadlines_tutors = [i.deadline_tutor for i in SessionExamDeadline.objects.all()]
self.assertListEqual(new_deadlines_tutors, correct_deadlines)
def test_get_delta_deadline_tutor(self):
today = datetime.today()
fourty_day_before = today - timedelta(days=40)
self.assertEqual(40, scores_encodings_deadline._compute_delta_deadline_tutor(today, fourty_day_before))
def test_get_delta_deadline_tutor_none_value(self):
today = datetime.today()
self.assertFalse(scores_encodings_deadline._compute_delta_deadline_tutor(None, None))
self.assertFalse(scores_encodings_deadline._compute_delta_deadline_tutor(None, today))
self.assertFalse(scores_encodings_deadline._compute_delta_deadline_tutor(today, None))
def test_case_only_global_scores_encoding_end_date_is_set(self):
self.offer_year_calendar_deliberation.delete()
OfferYearCalendarFactory(academic_calendar=self.ac_score_exam_submission, start_date=None, end_date=None, offer_year=self.off_year)
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline, self.ac_score_exam_submission.end_date)
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline_tutor_computed, self.ac_score_exam_submission.end_date)
def test_case_tutor_scores_submission_date_gt_student_deliberation_date(self):
delibe_date = self.offer_year_calendar_deliberation.end_date - timedelta(days=10)
self._change_student_deliberation_date(delibe_date)
self._create_tutor_scores_submission_end_date(delibe_date + timedelta(days=5))
self.assertEqual(self._get_persistent_session_exam_deadline().deadline_tutor_computed,
scores_encodings_deadline._one_day_before(delibe_date))
def test_case_tutor_scores_submission_date_gt_offer_year_deliberation_date(self):
offer_year_delibe_date = self.offer_year_calendar_deliberation.end_date
self._create_tutor_scores_submission_end_date(offer_year_delibe_date + timedelta(days=5))
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline_tutor_computed,
scores_encodings_deadline._one_day_before(self.offer_year_calendar_deliberation.end_date))
def test_case_tutor_scores_submission_date_gt_scores_encodings_end_date(self):
scores_encodings_end_date = self.ac_score_exam_submission.end_date
self._create_tutor_scores_submission_end_date(scores_encodings_end_date + timedelta(days=5))
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline_tutor_computed,
scores_encodings_deadline._one_day_before(self.ac_score_exam_submission.end_date))
def test_case_tutor_scores_submission_date_lt_student_deliberation_date(self):
delibe_date = self.offer_year_calendar_deliberation.end_date - timedelta(days=10)
self._change_student_deliberation_date(delibe_date)
off_year_cal = self._create_tutor_scores_submission_end_date(delibe_date - timedelta(days=5))
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline_tutor_computed,
off_year_cal.end_date)
def test_case_tutor_scores_submission_date_lt_offer_year_deliberation_date(self):
off_year_delibe_date = self.offer_year_calendar_deliberation.end_date
off_year_cal = self._create_tutor_scores_submission_end_date(off_year_delibe_date - timedelta(days=5))
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline_tutor_computed,
off_year_cal.end_date)
def test_case_tutor_scores_submission_date_lt_scores_encodings_end_date(self):
scores_encodings_end_date = self.ac_score_exam_submission.end_date
off_year_cal = self._create_tutor_scores_submission_end_date(scores_encodings_end_date - timedelta(days=5))
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline_tutor_computed,
off_year_cal.end_date)
def test_case_student_deliberation_date_gt_offer_year_deliberation_date(self):
offer_year_delibe_date = self.offer_year_calendar_deliberation.end_date
self._change_student_deliberation_date(offer_year_delibe_date + timedelta(days=5))
before = scores_encodings_deadline._one_day_before(offer_year_delibe_date)
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline,
before)
def test_case_student_deliberation_date_lt_offer_year_deliberation_date(self):
offer_year_delibe_date = self.offer_year_calendar_deliberation.end_date
self._change_student_deliberation_date(offer_year_delibe_date - timedelta(days=5))
self.assertEqual(self._get_persistent_session_exam_deadline().deadline,
scores_encodings_deadline._one_day_before(self.sess_exam_dealine.deliberation_date))
def test_case_global_submission_date_lt_student_and_offer_year_delibe_date(self):
offer_year_delibe_end_date = self.offer_year_calendar_deliberation.end_date
self._create_tutor_scores_submission_end_date(offer_year_delibe_end_date)
global_submission_end_date = offer_year_delibe_end_date - timedelta(days=20)
self.ac_score_exam_submission.end_date = global_submission_end_date
self.ac_score_exam_submission.save()
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline, global_submission_end_date)
def test_case_student_deliberation_date_lt_global_submission_date(self):
new_student_delibe_date = self.ac_score_exam_submission.end_date - timedelta(days=5)
self.sess_exam_dealine.deliberation_date = new_student_delibe_date
self.sess_exam_dealine.save()
self._assert_date_equal(self.sess_exam_dealine.deadline,
scores_encodings_deadline._one_day_before(new_student_delibe_date))
def test_case_offer_year_deliberation_lt_global_submission_date(self):
new_offer_year_delibe_date = self.ac_score_exam_submission.end_date - timedelta(days=5)
self.offer_year_calendar_deliberation.end_date = new_offer_year_delibe_date
self.offer_year_calendar_deliberation.save()
self._assert_date_equal(self._get_persistent_session_exam_deadline().deadline,
scores_encodings_deadline._one_day_before(new_offer_year_delibe_date))
def test_case_mutliple_students_offer_enrollments(self):
students = [StudentFactory() for _ in range(10)]
offer_enrollments = [
OfferEnrollmentFactory(student=student, offer_year=self.offer_year_calendar_deliberation.offer_year)
for student in students
]
session_exam_deadlines = [
SessionExamDeadlineFactory(offer_enrollment=offer_enrollment, number_session=self.nb_session,
deliberation_date=self.offer_year_calendar_deliberation.end_date,
deadline=scores_encodings_deadline._one_day_before(self.offer_year_calendar_deliberation.end_date),
deadline_tutor=0)
for offer_enrollment in offer_enrollments
]
new_global_submission_date = self.offer_year_calendar_deliberation.end_date - timedelta(days=20)
self.offer_year_calendar_deliberation.end_date = new_global_submission_date
self.offer_year_calendar_deliberation.save()
persistent_session_exams = SessionExamDeadline.objects.filter(pk__in=[obj.id for obj in session_exam_deadlines])
for obj in persistent_session_exams:
self._assert_date_equal(obj.deadline, scores_encodings_deadline._one_day_before(new_global_submission_date))
def test_get_oyc_by_reference_when_education_group_year_is_null(self):
ac_cal = AcademicCalendarFactory(reference=academic_calendar_type.DELIBERATION)
SessionExamCalendarFactory(academic_calendar=ac_cal)
OfferYearCalendarFactory(academic_calendar=ac_cal, education_group_year=None)
off_year_cal_expected = OfferYearCalendarFactory(academic_calendar=ac_cal, education_group_year=None)
oyc = scores_encodings_deadline._get_oyc_by_reference(off_year_cal_expected,
academic_calendar_type.DELIBERATION)
self.assertEqual(oyc, off_year_cal_expected)
def test_get_oyc_by_reference_when_no_matching_result(self):
ac_cal = AcademicCalendarFactory(reference=academic_calendar_type.DELIBERATION)
SessionExamCalendarFactory(academic_calendar=ac_cal)
off_year_cal = OfferYearCalendarFactory(academic_calendar=ac_cal)
oyc = scores_encodings_deadline._get_oyc_by_reference(off_year_cal, academic_calendar_type.COURSE_ENROLLMENT)
self.assertIsNone(oyc)
@mock.patch("assessments.business.scores_encodings_deadline.compute_deadline")
def test_recompute_all_deadlines_when_not_impact_scores_encodings_deadlines(self, mock_compute_deadline):
OfferYearCalendarFactory(
academic_calendar=AcademicCalendarFactory(reference=academic_calendar_type.DELIBERATION)
)
self.assertFalse(mock_compute_deadline.called)
@mock.patch("assessments.business.scores_encodings_deadline.compute_deadline")
def test_recompute_all_deadlines_when_not_impact_scores_encodings_deadlines(self, mock_compute_deadline):
OfferYearCalendarFactory(
academic_calendar=AcademicCalendarFactory(reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
)
self.assertTrue(mock_compute_deadline.called)