def two_no_show_exam_attempts(self):
"""Passed and later failed course, and two exam attempts"""
self.make_fa_program_enrollment(FinancialAidStatus.AUTO_APPROVED)
course = Course.objects.get(title='Digital Learning 200')
course_run = CourseRunFactory(course=course, edx_course_key='course-passed')
call_command(
"alter_data", 'set_to_passed', '--username', 'staff',
'--course-run-key', course_run.edx_course_key
)
ExamProfileFactory.create(status='success', profile=self.user.profile)
# run 1
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, exam_no_show=True
)
# run 2
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, exam_no_show=True
)
# another offered
course_run = CourseRunFactory.create(course=course, edx_course_key='course-enrollable')
call_command(
"alter_data", 'set_to_offered', '--username', 'staff',
'--course-run-key', course_run.edx_course_key
)
course_run = CourseRunFactory.create(course=course, edx_course_key='course-failed')
call_command(
"alter_data", 'set_to_failed', '--username', 'staff',
'--course-run-key', course_run.edx_course_key, '--audit',
)
def test_count_courses_mixed_fa(self):
"""
Test count_courses_passed with mixed course-exam configuration
"""
mmtrack = MMTrack(
user=self.user,
program=self.program_financial_aid,
edx_user_data=self.cached_edx_user_data
)
# this is course with exam run and the user has CombinedFinalGrade for it
course_with_exam_1 = CourseFactory.create(program=self.program_financial_aid)
ExamRunFactory.create(course=course_with_exam_1, date_grades_available=now_in_utc()-timedelta(weeks=1))
CombinedFinalGrade.objects.create(user=self.user, course=course_with_exam_1, grade=0.7)
# create course with exam run the user did not pass
ExamRunFactory.create(
course__program=self.program_financial_aid,
date_grades_available=now_in_utc() - timedelta(weeks=1)
)
# another course with no exam
FinalGradeFactory.create(
user=self.user,
course_run=self.crun_fa,
passed=True
)
assert mmtrack.count_courses_passed() == 2
def test_authorize_exam_runs(self, authorized,
authorize_for_latest_passed_course_mock):
"""Test authorize_exam_runs()"""
program, _ = create_program()
course = program.course_set.first()
enrollment = ProgramEnrollmentFactory.create(program=program)
current_run = ExamRunFactory.create(course=course,
authorized=authorized)
past_run = ExamRunFactory.create(course=course,
scheduling_future=True,
authorized=authorized)
future_run = ExamRunFactory.create(course=course,
scheduling_past=True,
authorized=authorized)
authorize_exam_runs()
if authorized:
assert authorize_for_latest_passed_course_mock.call_count == 0
else:
assert authorize_for_latest_passed_course_mock.call_count == 2
authorize_for_latest_passed_course_mock.assert_any_call(
enrollment.user, current_run)
authorize_for_latest_passed_course_mock.assert_any_call(
enrollment.user, future_run)
for exam_run in (current_run, future_run):
exam_run.refresh_from_db()
assert exam_run.authorized is True
past_run.refresh_from_db()
assert past_run.authorized is False
def test_count_courses_mixed_fa(self):
"""
Test count_courses_passed with mixed course-exam configuration
"""
mmtrack = MMTrack(
user=self.user,
program=self.program_financial_aid,
edx_user_data=self.cached_edx_user_data
)
# this is course with exam run and the user has CombinedFinalGrade for it
course_with_exam_1 = CourseFactory.create(program=self.program_financial_aid)
ExamRunFactory.create(course=course_with_exam_1, date_grades_available=now_in_utc()-timedelta(weeks=1))
CombinedFinalGrade.objects.create(user=self.user, course=course_with_exam_1, grade=0.7)
# create course with exam run the user did not pass
ExamRunFactory.create(
course__program=self.program_financial_aid,
date_grades_available=now_in_utc() - timedelta(weeks=1)
)
# another course with no exam
FinalGradeFactory.create(
user=self.user,
course_run=self.crun_fa,
passed=True
)
assert mmtrack.count_courses_passed() == 2
def create_missed_payment_for_exam(self, enrollable, future_exam, current):
"""Passed course but missed deadline to pay to take exam"""
self.make_fa_program_enrollment(FinancialAidStatus.AUTO_APPROVED)
if current:
call_command(
"alter_data", 'set_to_enrolled', '--username', 'staff',
'--course-title', 'Digital Learning 200',
'--missed-deadline'
)
else:
call_command(
"alter_data", 'set_past_run_to_passed', '--username', 'staff',
'--course-title', 'Digital Learning 200', '--grade', '87', '--audit',
'--missed-deadline'
)
course = Course.objects.get(title='Digital Learning 200')
ExamProfileFactory.create(status='success', profile=self.user.profile)
ExamRunFactory.create(course=course, eligibility_past=True, scheduling_past=True)
if enrollable:
course_run = CourseRunFactory.create(course=course, edx_course_key='course-enrollable')
call_command(
"alter_data", 'set_to_offered', '--username', 'staff',
'--course-run-key', course_run.edx_course_key
)
if future_exam:
ExamRunFactory.create(
scheduling_past=False,
scheduling_future=True,
authorized=True,
course=course
)
def test_get_exam_card_status_for_edx_exams(self, profile_status, expected_status, make_exam_run,
make_profile, make_auth):
"""
test get_exam_card_status
"""
now = now_in_utc()
exam_run = None
if make_exam_run:
exam_run = ExamRunFactory.create(
course=self.course,
date_first_eligible=now - timedelta(weeks=1),
date_last_eligible=now + timedelta(weeks=1),
)
if make_profile:
ExamProfileFactory.create(
profile=self.user.profile,
status=profile_status,
)
if make_auth:
ExamAuthorizationFactory.create(
user=self.user,
status=ExamAuthorization.STATUS_SUCCESS,
exam_run=exam_run,
)
mmtrack = MMTrack(
user=self.user,
program=self.program,
edx_user_data=self.cached_edx_user_data
)
assert mmtrack.get_exam_card_status() == expected_status
def test_get_overall_final_grade_for_course(self):
"""
Test for get_overall_final_grade_for_course to return CombinedFinalGrade for course
"""
mmtrack = MMTrack(
user=self.user,
program=self.program_financial_aid,
edx_user_data=self.cached_edx_user_data
)
finaid_course = self.crun_fa.course
assert mmtrack.get_overall_final_grade_for_course(finaid_course) == ""
FinalGradeFactory.create(user=self.user, course_run=self.crun_fa, passed=True, grade=0.8)
assert mmtrack.get_overall_final_grade_for_course(finaid_course) == "80"
ExamRunFactory.create(course=finaid_course)
CombinedFinalGrade.objects.create(user=self.user, course=finaid_course, grade="74")
assert mmtrack.get_overall_final_grade_for_course(finaid_course) == "74"
def test_get_pearson_exam_status(self, profile_status, expected_status, make_exam_run,
make_profile, make_auth, log_error_called, log_mock):
"""
test get_pearson_exam_status
"""
now = now_in_utc()
exam_run = None
if make_exam_run:
exam_run = ExamRunFactory.create(
course=self.course,
date_first_eligible=now - timedelta(weeks=1),
date_last_eligible=now + timedelta(weeks=1),
)
if make_profile:
ExamProfileFactory.create(
profile=self.user.profile,
status=profile_status,
)
if make_auth:
ExamAuthorizationFactory.create(
user=self.user,
status=ExamAuthorization.STATUS_SUCCESS,
exam_run=exam_run,
)
mmtrack = MMTrack(
user=self.user,
program=self.program,
edx_user_data=self.cached_edx_user_data
)
assert mmtrack.get_pearson_exam_status() == expected_status
assert log_mock.error.called is log_error_called
def test_exam_authorization_attempts_consumed(self):
"""
test exam_authorization when user passed and paid, but used all their attempts
"""
create_order(self.user, self.course_run)
mmtrack = get_mmtrack(self.user, self.program)
self.assertTrue(mmtrack.has_paid(self.course_run.edx_course_key))
self.assertTrue(mmtrack.has_passed_course(self.course_run.edx_course_key))
old_run = ExamRunFactory.create(course=self.course_run.course)
ExamAuthorizationFactory.create_batch(
ATTEMPTS_PER_PAID_RUN,
exam_run=old_run,
user=mmtrack.user,
course=self.course_run.course,
exam_taken=True,
)
assert ExamAuthorization.objects.filter(
user=mmtrack.user,
course=self.course_run.course
).count() == 2
with self.assertRaises(ExamAuthorizationException):
authorize_for_exam_run(mmtrack, self.course_run, self.exam_run)
# assert no new authorizations got created
assert ExamAuthorization.objects.filter(
user=mmtrack.user,
course=self.course_run.course
).count() == 2
def test_exam_authorization_attempts_consumed(self):
"""
test exam_authorization when user passed and paid, but used all their attempts
"""
create_order(self.user, self.course_run)
mmtrack = get_mmtrack(self.user, self.program)
self.assertTrue(mmtrack.has_paid(self.course_run.edx_course_key))
self.assertTrue(
mmtrack.has_passed_course(self.course_run.edx_course_key))
old_run = ExamRunFactory.create(course=self.course_run.course)
ExamAuthorizationFactory.create_batch(
ATTEMPTS_PER_PAID_RUN,
exam_run=old_run,
user=mmtrack.user,
course=self.course_run.course,
exam_taken=True,
)
assert ExamAuthorization.objects.filter(
user=mmtrack.user, course=self.course_run.course).count() == 2
with self.assertRaises(ExamAuthorizationException):
authorize_for_exam_run(self.user, self.course_run, self.exam_run)
# assert no new authorizations got created
assert ExamAuthorization.objects.filter(
user=mmtrack.user, course=self.course_run.course).count() == 2
def test_get_overall_final_grade_for_course(self):
"""
Test for get_overall_final_grade_for_course to return CombinedFinalGrade for course
"""
mmtrack = MMTrack(
user=self.user,
program=self.program_financial_aid,
edx_user_data=self.cached_edx_user_data
)
finaid_course = self.crun_fa.course
assert mmtrack.get_overall_final_grade_for_course(finaid_course) == ""
FinalGradeFactory.create(user=self.user, course_run=self.crun_fa, passed=True, grade=0.8)
assert mmtrack.get_overall_final_grade_for_course(finaid_course) == "80"
ExamRunFactory.create(course=finaid_course)
CombinedFinalGrade.objects.create(user=self.user, course=finaid_course, grade="74")
assert mmtrack.get_overall_final_grade_for_course(finaid_course) == "74"
def test_update_exam_run(self, update_mock):
"""Test update_exam_run()"""
exam_run = ExamRunFactory.create()
update_exam_run(exam_run.id)
update_exam_run(-exam_run.id)
update_mock.assert_called_once_with(exam_run)
def test_update_exam_run(self, update_mock):
"""Test update_exam_run()"""
exam_run = ExamRunFactory.create()
update_exam_run(exam_run.id)
update_exam_run(-exam_run.id)
update_mock.assert_called_once_with(exam_run)
def setUpTestData(cls):
cls.user = SocialUserFactory.create()
cls.course_run = CourseRunFactory.create(
course__program__financial_aid_availability=True)
cls.exam_run = ExamRunFactory.create(
course=cls.course_run.course,
date_grades_available=now_in_utc() - timedelta(weeks=1))
cls.not_passing_final_grade = FinalGradeFactory.create(
user=cls.user, course_run=cls.course_run, grade=0.5, passed=False)
def test_exam_authorization_multiple_runs(self):
"""Test that if the first enrollment is invalid it checks the second, but not the third"""
exam_run = ExamRunFactory.create(course=self.course)
mmtrack = get_mmtrack(self.user, self.program)
with patch('exams.api.authorize_for_exam_run') as mock:
mock.side_effect = [ExamAuthorizationException('invalid'), None, None]
authorize_for_latest_passed_course(mmtrack, exam_run)
assert mock.call_count == 2
for enrollment in self.final_grades[:2]: # two most recent runs
mock.assert_any_call(mmtrack, enrollment.course_run, exam_run)
def test_authorize_exam_runs(self, authorized, bulk_authorize_for_exam_run_mock):
"""Test authorize_exam_runs()"""
current_run = ExamRunFactory.create(authorized=authorized)
past_run = ExamRunFactory.create(scheduling_future=True, authorized=authorized)
future_run = ExamRunFactory.create(scheduling_past=True, authorized=authorized)
authorize_exam_runs()
if authorized:
assert bulk_authorize_for_exam_run_mock.call_count == 0
else:
assert bulk_authorize_for_exam_run_mock.call_count == 2
# past run shouldn't be called
bulk_authorize_for_exam_run_mock.assert_any_call(current_run)
bulk_authorize_for_exam_run_mock.assert_any_call(future_run)
for exam_run in (current_run, future_run):
exam_run.refresh_from_db()
assert exam_run.authorized is True
past_run.refresh_from_db()
assert past_run.authorized is False
def test_bulk_authorize_for_exam_run_current(self):
"""Test that we do create an authorization for a current run"""
exam_run = ExamRunFactory.create(course=self.course_run.course)
assert ExamAuthorization.objects.filter(
course=exam_run.course,
).count() == 0
bulk_authorize_for_exam_run(exam_run)
assert ExamAuthorization.objects.filter(
course=exam_run.course,
).count() == 1
def test_authorize_enrollment_for_exam_run(self, authorize_for_latest_passed_course_mock):
"""Test authorize_enrollment_for_exam_run()"""
program, _ = create_program()
course = program.course_set.first()
enrollment_1 = ProgramEnrollmentFactory.create(program=program)
enrollment_2 = ProgramEnrollmentFactory.create(program=program)
exam_run = ExamRunFactory.create(course=course)
authorize_enrollment_for_exam_run([enrollment_1.id, enrollment_2.id], exam_run.id)
assert authorize_for_latest_passed_course_mock.call_count == 2
authorize_for_latest_passed_course_mock.assert_any_call(enrollment_1.user, exam_run)
authorize_for_latest_passed_course_mock.assert_any_call(enrollment_2.user, exam_run)
def test_get_corresponding_course_run(self, weeks, has_course_run):
"""test get_past_recent_exam_run"""
now = now_in_utc()
exam_run = ExamRunFactory.create(date_first_schedulable=now +
datetime.timedelta(weeks=weeks))
expected = CourseRunFactory.create(course=exam_run.course,
start_date=now -
datetime.timedelta(weeks=16),
end_date=now)
if has_course_run:
self.assertEqual(get_corresponding_course_run(exam_run), expected)
else:
self.assertEqual(get_corresponding_course_run(exam_run), None)
def test_has_future_exam(self):
"""Test course has exam"""
course_run = self.create_run()
assert course_run.has_future_exam is False
exam_run = ExamRunFactory.create(course=course_run.course)
assert course_run.has_future_exam is True
exam_run.delete()
assert course_run.has_future_exam is False
exam_run = ExamRunFactory.create(
course=course_run.course,
date_last_eligible=now_in_utc().date(),
)
assert course_run.has_future_exam is False
exam_run.delete()
assert course_run.has_future_exam is False
ExamRunFactory.create(
course=course_run.course,
date_last_eligible=(now_in_utc() - timedelta(days=1)).date(),
)
assert course_run.has_future_exam is False
def test_has_future_exam(self):
"""Test course has exam"""
course_run = self.create_run()
assert course_run.has_future_exam is False
exam_run = ExamRunFactory.create(course=course_run.course)
assert course_run.has_future_exam is True
exam_run.delete()
assert course_run.has_future_exam is False
exam_run = ExamRunFactory.create(
course=course_run.course,
date_last_eligible=now_in_utc().date(),
)
assert course_run.has_future_exam is False
exam_run.delete()
assert course_run.has_future_exam is False
ExamRunFactory.create(
course=course_run.course,
date_last_eligible=(now_in_utc() - timedelta(days=1)).date(),
)
assert course_run.has_future_exam is False
def test_bulk_authorize_for_exam_run_multiple(self):
"""Test that we check all program enrollments"""
ProgramEnrollmentFactory.create(program=self.program)
exam_run = ExamRunFactory.create(course=self.course_run.course)
assert ExamAuthorization.objects.filter(
course=exam_run.course,
).count() == 0
bulk_authorize_for_exam_run(exam_run)
assert ExamAuthorization.objects.filter(
course=exam_run.course,
user=self.user
).count() == 1
def test_authorize_exam_runs(self, authorized,
bulk_authorize_for_exam_run_mock):
"""Test authorize_exam_runs()"""
current_run = ExamRunFactory.create(authorized=authorized)
past_run = ExamRunFactory.create(scheduling_future=True,
authorized=authorized)
future_run = ExamRunFactory.create(scheduling_past=True,
authorized=authorized)
authorize_exam_runs()
if authorized:
assert bulk_authorize_for_exam_run_mock.call_count == 0
else:
assert bulk_authorize_for_exam_run_mock.call_count == 2
# past run shouldn't be called
bulk_authorize_for_exam_run_mock.assert_any_call(current_run)
bulk_authorize_for_exam_run_mock.assert_any_call(future_run)
for exam_run in (current_run, future_run):
exam_run.refresh_from_db()
assert exam_run.authorized is True
past_run.refresh_from_db()
assert past_run.authorized is False
def setUpTestData(cls):
cls.user = SocialUserFactory.create()
cls.course_run = CourseRunFactory.create(
course__program__financial_aid_availability=True
)
cls.exam_run = ExamRunFactory.create(
course=cls.course_run.course,
date_grades_available=now_in_utc() - timedelta(weeks=1)
)
cls.not_passing_final_grade = FinalGradeFactory.create(
user=cls.user,
course_run=cls.course_run,
grade=0.5,
passed=False
)
def test_bulk_authorize_for_exam_run_past(self):
"""Test that we don't create an authorization for a run in the past"""
exam_run = ExamRunFactory.create(
scheduling_past=True,
course=self.course_run.course,
)
assert ExamAuthorization.objects.filter(
course=exam_run.course,
).count() == 0
bulk_authorize_for_exam_run(exam_run)
assert ExamAuthorization.objects.filter(
course=exam_run.course,
).count() == 0
def setUpTestData(cls):
with mute_signals(post_save):
profile = ProfileFactory.create()
cls.program, _ = create_program(past=True)
cls.user = profile.user
cls.course_run = cls.program.course_set.first().courserun_set.first()
with mute_signals(post_save):
CachedEnrollmentFactory.create(user=cls.user, course_run=cls.course_run)
cls.exam_run = ExamRunFactory.create(course=cls.course_run.course)
with mute_signals(post_save):
cls.final_grade = FinalGradeFactory.create(
user=cls.user,
course_run=cls.course_run,
passed=True,
course_run_paid_on_edx=False,
)
def test_update_authorizations_for_exam_run(self, is_future, is_past):
"""Tests update_authorizations_for_exam_run()"""
exam_run = ExamRunFactory.create(scheduling_future=is_future,
scheduling_past=is_past)
taken_auth = ExamAuthorizationFactory.create(
exam_run=exam_run,
exam_taken=True,
status=ExamAuthorization.STATUS_SUCCESS,
operation=ExamAuthorization.OPERATION_ADD,
)
pending_auth = ExamAuthorizationFactory.create(
exam_run=exam_run,
status=ExamAuthorization.STATUS_PENDING,
operation=ExamAuthorization.OPERATION_ADD,
)
nonpending_auths = []
for status in [
ExamAuthorization.STATUS_IN_PROGRESS,
ExamAuthorization.STATUS_FAILED,
ExamAuthorization.STATUS_SUCCESS,
]:
nonpending_auths.append(
ExamAuthorizationFactory.create(
exam_run=exam_run,
status=status,
operation=ExamAuthorization.OPERATION_ADD,
))
update_authorizations_for_exam_run(exam_run)
taken_auth.refresh_from_db()
assert taken_auth.status == ExamAuthorization.STATUS_SUCCESS
assert taken_auth.operation == ExamAuthorization.OPERATION_ADD
pending_auth.refresh_from_db()
assert pending_auth.status == ExamAuthorization.STATUS_PENDING
assert pending_auth.operation == ExamAuthorization.OPERATION_ADD
for auth in nonpending_auths:
auth.refresh_from_db()
if is_past or is_future:
assert auth.status != ExamAuthorization.STATUS_PENDING
assert auth.operation == ExamAuthorization.OPERATION_ADD
else:
assert auth.status == ExamAuthorization.STATUS_PENDING
assert auth.operation == ExamAuthorization.OPERATION_UPDATE
def test_update_authorizations_for_exam_run(self, is_future, is_past):
"""Tests update_authorizations_for_exam_run()"""
exam_run = ExamRunFactory.create(scheduling_future=is_future, scheduling_past=is_past)
taken_auth = ExamAuthorizationFactory.create(
exam_run=exam_run,
exam_taken=True,
status=ExamAuthorization.STATUS_SUCCESS,
operation=ExamAuthorization.OPERATION_ADD,
)
pending_auth = ExamAuthorizationFactory.create(
exam_run=exam_run,
status=ExamAuthorization.STATUS_PENDING,
operation=ExamAuthorization.OPERATION_ADD,
)
nonpending_auths = []
for status in [
ExamAuthorization.STATUS_IN_PROGRESS,
ExamAuthorization.STATUS_FAILED,
ExamAuthorization.STATUS_SUCCESS,
]:
nonpending_auths.append(ExamAuthorizationFactory.create(
exam_run=exam_run,
status=status,
operation=ExamAuthorization.OPERATION_ADD,
))
update_authorizations_for_exam_run(exam_run)
taken_auth.refresh_from_db()
assert taken_auth.status == ExamAuthorization.STATUS_SUCCESS
assert taken_auth.operation == ExamAuthorization.OPERATION_ADD
pending_auth.refresh_from_db()
assert pending_auth.status == ExamAuthorization.STATUS_PENDING
assert pending_auth.operation == ExamAuthorization.OPERATION_ADD
for auth in nonpending_auths:
auth.refresh_from_db()
if is_past or is_future:
assert auth.status != ExamAuthorization.STATUS_PENDING
assert auth.operation == ExamAuthorization.OPERATION_ADD
else:
assert auth.status == ExamAuthorization.STATUS_PENDING
assert auth.operation == ExamAuthorization.OPERATION_UPDATE
def test_exam_authorization_course_mismatch(self):
"""
test exam_authorization fails if course_run and exam_run courses mismatch
"""
# Neither user has exam profile nor authorization.
assert ExamProfile.objects.filter(
profile=self.user.profile).exists() is False
assert ExamAuthorization.objects.filter(
user=self.user, course=self.course_run.course).exists() is False
exam_run = ExamRunFactory.create()
with self.assertRaises(ExamAuthorizationException):
authorize_for_exam_run(self.user, self.course_run, exam_run)
# Assert user has exam profile and authorization.
assert ExamProfile.objects.filter(
profile=self.user.profile).exists() is False
assert ExamAuthorization.objects.filter(
user=self.user, course=self.course_run.course).exists() is False
def test_create_combined_final_grade(mocker):
"""
Test create_combined_final_grade creates the grade when it is missing
"""
update_mock = mocker.patch(
'grades.api.update_or_create_combined_final_grade', autospec=True)
course_run = CourseRunFactory.create(
freeze_grade_date=now_in_utc() - timedelta(days=1),
course__program__financial_aid_availability=True,
course__program__live=True)
course = course_run.course
CourseRunGradingStatus.objects.create(course_run=course_run,
status='complete')
# Create exam run for course with date_grades_available True
exam_run_grades_available = ExamRunFactory.create(
course=course, date_grades_available=now_in_utc() - timedelta(weeks=1))
exam_grades = ProctoredExamGradeFactory.create_batch(
5,
course=course,
exam_run=exam_run_grades_available,
passed=True,
)
for exam_grade in exam_grades[:3]:
CombinedFinalGrade.objects.create(user=exam_grade.user,
course=course,
grade=0.7)
# Only 3 users will have combined grades
for exam_grade in exam_grades[3:]:
FinalGradeFactory.create(user=exam_grade.user,
course_run=course_run,
passed=True)
tasks.create_combined_final_grades.delay()
assert update_mock.call_count == 2
update_mock.assert_has_calls(
[call(exam_grades[3].user, course),
call(exam_grades[4].user, course)],
any_order=True)
def setUpTestData(cls):
with mute_signals(post_save):
cls.profile = ProfileFactory.create()
cls.program, _ = create_program(past=True)
cls.course_run = cls.program.course_set.first().courserun_set.first()
CachedCurrentGradeFactory.create(
user=cls.profile.user,
course_run=cls.course_run,
data={
"passed": True,
"percent": 0.9,
"course_key": cls.course_run.edx_course_key,
"username": cls.profile.user.username
}
)
CachedCertificateFactory.create(user=cls.profile.user, course_run=cls.course_run)
cls.exam_run = ExamRunFactory.create(
course=cls.course_run.course,
date_first_schedulable=now_in_utc() - timedelta(days=1),
)
def setUpTestData(cls):
with mute_signals(post_save):
cls.profile = ProfileFactory.create()
cls.program, _ = create_program(past=True)
cls.course_run = cls.program.course_set.first().courserun_set.first()
CachedCurrentGradeFactory.create(user=cls.profile.user,
course_run=cls.course_run,
data={
"passed": True,
"percent": 0.9,
"course_key":
cls.course_run.edx_course_key,
"username":
cls.profile.user.username
})
CachedCertificateFactory.create(user=cls.profile.user,
course_run=cls.course_run)
cls.exam_run = ExamRunFactory.create(
course=cls.course_run.course,
date_first_schedulable=now_in_utc() - timedelta(days=1),
)
def test_create_combined_final_grade(mocker):
"""
Test create_combined_final_grade creates the grade when it is missing
"""
update_mock = mocker.patch('grades.api.update_or_create_combined_final_grade', autospec=True)
course_run = CourseRunFactory.create(
freeze_grade_date=now_in_utc()-timedelta(days=1),
course__program__financial_aid_availability=True,
course__program__live=True
)
course = course_run.course
CourseRunGradingStatus.objects.create(course_run=course_run, status='complete')
# Create exam run for course with date_grades_available True
exam_run_grades_available = ExamRunFactory.create(
course=course,
date_grades_available=now_in_utc() - timedelta(weeks=1))
exam_grades = ProctoredExamGradeFactory.create_batch(
5,
course=course,
exam_run=exam_run_grades_available,
passed=True,
)
for exam_grade in exam_grades[:3]:
CombinedFinalGrade.objects.create(user=exam_grade.user, course=course, grade=0.7)
# Only 3 users will have combined grades
for exam_grade in exam_grades[3:]:
FinalGradeFactory.create(user=exam_grade.user, course_run=course_run, passed=True)
tasks.create_combined_final_grades.delay()
assert update_mock.call_count == 2
update_mock.assert_has_calls(
[call(exam_grades[3].user, course), call(exam_grades[4].user, course)],
any_order=True
)
def test_exam_authorization_for_missed_payment_deadline(self):
"""
test exam_authorization when user paid, but only after deadline
"""
create_order(self.user, self.course_run)
mmtrack = get_mmtrack(self.user, self.program)
course = self.course_run.course
now = now_in_utc()
exam_run = ExamRunFactory.create(course=course,
authorized=True,
date_first_schedulable=now,
date_last_schedulable=now +
datetime.timedelta(weeks=2))
self.course_run.upgrade_deadline = exam_run.date_first_schedulable - datetime.timedelta(
weeks=8)
self.course_run.save()
# paid after deadline
order_qset = Order.objects.filter(
user=self.user, line__course_key=self.course_run.edx_course_key)
order_qset.update(modified_at=now - datetime.timedelta(weeks=5))
with patch('exams.api.get_corresponding_course_run') as mock:
mock.side_effect = [self.course_run]
with self.assertRaises(ExamAuthorizationException):
authorize_for_exam_run(self.user, self.course_run,
self.exam_run)
assert ExamAuthorization.objects.filter(
user=mmtrack.user, course=course).exists() is False
# paid before deadline
order_qset.update(modified_at=exam_run.date_first_schedulable -
datetime.timedelta(weeks=9))
authorize_for_exam_run(self.user, self.course_run, self.exam_run)
assert ExamAuthorization.objects.filter(user=mmtrack.user,
course=course).exists() is True
def test_exam_authorization_course_mismatch(self):
"""
test exam_authorization fails if course_run and exam_run courses mismatch
"""
mmtrack = get_mmtrack(self.user, self.program)
# Neither user has exam profile nor authorization.
assert ExamProfile.objects.filter(profile=mmtrack.user.profile).exists() is False
assert ExamAuthorization.objects.filter(
user=mmtrack.user,
course=self.course_run.course
).exists() is False
exam_run = ExamRunFactory.create()
with self.assertRaises(ExamAuthorizationException):
authorize_for_exam_run(mmtrack, self.course_run, exam_run)
# Assert user has exam profile and authorization.
assert ExamProfile.objects.filter(profile=mmtrack.user.profile).exists() is False
assert ExamAuthorization.objects.filter(
user=mmtrack.user,
course=self.course_run.course
).exists() is False
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
)
def test_has_exam(self):
"""test that creating an exam run makes has_exam == true"""
assert self.course.has_exam is False
ExamRunFactory.create(course=self.course)
assert self.course.has_exam is True
def test_generate_course_certificates():
"""
Test that generate_course_certificates_for_fa_students creates certificates for appropriate FinalGrades
"""
program = ProgramFactory.create(financial_aid_availability=True, live=True)
week_ago = now_in_utc() - timedelta(weeks=1)
# Course without exams
course = CourseFactory.create(program=program)
passed_final_grades = FinalGradeFactory.create_batch(
4,
course_run__course=course,
course_run__freeze_grade_date=week_ago,
passed=True
)
# create a duplicate final grade for course for user
FinalGradeFactory.create(
user=passed_final_grades[0].user,
course_run__course=course,
course_run__freeze_grade_date=week_ago,
passed=True
)
# 2nd course for user
course_2 = CourseFactory.create(program=program)
FinalGradeFactory.create(
course_run__course=course_2,
course_run__freeze_grade_date=week_ago,
passed=True,
user=passed_final_grades[1].user
)
# Another non-fa course
non_fa_course = CourseFactory.create(program__financial_aid_availability=False)
# Course with exams
# Create two exam runs for course with different date_grades_available
exam_run_grades_available = ExamRunFactory.create(
course__program=program,
date_grades_available=now_in_utc() - timedelta(weeks=1))
course_with_exams = exam_run_grades_available.course
exam_run_no_grades = ExamRunFactory.create(
course=course_with_exams,
date_grades_available=now_in_utc() + timedelta(weeks=1))
passed_final_grades_with_exam = FinalGradeFactory.create_batch(
6,
course_run__course=course_with_exams,
passed=True
)
# Create ProctoredExamGrade records with a mix of passed and failed outcomes, and exam grade availability
final_grades_with_passed_exam = passed_final_grades_with_exam[:2]
ProctoredExamGradeFactory.create_batch(
2,
user=factory.Iterator([final_grade.user for final_grade in final_grades_with_passed_exam]),
course=course_with_exams,
exam_run=exam_run_grades_available,
passed=True,
)
ProctoredExamGradeFactory.create_batch(
2,
user=factory.Iterator([final_grade.user for final_grade in passed_final_grades_with_exam[2:4]]),
course=course_with_exams,
exam_run=exam_run_no_grades,
passed=True,
)
ProctoredExamGradeFactory.create_batch(
2,
user=factory.Iterator([final_grade.user for final_grade in passed_final_grades_with_exam[4:6]]),
course=course_with_exams,
passed=False,
)
# course runs need to have CourseRunGradingStatus to get certificates
all_grades = FinalGrade.objects.filter(course_run__course__in=[course, course_2, course_with_exams, non_fa_course])
for final_grade in all_grades:
CourseRunGradingStatus.objects.create(course_run=final_grade.course_run, status='complete')
tasks.generate_course_certificates_for_fa_students.delay()
# Make sure that certificates were created only for passed and 'complete' status FinalGrades that either
# had no course exam, or had a passed ProctoredExamGrade.
certificates = MicromastersCourseCertificate.objects.filter(course__in=[course, course_2, course_with_exams])
assert certificates.count() == 7
expected_certificate_final_grades = passed_final_grades + final_grades_with_passed_exam
assert set(certificates.values_list('user', flat=True)) == {
final_grade.user.id for final_grade in expected_certificate_final_grades
}
def test_has_exam(self):
"""test that creating an exam run makes has_exam == true"""
assert self.course.has_exam is False
ExamRunFactory.create(course=self.course)
assert self.course.has_exam is True
def test_generate_course_certificates():
"""
Test that generate_course_certificates_for_fa_students creates certificates for appropriate FinalGrades
"""
program = ProgramFactory.create(financial_aid_availability=True, live=True)
week_ago = now_in_utc() - timedelta(weeks=1)
# Course without exams
course = CourseFactory.create(program=program)
passed_final_grades = FinalGradeFactory.create_batch(
4,
course_run__course=course,
course_run__freeze_grade_date=week_ago,
passed=True
)
# create a duplicate final grade for course for user
FinalGradeFactory.create(
user=passed_final_grades[0].user,
course_run__course=course,
course_run__freeze_grade_date=week_ago,
passed=True
)
# 2nd course for user
course_2 = CourseFactory.create(program=program)
FinalGradeFactory.create(
course_run__course=course_2,
course_run__freeze_grade_date=week_ago,
passed=True,
user=passed_final_grades[1].user
)
# Another non-fa course
non_fa_course = CourseFactory.create(program__financial_aid_availability=False)
# Course with exams
# Create two exam runs for course with different date_grades_available
exam_run_grades_available = ExamRunFactory.create(
course__program=program,
date_grades_available=now_in_utc() - timedelta(weeks=1))
course_with_exams = exam_run_grades_available.course
exam_run_no_grades = ExamRunFactory.create(
course=course_with_exams,
date_grades_available=now_in_utc() + timedelta(weeks=1))
passed_final_grades_with_exam = FinalGradeFactory.create_batch(
6,
course_run__course=course_with_exams,
passed=True
)
# Create ProctoredExamGrade records with a mix of passed and failed outcomes, and exam grade availability
final_grades_with_passed_exam = passed_final_grades_with_exam[:2]
ProctoredExamGradeFactory.create_batch(
2,
user=factory.Iterator([final_grade.user for final_grade in final_grades_with_passed_exam]),
course=course_with_exams,
exam_run=exam_run_grades_available,
passed=True,
)
ProctoredExamGradeFactory.create_batch(
2,
user=factory.Iterator([final_grade.user for final_grade in passed_final_grades_with_exam[2:4]]),
course=course_with_exams,
exam_run=exam_run_no_grades,
passed=True,
)
ProctoredExamGradeFactory.create_batch(
2,
user=factory.Iterator([final_grade.user for final_grade in passed_final_grades_with_exam[4:6]]),
course=course_with_exams,
passed=False,
)
# course runs need to have CourseRunGradingStatus to get certificates
all_grades = FinalGrade.objects.filter(course_run__course__in=[course, course_2, course_with_exams, non_fa_course])
for final_grade in all_grades:
CourseRunGradingStatus.objects.create(course_run=final_grade.course_run, status='complete')
tasks.generate_course_certificates_for_fa_students.delay()
# Make sure that certificates were created only for passed and 'complete' status FinalGrades that either
# had no course exam, or had a passed ProctoredExamGrade.
certificates = MicromastersCourseCertificate.objects.filter(course__in=[course, course_2, course_with_exams])
assert certificates.count() == 7
expected_certificate_final_grades = passed_final_grades + final_grades_with_passed_exam
assert set(certificates.values_list('user', flat=True)) == set(
[final_grade.user.id for final_grade in expected_certificate_final_grades]
)
