215 lines
7.6 KiB
Python
215 lines
7.6 KiB
Python
"""Tests for display of certificates on the student dashboard. """
|
|
|
|
|
|
import datetime
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
import ddt
|
|
from django.conf import settings
|
|
from django.test.utils import override_settings
|
|
from django.urls import reverse
|
|
from pytz import UTC
|
|
from xmodule.modulestore import ModuleStoreEnum
|
|
from xmodule.modulestore.tests.django_utils import TEST_DATA_MONGO_AMNESTY_MODULESTORE, SharedModuleStoreTestCase
|
|
from xmodule.modulestore.tests.factories import CourseFactory
|
|
from xmodule.data import CertificatesDisplayBehaviors
|
|
|
|
from common.djangoapps.student.tests.factories import CourseEnrollmentFactory, UserFactory
|
|
from lms.djangoapps.certificates.api import get_certificate_url
|
|
from lms.djangoapps.certificates.data import CertificateStatuses
|
|
from lms.djangoapps.certificates.tests.factories import (
|
|
GeneratedCertificateFactory,
|
|
LinkedInAddToProfileConfigurationFactory
|
|
)
|
|
|
|
# pylint: disable=no-member
|
|
|
|
PAST_DATE = datetime.datetime.now(UTC) - datetime.timedelta(days=2)
|
|
FUTURE_DATE = datetime.datetime.now(UTC) + datetime.timedelta(days=2)
|
|
|
|
|
|
class CertificateDisplayTestBase(SharedModuleStoreTestCase):
|
|
"""Tests display of certificates on the student dashboard. """
|
|
|
|
MODULESTORE = TEST_DATA_MONGO_AMNESTY_MODULESTORE
|
|
USERNAME = "test_user"
|
|
PASSWORD = "password"
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
cls.course = CourseFactory()
|
|
cls.course.certificates_display_behavior = CertificatesDisplayBehaviors.EARLY_NO_INFO
|
|
|
|
with cls.store.branch_setting(ModuleStoreEnum.Branch.draft_preferred, cls.course.id):
|
|
cls.store.update_item(cls.course, cls.USERNAME)
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.user = UserFactory.create(username=self.USERNAME, password=self.PASSWORD)
|
|
result = self.client.login(username=self.USERNAME, password=self.PASSWORD)
|
|
assert result, 'Could not log in'
|
|
|
|
def _check_linkedin_visibility(self, is_visible):
|
|
"""
|
|
Performs assertions on the Dashboard
|
|
"""
|
|
response = self.client.get(reverse('dashboard'))
|
|
if is_visible:
|
|
self.assertContains(response, 'Add Certificate to LinkedIn Profile')
|
|
else:
|
|
self.assertNotContains(response, 'Add Certificate to LinkedIn Profile')
|
|
|
|
def _create_certificate(self, enrollment_mode):
|
|
"""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,
|
|
status=CertificateStatuses.downloadable,
|
|
grade=0.98,
|
|
)
|
|
|
|
|
|
@ddt.ddt
|
|
@unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
|
|
class CertificateDashboardMessageDisplayTest(CertificateDisplayTestBase):
|
|
"""
|
|
Tests the certificates messages for a course in the dashboard.
|
|
"""
|
|
|
|
ENABLED_SIGNALS = ['course_published']
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
cls.course.certificates_display_behavior = CertificatesDisplayBehaviors.END_WITH_DATE
|
|
cls.course.save()
|
|
cls.store.update_item(cls.course, cls.USERNAME)
|
|
|
|
def _check_message(self, visible_date): # lint-amnesty, pylint: disable=missing-function-docstring
|
|
response = self.client.get(reverse('dashboard'))
|
|
test_message = 'Your grade and certificate will be ready after'
|
|
|
|
is_past = visible_date < datetime.datetime.now(UTC)
|
|
|
|
if is_past:
|
|
self.assertNotContains(response, test_message)
|
|
self.assertNotContains(response, "View Test_Certificate")
|
|
|
|
else:
|
|
self.assertContains(response, test_message)
|
|
self.assertNotContains(response, "View Test_Certificate")
|
|
|
|
@ddt.data(
|
|
(CertificatesDisplayBehaviors.END, True),
|
|
(CertificatesDisplayBehaviors.END, False),
|
|
(CertificatesDisplayBehaviors.END_WITH_DATE, True),
|
|
(CertificatesDisplayBehaviors.END_WITH_DATE, False)
|
|
)
|
|
@ddt.unpack
|
|
def test_certificate_available_date(self, certificates_display_behavior, past_date):
|
|
cert = self._create_certificate('verified')
|
|
cert.status = CertificateStatuses.downloadable
|
|
cert.save()
|
|
|
|
self.course.certificates_display_behavior = certificates_display_behavior
|
|
|
|
if certificates_display_behavior == CertificatesDisplayBehaviors.END:
|
|
if past_date:
|
|
self.course.end = PAST_DATE
|
|
else:
|
|
self.course.end = FUTURE_DATE
|
|
if certificates_display_behavior == CertificatesDisplayBehaviors.END_WITH_DATE:
|
|
if past_date:
|
|
self.course.certificate_available_date = PAST_DATE
|
|
else:
|
|
self.course.certificate_available_date = FUTURE_DATE
|
|
|
|
self.course.save()
|
|
self.store.update_item(self.course, self.USERNAME)
|
|
|
|
self._check_message(PAST_DATE if past_date else FUTURE_DATE)
|
|
|
|
|
|
@ddt.ddt
|
|
@unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
|
|
class CertificateDisplayTest(CertificateDisplayTestBase):
|
|
"""
|
|
Tests of certificate display.
|
|
"""
|
|
|
|
@ddt.data('verified', 'honor', 'professional')
|
|
def test_unverified_certificate_message(self, enrollment_mode):
|
|
cert = self._create_certificate(enrollment_mode)
|
|
cert.status = CertificateStatuses.unverified
|
|
cert.save()
|
|
response = self.client.get(reverse('dashboard'))
|
|
self.assertContains(
|
|
response,
|
|
'do not have a current verified identity with {platform_name}'
|
|
.format(platform_name=settings.PLATFORM_NAME))
|
|
|
|
def test_post_to_linkedin_visibility(self):
|
|
"""
|
|
Verifies that the post certificate to linked button
|
|
does not appear by default (when config is not set)
|
|
Then Verifies that the post certificate to linked button appears
|
|
as expected once a config is set
|
|
"""
|
|
self._create_certificate('honor')
|
|
|
|
# until we set up the configuration, the LinkedIn action
|
|
# button should not be visible
|
|
self._check_linkedin_visibility(False)
|
|
|
|
LinkedInAddToProfileConfigurationFactory()
|
|
# now we should see it
|
|
self._check_linkedin_visibility(True)
|
|
|
|
|
|
@ddt.ddt
|
|
@unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
|
|
class CertificateDisplayTestLinkedHtmlView(CertificateDisplayTestBase):
|
|
"""
|
|
Tests of linked student certificates.
|
|
"""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
cls.course.cert_html_view_enabled = True
|
|
|
|
certificates = [
|
|
{
|
|
'id': 0,
|
|
'name': 'Test Name',
|
|
'description': 'Test Description',
|
|
'is_active': True,
|
|
'signatories': [],
|
|
'version': 1
|
|
}
|
|
]
|
|
cls.course.certificates = {'certificates': certificates}
|
|
|
|
cls.course.save()
|
|
cls.store.update_item(cls.course, cls.USERNAME)
|
|
|
|
@ddt.data('verified')
|
|
@override_settings(CERT_NAME_SHORT='Test_Certificate')
|
|
@patch.dict('django.conf.settings.FEATURES', {'CERTIFICATES_HTML_VIEW': True})
|
|
def test_linked_student_to_web_view_credential(self, enrollment_mode):
|
|
|
|
cert = self._create_certificate(enrollment_mode)
|
|
test_url = get_certificate_url(course_id=self.course.id, uuid=cert.verify_uuid)
|
|
|
|
response = self.client.get(reverse('dashboard'))
|
|
|
|
self.assertContains(response, 'View my Test_Certificate')
|
|
self.assertContains(response, test_url)
|