"""Tests for the certificates Python API. """ import uuid from contextlib import contextmanager from datetime import datetime, timedelta from unittest import mock from unittest.mock import patch import ddt import pytz from config_models.models import cache from django.conf import settings from django.test import RequestFactory, TestCase from django.test.utils import override_settings from django.urls import reverse from django.utils import timezone from edx_toggles.toggles.testutils import override_waffle_switch from freezegun import freeze_time from opaque_keys.edx.keys import CourseKey from opaque_keys.edx.locator import CourseLocator from testfixtures import LogCapture from common.djangoapps.course_modes.models import CourseMode from common.djangoapps.course_modes.tests.factories import CourseModeFactory from common.djangoapps.student.tests.factories import CourseEnrollmentFactory, GlobalStaffFactory, UserFactory from common.djangoapps.util.testing import EventTestMixin from lms.djangoapps.certificates.api import ( auto_certificate_generation_enabled, available_date_for_certificate, can_be_added_to_allowlist, can_show_certificate_available_date_field, can_show_certificate_message, certificate_downloadable_status, certificate_status_for_student, clear_pii_from_certificate_records_for_user, create_certificate_invalidation_entry, create_or_update_certificate_allowlist_entry, display_date_for_certificate, generate_certificate_task, get_allowlist_entry, get_allowlisted_users, get_certificate_footer_context, get_certificate_for_user, get_certificate_for_user_id, get_certificate_header_context, get_certificate_invalidation_entry, get_certificate_url, get_certificates_for_user, get_certificates_for_user_by_course_keys, has_self_generated_certificates_enabled, is_certificate_invalidated, is_on_allowlist, remove_allowlist_entry, set_cert_generation_enabled, ) from lms.djangoapps.certificates.config import AUTO_CERTIFICATE_GENERATION from lms.djangoapps.certificates.models import ( CertificateGenerationConfiguration, CertificateStatuses, GeneratedCertificate, ) from lms.djangoapps.certificates.tests.factories import ( CertificateAllowlistFactory, CertificateInvalidationFactory, GeneratedCertificateFactory, ) from lms.djangoapps.certificates.tests.test_generation_handler import ID_VERIFIED_METHOD, PASSING_GRADE_METHOD from openedx.core.djangoapps.content.course_overviews.tests.factories import CourseOverviewFactory from openedx.core.djangoapps.site_configuration.tests.test_util import with_site_configuration from xmodule.data import CertificatesDisplayBehaviors from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase, SharedModuleStoreTestCase from xmodule.modulestore.tests.factories import CourseFactory CAN_GENERATE_METHOD = "lms.djangoapps.certificates.generation_handler._can_generate_regular_certificate" BETA_TESTER_METHOD = "lms.djangoapps.certificates.api.access.is_beta_tester" CERTS_VIEWABLE_METHOD = "lms.djangoapps.certificates.api.certificates_viewable_for_course" PASSED_OR_ALLOWLISTED_METHOD = "lms.djangoapps.certificates.api._has_passed_or_is_allowlisted" FEATURES_WITH_CERTS_ENABLED = settings.FEATURES.copy() FEATURES_WITH_CERTS_ENABLED["CERTIFICATES_HTML_VIEW"] = True class WebCertificateTestMixin: """ Mixin with helpers for testing Web Certificates. """ def _setup_course_certificate(self): """ Creates certificate configuration for course """ certificates = [ { "id": 1, "name": "Test Certificate Name", "description": "Test Certificate Description", "course_title": "tes_course_title", "signatories": [], "version": 1, "is_active": True, } ] self.course.certificates = {"certificates": certificates} self.course.cert_html_view_enabled = True self.course.save() self.store.update_item(self.course, self.user.id) @ddt.ddt class CertificateDownloadableStatusTests(WebCertificateTestMixin, ModuleStoreTestCase): """Tests for the `certificate_downloadable_status` helper function.""" ENABLED_SIGNALS = ["course_published"] def setUp(self): super().setUp() self.student = UserFactory() self.student_no_cert = UserFactory() self.course = CourseFactory.create( org="edx", number="verified", display_name="Verified Course", end=datetime.now(pytz.UTC), self_paced=False, certificate_available_date=datetime.now(pytz.UTC) - timedelta(days=2), ) GeneratedCertificateFactory.create( user=self.student, course_id=self.course.id, status=CertificateStatuses.downloadable, mode="verified" ) self.request_factory = RequestFactory() def test_cert_status_with_generating(self): cert_user = UserFactory() GeneratedCertificateFactory.create( user=cert_user, course_id=self.course.id, status=CertificateStatuses.generating, mode="verified" ) assert certificate_downloadable_status(cert_user, self.course.id) == { "is_downloadable": False, "is_generating": True, "is_unverified": False, "download_url": None, "uuid": None, } def test_cert_status_with_error(self): cert_user = UserFactory() GeneratedCertificateFactory.create( user=cert_user, course_id=self.course.id, status=CertificateStatuses.error, mode="verified" ) assert certificate_downloadable_status(cert_user, self.course.id) == { "is_downloadable": False, "is_generating": True, "is_unverified": False, "download_url": None, "uuid": None, } def test_without_cert(self): assert certificate_downloadable_status(self.student_no_cert, self.course.id) == { "is_downloadable": False, "is_generating": False, "is_unverified": False, "download_url": None, "uuid": None, } def verify_downloadable_pdf_cert(self): """ Verifies certificate_downloadable_status returns the correct response for PDF certificates. """ cert_user = UserFactory() cert = GeneratedCertificateFactory.create( user=cert_user, course_id=self.course.id, status=CertificateStatuses.downloadable, mode="verified", download_url="www.google.com", ) assert certificate_downloadable_status(cert_user, self.course.id) == { "is_downloadable": True, "is_generating": False, "is_unverified": False, "download_url": "www.google.com", "is_pdf_certificate": True, "uuid": cert.verify_uuid, } @patch.dict(settings.FEATURES, {"CERTIFICATES_HTML_VIEW": True}) def test_pdf_cert_with_html_enabled(self): self.verify_downloadable_pdf_cert() def test_pdf_cert_with_html_disabled(self): self.verify_downloadable_pdf_cert() @patch.dict(settings.FEATURES, {"CERTIFICATES_HTML_VIEW": True}) def test_with_downloadable_web_cert(self): cert_status = certificate_status_for_student(self.student, self.course.id) assert certificate_downloadable_status(self.student, self.course.id) == { "is_downloadable": True, "is_generating": False, "is_unverified": False, "download_url": f'/certificates/{cert_status["uuid"]}', "is_pdf_certificate": False, "uuid": cert_status["uuid"], } @ddt.data( (False, timedelta(days=2), False, True), (False, -timedelta(days=2), True, None), (True, timedelta(days=2), True, None), ) @ddt.unpack @patch.dict(settings.FEATURES, {"CERTIFICATES_HTML_VIEW": True}) @patch.dict(settings.FEATURES, {"ENABLE_V2_CERT_DISPLAY_SETTINGS": False}) def test_cert_api_return_v1(self, self_paced, cert_avail_delta, cert_downloadable_status, earned_but_not_available): """ Test 'downloadable status' """ cert_avail_date = datetime.now(pytz.UTC) + cert_avail_delta self.course.self_paced = self_paced self.course.certificate_available_date = cert_avail_date self.course.save() self._setup_course_certificate() downloadable_status = certificate_downloadable_status(self.student, self.course.id) assert downloadable_status["is_downloadable"] == cert_downloadable_status assert downloadable_status.get("earned_but_not_available") == earned_but_not_available @ddt.data( (True, timedelta(days=2), CertificatesDisplayBehaviors.END_WITH_DATE, True, None), (False, -timedelta(days=2), CertificatesDisplayBehaviors.EARLY_NO_INFO, True, None), (False, timedelta(days=2), CertificatesDisplayBehaviors.EARLY_NO_INFO, True, None), (False, -timedelta(days=2), CertificatesDisplayBehaviors.END, True, None), (False, timedelta(days=2), CertificatesDisplayBehaviors.END, False, True), (False, -timedelta(days=2), CertificatesDisplayBehaviors.END_WITH_DATE, True, None), (False, timedelta(days=2), CertificatesDisplayBehaviors.END_WITH_DATE, False, True), ) @ddt.unpack @patch.dict(settings.FEATURES, {"CERTIFICATES_HTML_VIEW": True}) @patch.dict(settings.FEATURES, {"ENABLE_V2_CERT_DISPLAY_SETTINGS": True}) def test_cert_api_return_v2( self, self_paced, cert_avail_delta, certificates_display_behavior, cert_downloadable_status, earned_but_not_available, ): """ Test 'downloadable status' """ cert_avail_date = datetime.now(pytz.UTC) + cert_avail_delta self.course.self_paced = self_paced self.course.certificate_available_date = cert_avail_date self.course.certificates_display_behavior = certificates_display_behavior self.course.save() self._setup_course_certificate() downloadable_status = certificate_downloadable_status(self.student, self.course.id) assert downloadable_status["is_downloadable"] == cert_downloadable_status assert downloadable_status.get("earned_but_not_available") == earned_but_not_available @ddt.ddt class CertificateIsInvalid(WebCertificateTestMixin, ModuleStoreTestCase): """Tests for the `is_certificate_invalid` helper function.""" def setUp(self): super().setUp() self.student = UserFactory() self.course = CourseFactory.create(org="edx", number="verified", display_name="Verified Course") self.course_overview = CourseOverviewFactory.create(id=self.course.id) self.global_staff = GlobalStaffFactory() self.request_factory = RequestFactory() def test_method_with_no_certificate(self): """Test the case when there is no certificate for a user for a specific course.""" course = CourseFactory.create(org="edx", number="honor", display_name="Course 1") # Also check query count for 'is_certificate_invalid' method. with self.assertNumQueries(1): assert not is_certificate_invalidated(self.student, course.id) @ddt.data( CertificateStatuses.generating, CertificateStatuses.downloadable, CertificateStatuses.notpassing, CertificateStatuses.error, CertificateStatuses.unverified, CertificateStatuses.deleted, CertificateStatuses.unavailable, ) def test_method_with_invalidated_cert(self, status): """Verify that if certificate is marked as invalid than method will return True.""" generated_cert = self._generate_cert(status) self._invalidate_certificate(generated_cert, True) assert is_certificate_invalidated(self.student, self.course.id) @ddt.data( CertificateStatuses.generating, CertificateStatuses.downloadable, CertificateStatuses.notpassing, CertificateStatuses.error, CertificateStatuses.unverified, CertificateStatuses.deleted, CertificateStatuses.unavailable, ) def test_method_with_inactive_invalidated_cert(self, status): """Verify that if certificate is valid but it's invalidated status is false than method will return false.""" generated_cert = self._generate_cert(status) self._invalidate_certificate(generated_cert, False) assert not is_certificate_invalidated(self.student, self.course.id) @ddt.data( CertificateStatuses.generating, CertificateStatuses.downloadable, CertificateStatuses.notpassing, CertificateStatuses.error, CertificateStatuses.unverified, CertificateStatuses.deleted, CertificateStatuses.unavailable, ) def test_method_with_all_statues(self, status): """Verify method return True if certificate has valid status but it is marked as invalid in CertificateInvalidation table.""" certificate = self._generate_cert(status) CertificateInvalidationFactory.create( generated_certificate=certificate, invalidated_by=self.global_staff, active=True ) # Also check query count for 'is_certificate_invalid' method. with self.assertNumQueries(2): assert is_certificate_invalidated(self.student, self.course.id) def _invalidate_certificate(self, certificate, active): """Dry method to mark certificate as invalid.""" CertificateInvalidationFactory.create( generated_certificate=certificate, invalidated_by=self.global_staff, active=active ) # Invalidate user certificate certificate.invalidate() assert not certificate.is_valid() def _generate_cert(self, status): """Dry method to generate certificate.""" return GeneratedCertificateFactory.create( user=self.student, course_id=self.course.id, status=status, mode="verified" ) class CertificateGetTests(SharedModuleStoreTestCase): """Tests for the `test_get_certificate_for_user` helper function.""" now = timezone.now() @classmethod def setUpClass(cls): cls.freezer = freeze_time(cls.now) cls.freezer.start() super().setUpClass() cls.student = UserFactory() cls.student_no_cert = UserFactory() cls.uuid = uuid.uuid4().hex cls.nonexistent_course_id = CourseKey.from_string("course-v1:some+fake+course") cls.web_cert_course = CourseFactory.create( org="edx", number="verified_1", display_name="Verified Course 1", cert_html_view_enabled=True ) cls.pdf_cert_course = CourseFactory.create( org="edx", number="verified_2", display_name="Verified Course 2", cert_html_view_enabled=False ) cls.no_cert_course = CourseFactory.create( org="edx", number="verified_3", display_name="Verified Course 3", ) # certificate for the first course GeneratedCertificateFactory.create( user=cls.student, course_id=cls.web_cert_course.id, status=CertificateStatuses.downloadable, mode="verified", download_url="www.google.com", grade="0.88", verify_uuid=cls.uuid, ) # certificate for the second course GeneratedCertificateFactory.create( user=cls.student, course_id=cls.pdf_cert_course.id, status=CertificateStatuses.downloadable, mode="honor", download_url="www.gmail.com", grade="0.99", verify_uuid=cls.uuid, ) # certificate for a course that will be deleted GeneratedCertificateFactory.create( user=cls.student, course_id=cls.nonexistent_course_id, status=CertificateStatuses.downloadable ) @classmethod def tearDownClass(cls): super().tearDownClass() cls.freezer.stop() def test_get_certificate_for_user(self): """ Test to get a certificate for a user for a specific course. """ cert = get_certificate_for_user(self.student.username, self.web_cert_course.id) assert cert["username"] == self.student.username assert cert["course_key"] == self.web_cert_course.id assert cert["created"] == self.now assert cert["type"] == CourseMode.VERIFIED assert cert["status"] == CertificateStatuses.downloadable assert cert["grade"] == "0.88" assert cert["is_passing"] is True assert cert["download_url"] == "www.google.com" def test_get_certificate_for_user_id(self): """ Test to get a certificate for a user id for a specific course. """ cert = get_certificate_for_user_id(self.student, self.web_cert_course.id) assert cert is not None assert cert.course_id == self.web_cert_course.id assert cert.mode == CourseMode.VERIFIED assert cert.status == CertificateStatuses.downloadable assert cert.grade == "0.88" def test_get_certificates_for_user(self): """ Test to get all the certificates for a user """ certs = get_certificates_for_user(self.student.username) assert len(certs) == 2 assert certs[0]["username"] == self.student.username assert certs[1]["username"] == self.student.username assert certs[0]["course_key"] == self.web_cert_course.id assert certs[1]["course_key"] == self.pdf_cert_course.id assert certs[0]["created"] == self.now assert certs[1]["created"] == self.now assert certs[0]["type"] == CourseMode.VERIFIED assert certs[1]["type"] == CourseMode.HONOR assert certs[0]["status"] == CertificateStatuses.downloadable assert certs[1]["status"] == CertificateStatuses.downloadable assert certs[0]["is_passing"] is True assert certs[1]["is_passing"] is True assert certs[0]["grade"] == "0.88" assert certs[1]["grade"] == "0.99" assert certs[0]["download_url"] == "www.google.com" assert certs[1]["download_url"] == "www.gmail.com" def test_get_certificates_for_user_by_course_keys(self): """ Test to get certificates for a user for certain course keys, in a dictionary indexed by those course keys. """ certs = get_certificates_for_user_by_course_keys( user=self.student, course_keys={self.web_cert_course.id, self.no_cert_course.id}, ) assert set(certs.keys()) == {self.web_cert_course.id} cert = certs[self.web_cert_course.id] assert cert["username"] == self.student.username assert cert["course_key"] == self.web_cert_course.id assert cert["download_url"] == "www.google.com" def test_no_certificate_for_user(self): """ Test the case when there is no certificate for a user for a specific course. """ assert get_certificate_for_user(self.student_no_cert.username, self.web_cert_course.id) is None def test_no_certificates_for_user(self): """ Test the case when there are no certificates for a user. """ assert not get_certificates_for_user(self.student_no_cert.username) @patch.dict(settings.FEATURES, {"CERTIFICATES_HTML_VIEW": True}) def test_get_web_certificate_url(self): """ Test the get_certificate_url with a web cert course """ expected_url = reverse("certificates:render_cert_by_uuid", kwargs=dict(certificate_uuid=self.uuid)) cert_url = get_certificate_url(user_id=self.student.id, course_id=self.web_cert_course.id, uuid=self.uuid) assert expected_url == cert_url expected_url = reverse("certificates:render_cert_by_uuid", kwargs=dict(certificate_uuid=self.uuid)) cert_url = get_certificate_url(user_id=self.student.id, course_id=self.web_cert_course.id, uuid=self.uuid) assert expected_url == cert_url @patch.dict(settings.FEATURES, {"CERTIFICATES_HTML_VIEW": True}) def test_get_pdf_certificate_url(self): """ Test the get_certificate_url with a pdf cert course """ cert_url = get_certificate_url(user_id=self.student.id, course_id=self.pdf_cert_course.id, uuid=self.uuid) assert "www.gmail.com" == cert_url def test_get_certificate_with_deleted_course(self): """ Test the case when there is a certificate but the course was deleted. """ assert get_certificate_for_user(self.student.username, self.nonexistent_course_id) is None @ddt.ddt class GenerateUserCertificatesTest(ModuleStoreTestCase): """Tests for generating certificates for students.""" def setUp(self): super().setUp() self.user = UserFactory() self.course_run = CourseFactory() self.course_run_key = self.course_run.id # pylint: disable=no-member self.enrollment = CourseEnrollmentFactory( user=self.user, course_id=self.course_run_key, is_active=True, mode=CourseMode.VERIFIED, ) @patch.dict(settings.FEATURES, {"CERTIFICATES_HTML_VIEW": False}) def test_cert_url_empty_with_invalid_certificate(self): """ Test certificate url is empty if html view is not enabled and certificate is not yet generated """ url = get_certificate_url(self.user.id, self.course_run_key) assert url == "" @patch.dict(settings.FEATURES, {"CERTIFICATES_HTML_VIEW": True}) def test_generation(self): """ Test that a cert is successfully generated """ cert = get_certificate_for_user_id(self.user.id, self.course_run_key) assert not cert with mock.patch(PASSING_GRADE_METHOD, return_value=True): with mock.patch(ID_VERIFIED_METHOD, return_value=True): generate_certificate_task(self.user, self.course_run_key) cert = get_certificate_for_user_id(self.user.id, self.course_run_key) assert cert.status == CertificateStatuses.downloadable assert cert.mode == CourseMode.VERIFIED @patch.dict(settings.FEATURES, {"CERTIFICATES_HTML_VIEW": True}) @ddt.data(True, False) def test_generation_unverified(self, enable_idv_requirement): """ Test that a cert is successfully generated with a status of unverified """ cert = get_certificate_for_user_id(self.user.id, self.course_run_key) assert not cert with mock.patch(PASSING_GRADE_METHOD, return_value=True): with mock.patch(ID_VERIFIED_METHOD, return_value=False): with mock.patch.dict(settings.FEATURES, ENABLE_CERTIFICATES_IDV_REQUIREMENT=enable_idv_requirement): generate_certificate_task(self.user, self.course_run_key) cert = get_certificate_for_user_id(self.user.id, self.course_run_key) assert cert.mode == CourseMode.VERIFIED if enable_idv_requirement: assert cert.status == CertificateStatuses.unverified else: assert cert.status == CertificateStatuses.downloadable @patch.dict(settings.FEATURES, {"CERTIFICATES_HTML_VIEW": True}) def test_generation_notpassing(self): """ Test that a cert is successfully generated with a status of notpassing """ GeneratedCertificateFactory( user=self.user, course_id=self.course_run_key, status=CertificateStatuses.unavailable, mode=CourseMode.AUDIT ) with mock.patch(PASSING_GRADE_METHOD, return_value=False): with mock.patch(ID_VERIFIED_METHOD, return_value=True): generate_certificate_task(self.user, self.course_run_key) cert = get_certificate_for_user_id(self.user.id, self.course_run_key) assert cert.status == CertificateStatuses.notpassing assert cert.mode == CourseMode.VERIFIED @ddt.ddt class CertificateGenerationEnabledTest(EventTestMixin, TestCase): """Test enabling/disabling self-generated certificates for a course.""" COURSE_KEY = CourseLocator(org="test", course="test", run="test") def setUp(self): # pylint: disable=arguments-differ super().setUp("lms.djangoapps.certificates.api.tracker") # Since model-based configuration is cached, we need # to clear the cache before each test. cache.clear() @ddt.data( (None, None, False), (False, None, False), (False, True, False), (True, None, False), (True, False, False), (True, True, True), ) @ddt.unpack def test_cert_generation_enabled(self, is_feature_enabled, is_course_enabled, expect_enabled): if is_feature_enabled is not None: CertificateGenerationConfiguration.objects.create(enabled=is_feature_enabled) if is_course_enabled is not None: set_cert_generation_enabled(self.COURSE_KEY, is_course_enabled) cert_event_type = "enabled" if is_course_enabled else "disabled" event_name = ".".join(["edx", "certificate", "generation", cert_event_type]) self.assert_event_emitted( event_name, course_id=str(self.COURSE_KEY), ) self._assert_enabled_for_course(self.COURSE_KEY, expect_enabled) def test_latest_setting_used(self): # Enable the feature CertificateGenerationConfiguration.objects.create(enabled=True) # Enable for the course set_cert_generation_enabled(self.COURSE_KEY, True) self._assert_enabled_for_course(self.COURSE_KEY, True) # Disable for the course set_cert_generation_enabled(self.COURSE_KEY, False) self._assert_enabled_for_course(self.COURSE_KEY, False) def test_setting_is_course_specific(self): # Enable the feature CertificateGenerationConfiguration.objects.create(enabled=True) # Enable for one course set_cert_generation_enabled(self.COURSE_KEY, True) self._assert_enabled_for_course(self.COURSE_KEY, True) # Should be disabled for another course other_course = CourseLocator(org="other", course="other", run="other") self._assert_enabled_for_course(other_course, False) def _assert_enabled_for_course(self, course_key, expect_enabled): """Check that self-generated certificates are enabled or disabled for the course.""" actual_enabled = has_self_generated_certificates_enabled(course_key) assert expect_enabled == actual_enabled @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED) class CertificatesBrandingTest(ModuleStoreTestCase): """Test certificates branding.""" COURSE_KEY = CourseLocator(org="test", course="test", run="test") configuration = { "logo_image_url": "test_site/images/header-logo.png", "SITE_NAME": "test_site.localhost", "urls": { "ABOUT": "test-site/about", "PRIVACY": "test-site/privacy", "TOS_AND_HONOR": "test-site/tos-and-honor", }, } @with_site_configuration(configuration=configuration) def test_certificate_header_data(self): """ Test that get_certificate_header_context from lms.djangoapps.certificates api returns data customized according to site branding. """ # Generate certificates for the course CourseModeFactory.create(course_id=self.COURSE_KEY, mode_slug=CourseMode.HONOR) data = get_certificate_header_context(is_secure=True) # Make sure there are not unexpected keys in dict returned by 'get_certificate_header_context' self.assertCountEqual(list(data.keys()), ["logo_src", "logo_url"]) assert self.configuration["logo_image_url"] in data["logo_src"] assert self.configuration["SITE_NAME"] in data["logo_url"] @with_site_configuration(configuration=configuration) def test_certificate_footer_data(self): """ Test that get_certificate_footer_context from lms.djangoapps.certificates api returns data customized according to site branding. """ # Generate certificates for the course CourseModeFactory.create(course_id=self.COURSE_KEY, mode_slug=CourseMode.HONOR) data = get_certificate_footer_context() # Make sure there are not unexpected keys in dict returned by 'get_certificate_footer_context' self.assertCountEqual(list(data.keys()), ["company_about_url", "company_privacy_url", "company_tos_url"]) assert self.configuration["urls"]["ABOUT"] in data["company_about_url"] assert self.configuration["urls"]["PRIVACY"] in data["company_privacy_url"] assert self.configuration["urls"]["TOS_AND_HONOR"] in data["company_tos_url"] class CertificateAllowlistTests(ModuleStoreTestCase): """ Tests for allowlist functionality. """ def setUp(self): super().setUp() self.user = UserFactory() self.global_staff = GlobalStaffFactory() self.course_run = CourseFactory() self.course_run_key = self.course_run.id # pylint: disable=no-member CourseEnrollmentFactory( user=self.user, course_id=self.course_run_key, is_active=True, mode="verified", ) def test_create_certificate_allowlist_entry(self): """ Test for creating and updating allowlist entries. """ result, __ = create_or_update_certificate_allowlist_entry(self.user, self.course_run_key, "Testing!") assert result.course_id == self.course_run_key assert result.user == self.user assert result.notes == "Testing!" result, __ = create_or_update_certificate_allowlist_entry(self.user, self.course_run_key, "New test", False) assert result.notes == "New test" assert not result.allowlist def test_remove_allowlist_entry(self): """ Test for removing an allowlist entry for a user in a given course-run. """ CertificateAllowlistFactory.create(course_id=self.course_run_key, user=self.user) assert is_on_allowlist(self.user, self.course_run_key) result = remove_allowlist_entry(self.user, self.course_run_key) assert result assert not is_on_allowlist(self.user, self.course_run_key) def test_remove_allowlist_entry_with_certificate(self): """ Test for removing an allowlist entry. Verify that we also invalidate the certificate for the student. """ CertificateAllowlistFactory.create(course_id=self.course_run_key, user=self.user) GeneratedCertificateFactory.create( user=self.user, course_id=self.course_run_key, status=CertificateStatuses.downloadable, mode="verified" ) assert is_on_allowlist(self.user, self.course_run_key) result = remove_allowlist_entry(self.user, self.course_run_key) assert result certificate = GeneratedCertificate.objects.get(user=self.user, course_id=self.course_run_key) assert certificate.status == CertificateStatuses.unavailable assert not is_on_allowlist(self.user, self.course_run_key) def test_remove_allowlist_entry_entry_dne(self): """ Test for removing an allowlist entry that does not exist """ result = remove_allowlist_entry(self.user, self.course_run_key) assert not result def test_get_allowlist_entry(self): """ Test to verify that we can retrieve an allowlist entry for a learner. """ allowlist_entry = CertificateAllowlistFactory.create(course_id=self.course_run_key, user=self.user) retrieved_entry = get_allowlist_entry(self.user, self.course_run_key) assert retrieved_entry.id == allowlist_entry.id assert retrieved_entry.course_id == allowlist_entry.course_id assert retrieved_entry.user == allowlist_entry.user def test_get_allowlist_entry_dne(self): """ Test to verify behavior when an allowlist entry for a user does not exist """ expected_messages = [ f"Attempting to retrieve an allowlist entry for student {self.user.id} in course {self.course_run_key}.", f"No allowlist entry found for student {self.user.id} in course {self.course_run_key}.", ] with LogCapture() as log: retrieved_entry = get_allowlist_entry(self.user, self.course_run_key) assert retrieved_entry is None for index, message in enumerate(expected_messages): assert message in log.records[index].getMessage() def test_is_on_allowlist(self): """ Test to verify that we return True when an allowlist entry exists. """ CertificateAllowlistFactory.create(course_id=self.course_run_key, user=self.user) result = is_on_allowlist(self.user, self.course_run_key) assert result def test_is_on_allowlist_expect_false(self): """ Test to verify that we will not return False when no allowlist entry exists. """ result = is_on_allowlist(self.user, self.course_run_key) assert not result def test_is_on_allowlist_entry_disabled(self): """ Test to verify that we will return False when the allowlist entry if it is disabled. """ CertificateAllowlistFactory.create(course_id=self.course_run_key, user=self.user, allowlist=False) result = is_on_allowlist(self.user, self.course_run_key) assert not result def test_can_be_added_to_allowlist(self): """ Test to verify that a learner can be added to the allowlist that fits all needed criteria. """ assert can_be_added_to_allowlist(self.user, self.course_run_key) def test_can_be_added_to_allowlist_not_enrolled(self): """ Test to verify that a learner will be rejected from the allowlist without an active enrollment in a course-run. """ new_course_run = CourseFactory() assert not can_be_added_to_allowlist(self.user, new_course_run.id) # pylint: disable=no-member def test_can_be_added_to_allowlist_certificate_invalidated(self): """ Test to verify that a learner will be rejected from the allowlist if they currently appear on the certificate invalidation list. """ certificate = GeneratedCertificateFactory.create( user=self.user, course_id=self.course_run_key, status=CertificateStatuses.unavailable, mode="verified" ) CertificateInvalidationFactory.create( generated_certificate=certificate, invalidated_by=self.global_staff, active=True ) assert not can_be_added_to_allowlist(self.user, self.course_run_key) def test_can_be_added_to_allowlist_is_already_on_allowlist(self): """ Test to verify that a learner will be rejected from the allowlist if they currently already appear on the allowlist. """ CertificateAllowlistFactory.create(course_id=self.course_run_key, user=self.user) assert not can_be_added_to_allowlist(self.user, self.course_run_key) def test_get_users_allowlist(self): """ Test that allowlisted users are returned correctly """ u1 = UserFactory() u2 = UserFactory() u3 = UserFactory() u4 = UserFactory() cr1 = CourseFactory() key1 = cr1.id # pylint: disable=no-member cr2 = CourseFactory() key2 = cr2.id # pylint: disable=no-member cr3 = CourseFactory() key3 = cr3.id # pylint: disable=no-member CourseEnrollmentFactory( user=u1, course_id=key1, is_active=True, mode="verified", ) CourseEnrollmentFactory( user=u2, course_id=key1, is_active=True, mode="verified", ) CourseEnrollmentFactory( user=u3, course_id=key1, is_active=True, mode="verified", ) CourseEnrollmentFactory( user=u4, course_id=key2, is_active=True, mode="verified", ) # Add user to the allowlist CertificateAllowlistFactory.create(course_id=key1, user=u1) # Add user to the allowlist, but set allowlist to false CertificateAllowlistFactory.create(course_id=key1, user=u2, allowlist=False) # Add user to the allowlist in the other course CertificateAllowlistFactory.create(course_id=key2, user=u4) users = get_allowlisted_users(key1) assert 1 == users.count() assert users[0].id == u1.id users = get_allowlisted_users(key2) assert 1 == users.count() assert users[0].id == u4.id users = get_allowlisted_users(key3) assert 0 == users.count() def test_add_and_update(self): """ Test add and update of the allowlist """ u1 = UserFactory() notes = "blah" # Check before adding user entry = get_allowlist_entry(u1, self.course_run_key) assert entry is None # Add user create_or_update_certificate_allowlist_entry(u1, self.course_run_key, notes) entry = get_allowlist_entry(u1, self.course_run_key) assert entry.notes == notes # Update user new_notes = "really useful info" create_or_update_certificate_allowlist_entry(u1, self.course_run_key, new_notes) entry = get_allowlist_entry(u1, self.course_run_key) assert entry.notes == new_notes def test_remove(self): """ Test removal from the allowlist """ u1 = UserFactory() notes = "I had a thought...." # Add user create_or_update_certificate_allowlist_entry(u1, self.course_run_key, notes) entry = get_allowlist_entry(u1, self.course_run_key) assert entry.notes == notes # Remove user remove_allowlist_entry(u1, self.course_run_key) entry = get_allowlist_entry(u1, self.course_run_key) assert entry is None class CertificateInvalidationTests(ModuleStoreTestCase): """ Tests for the certificate invalidation functionality. """ def setUp(self): super().setUp() self.global_staff = GlobalStaffFactory() self.user = UserFactory() self.course_run = CourseFactory() self.course_run_key = self.course_run.id # pylint: disable=no-member CourseEnrollmentFactory( user=self.user, course_id=self.course_run_key, is_active=True, mode="verified", ) def test_create_certificate_invalidation_entry(self): """ Test to verify that we can use the functionality defined in the Certificates api.py to create certificate invalidation entries. This is functionality the Instructor Dashboard django app relies on. """ certificate = GeneratedCertificateFactory.create( user=self.user, course_id=self.course_run_key, status=CertificateStatuses.unavailable, mode="verified" ) result = create_certificate_invalidation_entry(certificate, self.global_staff, "Test!") assert result.generated_certificate == certificate assert result.active is True assert result.notes == "Test!" def test_get_certificate_invalidation_entry(self): """ Test to verify that we can retrieve a certificate invalidation entry for a learner. """ certificate = GeneratedCertificateFactory.create( user=self.user, course_id=self.course_run_key, status=CertificateStatuses.unavailable, mode="verified" ) invalidation = CertificateInvalidationFactory.create( generated_certificate=certificate, invalidated_by=self.global_staff, active=True ) retrieved_invalidation = get_certificate_invalidation_entry(certificate) assert retrieved_invalidation.id == invalidation.id assert retrieved_invalidation.generated_certificate == certificate assert retrieved_invalidation.active == invalidation.active def test_get_certificate_invalidation_entry_dne(self): """ Test to verify behavior when a certificate invalidation entry does not exist. """ certificate = GeneratedCertificateFactory.create( user=self.user, course_id=self.course_run_key, status=CertificateStatuses.unavailable, mode="verified" ) expected_messages = [ f"Attempting to retrieve certificate invalidation entry for certificate with id {certificate.id}.", f"No certificate invalidation found linked to certificate with id {certificate.id}.", ] with LogCapture() as log: retrieved_invalidation = get_certificate_invalidation_entry(certificate) assert retrieved_invalidation is None for index, message in enumerate(expected_messages): assert message in log.records[index].getMessage() class MockGeneratedCertificate: """ We can't import GeneratedCertificate from LMS here, so we roll our own minimal Certificate model for testing. """ def __init__(self, user=None, course_id=None, mode=None, status=None): self.user = user self.course_id = course_id self.mode = mode self.status = status self.created_date = datetime.now(pytz.UTC) self.modified_date = datetime.now(pytz.UTC) self.date_override = None def is_valid(self): """ Return True if certificate is valid else return False. """ return self.status == CertificateStatuses.downloadable class MockCertificateDateOverride: def __init__(self, date=None): self.date = date or datetime.now(pytz.UTC) @contextmanager def configure_waffle_namespace(feature_enabled): """ Context manager to configure the certs flags """ with override_waffle_switch(AUTO_CERTIFICATE_GENERATION, active=feature_enabled): yield @ddt.ddt class CertificatesApiTestCase(TestCase): """ API tests """ def setUp(self): super().setUp() self.course = CourseOverviewFactory.create( start=datetime(2017, 1, 1, tzinfo=pytz.UTC), end=datetime(2017, 1, 31, tzinfo=pytz.UTC), certificate_available_date=None, ) self.user = UserFactory.create() self.enrollment = CourseEnrollmentFactory( user=self.user, course_id=self.course.id, is_active=True, mode="audit", ) self.certificate = MockGeneratedCertificate(user=self.user, course_id=self.course.id) @ddt.data(True, False) def test_auto_certificate_generation_enabled(self, feature_enabled): with configure_waffle_namespace(feature_enabled): assert feature_enabled == auto_certificate_generation_enabled() @ddt.data( (True, True, False), # feature enabled and self-paced should return False (True, False, True), # feature enabled and instructor-paced should return True (False, True, False), # feature not enabled and self-paced should return False (False, False, False), # feature not enabled and instructor-paced should return False ) @ddt.unpack def test_can_show_certificate_available_date_field(self, feature_enabled, is_self_paced, expected_value): self.course.self_paced = is_self_paced with configure_waffle_namespace(feature_enabled): assert expected_value == can_show_certificate_available_date_field(self.course) @ddt.data( (True, True, False), # feature enabled and self-paced should return False (True, False, True), # feature enabled and instructor-paced should return True (False, True, False), # feature not enabled and self-paced should return False (False, False, False), # feature not enabled and instructor-paced should return False ) @ddt.unpack def test_available_vs_display_date(self, feature_enabled, is_self_paced, uses_avail_date): self.course.self_paced = is_self_paced with configure_waffle_namespace(feature_enabled): # With no available_date set, both return modified_date assert self.certificate.modified_date == available_date_for_certificate(self.course, self.certificate) assert self.certificate.modified_date == display_date_for_certificate(self.course, self.certificate) # With an available date set in the past, both return the available date (if configured) self.course.certificate_available_date = datetime(2017, 2, 1, tzinfo=pytz.UTC) self.course.certificates_display_behavior = CertificatesDisplayBehaviors.END_WITH_DATE maybe_avail = self.course.certificate_available_date if uses_avail_date else self.certificate.modified_date assert maybe_avail == available_date_for_certificate(self.course, self.certificate) assert maybe_avail == display_date_for_certificate(self.course, self.certificate) # With a future available date, they each return a different date self.course.certificate_available_date = datetime.max.replace(tzinfo=pytz.UTC) maybe_avail = self.course.certificate_available_date if uses_avail_date else self.certificate.modified_date assert maybe_avail == available_date_for_certificate(self.course, self.certificate) assert self.certificate.modified_date == display_date_for_certificate(self.course, self.certificate) # With a certificate date override, display date returns the override, available date ignores it self.certificate.date_override = MockCertificateDateOverride() date = self.certificate.date_override.date assert date == display_date_for_certificate(self.course, self.certificate) assert maybe_avail == available_date_for_certificate(self.course, self.certificate) @ddt.ddt class CertificatesMessagingTestCase(ModuleStoreTestCase): """ API tests for certificate messaging """ def setUp(self): super().setUp() self.course = CourseOverviewFactory.create() self.course_run_key = self.course.id self.user = UserFactory.create() self.enrollment = CourseEnrollmentFactory( user=self.user, course_id=self.course_run_key, is_active=True, mode=CourseMode.VERIFIED, ) def test_beta_tester(self): grade = None certs_enabled = True with patch(PASSED_OR_ALLOWLISTED_METHOD, return_value=True): with patch(CERTS_VIEWABLE_METHOD, return_value=True): with patch(BETA_TESTER_METHOD, return_value=False): assert can_show_certificate_message(self.course, self.user, grade, certs_enabled) with patch(BETA_TESTER_METHOD, return_value=True): assert not can_show_certificate_message(self.course, self.user, grade, certs_enabled) class CertificatesLearnerRetirementFunctionality(ModuleStoreTestCase): """ API tests for utility functions used as part of the learner retirement pipeline to remove PII from certificate records. """ def setUp(self): super().setUp() self.user = UserFactory() self.user_full_name = "Maeby Funke" self.course1 = CourseOverviewFactory() self.course2 = CourseOverviewFactory() GeneratedCertificateFactory( course_id=self.course1.id, name=self.user_full_name, user=self.user, ) GeneratedCertificateFactory( course_id=self.course2.id, name=self.user_full_name, user=self.user, ) def test_clear_pii_from_certificate_records(self): """ Unit test for the `clear_pii_from_certificate_records` utility function, used to wipe PII from certificate records when a learner's account is being retired. """ cert_course1 = GeneratedCertificate.objects.get(user=self.user, course_id=self.course1.id) cert_course2 = GeneratedCertificate.objects.get(user=self.user, course_id=self.course2.id) assert cert_course1.name == self.user_full_name assert cert_course2.name == self.user_full_name clear_pii_from_certificate_records_for_user(self.user) cert_course1 = GeneratedCertificate.objects.get(user=self.user, course_id=self.course1.id) cert_course2 = GeneratedCertificate.objects.get(user=self.user, course_id=self.course2.id) assert cert_course1.name == "" assert cert_course2.name == ""