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 setUpTestData(cls):
with mute_signals(post_save):
# valid profiles
cls.expected_in_progress_profiles = ExamProfileFactory.create_batch(5, status=ExamProfile.PROFILE_PENDING)
# invalid profiles
cls.expected_invalid_profiles = ExamProfileFactory.create_batch(5, status=ExamProfile.PROFILE_PENDING)
cls.all_profiles = cls.expected_in_progress_profiles + cls.expected_invalid_profiles
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 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 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 setUpTestData(cls):
with mute_signals(post_save):
# valid profiles
cls.expected_in_progress_profiles = ExamProfileFactory.create_batch(
5, status=ExamProfile.PROFILE_PENDING)
# invalid profiles
cls.expected_invalid_profiles = ExamProfileFactory.create_batch(
5, status=ExamProfile.PROFILE_PENDING)
cls.all_profiles = cls.expected_in_progress_profiles + cls.expected_invalid_profiles
def test_write_cdd_file(self):
"""
Tests cdd_writer against a set of profiles
"""
kwargs = {
'profile__id': 14879,
'profile__romanized_first_name': 'Jane',
'profile__romanized_last_name': 'Smith',
'profile__user__email': '*****@*****.**',
'profile__address': '1 Main St, Room B345',
'profile__city': 'Boston',
'profile__state_or_territory': 'US-MA',
'profile__country': 'US',
'profile__postal_code': '02115',
'profile__phone_number': '+1 617 293-3423',
}
with mute_signals(post_save):
exam_profiles = [ExamProfileFactory.create(**kwargs)]
exam_profiles[0].updated_on = FIXED_DATETIME
self.cdd_writer.write(self.tsv_file, exam_profiles)
assert self.tsv_rows[0] == (
"14879\tJane\tSmith\[email protected]\t"
"1 Main St, Room B345\t\t\t" # triple tab is for blank address2 and address3
"Boston\tMA\t02115\tUSA\t"
"6172933423\t1\t2016/05/15 15:02:55")
def test_write_cdd_file(self):
"""
Tests cdd_writer against a set of profiles
"""
kwargs = {
'profile__id': 14879,
'profile__romanized_first_name': 'Jane',
'profile__romanized_last_name': 'Smith',
'profile__user__email': '*****@*****.**',
'profile__address': '1 Main St, Room B345',
'profile__city': 'Boston',
'profile__state_or_territory': 'US-MA',
'profile__country': 'US',
'profile__postal_code': '02115',
'profile__phone_number': '+1 617 293-3423',
}
with mute_signals(post_save):
exam_profiles = [ExamProfileFactory.create(**kwargs)]
exam_profiles[0].updated_on = FIXED_DATETIME
self.cdd_writer.write(self.tsv_file, exam_profiles)
assert self.tsv_rows[0] == (
"14879\tJane\tSmith\[email protected]\t"
"1 Main St, Room B345\t\t\t" # triple tab is for blank address2 and address3
"Boston\tMA\t02115\tUSA\t"
"6172933423\t1\t2016/05/15 15:02:55"
)
def test_get_exam_card_status_eligible(self):
"""
test get_exam_card_status against valid eligibility dates
"""
ExamProfileFactory.create(
profile=self.user.profile,
status=ExamProfile.PROFILE_SUCCESS,
)
now = datetime(2016, 3, 15, tzinfo=pytz.UTC)
past = datetime(2016, 3, 10, tzinfo=pytz.UTC)
future = datetime(2016, 3, 20, tzinfo=pytz.UTC)
valid_dates = [
past - timedelta(days=1),
past,
now,
future,
]
invalid_dates = [
future + timedelta(days=1),
]
ExamAuthorizationFactory.create(
user=self.user,
status=ExamAuthorization.STATUS_SUCCESS,
exam_run__course=self.course,
exam_run__date_first_eligible=past.date(),
exam_run__date_last_eligible=future.date(),
)
mmtrack = MMTrack(
user=self.user,
program=self.program,
edx_user_data=self.cached_edx_user_data
)
# should be considered schedulable if past <= datetime.now() <= future
for now_value in valid_dates:
mmtrack.now = now_value
assert mmtrack.get_exam_card_status() == ExamProfile.PROFILE_SCHEDULABLE
# not eligible
for now_value in invalid_dates:
mmtrack.now = now_value
assert mmtrack.get_exam_card_status() == ExamProfile.PROFILE_SUCCESS
def test_get_pearson_exam_status_eligible(self):
"""
test get_pearson_exam_status against valid eligibility dates
"""
ExamProfileFactory.create(
profile=self.user.profile,
status=ExamProfile.PROFILE_SUCCESS,
)
now = datetime(2016, 3, 15, tzinfo=pytz.UTC)
past = datetime(2016, 3, 10, tzinfo=pytz.UTC)
future = datetime(2016, 3, 20, tzinfo=pytz.UTC)
valid_dates = [
past - timedelta(days=1),
past,
now,
future,
]
invalid_dates = [
future + timedelta(days=1),
]
ExamAuthorizationFactory.create(
user=self.user,
status=ExamAuthorization.STATUS_SUCCESS,
exam_run__course=self.course,
exam_run__date_first_eligible=past.date(),
exam_run__date_last_eligible=future.date(),
)
mmtrack = MMTrack(
user=self.user,
program=self.program,
edx_user_data=self.cached_edx_user_data
)
# should be considered schedulable if past <= datetime.now() <= future
for now_value in valid_dates:
mmtrack.now = now_value
assert mmtrack.get_pearson_exam_status() == ExamProfile.PROFILE_SCHEDULABLE
# not eligible
for now_value in invalid_dates:
mmtrack.now = now_value
assert mmtrack.get_pearson_exam_status() == ExamProfile.PROFILE_SUCCESS
def test_profile_country_to_alpha3_invalid_country(self):
"""
A profile with an invalid country code should raise an InvalidProfileDataException
"""
with mute_signals(post_save):
profile = ExamProfileFactory(profile__country='XXXX')
with self.assertRaises(InvalidProfileDataException):
CDDWriter.profile_country_to_alpha3(profile)
def test_profile_phone_number_exceptions(self, bad_number):
"""
It should raise exceptions for bad data
"""
with mute_signals(post_save):
profile = ExamProfileFactory(profile__phone_number=bad_number)
with self.assertRaises(InvalidProfileDataException):
CDDWriter.profile_phone_number_to_raw_number(profile)
with self.assertRaises(InvalidProfileDataException):
CDDWriter.profile_phone_number_to_country_code(profile)
def test_last_name(self, unromanized, romanized, expected):
"""
Test that the `last_name` method prefers the `romanized_last_name`
field, and falls back on `last_name` field.
"""
with mute_signals(post_save):
profile = ExamProfileFactory(
profile__last_name=unromanized,
profile__romanized_last_name=romanized,
)
assert CDDWriter.last_name(profile) == expected
def test_profile_phone_number_functions(self, input_number,
expected_country_code,
expected_number):
"""
A profile with a valid phone number should be parsed correctly
"""
with mute_signals(post_save):
profile = ExamProfileFactory(profile__phone_number=input_number)
assert CDDWriter.profile_phone_number_to_raw_number(
profile) == expected_number
assert CDDWriter.profile_phone_number_to_country_code(
profile) == expected_country_code
def setUpTestData(cls):
sftp = Mock()
cls.now = now_in_utc()
cls.processor = download.ArchivedResponseProcessor(sftp)
with mute_signals(post_save):
cls.success_profiles = ExamProfileFactory.create_batch(2) + [
ExamProfileFactory.create(
profile__id=999,
profile__student_id=1000), # disjoint id and student_id
]
cls.failure_profiles = ExamProfileFactory.create_batch(2)
cls.success_results = ([
VCDCResult(
client_candidate_id=exam_profile.profile.student_id,
status=VCDC_SUCCESS_STATUS,
date=cls.now,
message='',
) for exam_profile in cls.success_profiles
], [])
cls.failed_results = ([
VCDCResult(
client_candidate_id=cls.failure_profiles[0].profile.student_id,
status=VCDC_FAILURE_STATUS,
date=cls.now,
message='',
),
VCDCResult(
client_candidate_id=cls.failure_profiles[1].profile.student_id,
status=VCDC_FAILURE_STATUS,
date=cls.now,
message='Bad address',
),
], [])
cls.all_results = (
cls.success_results[0] + cls.failed_results[0],
cls.success_results[1] + cls.failed_results[1],
)
def setUpTestData(cls):
sftp = Mock()
cls.now = now_in_utc()
cls.processor = download.ArchivedResponseProcessor(sftp)
with mute_signals(post_save):
cls.success_profiles = ExamProfileFactory.create_batch(2) + [
ExamProfileFactory.create(profile__id=999, profile__student_id=1000), # disjoint id and student_id
]
cls.failure_profiles = ExamProfileFactory.create_batch(2)
cls.success_results = ([
VCDCResult(
client_candidate_id=exam_profile.profile.student_id,
status=VCDC_SUCCESS_STATUS,
date=cls.now,
message='',
) for exam_profile in cls.success_profiles
], [])
cls.failed_results = ([
VCDCResult(
client_candidate_id=cls.failure_profiles[0].profile.student_id,
status=VCDC_FAILURE_STATUS,
date=cls.now,
message='',
),
VCDCResult(
client_candidate_id=cls.failure_profiles[1].profile.student_id,
status=VCDC_FAILURE_STATUS,
date=cls.now,
message='Bad address',
),
], [])
cls.all_results = (
cls.success_results[0] + cls.failed_results[0],
cls.success_results[1] + cls.failed_results[1],
)
def test_write_cdd_file_with_blank_romanized_name(self):
"""
Tests cdd_writer against a profile without romanized name fields
"""
kwargs = {
'profile__id': 9876,
'profile__first_name': 'Jane',
'profile__last_name': 'Smith',
'profile__romanized_first_name': None,
'profile__romanized_last_name': None,
'profile__phone_number': '+1 617 293-3423',
}
with mute_signals(post_save):
exam_profiles = [ExamProfileFactory.create(**kwargs)]
exam_profiles[0].profile.updated_on = FIXED_DATETIME
self.cdd_writer.write(self.tsv_file, exam_profiles)
assert self.tsv_rows[0].startswith("9876\tJane\tSmith\t")
def test_write_cdd_file_with_blank_romanized_name(self):
"""
Tests cdd_writer against a profile without romanized name fields
"""
kwargs = {
'profile__id': 9876,
'profile__first_name': 'Jane',
'profile__last_name': 'Smith',
'profile__romanized_first_name': None,
'profile__romanized_last_name': None,
'profile__phone_number': '+1 617 293-3423',
}
with mute_signals(post_save):
exam_profiles = [ExamProfileFactory.create(**kwargs)]
exam_profiles[0].profile.updated_on = FIXED_DATETIME
self.cdd_writer.write(self.tsv_file, exam_profiles)
assert self.tsv_rows[0].startswith("9876\tJane\tSmith\t")
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_profile_state(self, country, state, expected):
"""Test that profile_state returns expected values"""
with mute_signals(post_save):
profile = ExamProfileFactory(profile__country=country,
profile__state_or_territory=state)
assert CDDWriter.profile_state(profile) == expected