def test_generation_verified_name(self, should_use_verified_name_for_certs, status):
"""
Test that if the user has their preference set to use
verified name for certificates, their verified name will appear on the certificate rather than
their profile name.
"""
verified_name = 'Jonathan Doe'
create_verified_name(self.u, verified_name, self.name, status=status)
create_verified_name_config(self.u, use_verified_name_for_certs=should_use_verified_name_for_certs)
GeneratedCertificateFactory(
user=self.u,
course_id=self.key,
mode=CourseMode.AUDIT,
status=CertificateStatuses.unverified
)
generate_course_certificate(
self.u, self.key, CertificateStatuses.downloadable, self.enrollment_mode, self.grade, self.gen_mode,
)
cert = GeneratedCertificate.objects.get(user=self.u, course_id=self.key)
if should_use_verified_name_for_certs and status == VerifiedNameStatus.APPROVED:
assert cert.name == verified_name
else:
assert cert.name == self.name
def test_generation_existing_unverified(self):
"""
Test certificate generation when a certificate already exists and we want to mark it as unverified
"""
error_reason = 'Some PDF error'
GeneratedCertificateFactory(
user=self.u,
course_id=self.key,
mode=CourseMode.AUDIT,
status=CertificateStatuses.error,
error_reason=error_reason
)
cert = GeneratedCertificate.objects.get(user=self.u, course_id=self.key)
assert cert.error_reason == error_reason
assert cert.mode == CourseMode.AUDIT
assert cert.status == CertificateStatuses.error
generate_course_certificate(self.u, self.key, CertificateStatuses.unverified, self.enrollment_mode, self.grade,
self.gen_mode)
cert = GeneratedCertificate.objects.get(user=self.u, course_id=self.key)
assert cert.error_reason == ''
assert cert.status == CertificateStatuses.unverified
assert cert.mode == self.enrollment_mode
assert cert.grade == ''
def test_can_generate_invalidated(self):
"""
Test handling when user is on the invalidate list
"""
u = UserFactory()
cr = CourseFactory()
key = cr.id # pylint: disable=no-member
CourseEnrollmentFactory(
user=u,
course_id=key,
is_active=True,
mode=CourseMode.VERIFIED,
)
cert = GeneratedCertificateFactory(
user=u,
course_id=key,
mode=GeneratedCertificate.MODES.verified,
status=CertificateStatuses.downloadable
)
CertificateInvalidationFactory.create(
generated_certificate=cert,
invalidated_by=self.user,
active=True
)
assert not _can_generate_regular_certificate(u, key, self.enrollment_mode, self.grade)
assert _set_regular_cert_status(u, key, self.enrollment_mode, self.grade) == CertificateStatuses.unavailable
def test_can_generate_not_verified_not_passing_allowlist(self, enable_integrity_signature):
"""
Test handling when the user's id is not verified and the user is not passing but is on the allowlist
"""
u = UserFactory()
CourseEnrollmentFactory(
user=u,
course_id=self.course_run_key,
is_active=True,
mode=CourseMode.VERIFIED,
)
GeneratedCertificateFactory(
user=u,
course_id=self.course_run_key,
mode=GeneratedCertificate.MODES.verified,
status=CertificateStatuses.generating
)
CertificateAllowlistFactory(course_id=self.course_run_key, user=u)
with mock.patch(ID_VERIFIED_METHOD, return_value=False), \
mock.patch.dict(settings.FEATURES, ENABLE_INTEGRITY_SIGNATURE=enable_integrity_signature), \
mock.patch(PASSING_GRADE_METHOD, return_value=False):
assert not _can_generate_regular_certificate(u, self.course_run_key, self.enrollment_mode, self.grade)
if enable_integrity_signature:
assert _set_regular_cert_status(u, self.course_run_key, self.enrollment_mode,
self.grade) == CertificateStatuses.notpassing
else:
assert _set_regular_cert_status(u, self.course_run_key, self.enrollment_mode,
self.grade) == CertificateStatuses.unverified
def test_can_generate_not_verified_cert(self, enable_integrity_signature):
"""
Test handling when the user's id is not verified and they have a cert
"""
u = UserFactory()
CourseEnrollmentFactory(
user=u,
course_id=self.course_run_key,
is_active=True,
mode=CourseMode.VERIFIED,
)
GeneratedCertificateFactory(
user=u,
course_id=self.course_run_key,
mode=GeneratedCertificate.MODES.verified,
status=CertificateStatuses.generating
)
with mock.patch(ID_VERIFIED_METHOD, return_value=False), \
mock.patch.dict(settings.FEATURES, ENABLE_INTEGRITY_SIGNATURE=enable_integrity_signature):
self.assertEqual(
enable_integrity_signature,
_can_generate_regular_certificate(u, self.course_run_key, self.enrollment_mode, self.grade)
)
regular_cert_status = _set_regular_cert_status(u, self.course_run_key, self.enrollment_mode, self.grade)
self.assertIsNot(enable_integrity_signature, regular_cert_status == CertificateStatuses.unverified)
def test_is_entitlement_regainable(self):
"""
Test that the entitlement is not expired when created now, and is expired when created20 days
ago with a policy that sets the expiration period to 14 days
"""
entitlement = CourseEntitlementFactory.create(enrollment_course_run=self.enrollment)
assert entitlement.is_entitlement_regainable() is True
# Create and associate a GeneratedCertificate for a user and course and make sure it isn't regainable
GeneratedCertificateFactory(
user=entitlement.user,
course_id=entitlement.enrollment_course_run.course_id,
mode=MODES.verified,
status=CertificateStatuses.downloadable,
)
assert entitlement.is_entitlement_regainable() is False
# Create a date 20 days in the past (greater than the policy expire period of 14 days)
# and apply it to both the entitlement and the course
past_datetime = now() - timedelta(days=20)
entitlement = CourseEntitlementFactory.create(enrollment_course_run=self.enrollment, created=past_datetime)
self.enrollment.created = past_datetime
self.course.start = past_datetime
self.course.save()
self.enrollment.save()
assert entitlement.is_entitlement_regainable() is False
entitlement = CourseEntitlementFactory.create(expired_at=now())
assert entitlement.is_entitlement_regainable
def test_regen_audit_certs_eligibility(self, status, created_delta, grade, expected_status):
"""
Test that existing audit certificates remain eligible even if cert
generation is re-run.
"""
# Create an existing audit enrollment and certificate
CourseEnrollmentFactory(
user=self.user_2,
course_id=self.course.id,
is_active=True,
mode=CourseMode.AUDIT,
)
created_date = datetime.now(pytz.UTC) + created_delta
with freezegun.freeze_time(created_date):
GeneratedCertificateFactory(
user=self.user_2,
course_id=self.course.id,
grade='1.0',
status=status,
mode=GeneratedCertificate.MODES.audit,
)
# Run grading/cert generation again
with mock_passing_grade(letter_grade=grade):
with patch.object(XQueueInterface, 'send_to_queue') as mock_send:
mock_send.return_value = (0, None)
self.xqueue.add_cert(self.user_2, self.course.id)
assert GeneratedCertificate.objects.get(user=self.user_2, course_id=self.course.id).status == expected_status
def test_handle_not_passing_id_verified_cert(self):
"""
Test handling of a user who is not passing and is id verified and has a cert
"""
different_user = UserFactory()
CourseEnrollmentFactory(
user=different_user,
course_id=self.course_run_key,
is_active=True,
mode=CourseMode.VERIFIED,
)
GeneratedCertificateFactory(
user=different_user,
course_id=self.course_run_key,
mode=GeneratedCertificate.MODES.verified,
status=CertificateStatuses.generating,
)
with mock.patch(PASSING_GRADE_METHOD, return_value=False):
assert _set_regular_cert_status(different_user, self.course_run_key, self.enrollment_mode, self.grade) == \
CertificateStatuses.notpassing
assert _generate_regular_certificate_task(
different_user, self.course_run_key) is True
assert not _can_generate_regular_certificate(
different_user, self.course_run_key, self.enrollment_mode,
self.grade)
def test_can_generate_not_verified_not_passing(self,
enable_idv_requirement):
"""
Test handling when the user's id is not verified and the user is not passing
"""
u = UserFactory()
CourseEnrollmentFactory(
user=u,
course_id=self.course_run_key,
is_active=True,
mode=CourseMode.VERIFIED,
)
GeneratedCertificateFactory(user=u,
course_id=self.course_run_key,
mode=GeneratedCertificate.MODES.verified,
status=CertificateStatuses.generating)
with mock.patch(ID_VERIFIED_METHOD, return_value=False), \
mock.patch.dict(settings.FEATURES, ENABLE_CERTIFICATES_IDV_REQUIREMENT=enable_idv_requirement), \
mock.patch(PASSING_GRADE_METHOD, return_value=False):
assert not _can_generate_regular_certificate(
u, self.course_run_key, self.enrollment_mode, self.grade)
if enable_idv_requirement:
assert _set_regular_cert_status(u, self.course_run_key,
self.enrollment_mode,
self.grade) is None
else:
assert _set_regular_cert_status(u, self.course_run_key, self.enrollment_mode, self.grade) \
== CertificateStatuses.notpassing
def setUp(self):
super().setUp()
self.client = Client()
self.course = CourseFactory.create(
org='testorg',
number='run1',
display_name='refundable course',
certificate_available_date=datetime.datetime.today() -
datetime.timedelta(days=1))
self.course.cert_html_view_enabled = True
self.course.save()
self.store.update_item(self.course, self.user.id)
self.course_id = self.course.location.course_key
self.user = UserFactory.create(email='*****@*****.**',
username='******',
password='******')
self.user.profile.name = "Joe User"
self.user.profile.save()
self.client.login(username=self.user.username, password='******')
self.cert = GeneratedCertificateFactory(
user=self.user,
course_id=self.course_id,
download_uuid=uuid4().hex,
grade="0.95",
key='the_key',
distinction=True,
status=CertificateStatuses.downloadable,
mode='honor',
name=self.user.profile.name,
verify_uuid=uuid4().hex)
self._setup_configuration()
def test_generation_existing(self):
"""
Test certificate generation when a certificate already exists
"""
# Create user, a course run, and an enrollment
u = UserFactory()
cr = CourseFactory()
key = cr.id # pylint: disable=no-member
CourseEnrollmentFactory(
user=u,
course_id=key,
is_active=True,
mode='verified',
)
error_reason = 'Some PDF error'
GeneratedCertificateFactory(
user=u,
course_id=key,
mode='verified',
status=CertificateStatuses.error,
error_reason=error_reason
)
gen_mode = 'batch'
cert = GeneratedCertificate.objects.get(user=u, course_id=key)
assert cert.error_reason == error_reason
generated_cert = generate_course_certificate(u, key, gen_mode)
assert generated_cert.status, CertificateStatuses.downloadable
cert = GeneratedCertificate.objects.get(user=u, course_id=key)
assert cert.error_reason == ''
def test_dashboard_view_context_data(user_with_profile, courses, webinar,
mocker, request):
"""
Test dashboard page context data
"""
mocker.patch(
'openedx.adg.lms.student.views.DashboardView.get_filtered_enrolled_courses'
)
mocker.patch('openedx.adg.lms.student.views.get_course_by_id',
return_value=courses['test_course1'])
mocker.patch('openedx.adg.lms.student.views.reverse',
return_value='/account/settings')
dashboard_request = request
user_with_profile.is_active = False
dashboard_request.user = user_with_profile
CourseEnrollment.enroll(user=user_with_profile,
course_key=courses['test_course1'].id)
CourseEnrollment.enroll(user=user_with_profile,
course_key=courses['test_course2'].id)
PersistentCourseGrade.update_or_create(
user_id=user_with_profile.id,
course_id=courses['test_course1'].id,
percent_grade=0.8,
passed=True)
WebinarRegistrationFactory(email=user_with_profile.email,
webinar=webinar,
is_registered=True)
GeneratedCertificateFactory(user=user_with_profile,
course_id=courses['test_course1'].id,
status=CertificateStatuses.downloadable)
context_data = DashboardView(request=dashboard_request).get_context_data()
assert 'user' in context_data
assert 'user_profile' in context_data
assert 'profile_image_url' in context_data
assert 'edit_account_link' in context_data
assert 'application_link' in context_data
assert 'courses' in context_data
assert 'courses_filter_options' in context_data
assert 'courses_filter' in context_data
assert 'webinars' in context_data
assert 'webinars_filter_options' in context_data
assert 'webinars_filter' in context_data
assert 'certificates' in context_data
assert 'activate_account_message' in context_data
assert 'account_activation_messages' in context_data
assert context_data[
'profile_image_url'] == get_profile_image_urls_for_user(
user_with_profile)['full']
assert context_data['edit_account_link'] == '/account/settings'
assert context_data['user'] == user_with_profile
assert len(context_data['webinars']) == 1
def test_handle_enqueue_failure(self, mock_log, mock_task, mock_get_programs):
"""Verify that failure to enqueue a task doesn't halt execution."""
def side_effect(username):
"""Simulate failure to enqueue a task."""
if username == self.alice.username:
raise Exception
mock_task.side_effect = side_effect
data = [
ProgramFactory(
courses=[
CourseFactory(course_runs=[
CourseRunFactory(key=self.course_run_key),
]),
]
),
]
mock_get_programs.return_value = data
GeneratedCertificateFactory(
user=self.alice,
course_id=self.course_run_key,
mode=MODES.verified,
status=CertificateStatuses.downloadable,
)
GeneratedCertificateFactory(
user=self.bob,
course_id=self.course_run_key,
mode=MODES.verified,
status=CertificateStatuses.downloadable,
)
call_command('backpopulate_program_credentials', commit=True)
self.assertTrue(mock_log.called)
calls = [
mock.call(self.alice.username),
mock.call(self.bob.username)
]
mock_task.assert_has_calls(calls, any_order=True)
def setUp(self):
super().setUp()
self.user = UserFactory.create()
self.user2 = UserFactory.create()
with freeze_time(datetime(2017, 1, 1)):
self.cert1 = GeneratedCertificateFactory(
user=self.user, course_id='course-v1:edX+Test+1')
with freeze_time(datetime(2017, 2, 1, 0)):
self.cert2 = GeneratedCertificateFactory(
user=self.user, course_id='course-v1:edX+Test+2')
with freeze_time(datetime(2017, 3, 1)):
self.cert3 = GeneratedCertificateFactory(
user=self.user, course_id='course-v1:testX+Test+3')
with freeze_time(datetime(2017, 2, 1, 5)):
self.cert4 = GeneratedCertificateFactory(
user=self.user2,
course_id='course-v1:edX+Test+4',
status=CertificateStatuses.downloadable)
print(('self.cert1.modified_date', self.cert1.modified_date))
# No factory for these
with freeze_time(datetime(2017, 1, 1)):
self.grade1 = PersistentCourseGrade.objects.create(
user_id=self.user.id,
course_id='course-v1:edX+Test+1',
percent_grade=1)
with freeze_time(datetime(2017, 2, 1)):
self.grade2 = PersistentCourseGrade.objects.create(
user_id=self.user.id,
course_id='course-v1:edX+Test+2',
percent_grade=1)
with freeze_time(datetime(2017, 3, 1)):
self.grade3 = PersistentCourseGrade.objects.create(
user_id=self.user.id,
course_id='course-v1:testX+Test+3',
percent_grade=1)
with freeze_time(datetime(2017, 2, 1, 5)):
self.grade4 = PersistentCourseGrade.objects.create(
user_id=self.user2.id,
course_id='course-v1:edX+Test+4',
percent_grade=1)
print(('self.grade1.modified', self.grade1.modified))
def _create_certificate(self, course_key=None, enrollment_mode=CourseMode.HONOR, status='downloadable'):
"""Simulate that the user has a generated certificate. """
CourseEnrollmentFactory.create(user=self.user, course_id=self.course.id, mode=enrollment_mode)
return GeneratedCertificateFactory(
user=self.user,
course_id=course_key or self.course.id,
mode=enrollment_mode,
download_url=self.DOWNLOAD_URL,
status=status,
)
def setUp(self): # lint-amnesty, pylint: disable=super-method-not-called
self.student = UserFactory.create(username='******')
self.course = CourseOverviewFactory.create(
self_paced=
True # Any option to allow the certificate to be viewable for the course
)
self.certificate = GeneratedCertificateFactory(
user=self.student,
mode='verified',
course_id=self.course.id,
status='downloadable')
def _create_cert(self, course_key, user, status, mode=CourseMode.HONOR):
"""Create a certificate entry. """
# Enroll the user in the course
CourseEnrollmentFactory.create(user=user,
course_id=course_key,
mode=mode)
# Create the certificate
GeneratedCertificateFactory(user=user,
course_id=course_key,
status=status)
def test_handle_enqueue_failure(self, mock_log, mock_task):
"""Verify that failure to enqueue a task doesn't halt execution."""
def side_effect(username):
"""Simulate failure to enqueue a task."""
if username == self.alice.username:
raise Exception
mock_task.side_effect = side_effect
data = [
factories.Program(
organizations=[factories.Organization()],
course_codes=[
factories.CourseCode(run_modes=[
factories.RunMode(course_key=self.course_id),
]),
]),
]
self._mock_programs_api(data)
self._link_oauth2_user()
GeneratedCertificateFactory(
user=self.alice,
course_id=self.course_id,
mode=MODES.verified,
status=CertificateStatuses.downloadable,
)
GeneratedCertificateFactory(
user=self.bob,
course_id=self.course_id,
mode=MODES.verified,
status=CertificateStatuses.downloadable,
)
call_command('backpopulate_program_credentials', commit=True)
self.assertTrue(mock_log.called)
calls = [mock.call(self.alice.username), mock.call(self.bob.username)]
mock_task.assert_has_calls(calls, any_order=True)
def test_cert_failure(self, status):
if CertificateStatuses.is_passing_status(status):
expected_status = CertificateStatuses.notpassing
else:
expected_status = status
GeneratedCertificateFactory(user=self.user,
course_id=self.course.id,
status=status)
CourseGradeFactory().update(self.user, self.course)
cert = GeneratedCertificate.certificate_for_student(
self.user, self.course.id)
self.assertEqual(cert.status, expected_status)
def test_failing_grade_allowlist(self):
# User who is not on the allowlist
GeneratedCertificateFactory(user=self.user,
course_id=self.course.id,
status=CertificateStatuses.downloadable)
CourseGradeFactory().update(self.user, self.course)
cert = GeneratedCertificate.certificate_for_student(
self.user, self.course.id)
self.assertEqual(cert.status, CertificateStatuses.notpassing)
# User who is on the allowlist
u = UserFactory.create()
c = CourseFactory()
course_key = c.id # pylint: disable=no-member
CertificateWhitelistFactory(user=u, course_id=course_key)
GeneratedCertificateFactory(user=u,
course_id=course_key,
status=CertificateStatuses.downloadable)
CourseGradeFactory().update(u, c)
cert = GeneratedCertificate.certificate_for_student(u, course_key)
self.assertEqual(cert.status, CertificateStatuses.downloadable)
def test_handle_passing_status(self, mock_task):
"""Verify that only certificates with a passing status are selected."""
data = [
factories.Program(
organizations=[factories.Organization()],
course_codes=[
factories.CourseCode(run_modes=[
factories.RunMode(course_key=self.course_id),
factories.RunMode(course_key=self.alternate_course_id),
]),
]),
]
self._mock_programs_api(data)
self._link_oauth2_user()
passing_status = CertificateStatuses.downloadable
failing_status = CertificateStatuses.notpassing
self.assertIn(passing_status, CertificateStatuses.PASSED_STATUSES)
self.assertNotIn(failing_status, CertificateStatuses.PASSED_STATUSES)
GeneratedCertificateFactory(
user=self.alice,
course_id=self.course_id,
mode=MODES.verified,
status=passing_status,
)
# The alternate course is used here to verify that the status and run_mode
# queries are being ANDed together correctly.
GeneratedCertificateFactory(
user=self.bob,
course_id=self.alternate_course_id,
mode=MODES.verified,
status=failing_status,
)
call_command('backpopulate_program_credentials', commit=True)
mock_task.assert_called_once_with(self.alice.username)
def test_auto_execution(self, mock_send):
cert_filter_args = {}
with freeze_time(datetime(2017, 5, 1, 0)):
cert1 = GeneratedCertificateFactory(user=self.user, course_id='course-v1:edX+Test+11')
with freeze_time(datetime(2017, 5, 1, 3)):
cert2 = GeneratedCertificateFactory(user=self.user, course_id='course-v1:edX+Test+22')
# `auto` execution should include certificates with date overrides
# modified within the time range. See the next test
# (`test_certs_with_modified_date_overrides`) for more.
with freeze_time(datetime(2017, 4, 30, 0)):
cert3 = GeneratedCertificateFactory(user=self.user, course_id='course-v1:edX+Test+33')
with freeze_time(datetime(2017, 5, 1, 2)):
CertificateDateOverrideFactory(
generated_certificate=cert3,
overridden_by=self.user,
)
with freeze_time(datetime(2017, 5, 1, 0)):
grade1 = PersistentCourseGrade.objects.create(user_id=self.user.id, course_id='course-v1:edX+Test+11',
percent_grade=1)
with freeze_time(datetime(2017, 5, 1, 3)):
grade2 = PersistentCourseGrade.objects.create(user_id=self.user.id, course_id='course-v1:edX+Test+22',
percent_grade=1)
total_certificates = GeneratedCertificate.objects.filter(**cert_filter_args).order_by('modified_date') # pylint: disable=no-member
total_grades = PersistentCourseGrade.objects.all()
self.options['auto'] = True
self.options['start_date'] = '2017-05-01T00:00:00'
self.options['end_date'] = '2017-05-01T04:00:00'
tasks.handle_notify_credentials(options=self.options, course_keys=[])
assert mock_send.called
self.assertListEqual(list(mock_send.call_args[0][0]), [cert3, cert1, cert2])
self.assertListEqual(list(mock_send.call_args[0][1]), [grade1, grade2])
assert len(list(mock_send.call_args[0][0])) <= len(total_certificates)
assert len(list(mock_send.call_args[0][1])) <= len(total_grades)
def _create_certificate(self, enrollment_mode, download_url=DOWNLOAD_URL):
"""Simulate that the user has a generated certificate. """
CourseEnrollmentFactory.create(user=self.user,
course_id=self.course.id,
mode=enrollment_mode)
return GeneratedCertificateFactory(
user=self.user,
course_id=self.course.id,
mode=enrollment_mode,
download_url=download_url,
status=CertificateStatuses.downloadable,
grade=0.98,
)
def test_handle_flatten(self, data, mock_task, mock_get_programs):
"""Verify that program structures are flattened correctly."""
mock_get_programs.return_value = data
GeneratedCertificateFactory(
user=self.alice,
course_id=self.course_id,
mode=MODES.verified,
status=CertificateStatuses.downloadable,
)
GeneratedCertificateFactory(
user=self.bob,
course_id=self.alternate_course_id,
mode=MODES.verified,
status=CertificateStatuses.downloadable,
)
call_command('backpopulate_program_credentials', commit=True)
calls = [mock.call(self.alice.username), mock.call(self.bob.username)]
mock_task.assert_has_calls(calls, any_order=True)
def test_handle_passing_status(self, mock_task, mock_get_programs):
"""
Verify that only course run certificates with a passing status are selected.
"""
data = [
ProgramFactory(
courses=[
CourseFactory(course_runs=[
CourseRunFactory(key=self.course_run_key),
]),
]
),
]
mock_get_programs.return_value = data
passing_status = CertificateStatuses.downloadable
failing_status = CertificateStatuses.notpassing
self.assertIn(passing_status, CertificateStatuses.PASSED_STATUSES)
self.assertNotIn(failing_status, CertificateStatuses.PASSED_STATUSES)
GeneratedCertificateFactory(
user=self.alice,
course_id=self.course_run_key,
mode=MODES.verified,
status=passing_status,
)
GeneratedCertificateFactory(
user=self.bob,
course_id=self.course_run_key,
mode=MODES.verified,
status=failing_status,
)
call_command('backpopulate_program_credentials', commit=True)
mock_task.assert_called_once_with(self.alice.username)
def test_generation_creates_verify_uuid_when_needed(self):
"""
Test that ensures we will create a verify_uuid when needed.
"""
GeneratedCertificateFactory(user=self.u,
course_id=self.key,
mode='verified',
status=CertificateStatuses.unverified,
verify_uuid='')
generated_cert = generate_course_certificate(self.u, self.key,
self.gen_mode)
assert generated_cert.status, CertificateStatuses.downloadable
assert generated_cert.verify_uuid != ''
def setUp(self):
super(TestNotifyCredentials, self).setUp()
self.user = UserFactory.create()
with freeze_time(datetime(2017, 1, 1)):
self.cert1 = GeneratedCertificateFactory(user=self.user, course_id='course-v1:edX+Test+1')
with freeze_time(datetime(2017, 2, 1)):
self.cert2 = GeneratedCertificateFactory(user=self.user, course_id='course-v1:edX+Test+2')
with freeze_time(datetime(2017, 3, 1)):
self.cert3 = GeneratedCertificateFactory(user=self.user, course_id='course-v1:testX+Test+3')
print('self.cert1.modified_date', self.cert1.modified_date)
# No factory for these
with freeze_time(datetime(2017, 1, 1)):
self.grade1 = PersistentCourseGrade.objects.create(user_id=self.user.id, course_id='course-v1:edX+Test+1',
percent_grade=1)
with freeze_time(datetime(2017, 2, 1)):
self.grade2 = PersistentCourseGrade.objects.create(user_id=self.user.id, course_id='course-v1:edX+Test+2',
percent_grade=1)
with freeze_time(datetime(2017, 3, 1)):
self.grade3 = PersistentCourseGrade.objects.create(user_id=self.user.id, course_id='course-v1:testX+Test+3',
percent_grade=1)
print('self.grade1.modified', self.grade1.modified)
def test_cert_already_generated(self):
with mock.patch(
'lms.djangoapps.certificates.signals.generate_certificate.apply_async',
return_value=None) as mock_generate_certificate_apply_async:
grade_factory = CourseGradeFactory()
# Create the certificate
GeneratedCertificateFactory(
user=self.user,
course_id=self.course.id,
status=CertificateStatuses.downloadable)
# Certs are not re-fired after passing
with mock_passing_grade():
grade_factory.update(self.user, self.course)
mock_generate_certificate_apply_async.assert_not_called()
def test_cert_already_generated_unverified(self):
with override_waffle_switch(AUTO_CERTIFICATE_GENERATION, active=True):
GeneratedCertificateFactory(user=self.user,
course_id=self.course.id,
status=CertificateStatuses.unverified)
with mock.patch(
'lms.djangoapps.certificates.signals.generate_certificate_task',
return_value=None) as mock_cert_task:
grade_factory = CourseGradeFactory()
with mock_passing_grade():
grade_factory.update(self.user, self.course)
mock_cert_task.assert_called_with(self.user,
self.course_key)
def test_grade_not_appears_before_cert_available_date(self):
"""
Verify that learners are able to see their final grade of the course in
the learner dashboard after the course had ended
"""
self.course_key = CourseKey.from_string('course-v1:edX+DemoX+Demo_Course')
self.course = CourseOverviewFactory.create(id=self.course_key, end_date=self.THREE_YEARS_AGO,
certificate_available_date=self.TOMORROW,
lowest_passing_grade=0.3)
self.course_enrollment = CourseEnrollmentFactory(course_id=self.course.id, user=self.user)
GeneratedCertificateFactory(status='notpassing', course_id=self.course.id, user=self.user, grade=0.45)
response = self.client.get(reverse('dashboard'))
self.assertNotContains(response, 'Your final grade:')
self.assertNotContains(response, '<span class="grade-value">45%</span>')
