""" Miscellaneous tests for the student app. """ import logging import unittest from datetime import datetime, timedelta from unittest.mock import Mock, patch from urllib.parse import quote import ddt import pytz from config_models.models import cache from django.conf import settings from django.contrib.auth.models import AnonymousUser, User # lint-amnesty, pylint: disable=imported-auth-user from django.test import TestCase, override_settings from django.test.client import Client from django.urls import reverse from markupsafe import escape from opaque_keys.edx.keys import CourseKey from opaque_keys.edx.locations import CourseLocator from pyquery import PyQuery as pq from common.djangoapps.course_modes.models import CourseMode from common.djangoapps.course_modes.tests.factories import CourseModeFactory from common.djangoapps.student.helpers import _cert_info, process_survey_link from common.djangoapps.student.models import ( AnonymousUserId, CourseEnrollment, LinkedInAddToProfileConfiguration, UserAttribute, anonymous_id_for_user, unique_id_for_user, user_by_anonymous_id ) from common.djangoapps.student.tests.factories import CourseEnrollmentFactory, UserFactory from common.djangoapps.student.views import complete_course_mode_info from common.djangoapps.util.model_utils import USER_SETTINGS_CHANGED_EVENT_NAME from common.djangoapps.util.testing import EventTestMixin from lms.djangoapps.certificates.models import CertificateStatuses from lms.djangoapps.certificates.tests.factories import GeneratedCertificateFactory from lms.djangoapps.verify_student.tests import TestVerificationBase from openedx.core.djangoapps.catalog.tests.factories import CourseFactory as CatalogCourseFactory from openedx.core.djangoapps.catalog.tests.factories import CourseRunFactory, ProgramFactory, generate_course_run_key from openedx.core.djangoapps.content.course_overviews.tests.factories import CourseOverviewFactory from openedx.core.djangoapps.programs.tests.mixins import ProgramsApiConfigMixin from openedx.core.djangoapps.site_configuration.tests.mixins import SiteMixin from openedx.core.djangolib.testing.utils import CacheIsolationTestCase, skip_unless_lms from xmodule.modulestore.tests.django_utils import ModuleStoreEnum, ModuleStoreTestCase, SharedModuleStoreTestCase from xmodule.modulestore.tests.factories import CourseFactory, check_mongo_calls log = logging.getLogger(__name__) @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') @ddt.ddt class CourseEndingTest(ModuleStoreTestCase): """Test things related to course endings: certificates, surveys, etc""" def test_process_survey_link(self): username = "fred" user = Mock(username=username) user_id = unique_id_for_user(user) link1 = "http://www.mysurvey.com" assert process_survey_link(link1, user) == link1 link2 = "http://www.mysurvey.com?unique={UNIQUE_ID}" link2_expected = f"http://www.mysurvey.com?unique={user_id}" assert process_survey_link(link2, user) == link2_expected @patch.dict('django.conf.settings.FEATURES', {'CERTIFICATES_HTML_VIEW': False}) def test_cert_info(self): user = UserFactory.create() survey_url = "http://a_survey.com" course = CourseOverviewFactory.create( end_of_course_survey_url=survey_url, certificates_display_behavior='end', ) cert = GeneratedCertificateFactory.create( user=user, course_id=course.id, status=CertificateStatuses.downloadable, mode='honor', grade='67', download_url='http://s3.edx/cert' ) assert _cert_info(user, course, None) ==\ {'status': 'processing', 'show_survey_button': False, 'can_unenroll': True} cert_status = {'status': 'unavailable', 'mode': 'honor', 'uuid': None} assert _cert_info(user, course, cert_status) == {'status': 'processing', 'show_survey_button': False, 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': True} cert_status = {'status': 'generating', 'grade': '0.67', 'mode': 'honor', 'uuid': None} with patch('lms.djangoapps.grades.course_grade_factory.CourseGradeFactory.read') as patch_persisted_grade: patch_persisted_grade.return_value = Mock(percent=1.0) assert _cert_info(user, course, cert_status) == {'status': 'generating', 'show_survey_button': True, 'survey_url': survey_url, 'grade': '1.0', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False} cert_status = {'status': 'generating', 'grade': '0.67', 'mode': 'honor', 'uuid': None} assert _cert_info(user, course, cert_status) == {'status': 'generating', 'show_survey_button': True, 'survey_url': survey_url, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False} cert_status = { 'status': 'downloadable', 'grade': '0.67', 'download_url': cert.download_url, 'mode': 'honor', 'uuid': 'fakeuuidbutitsfine', } assert _cert_info(user, course, cert_status) == {'status': 'downloadable', 'download_url': cert.download_url, 'show_survey_button': True, 'survey_url': survey_url, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False} cert_status = { 'status': 'notpassing', 'grade': '0.67', 'download_url': cert.download_url, 'mode': 'honor', 'uuid': 'fakeuuidbutitsfine', } assert _cert_info(user, course, cert_status) == {'status': 'notpassing', 'show_survey_button': True, 'survey_url': survey_url, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': True} # Test a course that doesn't have a survey specified course2 = Mock(end_of_course_survey_url=None, id=CourseLocator(org="a", course="b", run="c")) cert_status = { 'status': 'notpassing', 'grade': '0.67', 'download_url': cert.download_url, 'mode': 'honor', 'uuid': 'fakeuuidbutitsfine' } assert _cert_info(user, course2, cert_status) == {'status': 'notpassing', 'show_survey_button': False, 'grade': '0.67', 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': True} # test when the display is unavailable or notpassing, we get the correct results out course2.certificates_display_behavior = 'early_no_info' cert_status = {'status': 'unavailable', 'mode': 'honor', 'uuid': None} assert _cert_info(user, course2, cert_status) == {'status': 'processing', 'show_survey_button': False, 'can_unenroll': True} cert_status = { 'status': 'notpassing', 'grade': '0.67', 'download_url': cert.download_url, 'mode': 'honor', 'uuid': 'fakeuuidbutitsfine' } assert _cert_info(user, course2, cert_status) == {'status': 'processing', 'show_survey_button': False, 'can_unenroll': True} @ddt.data( (0.70, 0.60), (0.60, 0.70), (None, 0.70), (None, 0.0), (0.70, None), (0.0, None), (0.70, 0.0), (0.0, 0.70), ) @ddt.unpack def test_cert_grade(self, persisted_grade, cert_grade): """ Tests that the higher of the persisted grade and the grade from the certs table is used on the learner dashboard. """ expected_grade = max(filter(lambda x: x is not None, [persisted_grade, cert_grade])) user = UserFactory.create() survey_url = "http://a_survey.com" course = CourseOverviewFactory.create( end_of_course_survey_url=survey_url, certificates_display_behavior='end', ) if cert_grade is not None: cert_status = {'status': 'generating', 'grade': str(cert_grade), 'mode': 'honor', 'uuid': None} else: cert_status = {'status': 'generating', 'mode': 'honor', 'uuid': None} with patch('lms.djangoapps.grades.course_grade_factory.CourseGradeFactory.read') as patch_persisted_grade: patch_persisted_grade.return_value = Mock(percent=persisted_grade) assert _cert_info(user, course, cert_status) == {'status': 'generating', 'show_survey_button': True, 'survey_url': survey_url, 'grade': str(expected_grade), 'mode': 'honor', 'linked_in_url': None, 'can_unenroll': False} def test_cert_grade_no_grades(self): """ Tests that the default cert info is returned when the learner has no persisted grade or grade in the certs table. """ user = UserFactory.create() survey_url = "http://a_survey.com" course = CourseOverviewFactory.create( end_of_course_survey_url=survey_url, certificates_display_behavior='end', ) cert_status = {'status': 'generating', 'mode': 'honor', 'uuid': None} with patch('lms.djangoapps.grades.course_grade_factory.CourseGradeFactory.read') as patch_persisted_grade: patch_persisted_grade.return_value = None assert _cert_info(user, course, cert_status) == {'status': 'processing', 'show_survey_button': False, 'can_unenroll': True} @ddt.ddt class DashboardTest(ModuleStoreTestCase, TestVerificationBase): """ Tests for dashboard utility functions """ ENABLED_SIGNALS = ['course_published'] def setUp(self): super().setUp() self.course = CourseFactory.create() self.user = UserFactory.create(username="jack", email="jack@fake.edx.org", password='test') self.client = Client() cache.clear() @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') def _check_verification_status_on(self, mode, value): """ Check that the css class and the status message are in the dashboard html. """ CourseModeFactory.create(mode_slug=mode, course_id=self.course.id) CourseEnrollment.enroll(self.user, self.course.location.course_key, mode=mode) if mode == 'verified': # Simulate a successful verification attempt attempt = self.create_and_submit_attempt_for_user(self.user) attempt.approve() response = self.client.get(reverse('dashboard')) if mode in ['professional', 'no-id-professional']: self.assertContains(response, 'class="course professional"') else: self.assertContains(response, f'class="course {mode}"') self.assertContains(response, value) @patch.dict("django.conf.settings.FEATURES", {'ENABLE_VERIFIED_CERTIFICATES': True}) def test_verification_status_visible(self): """ Test that the certificate verification status for courses is visible on the dashboard. """ self.client.login(username="jack", password="test") self._check_verification_status_on('verified', 'You're enrolled as a verified student') self._check_verification_status_on('honor', 'You're enrolled as an honor code student') self._check_verification_status_off('audit', '') self._check_verification_status_on('professional', 'You're enrolled as a professional education student') self._check_verification_status_on( 'no-id-professional', 'You're enrolled as a professional education student', ) @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') def _check_verification_status_off(self, mode, value): """ Check that the css class and the status message are not in the dashboard html. """ CourseModeFactory.create(mode_slug=mode, course_id=self.course.id) CourseEnrollment.enroll(self.user, self.course.location.course_key, mode=mode) if mode == 'verified': # Simulate a successful verification attempt attempt = self.create_and_submit_attempt_for_user(self.user) attempt.approve() response = self.client.get(reverse('dashboard')) if mode == 'audit': # Audit mode does not have a banner. Assert no banner element. assert pq(response.content)('.sts-enrollment').length == 0 else: self.assertNotContains(response, f"class=\"course {mode}\"") self.assertNotContains(response, value) @patch.dict("django.conf.settings.FEATURES", {'ENABLE_VERIFIED_CERTIFICATES': False}) def test_verification_status_invisible(self): """ Test that the certificate verification status for courses is not visible on the dashboard if the verified certificates setting is off. """ self.client.login(username="jack", password="test") self._check_verification_status_off('verified', 'You\'re enrolled as a verified student') self._check_verification_status_off('honor', 'You\'re enrolled as an honor code student') self._check_verification_status_off('audit', '') def test_course_mode_info(self): verified_mode = CourseModeFactory.create( course_id=self.course.id, mode_slug='verified', mode_display_name='Verified', expiration_datetime=datetime.now(pytz.UTC) + timedelta(days=1) ) enrollment = CourseEnrollment.enroll(self.user, self.course.id) course_mode_info = complete_course_mode_info(self.course.id, enrollment) assert course_mode_info['show_upsell'] assert course_mode_info['days_for_upsell'] == 1 verified_mode.expiration_datetime = datetime.now(pytz.UTC) + timedelta(days=-1) verified_mode.save() course_mode_info = complete_course_mode_info(self.course.id, enrollment) assert not course_mode_info['show_upsell'] assert course_mode_info['days_for_upsell'] is None @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') def test_linked_in_add_to_profile_btn_not_appearing_without_config(self): # Without linked-in config don't show Add Certificate to LinkedIn button self.client.login(username="jack", password="test") CourseModeFactory.create( course_id=self.course.id, mode_slug='verified', mode_display_name='verified', expiration_datetime=datetime.now(pytz.UTC) - timedelta(days=1) ) CourseEnrollment.enroll(self.user, self.course.id, mode='honor') self.course.start = datetime.now(pytz.UTC) - timedelta(days=2) self.course.end = datetime.now(pytz.UTC) - timedelta(days=1) self.course.display_name = "Omega" self.course = self.update_course(self.course, self.user.id) download_url = 'www.edx.org' GeneratedCertificateFactory.create( user=self.user, course_id=self.course.id, status=CertificateStatuses.downloadable, mode='honor', grade='67', download_url=download_url ) response = self.client.get(reverse('dashboard')) assert response.status_code == 200 self.assertNotContains(response, 'Add Certificate to LinkedIn') response_url = 'https://www.linkedin.com/profile/add?startTask=CERTIFICATION_NAME' self.assertNotContains(response, escape(response_url)) @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') @patch.dict('django.conf.settings.FEATURES', {'CERTIFICATES_HTML_VIEW': False}) def test_linked_in_add_to_profile_btn_with_certificate(self): # If user has a certificate with valid linked-in config then Add Certificate to LinkedIn button # should be visible. and it has URL value with valid parameters. self.client.login(username="jack", password="test") linkedin_config = LinkedInAddToProfileConfiguration.objects.create(company_identifier='1337', enabled=True) CourseModeFactory.create( course_id=self.course.id, mode_slug='verified', mode_display_name='verified', expiration_datetime=datetime.now(pytz.UTC) - timedelta(days=1) ) CourseEnrollment.enroll(self.user, self.course.id, mode='honor') self.course.certificate_available_date = datetime.now(pytz.UTC) - timedelta(days=1) self.course.start = datetime.now(pytz.UTC) - timedelta(days=2) self.course.end = datetime.now(pytz.UTC) - timedelta(days=1) self.course.display_name = 'Omega' self.course = self.update_course(self.course, self.user.id) cert = GeneratedCertificateFactory.create( user=self.user, course_id=self.course.id, status=CertificateStatuses.downloadable, mode='honor', grade='67', download_url='https://www.edx.org' ) response = self.client.get(reverse('dashboard')) assert response.status_code == 200 self.assertContains(response, 'Add Certificate to LinkedIn') # We can switch to this and the commented out assertContains once edx-platform reaches Python 3.8 # expected_url = ( # 'https://www.linkedin.com/profile/add?startTask=CERTIFICATION_NAME&' # 'name={platform}+Honor+Code+Certificate+for+Omega&certUrl={cert_url}&' # 'organizationId={company_identifier}' # ).format( # platform=quote(settings.PLATFORM_NAME.encode('utf-8')), # cert_url=quote(cert.download_url, safe=''), # company_identifier=linkedin_config.company_identifier, # ) # self.assertContains(response, escape(expected_url)) # These can be removed (in favor of the above) once we are on Python 3.8. Fails in 3.5 because of dict ordering self.assertContains(response, escape('https://www.linkedin.com/profile/add?startTask=CERTIFICATION_NAME')) self.assertContains(response, escape('&name={platform}+Honor+Code+Certificate+for+Omega'.format( platform=quote(settings.PLATFORM_NAME.encode('utf-8')) ))) self.assertContains(response, escape('&certUrl={cert_url}'.format(cert_url=quote(cert.download_url, safe='')))) self.assertContains(response, escape('&organizationId={company_identifier}'.format( company_identifier=linkedin_config.company_identifier ))) @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split) def test_dashboard_metadata_caching(self, modulestore_type): """ Check that the student dashboard makes use of course metadata caching. After creating a course, that course's metadata should be cached as a CourseOverview. The student dashboard should never have to make calls to the modulestore. Arguments: modulestore_type (ModuleStoreEnum.Type): Type of modulestore to create test course in. Note to future developers: If you break this test so that the "check_mongo_calls(0)" fails, please do NOT change it to "check_mongo_calls(n>=1)". Instead, change your code to not load courses from the module store. This may involve adding fields to CourseOverview so that loading a full CourseBlock isn't necessary. """ # Create a course and log in the user. # Creating a new course will trigger a publish event and the course will be cached test_course = CourseFactory.create(default_store=modulestore_type, emit_signals=True) self.client.login(username="jack", password="test") with check_mongo_calls(0): CourseEnrollment.enroll(self.user, test_course.id) # Subsequent requests will only result in SQL queries to load the # CourseOverview object that has been created. with check_mongo_calls(0): response_1 = self.client.get(reverse('dashboard')) assert response_1.status_code == 200 response_2 = self.client.get(reverse('dashboard')) assert response_2.status_code == 200 @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') def test_dashboard_header_nav_has_find_courses(self): self.client.login(username="jack", password="test") response = self.client.get(reverse("dashboard")) # "Explore courses" is shown in the side panel self.assertContains(response, "Explore courses") # But other links are hidden in the navigation self.assertNotContains(response, "How it Works") self.assertNotContains(response, "Schools & Partners") def test_course_mode_info_with_honor_enrollment(self): """It will be true only if enrollment mode is honor and course has verified mode.""" course_mode_info = self._enrollment_with_complete_course('honor') assert course_mode_info['show_upsell'] assert course_mode_info['days_for_upsell'] == 1 @ddt.data('verified', 'credit') def test_course_mode_info_with_different_enrollments(self, enrollment_mode): """If user enrollment mode is either verified or credit then show_upsell will be always false. """ course_mode_info = self._enrollment_with_complete_course(enrollment_mode) assert not course_mode_info['show_upsell'] assert course_mode_info['days_for_upsell'] is None def _enrollment_with_complete_course(self, enrollment_mode): """"Dry method for course enrollment.""" CourseModeFactory.create( course_id=self.course.id, mode_slug='verified', mode_display_name='Verified', expiration_datetime=datetime.now(pytz.UTC) + timedelta(days=1) ) enrollment = CourseEnrollment.enroll(self.user, self.course.id, mode=enrollment_mode) return complete_course_mode_info(self.course.id, enrollment) @ddt.ddt class DashboardTestsWithSiteOverrides(SiteMixin, ModuleStoreTestCase): """ Tests for site settings overrides used when rendering the dashboard view """ def setUp(self): super().setUp() self.org = 'fakeX' self.course = CourseFactory.create(org=self.org) self.user = UserFactory.create(username='jack', email='jack@fake.edx.org', password='test') CourseModeFactory.create(mode_slug='no-id-professional', course_id=self.course.id) CourseEnrollment.enroll(self.user, self.course.location.course_key, mode='no-id-professional') cache.clear() @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') @patch.dict("django.conf.settings.FEATURES", {'ENABLE_VERIFIED_CERTIFICATES': False}) @ddt.data( ('testserver1.com', {'ENABLE_VERIFIED_CERTIFICATES': True}), ('testserver2.com', {'ENABLE_VERIFIED_CERTIFICATES': True, 'DISPLAY_COURSE_MODES_ON_DASHBOARD': True}), ) @ddt.unpack def test_course_mode_visible(self, site_domain, site_configuration_values): """ Test that the course mode for courses is visible on the dashboard when settings have been overridden by site configuration. """ site_configuration_values.update({ 'SITE_NAME': site_domain, 'course_org_filter': self.org }) self.set_up_site(site_domain, site_configuration_values) self.client.login(username='jack', password='test') response = self.client.get(reverse('dashboard')) self.assertContains(response, 'class="course professional"') @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') @patch.dict("django.conf.settings.FEATURES", {'ENABLE_VERIFIED_CERTIFICATES': False}) @ddt.data( ('testserver3.com', {'ENABLE_VERIFIED_CERTIFICATES': False}), ('testserver4.com', {'DISPLAY_COURSE_MODES_ON_DASHBOARD': False}), ) @ddt.unpack def test_course_mode_invisible(self, site_domain, site_configuration_values): """ Test that the course mode for courses is invisible on the dashboard when settings have been overridden by site configuration. """ site_configuration_values.update({ 'SITE_NAME': site_domain, 'course_org_filter': self.org }) self.set_up_site(site_domain, site_configuration_values) self.client.login(username='jack', password='test') response = self.client.get(reverse('dashboard')) self.assertNotContains(response, 'class="course professional"') class UserSettingsEventTestMixin(EventTestMixin): """ Mixin for verifying that user setting events were emitted during a test. """ def setUp(self): # lint-amnesty, pylint: disable=arguments-differ super().setUp('common.djangoapps.util.model_utils.tracker') def assert_user_setting_event_emitted(self, **kwargs): """ Helper method to assert that we emit the expected user settings events. Expected settings are passed in via `kwargs`. """ if 'truncated' not in kwargs: kwargs['truncated'] = [] self.assert_event_emitted( USER_SETTINGS_CHANGED_EVENT_NAME, table=self.table, user_id=self.user.id, **kwargs ) def assert_user_enrollment_occurred(self, course_key): """ Helper method to assert that the user is enrolled in the given course. """ assert CourseEnrollment.is_enrolled(self.user, CourseKey.from_string(course_key)) class EnrollmentEventTestMixin(EventTestMixin): """ Mixin with assertions for validating enrollment events. """ def setUp(self): # lint-amnesty, pylint: disable=arguments-differ super().setUp('common.djangoapps.student.models.tracker') def assert_enrollment_mode_change_event_was_emitted(self, user, course_key, mode): """Ensures an enrollment mode change event was emitted""" self.mock_tracker.emit.assert_called_once_with( 'edx.course.enrollment.mode_changed', { 'course_id': str(course_key), 'user_id': user.pk, 'mode': mode } ) self.mock_tracker.reset_mock() def assert_enrollment_event_was_emitted(self, user, course_key): """Ensures an enrollment event was emitted since the last event related assertion""" self.mock_tracker.emit.assert_called_once_with( 'edx.course.enrollment.activated', { 'course_id': str(course_key), 'user_id': user.pk, 'mode': CourseMode.DEFAULT_MODE_SLUG } ) self.mock_tracker.reset_mock() def assert_unenrollment_event_was_emitted(self, user, course_key): """Ensures an unenrollment event was emitted since the last event related assertion""" self.mock_tracker.emit.assert_called_once_with( 'edx.course.enrollment.deactivated', { 'course_id': str(course_key), 'user_id': user.pk, 'mode': CourseMode.DEFAULT_MODE_SLUG } ) self.mock_tracker.reset_mock() class EnrollInCourseTest(EnrollmentEventTestMixin, CacheIsolationTestCase): """Tests enrolling and unenrolling in courses.""" @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') def test_enrollment(self): user = User.objects.create_user("joe", "joe@joe.com", "password") course_id = CourseKey.from_string("edX/Test101/2013") course_id_partial = CourseKey.from_string("edX/Test101/") # Test basic enrollment assert not CourseEnrollment.is_enrolled(user, course_id) assert not CourseEnrollment.is_enrolled_by_partial(user, course_id_partial) CourseEnrollment.enroll(user, course_id) assert CourseEnrollment.is_enrolled(user, course_id) assert CourseEnrollment.is_enrolled_by_partial(user, course_id_partial) self.assert_enrollment_event_was_emitted(user, course_id) # Enrolling them again should be harmless CourseEnrollment.enroll(user, course_id) assert CourseEnrollment.is_enrolled(user, course_id) assert CourseEnrollment.is_enrolled_by_partial(user, course_id_partial) self.assert_no_events_were_emitted() # Now unenroll the user CourseEnrollment.unenroll(user, course_id) assert not CourseEnrollment.is_enrolled(user, course_id) assert not CourseEnrollment.is_enrolled_by_partial(user, course_id_partial) self.assert_unenrollment_event_was_emitted(user, course_id) # Unenrolling them again should also be harmless CourseEnrollment.unenroll(user, course_id) assert not CourseEnrollment.is_enrolled(user, course_id) assert not CourseEnrollment.is_enrolled_by_partial(user, course_id_partial) self.assert_no_events_were_emitted() # The enrollment record should still exist, just be inactive enrollment_record = CourseEnrollment.objects.get( user=user, course_id=course_id ) assert not enrollment_record.is_active # Make sure mode is updated properly if user unenrolls & re-enrolls enrollment = CourseEnrollment.enroll(user, course_id, "verified") assert enrollment.mode == 'verified' CourseEnrollment.unenroll(user, course_id) enrollment = CourseEnrollment.enroll(user, course_id, "audit") assert CourseEnrollment.is_enrolled(user, course_id) assert enrollment.mode == 'audit' def test_enrollment_non_existent_user(self): # Testing enrollment of newly unsaved user (i.e. no database entry) user = User(username="rusty", email="rusty@fake.edx.org") course_id = CourseLocator("edX", "Test101", "2013") assert not CourseEnrollment.is_enrolled(user, course_id) # Unenroll does nothing CourseEnrollment.unenroll(user, course_id) self.assert_no_events_were_emitted() # Implicit save() happens on new User object when enrolling, so this # should still work CourseEnrollment.enroll(user, course_id) assert CourseEnrollment.is_enrolled(user, course_id) self.assert_enrollment_event_was_emitted(user, course_id) @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') def test_enrollment_by_email(self): user = User.objects.create(username="jack", email="jack@fake.edx.org") course_id = CourseLocator("edX", "Test101", "2013") CourseEnrollment.enroll_by_email("jack@fake.edx.org", course_id) assert CourseEnrollment.is_enrolled(user, course_id) self.assert_enrollment_event_was_emitted(user, course_id) # This won't throw an exception, even though the user is not found assert CourseEnrollment.enroll_by_email('not_jack@fake.edx.org', course_id) is None self.assert_no_events_were_emitted() self.assertRaises( User.DoesNotExist, CourseEnrollment.enroll_by_email, "not_jack@fake.edx.org", course_id, ignore_errors=False ) self.assert_no_events_were_emitted() # Now unenroll them by email CourseEnrollment.unenroll_by_email("jack@fake.edx.org", course_id) assert not CourseEnrollment.is_enrolled(user, course_id) self.assert_unenrollment_event_was_emitted(user, course_id) # Harmless second unenroll CourseEnrollment.unenroll_by_email("jack@fake.edx.org", course_id) assert not CourseEnrollment.is_enrolled(user, course_id) self.assert_no_events_were_emitted() # Unenroll on non-existent user shouldn't throw an error CourseEnrollment.unenroll_by_email("not_jack@fake.edx.org", course_id) self.assert_no_events_were_emitted() @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') def test_enrollment_multiple_classes(self): user = User(username="rusty", email="rusty@fake.edx.org") course_id1 = CourseLocator("edX", "Test101", "2013") course_id2 = CourseLocator("MITx", "6.003z", "2012") CourseEnrollment.enroll(user, course_id1) self.assert_enrollment_event_was_emitted(user, course_id1) CourseEnrollment.enroll(user, course_id2) self.assert_enrollment_event_was_emitted(user, course_id2) assert CourseEnrollment.is_enrolled(user, course_id1) assert CourseEnrollment.is_enrolled(user, course_id2) CourseEnrollment.unenroll(user, course_id1) self.assert_unenrollment_event_was_emitted(user, course_id1) assert not CourseEnrollment.is_enrolled(user, course_id1) assert CourseEnrollment.is_enrolled(user, course_id2) CourseEnrollment.unenroll(user, course_id2) self.assert_unenrollment_event_was_emitted(user, course_id2) assert not CourseEnrollment.is_enrolled(user, course_id1) assert not CourseEnrollment.is_enrolled(user, course_id2) @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') def test_activation(self): user = User.objects.create(username="jack", email="jack@fake.edx.org") course_id = CourseLocator("edX", "Test101", "2013") assert not CourseEnrollment.is_enrolled(user, course_id) # Creating an enrollment doesn't actually enroll a student # (calling CourseEnrollment.enroll() would have) enrollment = CourseEnrollment.get_or_create_enrollment(user, course_id) assert not CourseEnrollment.is_enrolled(user, course_id) self.assert_no_events_were_emitted() # Until you explicitly activate it enrollment.activate() assert CourseEnrollment.is_enrolled(user, course_id) self.assert_enrollment_event_was_emitted(user, course_id) # Activating something that's already active does nothing enrollment.activate() assert CourseEnrollment.is_enrolled(user, course_id) self.assert_no_events_were_emitted() # Now deactive enrollment.deactivate() assert not CourseEnrollment.is_enrolled(user, course_id) self.assert_unenrollment_event_was_emitted(user, course_id) # Deactivating something that's already inactive does nothing enrollment.deactivate() assert not CourseEnrollment.is_enrolled(user, course_id) self.assert_no_events_were_emitted() # A deactivated enrollment should be activated if enroll() is called # for that user/course_id combination CourseEnrollment.enroll(user, course_id) assert CourseEnrollment.is_enrolled(user, course_id) self.assert_enrollment_event_was_emitted(user, course_id) def test_change_enrollment_modes(self): user = User.objects.create(username="justin", email="jh@fake.edx.org") course_id = CourseLocator("edX", "Test101", "2013") CourseEnrollment.enroll(user, course_id, "audit") self.assert_enrollment_event_was_emitted(user, course_id) CourseEnrollment.enroll(user, course_id, "honor") self.assert_enrollment_mode_change_event_was_emitted(user, course_id, "honor") # same enrollment mode does not emit an event CourseEnrollment.enroll(user, course_id, "honor") self.assert_no_events_were_emitted() CourseEnrollment.enroll(user, course_id, "audit") self.assert_enrollment_mode_change_event_was_emitted(user, course_id, "audit") @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms') class ChangeEnrollmentViewTest(ModuleStoreTestCase): """Tests the student.views.change_enrollment view""" def setUp(self): super().setUp() self.course = CourseFactory.create() self.user = UserFactory.create(password='secret') self.client.login(username=self.user.username, password='secret') self.url = reverse('change_enrollment') def _enroll_through_view(self, course): """ Enroll a student in a course. """ response = self.client.post( reverse('change_enrollment'), { 'course_id': course.id, 'enrollment_action': 'enroll' } ) return response def test_enroll_as_default(self): """Tests that a student can successfully enroll through this view""" response = self._enroll_through_view(self.course) assert response.status_code == 200 enrollment_mode, is_active = CourseEnrollment.enrollment_mode_for_user( self.user, self.course.id ) assert is_active assert enrollment_mode == CourseMode.DEFAULT_MODE_SLUG def test_cannot_enroll_if_already_enrolled(self): """ Tests that a student will not be able to enroll through this view if they are already enrolled in the course """ CourseEnrollment.enroll(self.user, self.course.id) assert CourseEnrollment.is_enrolled(self.user, self.course.id) # now try to enroll that student response = self._enroll_through_view(self.course) assert response.status_code == 400 def test_change_to_default_if_verified(self): """ Tests that a student that is a currently enrolled verified student cannot accidentally change their enrollment mode """ CourseEnrollment.enroll(self.user, self.course.id, mode='verified') assert CourseEnrollment.is_enrolled(self.user, self.course.id) # now try to enroll the student in the default mode: response = self._enroll_through_view(self.course) assert response.status_code == 400 enrollment_mode, is_active = CourseEnrollment.enrollment_mode_for_user( self.user, self.course.id ) assert is_active assert enrollment_mode == 'verified' def test_change_to_default_if_verified_not_active(self): """ Tests that one can renroll for a course if one has already unenrolled """ # enroll student CourseEnrollment.enroll(self.user, self.course.id, mode='verified') # now unenroll student: CourseEnrollment.unenroll(self.user, self.course.id) # check that they are verified but inactive enrollment_mode, is_active = CourseEnrollment.enrollment_mode_for_user( self.user, self.course.id ) assert not is_active assert enrollment_mode == 'verified' # now enroll them through the view: response = self._enroll_through_view(self.course) assert response.status_code == 200 enrollment_mode, is_active = CourseEnrollment.enrollment_mode_for_user( self.user, self.course.id ) assert is_active assert enrollment_mode == CourseMode.DEFAULT_MODE_SLUG class AnonymousLookupTable(ModuleStoreTestCase): """ Tests for anonymous_id_functions """ def setUp(self): super().setUp() self.course = CourseFactory.create() self.user = UserFactory.create() CourseModeFactory.create( course_id=self.course.id, mode_slug='honor', mode_display_name='Honor Code', ) self.user2 = UserFactory.create() patcher = patch('common.djangoapps.student.models.tracker') patcher.start() self.addCleanup(patcher.stop) def test_same_user_over_multiple_sessions(self): """ Anonymous ids are stored in AnonymousUserId model. This tests to make sure stored value is used rather than a creating a new one """ anonymous_id_1 = anonymous_id_for_user(self.user, None) delattr(self.user, "_anonymous_id") # pylint: disable=literal-used-as-attribute anonymous_id_2 = anonymous_id_for_user(self.user, None) assert anonymous_id_1 == anonymous_id_2 def test_diff_anonymous_id_for_diff_users(self): anonymous_id_1 = anonymous_id_for_user(self.user, None) anonymous_id_2 = anonymous_id_for_user(self.user2, None) assert anonymous_id_1 != anonymous_id_2 def test_for_unregistered_user(self): # same path as for logged out user assert anonymous_id_for_user(AnonymousUser(), self.course.id) is None assert user_by_anonymous_id(None) is None def test_roundtrip_for_logged_user(self): CourseEnrollment.enroll(self.user, self.course.id) anonymous_id = anonymous_id_for_user(self.user, self.course.id) real_user = user_by_anonymous_id(anonymous_id) assert self.user == real_user assert anonymous_id == anonymous_id_for_user(self.user, self.course.id) def test_roundtrip_with_unicode_course_id(self): course2 = CourseFactory.create(display_name="Omega Course Ω") CourseEnrollment.enroll(self.user, course2.id) anonymous_id = anonymous_id_for_user(self.user, course2.id) real_user = user_by_anonymous_id(anonymous_id) assert self.user == real_user assert anonymous_id == anonymous_id_for_user(self.user, course2.id) def test_anonymous_id_secret_key_changes_do_not_change_existing_anonymous_ids(self): """Test that a same anonymous id is returned when the SECRET_KEY changes.""" CourseEnrollment.enroll(self.user, self.course.id) anonymous_id = anonymous_id_for_user(self.user, self.course.id) with override_settings(SECRET_KEY='some_new_and_totally_secret_key'): # Recreate user object to clear cached anonymous id. self.user = User.objects.get(pk=self.user.id) new_anonymous_id = anonymous_id_for_user(self.user, self.course.id) assert anonymous_id == new_anonymous_id assert self.user == user_by_anonymous_id(anonymous_id) assert self.user == user_by_anonymous_id(new_anonymous_id) def test_anonymous_id_secret_key_changes_result_in_diff_values_for_same_new_user(self): """Test that a different anonymous id is returned when the SECRET_KEY changes.""" CourseEnrollment.enroll(self.user, self.course.id) anonymous_id = anonymous_id_for_user(self.user, self.course.id) with override_settings(SECRET_KEY='some_new_and_totally_secret_key'): # Recreate user object to clear cached anonymous id. self.user = User.objects.get(pk=self.user.id) AnonymousUserId.objects.filter(user=self.user).filter(course_id=self.course.id).delete() new_anonymous_id = anonymous_id_for_user(self.user, self.course.id) assert anonymous_id != new_anonymous_id assert self.user == user_by_anonymous_id(new_anonymous_id) @skip_unless_lms @patch('openedx.core.djangoapps.programs.utils.get_programs') class RelatedProgramsTests(ProgramsApiConfigMixin, SharedModuleStoreTestCase): """Tests verifying that related programs appear on the course dashboard.""" maxDiff = None password = 'test' related_programs_preface = 'Related Programs' @classmethod def setUpClass(cls): super().setUpClass() cls.user = UserFactory() cls.course = CourseFactory() cls.enrollment = CourseEnrollmentFactory(user=cls.user, course_id=cls.course.id) # pylint: disable=no-member def setUp(self): super().setUp() self.url = reverse('dashboard') self.create_programs_config() self.client.login(username=self.user.username, password=self.password) course_run = CourseRunFactory(key=str(self.course.id)) # pylint: disable=no-member course = CatalogCourseFactory(course_runs=[course_run]) self.programs = [ProgramFactory(courses=[course]) for __ in range(2)] def assert_related_programs(self, response, are_programs_present=True): """Assertion for verifying response contents.""" assertion = getattr(self, 'assert{}Contains'.format('' if are_programs_present else 'Not')) for program in self.programs: assertion(response, self.expected_link_text(program)) assertion(response, self.related_programs_preface) def expected_link_text(self, program): """Construct expected dashboard link text.""" return '{title} {type}'.format(title=program['title'], type=program['type']) def test_related_programs_listed(self, mock_get_programs): """Verify that related programs are listed when available.""" mock_get_programs.return_value = self.programs response = self.client.get(self.url) self.assert_related_programs(response) def test_no_data_no_programs(self, mock_get_programs): """Verify that related programs aren't listed when none are available.""" mock_get_programs.return_value = [] response = self.client.get(self.url) self.assert_related_programs(response, are_programs_present=False) def test_unrelated_program_not_listed(self, mock_get_programs): """Verify that unrelated programs don't appear in the listing.""" nonexistent_course_run_id = generate_course_run_key() course_run = CourseRunFactory(key=nonexistent_course_run_id) course = CatalogCourseFactory(course_runs=[course_run]) unrelated_program = ProgramFactory(courses=[course]) mock_get_programs.return_value = self.programs + [unrelated_program] response = self.client.get(self.url) self.assert_related_programs(response) self.assertNotContains(response, unrelated_program['title']) def test_program_title_unicode(self, mock_get_programs): """Verify that the dashboard can deal with programs whose titles contain Unicode.""" self.programs[0]['title'] = 'Bases matemáticas para estudiar ingeniería' mock_get_programs.return_value = self.programs response = self.client.get(self.url) self.assert_related_programs(response) class UserAttributeTests(TestCase): """Tests for the UserAttribute model.""" def setUp(self): super().setUp() self.user = UserFactory() self.name = 'test' self.value = 'test-value' def test_get_set_attribute(self): assert UserAttribute.get_user_attribute(self.user, self.name) is None UserAttribute.set_user_attribute(self.user, self.name, self.value) assert UserAttribute.get_user_attribute(self.user, self.name) == self.value new_value = 'new_value' UserAttribute.set_user_attribute(self.user, self.name, new_value) assert UserAttribute.get_user_attribute(self.user, self.name) == new_value def test_unicode(self): UserAttribute.set_user_attribute(self.user, self.name, self.value) for field in (self.name, self.value, self.user.username): assert field in str(UserAttribute.objects.get(user=self.user))