def test_can_generate_honor_cert(self):
"""
Test that verifies we can generate an Honor cert for an Open edX installation configured to support Honor
certificates.
"""
course_run = CourseFactory()
course_run_key = course_run.id # pylint: disable=no-member
enrollment_mode = CourseMode.HONOR
grade = CourseGradeFactory().read(self.user, course_run)
CourseEnrollmentFactory(
user=self.user,
course_id=course_run_key,
is_active=True,
mode=enrollment_mode,
)
# Enable Honor Certificates and verify we can generate a certificate
with mock.patch(ID_VERIFIED_METHOD, return_value=False), \
mock.patch(PASSING_GRADE_METHOD, return_value=True), \
override_settings(FEATURES={**settings.FEATURES, 'DISABLE_HONOR_CERTIFICATES': False}):
assert _can_generate_regular_certificate(self.user, course_run_key, enrollment_mode, grade)
# Disable Honor Certificates and verify we cannot generate a certificate
with mock.patch(ID_VERIFIED_METHOD, return_value=False), \
mock.patch(PASSING_GRADE_METHOD, return_value=True), \
override_settings(FEATURES={**settings.FEATURES, 'DISABLE_HONOR_CERTIFICATES': True}):
assert not _can_generate_regular_certificate(self.user, course_run_key, enrollment_mode, grade)
def test_can_generate_not_verified_not_passing_allowlist(
self, enable_idv_requirement):
"""
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_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) == CertificateStatuses.unverified
else:
assert _set_regular_cert_status(
u, self.course_run_key, self.enrollment_mode,
self.grade) == CertificateStatuses.notpassing
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_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(self, enable_integrity_signature):
"""
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_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) is None
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_can_generate_not_verified_not_passing_allowlist(self, idv_retired):
"""
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(INTEGRITY_ENABLED_METHOD, return_value=idv_retired), \
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 idv_retired:
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_ccx(self):
"""
Test handling when the course is a CCX (custom edX) course
"""
with mock.patch(CCX_COURSE_METHOD, return_value=True):
assert not _can_generate_regular_certificate(self.user, self.course_run_key, self.enrollment_mode,
self.grade)
assert _set_regular_cert_status(self.user, self.course_run_key, self.enrollment_mode, self.grade) is None
def test_can_generate_web_cert_disabled(self):
"""
Test handling when web certs are not enabled
"""
with mock.patch(WEB_CERTS_METHOD, return_value=False):
assert not _can_generate_regular_certificate(self.user, self.course_run_key, self.enrollment_mode,
self.grade)
assert _set_regular_cert_status(self.user, self.course_run_key, self.enrollment_mode, self.grade) is None
def test_can_generate_no_overview(self):
"""
Test handling when the course overview is missing
"""
with mock.patch(COURSE_OVERVIEW_METHOD, return_value=None):
assert not _can_generate_regular_certificate(self.user, self.course_run_key, self.enrollment_mode,
self.grade)
assert _set_regular_cert_status(self.user, self.course_run_key, self.enrollment_mode, self.grade) is None
def test_can_generate_not_passing_no_cert(self):
"""
Test handling when the user does not have a passing grade and no cert exists
"""
with mock.patch(PASSING_GRADE_METHOD, return_value=False):
assert not _can_generate_regular_certificate(self.user, self.course_run_key, self.enrollment_mode,
self.grade)
assert _set_regular_cert_status(self.user, self.course_run_key, self.enrollment_mode, self.grade) is None
def test_can_generate_beta_tester(self):
"""
Test handling when the user is a beta tester
"""
with mock.patch(BETA_TESTER_METHOD, return_value=True):
assert not _can_generate_regular_certificate(self.user, self.course_run_key, self.enrollment_mode,
self.grade)
assert _set_regular_cert_status(self.user, self.course_run_key, self.enrollment_mode, self.grade) is None
def test_handle_valid(self):
"""
Test handling of a valid user/course run combo.
"""
assert _can_generate_regular_certificate(self.user,
self.course_run_key,
self.enrollment_mode,
self.grade)
assert generate_certificate_task(self.user, self.course_run_key)
def test_handle_invalid(self):
"""
Test handling of an invalid user/course run combo
"""
other_user = UserFactory()
mode = None
grade = None
assert not _can_generate_regular_certificate(other_user, self.course_run_key, mode, grade)
assert not generate_certificate_task(other_user, self.course_run_key)
assert not _generate_regular_certificate_task(other_user, self.course_run_key)
def test_can_generate_not_enrolled(self):
"""
Test handling when user is not enrolled
"""
u = UserFactory()
cr = CourseFactory()
key = cr.id # pylint: disable=no-member
mode = None
grade = None
assert not _can_generate_regular_certificate(u, key, mode, grade)
assert _set_regular_cert_status(u, key, mode, grade) is None
def test_can_generate_audit(self):
"""
Test handling when user is enrolled in audit mode
"""
u = UserFactory()
cr = CourseFactory()
key = cr.id # pylint: disable=no-member
mode = CourseMode.AUDIT
CourseEnrollmentFactory(
user=u,
course_id=key,
is_active=True,
mode=mode,
)
assert not _can_generate_regular_certificate(u, key, mode, self.grade)
assert _set_regular_cert_status(u, key, mode, self.grade) is None
def test_can_generate_not_verified_no_cert(self, idv_retired):
"""
Test handling when the user's id is not verified and they don't have a cert
"""
u = UserFactory()
CourseEnrollmentFactory(
user=u,
course_id=self.course_run_key,
is_active=True,
mode=CourseMode.VERIFIED,
)
with mock.patch(ID_VERIFIED_METHOD, return_value=False), \
mock.patch(INTEGRITY_ENABLED_METHOD, return_value=idv_retired):
self.assertEqual(idv_retired, _can_generate_regular_certificate(u, self.course_run_key,
self.enrollment_mode, self.grade))
self.assertIsNot(idv_retired, _set_regular_cert_status(u, self.course_run_key, self.enrollment_mode,
self.grade) == CertificateStatuses.unverified)
def test_can_generate_not_passing_cert(self):
"""
Test handling when the user does not have a passing grade and a cert exists
"""
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(PASSING_GRADE_METHOD, return_value=False):
assert not _can_generate_regular_certificate(u, self.course_run_key, self.enrollment_mode, self.grade)
assert _set_regular_cert_status(u, self.course_run_key, self.enrollment_mode,
self.grade) == CertificateStatuses.notpassing
def test_can_generate_not_verified_cert(self):
"""
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):
assert not _can_generate_regular_certificate(
u, self.course_run_key, self.enrollment_mode, self.grade)
assert _set_regular_cert_status(
u, self.course_run_key, self.enrollment_mode,
self.grade) == CertificateStatuses.unverified
def test_can_generate_not_verified_no_cert(self, enable_idv_requirement):
"""
Test handling when the user's id is not verified and they don't have a cert
"""
u = UserFactory()
CourseEnrollmentFactory(
user=u,
course_id=self.course_run_key,
is_active=True,
mode=CourseMode.VERIFIED,
)
with mock.patch(ID_VERIFIED_METHOD, return_value=False), \
mock.patch.dict(settings.FEATURES, ENABLE_CERTIFICATES_IDV_REQUIREMENT=enable_idv_requirement):
self.assertNotEqual(
enable_idv_requirement,
_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.assertIs(
enable_idv_requirement,
regular_cert_status == CertificateStatuses.unverified)
