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')
CertificateAllowlistFactory(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_certificate_task',
return_value=None) as mock_cert_task:
CourseGradeFactory().update(self.user, self.course)
mock_cert_task.assert_not_called()
# User who is on the allowlist
u = UserFactory.create()
c = CourseFactory()
course_key = c.id # pylint: disable=no-member
CertificateAllowlistFactory(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_certificate_task',
return_value=None) as mock_cert_task:
CourseGradeFactory().update(u, c)
mock_cert_task.assert_called_with(u, course_key)
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_fire_task_allowlist_auto_disabled(self):
"""
Test that the allowlist generation is not invoked if automatic generation is disabled
"""
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,
active=False):
CertificateAllowlistFactory(user=self.user,
course_id=self.ip_course.id)
mock_generate_allowlist_task.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',
)
CertificateAllowlistFactory(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',
)
CertificateAllowlistFactory(user=self.user,
course_id=self.audit_course_key)
def test_fire_task_allowlist_auto_enabled(self):
"""
Test that the allowlist generation is invoked if automatic generation is enabled
"""
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):
CertificateAllowlistFactory(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)
CertificateAllowlistFactory(user=u, course_id=course_key)
success = self.service.invalidate_certificate(u.id, course_key)
assert not success
cert = GeneratedCertificate.objects.get(user=u.id,
course_id=course_key)
assert cert.status == CertificateStatuses.downloadable
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)
assert cert.status == CertificateStatuses.notpassing
# User who is on the allowlist
u = UserFactory.create()
c = CourseFactory()
course_key = c.id # pylint: disable=no-member
CertificateAllowlistFactory(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)
assert cert.status == CertificateStatuses.downloadable
def test_can_generate_not_verified_not_passing_allowlist(self):
"""
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=GeneratedCertificate.MODES.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):
with mock.patch(PASSING_GRADE_METHOD, return_value=False):
assert not _can_generate_v2_certificate(u, self.course_run_key)
assert _set_v2_cert_status(
u, self.course_run_key) == CertificateStatuses.unverified
