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,
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()
# Mock academic_year / session_exam_calendar in order to be decouple from system time
self.mock_academic_year(
current_academic_year=academic_year,
starting_academic_year=academic_year,
)
self.mock_session_exam_calendar(current_session_exam=self.session_exam_calendar)
def test_multiple_messages_outside_encoding_period(self):
date_format = str(_('date_format'))
# Submission of score encoding - 1 [Two day before today]
self.academic_calendar.end_date = timezone.now() - timedelta(days=2)
self.academic_calendar.start_date = timezone.now() - timedelta(days=20)
self.academic_calendar.save()
# Create submission of score encoding - 2 [Start in 100 days]
ac = AcademicCalendarFactory.build(title="Submission of score encoding - 2",
academic_year=self.academic_year,
start_date=self.academic_calendar.end_date + timedelta(days=100),
end_date=self.academic_calendar.end_date + timedelta(days=130),
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
ac.save()
SessionExamCalendarFactory(academic_calendar=ac, number_session=number_session.TWO)
url = reverse('scores_encoding')
response = self.client.get(url, follow=True)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 2)
self.assertEqual(messages[0].tags, 'warning')
end_date_str = self.academic_calendar.end_date.strftime(date_format)
self.assertEqual(messages[0].message,
_("The period of scores' encoding %(session_number)s is closed since %(str_date)s")
% {'session_number': 1, 'str_date': end_date_str})
self.assertEqual(messages[1].tags, 'warning')
start_date_str = ac.start_date.strftime(date_format)
self.assertEqual(messages[1].message,
_("The period of scores' encoding %(session_number)s will be open %(str_date)s")
% {'session_number': 2, 'str_date': start_date_str})
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 setUp(self):
self.user = User.objects.create_user(username='******', password='******')
add_permission(self.user, "can_access_scoreencoding")
self.client.force_login(self.user)
# Create context out of range
self.academic_year = _get_academic_year(2017)
self.academic_calendar = AcademicCalendarFactory(title="Submission of score encoding - 1",
academic_year=self.academic_year,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
self.session_exam_calendar = SessionExamCalendarFactory(academic_calendar=self.academic_calendar,
number_session=number_session.ONE)
# 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=None)
class TestEducationGroupAsFacultyManagerTag(TestCase):
""" This class will test the tag as faculty manager """
def setUp(self):
academic_year = AcademicYearFactory(year=2020)
self.education_group_year = TrainingFactory(
academic_year=academic_year)
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=academic_year,
)
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 test_li_tag_case_not_in_education_group_edition_period(self):
""" This test ensure that as faculty manager, the li tag is disabled when outside of encoding period"""
self.academic_calendar.delete()
result = li_with_deletion_perm(self.context, self.url, DELETE_MSG)
self.assertEqual(
result, {
'load_modal': False,
'title': PERMISSION_DENIED_MSG,
'class_li': 'disabled',
'id_li': 'link_delete',
'url': "#",
'text': DELETE_MSG
})
def test_li_tag_case_inside_education_group_edition_period(self):
result = li_with_deletion_perm(self.context, self.url, DELETE_MSG)
self.assertEqual(
result, {
'load_modal': True,
'text': DELETE_MSG,
'class_li': '',
'id_li': "link_delete",
'url': self.url,
'title': ''
})
def test_li_with_create_perm_mini_training(self):
"""
This test ensure that as faculty manager, the li tag is enable for mini training
"""
relation = AuthorizedRelationshipFactory(
parent_type=self.education_group_year.education_group_type)
relation.child_type.category = Categories.MINI_TRAINING.name
relation.child_type.save()
result = li_with_create_perm_mini_training(self.context, self.url, "")
self.assertEqual(
result, {
'load_modal': True,
'id_li': 'link_create_mini_training',
'url': self.url,
'title': '',
'class_li': '',
'text': ''
})
def test_li_tag_case_training_disabled(self):
"""
This test ensure that as faculty manager, the li tag is disabled for training
Faculty manager must enter in proposition mode for training
"""
self.context['education_group_year'] = TrainingFactory()
result = li_with_create_perm_training(self.context, self.url, "")
msg = pgettext(
"female",
"The user has not permission to create a %(category)s.") % {
"category": Categories.TRAINING.value
}
msg = msg.capitalize()
self.assertEqual(
result, {
'load_modal': False,
'title': msg,
'class_li': 'disabled',
'id_li': 'link_create_training',
'url': "#",
'text': ''
})
def test_button_edit_administrative_data_disabled(self):
result = button_edit_administrative_data(self.context)
self.assertEqual(result["url"], "#")
self.assertEqual(
result["title"],
_('Only program managers of the education group OR central manager linked to entity can edit.'
))
self.assertEqual(result["class_li"], "disabled")
self.assertEqual(result["text"], _("Modify"))
def step_impl(context: Context):
calendar = AcademicCalendarFactory(academic_year=current_academic_year(),
reference=EDUCATION_GROUP_EDITION)
calendar.end_date = (datetime.now() + timedelta(days=1)).date()
calendar.save()
class OutsideEncodingPeriodTest(AcademicYearMockMixin, SessionExamCalendarMockMixin, TestCase):
def setUp(self):
self.user = User.objects.create_user(username='******', password='******')
add_permission(self.user, "can_access_scoreencoding")
self.client.force_login(self.user)
# Create context out of range
self.academic_year = _get_academic_year(2017)
self.academic_calendar = AcademicCalendarFactory(title="Submission of score encoding - 1",
academic_year=self.academic_year,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
self.session_exam_calendar = SessionExamCalendarFactory(academic_calendar=self.academic_calendar,
number_session=number_session.ONE)
# 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=None)
def test_redirection_to_current_exam_session(self):
self.mock_session_exam_calendar(current_session_exam=self.session_exam_calendar)
url = reverse('outside_scores_encodings_period')
response = self.client.get(url)
self.assertRedirects(response, "%s?next=%s" % (reverse('scores_encoding'), reverse('outside_scores_encodings_period'))) # Redirection
def test_redirection_to_outside_encoding_period(self):
url = reverse('scores_encoding')
response = self.client.get(url)
self.assertRedirects(response, "%s?next=%s" % (reverse('outside_scores_encodings_period'), reverse('scores_encoding'))) # Redirection
def test_message_score_encoding_not_open(self):
self.session_exam_calendar.delete()
url = reverse('outside_scores_encodings_period')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0].tags, 'warning')
self.assertEqual(messages[0].message, _("The period of scores' encoding is not opened"))
def test_multiple_messages_outside_encoding_period(self):
date_format = str(_('date_format'))
# Submission of score encoding - 1 [Two day before today]
self.academic_calendar.end_date = timezone.now() - timedelta(days=2)
self.academic_calendar.start_date = timezone.now() - timedelta(days=20)
self.academic_calendar.save()
# Create submission of score encoding - 2 [Start in 100 days]
ac = AcademicCalendarFactory.build(title="Submission of score encoding - 2",
academic_year=self.academic_year,
start_date=self.academic_calendar.end_date + timedelta(days=100),
end_date=self.academic_calendar.end_date + timedelta(days=130),
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
ac.save()
SessionExamCalendarFactory(academic_calendar=ac, number_session=number_session.TWO)
url = reverse('scores_encoding')
response = self.client.get(url, follow=True)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 2)
self.assertEqual(messages[0].tags, 'warning')
end_date_str = self.academic_calendar.end_date.strftime(date_format)
self.assertEqual(messages[0].message,
_("The period of scores' encoding %(session_number)s is closed since %(str_date)s")
% {'session_number': 1, 'str_date': end_date_str})
self.assertEqual(messages[1].tags, 'warning')
start_date_str = ac.start_date.strftime(date_format)
self.assertEqual(messages[1].message,
_("The period of scores' encoding %(session_number)s will be open %(str_date)s")
% {'session_number': 2, 'str_date': start_date_str})
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)
def setUpTestData(cls):
now = datetime.datetime.now()
cls.academic_years = AcademicYearFactory.produce(number_past=5,
number_future=5)
cls.academic_year = cls.academic_years[5]
cls.old_academic_year = cls.academic_years[4]
cls.next_academic_year = cls.academic_years[5]
cls.previous_academic_year = cls.academic_years[4]
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 setUp(self):
self.academic_year_1 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 1),
end_date=today.replace(year=today.year + 2),
year=today.year + 1)
self.academic_year_2 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 2),
end_date=today.replace(year=today.year + 3),
year=today.year + 2)
self.academic_year_3 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 3),
end_date=today.replace(year=today.year + 4),
year=today.year + 3)
self.academic_year_4 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 4),
end_date=today.replace(year=today.year + 5),
year=today.year + 4)
self.academic_year_5 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 5),
end_date=today.replace(year=today.year + 6),
year=today.year + 5)
self.academic_year_6 = AcademicYearFactory.build(
start_date=today.replace(year=today.year + 6),
end_date=today.replace(year=today.year + 7),
year=today.year + 6)
self.current_academic_year = AcademicYearFactory.build(
start_date=today,
end_date=today.replace(year=today.year + 1),
year=today.year)
self.current_academic_year.save()
super(AcademicYear, self.academic_year_1).save()
super(AcademicYear, self.academic_year_2).save()
super(AcademicYear, self.academic_year_3).save()
super(AcademicYear, self.academic_year_4).save()
super(AcademicYear, self.academic_year_5).save()
super(AcademicYear, self.academic_year_6).save()
self.current_academic_calendar = AcademicCalendarFactory.build(
academic_year=self.current_academic_year)
self.current_academic_calendar.save(functions=[])
self.academic_calendar_1 = AcademicCalendarFactory.build(
academic_year=self.academic_year_1)
self.academic_calendar_1.save(functions=[])
AcademicCalendarFactory.build(academic_year=self.academic_year_2).save(
functions=[])
AcademicCalendarFactory.build(academic_year=self.academic_year_3).save(
functions=[])
AcademicCalendarFactory.build(academic_year=self.academic_year_4).save(
functions=[])
AcademicCalendarFactory.build(academic_year=self.academic_year_5).save(
functions=[])
AcademicCalendarFactory.build(academic_year=self.academic_year_6).save(
functions=[])
class TestOnlineApplication(TestCase):
def setUp(self):
# Create Group tutor
Group.objects.create(name="tutors")
# Create user
user = UserFactory(username="******")
person = PersonFactory(global_id="578945612", user=user)
self.tutor = TutorFactory(person=person)
# Add permission and log into app
add_permission(user, "can_access_attribution_application")
self.client.force_login(user)
# Create current academic year
today = datetime.datetime.today()
self.current_academic_year = AcademicYearFactory(year=today.year,
start_date=today)
# Create application year
# Application is always next year
self.application_academic_year = AcademicYearFactory(year=today.year +
1)
# Create Event to allow teacher to register
start_date = datetime.datetime.today() - datetime.timedelta(days=10)
end_date = datetime.datetime.today() + datetime.timedelta(days=15)
self.academic_calendar = AcademicCalendarFactory(
academic_year=self.current_academic_year,
reference=academic_calendar_type.TEACHING_CHARGE_APPLICATION,
start_date=start_date,
end_date=end_date)
# Creation context with multiple learning container year
self._create_multiple_learning_container_year()
self.attribution = AttributionNewFactory(
global_id=person.global_id,
applications=self._get_default_application_list(),
attributions=self._get_default_attribution_list())
def test_redirection_to_outside_encoding_period(self):
# Remove teaching charge application event
self.academic_calendar.delete()
url = reverse('applications_overview')
url_outside = reverse('outside_applications_period')
response = self.client.get(url)
self.assertRedirects(response,
"%s?next=%s" % (url_outside, url)) # Redirection
def test_message_outside_encoding_period(self):
# Remove teaching charge application event
self.academic_calendar.delete()
url = reverse('outside_applications_period')
response = self.client.get(url)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0].tags, 'warning')
self.assertEqual(messages[0].message, _('application_denied'))
def test_applictions_overview(self):
url = reverse('applications_overview')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(context['a_tutor'], self.tutor)
self.assertEqual(context['current_academic_year'],
self.current_academic_year)
self.assertEqual(context['application_year'],
self.application_academic_year)
self.assertEqual(len(context['attributions']), 1)
self.assertEqual(context['attributions'][0]['acronym'],
self.lagro2500_next.acronym)
self.assertEqual(len(context['applications']), 1)
self.assertEqual(context['applications'][0]['acronym'],
self.lagro1600_next.acronym)
self.assertEqual(len(context['attributions_about_to_expire']), 1)
self.assertEqual(context['attributions_about_to_expire'][0]['acronym'],
self.lbir1300_current.acronym)
def test_applications_overview_post_method_not_allowed(self):
url = reverse('applications_overview')
response = self.client.post(url)
self.assertEqual(response.status_code, 405)
def test_search_vacant_attribution_initial(self):
url = reverse('vacant_attributions_search')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(context['a_tutor'], self.tutor)
self.assertTrue(context['search_form'])
self.assertFalse(context['attributions_vacant'])
def test_search_vacant_attribution_post_not_allowed(self):
url = reverse('vacant_attributions_search')
response = self.client.post(url)
self.assertEqual(response.status_code, 405)
def test_search_vacant_attribution_search_list(self):
url = reverse('vacant_attributions_search')
response = self.client.get(
url, data={'learning_container_acronym': 'LAGRO'})
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(context['a_tutor'], self.tutor)
self.assertTrue(context['search_form'])
self.assertEqual(len(context['attributions_vacant']), 2)
# Check if LAGRO1600 have the boolean already applied
self.assertTrue(
(next(attrib for attrib in context['attributions_vacant']
if attrib.get('acronym') == self.lagro1600_next.acronym
and attrib.get('already_applied')), False))
def test_search_vacant_attribution_with_delcaration_vac_not_allowed(self):
# Create container with type_declaration_vacant not in [RESEVED_FOR_INTERNS, OPEN_FOR_EXTERNS]
self.lagro1234_current = _create_learning_container_with_components(
"LAGRO1234", self.current_academic_year)
# Creation learning container for next academic year [==> application academic year]
self.lagro1234_next = _create_learning_container_with_components\
("LAGRO1234", self.application_academic_year, 70, 70,
type_declaration_vacant=vacant_declaration_type.DO_NOT_ASSIGN)
url = reverse('vacant_attributions_search')
response = self.client.get(
url, data={'learning_container_acronym': 'LAGRO1234'})
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(context['a_tutor'], self.tutor)
self.assertTrue(context['search_form'])
self.assertFalse(context['attributions_vacant'])
def test_renew_applications(self):
url = reverse('renew_applications')
post_data = {
'learning_container_year_' + self.lbir1300_next.acronym: 'on'
}
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302) # redirection
self.attribution.refresh_from_db()
self.assertEqual(len(self.attribution.applications),
2) # Now we have two applications
def test_renew_applications_with_bad_learning_container(self):
url = reverse('renew_applications')
post_data = {
'learning_container_year_' + self.lagro2500_next.acronym: 'on'
}
response = self.client.post(url, data=post_data, follow=True)
self.assertEqual(response.status_code, 200)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0].tags, 'error')
self.assertEqual(messages[0].message, _('no_attribution_renewed'))
def test_renew_applications_method_not_allowed(self):
url = reverse('renew_applications')
response = self.client.get(url)
self.assertEqual(response.status_code, 405)
def test_delete_application(self):
url = reverse(
'delete_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
response = self.client.post(url)
self.assertEqual(response.status_code, 302) # redirection
self.attribution.refresh_from_db()
# pending flag must be set to 'deleted'
self.assertTrue((next(
attrib for attrib in self.attribution.applications
if attrib.get('acronym') == self.lagro1600_next.acronym and
attrib.get('pending') == tutor_application_epc.DELETE_OPERATION),
False))
def test_delete_application_with_wrong_container(self):
url = reverse(
'delete_tutor_application',
kwargs={'learning_container_year_id': self.lbir1300_next.id})
response = self.client.post(url)
self.assertEqual(response.status_code, 404) # Not found
def test_delete_application_method_not_allowed(self):
url = reverse(
'delete_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
response = self.client.get(url)
self.assertEqual(response.status_code, 405)
def test_get_edit_application_form(self):
url = reverse(
'create_or_update_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(context['a_tutor'], self.tutor)
self.assertEqual(context['learning_container_year'],
self.lagro1600_next)
self.assertTrue(context['form'])
def test_post_edit_application_form(self):
url = reverse(
'create_or_update_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
post_data = _get_application_example(self.lagro1600_next, '54', '7')
response = self.client.post(url, data=post_data, follow=True)
self.assertEqual(response.status_code, 200)
self.attribution.refresh_from_db()
self.assertEqual(len(self.attribution.applications), 1)
self.assertEqual(
self.attribution.applications[0]['charge_lecturing_asked'], '54.0')
self.assertEqual(
self.attribution.applications[0]['charge_practical_asked'], '7.0')
self.assertEqual(self.attribution.applications[0]['pending'],
tutor_application_epc.UPDATE_OPERATION)
def test_post_edit_application_form_with_empty_value(self):
url = reverse(
'create_or_update_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
post_data = _get_application_example(self.lagro1600_next, None, None)
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertTrue(context.get('form'))
form = context['form']
self.assertTrue(form.errors) # Not valid because not number entered
def test_post_edit_application_form_with_empty_lecturing_value(self):
url = reverse(
'create_or_update_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
post_data = _get_application_example(self.lagro1600_next, "15", "")
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302)
self.attribution.refresh_from_db()
self.assertEqual(len(self.attribution.applications), 1)
self.assertEqual(
self.attribution.applications[0]['charge_lecturing_asked'], '15.0')
self.assertEqual(
self.attribution.applications[0]['charge_practical_asked'], '0.0')
self.assertEqual(self.attribution.applications[0]['pending'],
tutor_application_epc.UPDATE_OPERATION)
def test_post_edit_application_form_with_value_under_zero(self):
url = reverse(
'create_or_update_tutor_application',
kwargs={'learning_container_year_id': self.lagro1600_next.id})
post_data = _get_application_example(self.lagro1600_next, '-1', '5')
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertTrue(context.get('form'))
form = context['form']
self.assertTrue(form.errors) # Not valid because -1 entered
def test_post_overview_with_lecturing_and_practical_component_partim(self):
self.attribution.delete()
self.attribution = AttributionNewFactory(
global_id=self.tutor.person.global_id,
applications=[
_get_application_example(self.lbira2101_next, "10", "10")
])
url = reverse('applications_overview')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(len(context['applications']), 1)
self.assertEqual(context['applications'][0]['acronym'],
self.lbira2101_next.acronym)
with self.assertRaises(KeyError):
context['applications'][0]['PRACTICAL_EXERCISES']
with self.assertRaises(KeyError):
context['applications'][0]['LECTURING']
def _create_multiple_learning_container_year(self):
# Creation learning container for current academic year
self.lbir1200_current = _create_learning_container_with_components(
"LBIR1200", self.current_academic_year)
self.lbir1300_current = _create_learning_container_with_components(
"LBIR1300", self.current_academic_year)
self.ldroi1500_current = _create_learning_container_with_components(
"LDROI1500", self.current_academic_year)
self.lbira2101_current = _create_learning_container_with_components(
"LBIRA2101",
self.current_academic_year,
subtype=learning_unit_year_subtypes.PARTIM)
# Creation learning container for next academic year [==> application academic year]
self.lbir1200_next = _create_learning_container_with_components(
"LBIR1200", self.application_academic_year, 70, 70)
self.lbir1300_next = _create_learning_container_with_components(
"LBIR1300", self.application_academic_year, 60, 60)
self.lagro1600_next = _create_learning_container_with_components(
"LAGRO1600", self.application_academic_year, 54, 7)
self.lagro2500_next = _create_learning_container_with_components(
"LAGRO2500", self.application_academic_year, 0, 70)
self.lbira2101_next = _create_learning_container_with_components(
"LBIRA2101",
self.application_academic_year,
20,
20,
subtype=learning_unit_year_subtypes.PARTIM)
def _get_default_application_list(self):
return [_get_application_example(self.lagro1600_next, '15', '0')]
def _get_default_attribution_list(self):
return [
# Attribution in current year
_get_attribution_example(self.lbir1200_current, '20.0', '31.5',
2015, 2019),
_get_attribution_example(self.lbir1300_current, '21.5', '40', 2015,
self.current_academic_year.year),
# Attribution in next year
_get_attribution_example(self.lagro2500_next, '29', '10', 2015,
2020)
]
def setUp(self):
self.academic_calendar = AcademicCalendarFactory(
academic_year=self.academic_year)
self.client.force_login(self.person.user)
self.url = reverse('academic_calendar_delete',
kwargs={'pk': self.academic_calendar.pk})
def test_compute_deadline_is_called_case_academic_calendar_save(self):
with mock.patch.object(compute_all_scores_encodings_deadlines,
'send') as mock_method:
AcademicCalendarFactory()
self.assertTrue(mock_method.called)
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)
def test_case_not_yet_persistent_parameter(self):
academic_calendar = AcademicCalendarFactory.build(
academic_year=self.academic_year)
with self.assertRaises(ValueError):
offer_year_calendar.save_from_academic_calendar(academic_calendar)
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)
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)
class TestEducationGroupAsFacultyManagerTag(TestCase):
""" This class will test the tag as faculty manager """
def setUp(self):
self.education_group_year = TrainingFactory()
self.person = FacultyManagerFactory("delete_educationgroup", "change_educationgroup", "add_educationgroup")
PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity)
current_ac = create_current_academic_year()
# 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.next_ac = AcademicYearFactory(year=current_ac.year + 1)
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 test_button_tag_case_not_in_education_group_edition_period(self):
""" This test ensure that as faculty manager, the button tag is disabled when outside of encoding period"""
self.academic_calendar.delete()
result = button_with_permission(self.context, "title", "id", "edit")
self.assertEqual(result, BUTTON_TEMPLATE.format(PERMISSION_DENIED_MSG, "id", "disabled", "fa-edit"))
def test_button_tag_case_inside_education_group_edition_period(self):
self.education_group_year.academic_year = self.next_ac
result = button_with_permission(self.context, "title", "id", "edit")
self.assertEqual(result, BUTTON_TEMPLATE.format("title", "id", "", "fa-edit"))
def test_li_tag_case_not_in_education_group_edition_period(self):
""" This test ensure that as faculty manager, the li tag is disabled when outside of encoding period"""
self.academic_calendar.delete()
result = li_with_deletion_perm(self.context, self.url, DELETE_MSG)
self.assertEqual(result, DISABLED_LI.format("link_delete", PERMISSION_DENIED_MSG, DELETE_MSG))
def test_li_tag_case_inside_education_group_edition_period(self):
self.education_group_year.academic_year = self.next_ac
result = li_with_deletion_perm(self.context, self.url, DELETE_MSG)
self.assertEqual(result, ENABLED_LI.format("link_delete", self.url, DELETE_MSG))
def test_li_tag_case_mini_training_disabled(self):
"""
This test ensure that as faculty manager, the li tag is disabled for mini training
Faculty manager must enter in proposition mode for mini training
"""
self.context['education_group_year'] = MiniTrainingFactory()
result = li_with_create_perm_mini_training(self.context, self.url, "")
msg = _("The user has not permission to create a %(category)s.") % {"category": _(MINI_TRAINING)}
msg = msg.capitalize()
self.assertHTMLEqual(result, DISABLED_LI.format("link_create_mini_training", msg, ""))
def test_li_tag_case_training_disabled(self):
"""
This test ensure that as faculty manager, the li tag is disabled for training
Faculty manager must enter in proposition mode for training
"""
self.context['education_group_year'] = TrainingFactory()
result = li_with_create_perm_training(self.context, self.url, "")
msg = _("The user has not permission to create a %(category)s.") % {"category": _(TRAINING)}
msg = msg.capitalize()
self.assertHTMLEqual(result, DISABLED_LI.format("link_create_training", msg, ""))
def test_button_edit_administrative_data(self):
result = button_edit_administrative_data(self.context)
self.assertEqual(
result["url"],
reverse('education_group_edit_administrative', args=[
self.education_group_year.pk,
self.education_group_year.pk
])
)
self.assertEqual(
result["message"],
_('Only program managers of the education group OR central manager linked to entity can edit.')
)
self.assertEqual(result["is_disabled"], "disabled")
self.assertEqual(result["text"], _("edit"))
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,
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()
# Mock academic_year / session_exam_calendar in order to be decouple from system time
self.mock_academic_year(
current_academic_year=academic_year,
starting_academic_year=academic_year,
)
self.mock_session_exam_calendar(
current_session_exam=self.session_exam_calendar)
def setUp(self):
self.academic_year = AcademicYearFactory() # Current academic year
self.academic_calendar = AcademicCalendarFactory.build(
academic_year=self.academic_year)
self.academic_calendar.save(functions=[])
class OutsideEncodingPeriodTest(AcademicYearMockMixin, SessionExamCalendarMockMixin, TestCase):
def setUp(self):
self.user = User.objects.create_user(username='******', password='******')
add_permission(self.user, "can_access_scoreencoding")
self.client.force_login(self.user)
# Create context out of range
self.academic_year = _get_academic_year(2017)
self.academic_calendar = AcademicCalendarFactory(title="Submission of score encoding - 1",
academic_year=self.academic_year,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
self.session_exam_calendar = SessionExamCalendarFactory(academic_calendar=self.academic_calendar,
number_session=number_session.ONE)
# 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=None)
def test_redirection_to_current_exam_session(self):
self.mock_session_exam_calendar(current_session_exam=self.session_exam_calendar)
url = reverse('outside_scores_encodings_period')
response = self.client.get(url)
self.assertRedirects(response, "%s?next=%s" % (reverse('scores_encoding'), reverse('outside_scores_encodings_period'))) # Redirection
def test_redirection_to_outside_encoding_period(self):
url = reverse('scores_encoding')
response = self.client.get(url)
self.assertRedirects(response, "%s?next=%s" % (reverse('outside_scores_encodings_period'), reverse('scores_encoding'))) # Redirection
def test_message_score_encoding_not_open(self):
self.session_exam_calendar.delete()
url = reverse('outside_scores_encodings_period')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0].tags, 'warning')
self.assertEqual(messages[0].message, _("The period of scores' encoding is not opened"))
def test_multiple_messages_outside_encoding_period(self):
date_format = str(_('date_format'))
# Submission of score encoding - 1 [Two day before today]
self.academic_calendar.end_date = timezone.now() - timedelta(days=2)
self.academic_calendar.start_date = timezone.now() - timedelta(days=20)
self.academic_calendar.save()
# Create submission of score encoding - 2 [Start in 100 days]
ac = AcademicCalendarFactory.build(title="Submission of score encoding - 2",
academic_year=self.academic_year,
start_date=self.academic_calendar.end_date + timedelta(days=100),
end_date=self.academic_calendar.end_date + timedelta(days=130),
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
ac.save()
SessionExamCalendarFactory(academic_calendar=ac, number_session=number_session.TWO)
url = reverse('scores_encoding')
response = self.client.get(url, follow=True)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 2)
self.assertEqual(messages[0].tags, 'warning')
end_date_str = self.academic_calendar.end_date.strftime(date_format)
self.assertEqual(messages[0].message,
_("The period of scores' encoding %(session_number)s is closed since %(str_date)s")
% {'session_number': 1, 'str_date': end_date_str})
self.assertEqual(messages[1].tags, 'warning')
start_date_str = ac.start_date.strftime(date_format)
self.assertEqual(messages[1].message,
_("The period of scores' encoding %(session_number)s will be open %(str_date)s")
% {'session_number': 2, 'str_date': start_date_str})
class OutsideEncodingPeriodTest(TestCase):
def setUp(self):
self.user = User.objects.create_user(username='******',
password='******')
add_permission(self.user, "can_access_scoreencoding")
self.client.force_login(self.user)
# Create context out of range
self.academic_year = _get_academic_year(2017)
self.academic_calendar = AcademicCalendarFactory(
title="Submission of score encoding - 1",
academic_year=self.academic_year,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
self.session_exam_calendar = SessionExamCalendarFactory(
academic_calendar=self.academic_calendar,
number_session=number_session.ONE)
def test_redirection_to_current_exam_session(self):
url = reverse('outside_scores_encodings_period')
response = self.client.get(url)
self.assertRedirects(
response, "%s?next=%s" %
(reverse('scores_encoding'),
reverse('outside_scores_encodings_period'))) # Redirection
def test_redirection_to_outside_encoding_period(self):
self.session_exam_calendar.delete()
url = reverse('scores_encoding')
response = self.client.get(url)
self.assertRedirects(response, "%s?next=%s" %
(reverse('outside_scores_encodings_period'),
reverse('scores_encoding'))) # Redirection
def test_message_score_encoding_not_open(self):
self.session_exam_calendar.delete()
url = reverse('outside_scores_encodings_period')
response = self.client.get(url)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0].tags, 'warning')
self.assertEqual(messages[0].message,
_('score_encoding_period_not_open'))
def test_multiple_messages_outside_encoding_period(self):
date_format = str(_('date_format'))
# Submission of score encoding - 1 [Two day before today]
self.academic_calendar.end_date = timezone.now() - timedelta(days=2)
self.academic_calendar.start_date = timezone.now() - timedelta(days=20)
self.academic_calendar.save()
# Create submission of score encoding - 2 [Start in 100 days]
ac = AcademicCalendarFactory.build(
title="Submission of score encoding - 2",
academic_year=self.academic_year,
start_date=self.academic_calendar.end_date + timedelta(days=100),
end_date=self.academic_calendar.end_date + timedelta(days=130),
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
ac.save()
SessionExamCalendarFactory(academic_calendar=ac,
number_session=number_session.TWO)
url = reverse('scores_encoding')
response = self.client.get(url, follow=True)
messages = list(response.context['messages'])
self.assertEqual(len(messages), 2)
self.assertEqual(messages[0].tags, 'warning')
end_date_str = self.academic_calendar.end_date.strftime(date_format)
self.assertEqual(
messages[0].message,
_('outside_scores_encodings_period_latest_session') %
(1, end_date_str))
self.assertEqual(messages[1].tags, 'warning')
start_date_str = ac.start_date.strftime(date_format)
self.assertEqual(
messages[1].message,
_('outside_scores_encodings_period_closest_session') %
(2, start_date_str))
def test_start_date_higher_than_end_date(self):
fake = Faker()
with self.assertRaises(StartDateHigherThanEndDateException):
AcademicCalendarFactory(start_date=fake.future_date(),
end_date=fake.past_date())
def setUpTestData(cls):
cls.current_academic_calendar = AcademicCalendarFactory(
academic_year=create_current_academic_year(),
reference=academic_calendar_type.EXAM_ENROLLMENTS)
def setUpTestData(cls):
cls.current_academic_year = create_current_academic_year()
cls.current_academic_calendar = AcademicCalendarFactory(
academic_year=cls.current_academic_year,
reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION)
class TestEducationGroupTag(TestCase):
def setUp(self):
self.education_group_year = EducationGroupYearFactory()
self.person = PersonFactory()
PersonEntityFactory(person=self.person,
entity=self.education_group_year.management_entity)
self.url = reverse(
'delete_education_group',
args=[self.education_group_year.id, self.education_group_year.id])
self.person.user.user_permissions.add(
Permission.objects.get(codename="delete_educationgroup"))
self.person.user.user_permissions.add(
Permission.objects.get(codename="change_educationgroup"))
self.person.user.user_permissions.add(
Permission.objects.get(codename="add_educationgroup"))
self.client.force_login(user=self.person.user)
self.academic_calendar = AcademicCalendarFactory(
reference=EDUCATION_GROUP_EDITION,
start_date=timezone.now(),
end_date=timezone.now())
self.context = {
"person": self.person,
"education_group_year": self.education_group_year,
"request": RequestFactory().get("")
}
def test_li_with_deletion_perm(self):
result = li_with_deletion_perm(self.context, self.url, DELETE_MSG)
self.assertEqual(
result, ENABLED_LI.format("link_delete", self.url, DELETE_MSG))
def test_li_without_deletion_perm(self):
self.academic_calendar.delete()
result = li_with_deletion_perm(self.context, self.url, DELETE_MSG)
self.assertEqual(
result,
DISABLED_LI.format("link_delete", PERMISSION_DENIED_MSG,
DELETE_MSG))
def test_button_with_permission(self):
result = button_with_permission(self.context, "title", "id", "edit")
self.assertEqual(result,
BUTTON_TEMPLATE.format("title", "id", "", "fa-edit"))
def test_a_without_permission(self):
self.academic_calendar.delete()
result = button_with_permission(self.context, "title", "id", "edit")
self.assertEqual(
result,
BUTTON_TEMPLATE.format(PERMISSION_DENIED_MSG, "id", "disabled",
"fa-edit"))
def test_button_order_with_permission(self):
result = button_order_with_permission(self.context, "title", "id",
"edit")
self.assertEqual(
result,
BUTTON_ORDER_TEMPLATE.format("title", "id", "edit", "", "fa-edit"))
def test__without_permission(self):
self.academic_calendar.delete()
result = button_order_with_permission(self.context, "title", "id",
"edit")
self.assertEqual(
result,
BUTTON_ORDER_TEMPLATE.format(PERMISSION_DENIED_MSG, "id", "edit",
"disabled", "fa-edit"))
def test_li_with_create_perm_training(self):
relation = AuthorizedRelationshipFactory(
parent_type=self.education_group_year.education_group_type)
relation.child_type.category = TRAINING
relation.child_type.save()
result = li_with_create_perm_training(self.context, self.url, "")
self.assertHTMLEqual(result,
ENABLED_LI.format("link_create", self.url, ""))
def test_li_with_create_perm_mini_training(self):
relation = AuthorizedRelationshipFactory(
parent_type=self.education_group_year.education_group_type)
relation.child_type.category = MINI_TRAINING
relation.child_type.save()
result = li_with_create_perm_mini_training(self.context, self.url, "")
self.assertHTMLEqual(result,
ENABLED_LI.format("link_create", self.url, ""))
def test_li_with_create_perm_group(self):
relation = AuthorizedRelationshipFactory(
parent_type=self.education_group_year.education_group_type)
relation.child_type.category = GROUP
relation.child_type.save()
result = li_with_create_perm_group(self.context, self.url, "")
self.assertHTMLEqual(result,
ENABLED_LI.format("link_create", self.url, ""))
def test_li_with_create_perm_training_disabled(self):
result = li_with_create_perm_training(self.context, self.url, "")
msg = UNAUTHORIZED_TYPE_MSG % {
"category": _(
self.education_group_year.education_group_type.category),
"type": self.education_group_year.education_group_type.name
}
self.assertHTMLEqual(result,
DISABLED_LI.format("link_create", msg, ""))
def test_li_with_create_perm_mini_training_disabled(self):
result = li_with_create_perm_mini_training(self.context, self.url, "")
msg = UNAUTHORIZED_TYPE_MSG % {
"category": _(
self.education_group_year.education_group_type.category),
"type": self.education_group_year.education_group_type.name
}
self.assertHTMLEqual(result,
DISABLED_LI.format("link_create", msg, ""))
def test_li_with_create_perm_group_disabled(self):
result = li_with_create_perm_group(self.context, self.url, "")
msg = UNAUTHORIZED_TYPE_MSG % {
"category": _(
self.education_group_year.education_group_type.category),
"type": self.education_group_year.education_group_type.name
}
self.assertHTMLEqual(result,
DISABLED_LI.format("link_create", msg, ""))
