def test_get_best_proctored_exam_grade(self):
"""
Test get_best_proctorate_exam_grade to return a passed exam with the highest score
"""
mmtrack = MMTrack(
user=self.user,
program=self.program_financial_aid,
edx_user_data=self.cached_edx_user_data
)
finaid_course = self.crun_fa.course
last_week = now_in_utc() - timedelta(weeks=1)
ProctoredExamGradeFactory.create(user=self.user, course=finaid_course, passed=False, percentage_grade=0.6)
assert mmtrack.get_best_proctored_exam_grade(finaid_course) is None
best_exam = ProctoredExamGradeFactory.create(
user=self.user, course=finaid_course, passed=True, percentage_grade=0.9,
exam_run__date_grades_available=last_week
)
assert mmtrack.get_best_proctored_exam_grade(finaid_course) == best_exam
ProctoredExamGradeFactory.create(
user=self.user, course=finaid_course, passed=True, percentage_grade=0.8,
exam_run__date_grades_available=last_week
)
assert mmtrack.get_best_proctored_exam_grade(finaid_course) == best_exam
def test_combined_grade_created_updated(self):
"""
Test create and update
"""
combined_grade_qset = CombinedFinalGrade.objects.filter(user=self.user, course=self.course_run.course)
# no passing final grade
api.update_or_create_combined_final_grade(self.user, self.course_run.course)
assert combined_grade_qset.exists() is False
FinalGradeFactory.create(user=self.user, course_run__course=self.course_run.course, grade=0.6, passed=True)
# no passing exam grade
api.update_or_create_combined_final_grade(self.user, self.course_run.course)
assert combined_grade_qset.exists() is False
ProctoredExamGradeFactory.create(
user=self.user,
course=self.course_run.course,
percentage_grade=0.8,
passed=True,
exam_run=self.exam_run
)
# now should create combined grade
api.update_or_create_combined_final_grade(self.user, self.course_run.course)
assert combined_grade_qset.exists() is True
# now update it with a new grade
FinalGradeFactory.create(user=self.user, course_run__course=self.course_run.course, grade=0.8, passed=True)
api.update_or_create_combined_final_grade(self.user, self.course_run.course)
assert combined_grade_qset.first().grade == 80.0
def test_get_best_proctored_exam_grade(self):
"""
Test get_best_proctorate_exam_grade to return a passed exam with the highest score
"""
mmtrack = MMTrack(
user=self.user,
program=self.program_financial_aid,
edx_user_data=self.cached_edx_user_data
)
finaid_course = self.crun_fa.course
last_week = now_in_utc() - timedelta(weeks=1)
ProctoredExamGradeFactory.create(user=self.user, course=finaid_course, passed=False, percentage_grade=0.6)
assert mmtrack.get_best_proctored_exam_grade(finaid_course) is None
best_exam = ProctoredExamGradeFactory.create(
user=self.user, course=finaid_course, passed=True, percentage_grade=0.9,
exam_run__date_grades_available=last_week
)
assert mmtrack.get_best_proctored_exam_grade(finaid_course) == best_exam
ProctoredExamGradeFactory.create(
user=self.user, course=finaid_course, passed=True, percentage_grade=0.8,
exam_run__date_grades_available=last_week
)
assert mmtrack.get_best_proctored_exam_grade(finaid_course) == best_exam
def test_combined_grade_created_updated(self):
"""
Test create and update
"""
combined_grade_qset = CombinedFinalGrade.objects.filter(user=self.user, course=self.course_run.course)
# no passing final grade
api.update_or_create_combined_final_grade(self.user, self.course_run.course)
assert combined_grade_qset.exists() is False
FinalGradeFactory.create(user=self.user, course_run__course=self.course_run.course, grade=0.6, passed=True)
# no passing exam grade
api.update_or_create_combined_final_grade(self.user, self.course_run.course)
assert combined_grade_qset.exists() is False
ProctoredExamGradeFactory.create(
user=self.user,
course=self.course_run.course,
percentage_grade=0.8,
passed=True,
exam_run=self.exam_run
)
# now should create combined grade
api.update_or_create_combined_final_grade(self.user, self.course_run.course)
assert combined_grade_qset.exists() is True
# now update it with a new grade
FinalGradeFactory.create(user=self.user, course_run__course=self.course_run.course, grade=0.8, passed=True)
api.update_or_create_combined_final_grade(self.user, self.course_run.course)
assert combined_grade_qset.first().grade == 80.0
def test_create_exam_grade(self, update_grade_mock, mock_on_commit):
"""
Test that update_or_create_combined_final_grade is called when a proctored exam
grade is created or updated
"""
exam_grade = ProctoredExamGradeFactory.create(user=self.user, course=self.course)
update_grade_mock.assert_called_once_with(self.user, self.course)
exam_grade.save()
assert update_grade_mock.call_count == 2
# create another exam grade for a different exam run
ProctoredExamGradeFactory.create(user=self.user, course=self.course)
assert update_grade_mock.call_count == 3
def test_create_exam_grade(self, update_grade_mock, mock_on_commit):
"""
Test that update_or_create_combined_final_grade is called when a proctored exam
grade is created or updated
"""
exam_grade = ProctoredExamGradeFactory.create(user=self.user,
course=self.course)
update_grade_mock.assert_called_once_with(self.user, self.course)
exam_grade.save()
assert update_grade_mock.call_count == 2
# create another exam grade for a different exam run
ProctoredExamGradeFactory.create(user=self.user, course=self.course)
assert update_grade_mock.call_count == 3
def test_for_user_course(self):
"""Tests that for_user_course() does not return unavailable grades"""
user = UserFactory.create()
course = CourseFactory.create()
available_grade = ProctoredExamGradeFactory.create(
user=user,
course=course,
exam_run__course=course,
exam_run__eligibility_past=True)
ProctoredExamGradeFactory.create(user=user,
course=course,
exam_run__course=course,
exam_run__eligibility_future=True)
grades = ProctoredExamGrade.for_user_course(user, course)
assert list(grades) == [available_grade]
def test_create_exam_grade(self, update_grade_mock, mock_on_commit):
"""
Test that update_existing_combined_final_grade_for_exam_run is called when a proctored exam
grade is created and ExamRun updated
"""
exam_grade = ProctoredExamGradeFactory.create(user=self.user,
course=self.course)
assert update_grade_mock.call_count == 0
exam_grade.exam_run.save()
assert update_grade_mock.call_count == 1
# create another exam grade for a different exam run
exam_grade = ProctoredExamGradeFactory.create(user=self.user,
course=self.course)
assert update_grade_mock.call_count == 1
exam_grade.exam_run.save()
assert update_grade_mock.call_count == 2
def test_update_existing_combined_final_grade_for_exam_run(self, update_or_create_mock):
"""
Test update_existing_combined_final_grade_for_exam_run
"""
ProctoredExamGradeFactory.create(
user=self.user,
course=self.course_run.course,
percentage_grade=0.6,
passed=True,
exam_run=self.exam_run
)
FinalGradeFactory.create(user=self.user, course_run__course=self.course_run.course, grade=0.8, passed=True)
# should only update if combined grade already exists for user
api.update_existing_combined_final_grade_for_exam_run(self.exam_run)
assert update_or_create_mock.called is False
CombinedFinalGrade.objects.create(user=self.user, course=self.course_run.course, grade=0.7)
# should call it once since there is an existing combined grade
api.update_existing_combined_final_grade_for_exam_run(self.exam_run)
update_or_create_mock.assert_called_once_with(self.user, self.course_run.course)
exam_run = ExamRunFactory.create(
course=self.course_run.course,
date_grades_available=now_in_utc() - timedelta(weeks=1)
)
ProctoredExamGradeFactory.create(
user=self.user,
course=self.course_run.course,
percentage_grade=0.8,
passed=True,
exam_run=exam_run
)
# should call it again for a different exam grade
api.update_existing_combined_final_grade_for_exam_run(exam_run)
assert update_or_create_mock.call_count == 2
def create_exams(self, current, edx_passed, exam_passed, new_offering, can_schedule, future_exam, need_to_pay):
"""Create an exam and mark it and the related course as passed or not passed"""
# pylint: disable-msg=too-many-arguments
self.make_fa_program_enrollment(FinancialAidStatus.AUTO_APPROVED)
course = Course.objects.get(title='Digital Learning 200')
if current:
course_run = CourseRunFactory(course=course)
call_command(
"alter_data", 'set_to_enrolled', '--username', 'staff',
'--course-run-key', course_run.edx_course_key
)
FinalGradeFactory.create(
user=self.user, course_run=course_run, grade=0.8 if edx_passed else 0.2, passed=True
)
else:
if edx_passed:
call_command(
"alter_data", 'set_to_passed', '--username', 'staff',
'--course-title', 'Digital Learning 200', '--grade', '75',
)
else:
call_command(
"alter_data", 'set_to_failed', '--username', 'staff',
'--course-title', 'Digital Learning 200', '--grade', '45',
)
course_run = course.courserun_set.first()
ExamProfileFactory.create(status='success', profile=self.user.profile)
exam_run = ExamRunFactory.create(course=course, eligibility_past=True, scheduling_past=True)
ExamAuthorizationFactory.create(
user=self.user, course=course, exam_run=exam_run, status='success', exam_taken=True
)
LineFactory.create(
order__status=Order.FULFILLED,
course_key=course_run
)
ProctoredExamGradeFactory.create(
user=self.user,
course=course,
exam_run=exam_run,
passed=exam_passed,
percentage_grade=0.8 if exam_passed else 0.3
)
if new_offering:
CourseRunFactory.create(course=course)
if can_schedule:
exam_run = ExamRunFactory.create(
scheduling_past=False,
scheduling_future=False,
authorized=True,
course=course
)
ExamAuthorizationFactory.create(
user=self.user, course=course, exam_run=exam_run, status='success',
)
if future_exam:
ExamRunFactory.create(
scheduling_past=False,
scheduling_future=True,
authorized=True,
course=course
)
if need_to_pay:
exam_run = ExamRunFactory.create(course=course, eligibility_past=True, scheduling_past=True)
ExamAuthorizationFactory.create(
user=self.user, course=course, exam_run=exam_run, status='success', exam_taken=True
)
ProctoredExamGradeFactory.create(
user=self.user,
course=course,
exam_run=exam_run,
passed=False,
percentage_grade=0.3
)