def test_cert_generation_on_whitelist_append_self_paced(self):
"""
Verify that signal is sent, received, and fires task
based on 'AUTO_CERTIFICATE_GENERATION' flag
"""
with mock.patch(
'lms.djangoapps.certificates.signals.generate_certificate.apply_async',
return_value=None
) as mock_generate_certificate_apply_async:
with override_waffle_switch(AUTO_CERTIFICATE_GENERATION_SWITCH, active=False):
CertificateWhitelistFactory(
user=self.user,
course_id=self.course.id
)
mock_generate_certificate_apply_async.assert_not_called()
with override_waffle_switch(AUTO_CERTIFICATE_GENERATION_SWITCH, active=True):
CertificateWhitelistFactory(
user=self.user,
course_id=self.course.id
)
mock_generate_certificate_apply_async.assert_called_with(
countdown=CERTIFICATE_DELAY_SECONDS,
kwargs={
'student': six.text_type(self.user.id),
'course_key': six.text_type(self.course.id),
}
)
def test_ineligible_cert_whitelisted(self, disable_audit_cert, status):
"""
Test that audit mode students receive a certificate if DISABLE_AUDIT_CERTIFICATES
feature is set to false
"""
# Enroll as audit
CourseEnrollmentFactory(user=self.user_2,
course_id=self.course.id,
is_active=True,
mode='audit')
# Whitelist student
CertificateWhitelistFactory(course_id=self.course.id, user=self.user_2)
features = settings.FEATURES
features['DISABLE_AUDIT_CERTIFICATES'] = disable_audit_cert
with override_settings(FEATURES=features) and mock_passing_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)
certificate = GeneratedCertificate.certificate_for_student(
self.user_2, self.course.id)
self.assertIsNotNone(certificate)
self.assertEqual(certificate.mode, 'audit')
self.assertEqual(certificate.status, status)
def test_id_verification_allowlist(self):
# User is not on the allowlist
with mock.patch(
'lms.djangoapps.certificates.signals.generate_allowlist_certificate_task',
return_value=None) as mock_allowlist_task:
with override_waffle_switch(AUTO_CERTIFICATE_GENERATION_SWITCH,
active=True):
attempt = SoftwareSecurePhotoVerification.objects.create(
user=self.user_two, status='submitted')
attempt.approve()
mock_allowlist_task.assert_not_called()
# User is on the allowlist
with mock.patch(
'lms.djangoapps.certificates.signals.generate_allowlist_certificate_task',
return_value=None) as mock_allowlist_task:
with override_waffle_switch(AUTO_CERTIFICATE_GENERATION_SWITCH,
active=True):
u = UserFactory.create()
c = CourseFactory()
course_key = c.id # pylint: disable=no-member
CourseEnrollmentFactory(user=u,
course_id=course_key,
is_active=True,
mode='verified')
CertificateWhitelistFactory(user=u, course_id=course_key)
attempt = SoftwareSecurePhotoVerification.objects.create(
user=u, status='submitted')
attempt.approve()
mock_allowlist_task.assert_called_with(u, course_key)
def test_passing_grade_allowlist(self):
with override_waffle_switch(AUTO_CERTIFICATE_GENERATION_SWITCH,
active=True):
# User who is not on the allowlist
GeneratedCertificateFactory(user=self.user,
course_id=self.course.id,
status=CertificateStatuses.error)
with mock_passing_grade():
with mock.patch(
'lms.djangoapps.certificates.signals.generate_allowlist_certificate_task',
return_value=None) as mock_allowlist_task:
CourseGradeFactory().update(self.user, self.course)
mock_allowlist_task.assert_not_called()
# 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.error)
with mock_passing_grade():
with mock.patch(
'lms.djangoapps.certificates.signals.generate_allowlist_certificate_task',
return_value=None) as mock_allowlist_task:
CourseGradeFactory().update(u, c)
mock_allowlist_task.assert_called_with(u, course_key)
def test_fire_task_allowlist_disabled(self):
"""
Test that the normal logic is followed if the allowlist is disabled for a user on the list
"""
with mock.patch(
'lms.djangoapps.certificates.signals.generate_certificate.apply_async',
return_value=None
) as mock_generate_certificate_apply_async:
with mock.patch(
'lms.djangoapps.certificates.signals.generate_allowlist_certificate_task',
return_value=None
) as mock_generate_allowlist_task:
CertificateWhitelistFactory(
user=self.user,
course_id=self.ip_course.id,
whitelist=True
)
fire_ungenerated_certificate_task(self.user, self.ip_course.id)
mock_generate_certificate_apply_async.assert_called_with(
countdown=CERTIFICATE_DELAY_SECONDS,
kwargs={
'student': six.text_type(self.user.id),
'course_key': six.text_type(self.ip_course.id),
}
)
mock_generate_allowlist_task.assert_not_called()
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_cert_generation_on_allowlist_append_self_paced_auto_cert_generation_disabled(
self):
"""
Verify that signal is sent, received, and fires task
based on 'AUTO_CERTIFICATE_GENERATION' flag
"""
with mock.patch(
'lms.djangoapps.certificates.signals.generate_certificate.apply_async',
return_value=None) as mock_generate_certificate_apply_async:
with override_waffle_switch(AUTO_CERTIFICATE_GENERATION_SWITCH,
active=False):
CertificateWhitelistFactory(user=self.user,
course_id=self.course.id)
mock_generate_certificate_apply_async.assert_not_called()
def setUp(self):
super().setUp()
self.user = UserFactory.create()
self.verified_course = CourseFactory.create(self_paced=True, )
self.verified_course_key = self.verified_course.id # pylint: disable=no-member
self.verified_enrollment = CourseEnrollmentFactory(
user=self.user,
course_id=self.verified_course_key,
is_active=True,
mode='verified',
)
CertificateWhitelistFactory(user=self.user,
course_id=self.verified_course_key)
self.audit_course = CourseFactory.create(self_paced=False)
self.audit_course_key = self.audit_course.id # pylint: disable=no-member
self.audit_enrollment = CourseEnrollmentFactory(
user=self.user,
course_id=self.audit_course_key,
is_active=True,
mode='audit',
)
CertificateWhitelistFactory(user=self.user,
course_id=self.audit_course_key)
def test_fire_task_allowlist_enabled(self):
"""
Test that the allowlist generation is invoked if the allowlist is enabled for a user on the list
"""
with mock.patch(
'lms.djangoapps.certificates.signals.generate_certificate.apply_async',
return_value=None) as mock_generate_certificate_apply_async:
with mock.patch(
'lms.djangoapps.certificates.signals.generate_allowlist_certificate_task',
return_value=None) as mock_generate_allowlist_task:
CertificateWhitelistFactory(user=self.user,
course_id=self.ip_course.id,
whitelist=True)
fire_ungenerated_certificate_task(self.user, self.ip_course.id)
mock_generate_certificate_apply_async.assert_not_called()
mock_generate_allowlist_task.assert_called_with(
self.user, self.ip_course.id)
def test_fire_task_allowlist_enabled(self):
"""
Test that the allowlist generation is invoked if the allowlist is enabled for a user on the list
"""
with mock.patch(
'lms.djangoapps.certificates.signals.generate_certificate.apply_async',
return_value=None) as mock_generate_certificate_apply_async:
with mock.patch(
'lms.djangoapps.certificates.signals.generate_allowlist_certificate_task',
return_value=None) as mock_generate_allowlist_task:
with override_waffle_switch(AUTO_CERTIFICATE_GENERATION_SWITCH,
active=True):
CertificateWhitelistFactory(user=self.user,
course_id=self.ip_course.id,
whitelist=True)
mock_generate_certificate_apply_async.assert_not_called()
mock_generate_allowlist_task.assert_called_with(
self.user, self.ip_course.id)
def test_invalidate_certificate_allowlist(self):
"""
Verify that CertificateService does not invalidate the certificate if it is allowlisted
"""
u = UserFactory.create()
c = CourseFactory()
course_key = c.id # pylint: disable=no-member
GeneratedCertificateFactory.create(
status=CertificateStatuses.downloadable,
user=u,
course_id=course_key,
grade=1.0)
CertificateWhitelistFactory(user=u, course_id=course_key)
success = self.service.invalidate_certificate(u.id, course_key)
self.assertFalse(success)
cert = GeneratedCertificate.objects.get(user=u.id,
course_id=course_key)
self.assertEqual(cert.status, CertificateStatuses.downloadable)
def test_ineligible_cert_whitelisted(self):
"""Test that audit mode students can receive a certificate if they are whitelisted."""
# Enroll as audit
CourseEnrollmentFactory(user=self.user_2,
course_id=self.course.id,
is_active=True,
mode='audit')
# Whitelist student
CertificateWhitelistFactory(course_id=self.course.id, user=self.user_2)
# Generate certs
with mock_passing_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 cert generated correctly
self.assertTrue(mock_send.called)
certificate = GeneratedCertificate.certificate_for_student(
self.user_2, self.course.id)
self.assertIsNotNone(certificate)
self.assertEqual(certificate.mode, 'audit')