Don't modify courses inside SharedModuleStoreTestCase test methods in test_certificates

common/djangoapps/student/tests/test_certificates.py

@@ -30,9 +30,7 @@ def _fake_is_request_in_microsite():
     return True
 
 
-@ddt.ddt
-@unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
-class CertificateDisplayTest(SharedModuleStoreTestCase):
+class CertificateDisplayTestBase(SharedModuleStoreTestCase):
     """Tests display of certificates on the student dashboard. """
 
     USERNAME = "test_user"
@@ -41,7 +39,7 @@ class CertificateDisplayTest(SharedModuleStoreTestCase):
 
     @classmethod
     def setUpClass(cls):
-        super(CertificateDisplayTest, cls).setUpClass()
+        super(CertificateDisplayTestBase, cls).setUpClass()
         cls.course = CourseFactory()
         cls.course.certificates_display_behavior = "early_with_info"
 
@@ -49,11 +47,69 @@ class CertificateDisplayTest(SharedModuleStoreTestCase):
             cls.store.update_item(cls.course, cls.USERNAME)
 
     def setUp(self):
-        super(CertificateDisplayTest, self).setUp()
+        super(CertificateDisplayTestBase, self).setUp()
         self.user = UserFactory.create(username=self.USERNAME, password=self.PASSWORD)
         result = self.client.login(username=self.USERNAME, password=self.PASSWORD)
         self.assertTrue(result, msg="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, u'Add Certificate to LinkedIn Profile')
+        else:
+            self.assertNotContains(response, u'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,
+            download_url=self.DOWNLOAD_URL,
+            status="downloadable",
+            grade=0.98,
+        )
+
+    def _check_can_download_certificate(self):
+        """
+        Inspect the dashboard to see if a certificate can be downloaded.
+        """
+        response = self.client.get(reverse('dashboard'))
+        self.assertContains(response, u'Download Your ID Verified')
+        self.assertContains(response, self.DOWNLOAD_URL)
+
+    def _check_can_download_certificate_no_id(self):
+        """
+        Inspects the dashboard to see if a certificate for a non verified course enrollment
+        is present
+        """
+        response = self.client.get(reverse('dashboard'))
+        self.assertContains(response, u'Download')
+        self.assertContains(response, u'(PDF)')
+        self.assertContains(response, self.DOWNLOAD_URL)
+
+    def _check_can_not_download_certificate(self):
+        """
+        Make sure response does not have any of the download certificate buttons
+        """
+        response = self.client.get(reverse('dashboard'))
+        self.assertNotContains(response, u'View Test_Certificate')
+        self.assertNotContains(response, u'Download Your Test_Certificate (PDF)')
+        self.assertNotContains(response, u'Download Test_Certificate (PDF)')
+        self.assertNotContains(response, self.DOWNLOAD_URL)
+
+
+@ddt.ddt
+@unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
+class CertificateDisplayTest(CertificateDisplayTestBase):
+    """
+    Tests of certificate display.
+    """
+
     @ddt.data('verified', 'professional')
     @patch.dict('django.conf.settings.FEATURES', {'CERTIFICATES_HTML_VIEW': False})
     def test_display_verified_certificate(self, enrollment_mode):
@@ -69,49 +125,6 @@ class CertificateDisplayTest(SharedModuleStoreTestCase):
         self._create_certificate(CourseMode.NO_ID_PROFESSIONAL_MODE)
         self._check_can_download_certificate_no_id()
 
-    @ddt.data('verified', 'honor')
-    @override_settings(CERT_NAME_SHORT='Test_Certificate')
-    @patch.dict('django.conf.settings.FEATURES', {'CERTIFICATES_HTML_VIEW': True})
-    def test_display_download_certificate_button(self, enrollment_mode):
-        """
-        Tests if CERTIFICATES_HTML_VIEW is True
-        and course has enabled web certificates via cert_html_view_enabled setting
-        and no active certificate configuration available
-        then any of the Download certificate button should not be visible.
-        """
-        self.course.cert_html_view_enabled = True
-        self.course.save()
-        self.store.update_item(self.course, self.user.id)
-        self._create_certificate(enrollment_mode)
-        self._check_can_not_download_certificate()
-
-    @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):
-        certificates = [
-            {
-                'id': 0,
-                'name': 'Test Name',
-                'description': 'Test Description',
-                'is_active': True,
-                'signatories': [],
-                'version': 1
-            }
-        ]
-        self.course.certificates = {'certificates': certificates}
-        self.course.cert_html_view_enabled = True
-        self.course.save()   # pylint: disable=no-member
-        self.store.update_item(self.course, self.user.id)
-
-        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, u'View Test_Certificate')
-        self.assertContains(response, test_url)
-
     @ddt.data('verified', 'honor', 'professional')
     def test_unverified_certificate_message(self, enrollment_mode):
         cert = self._create_certificate(enrollment_mode)
@@ -167,49 +180,71 @@ class CertificateDisplayTest(SharedModuleStoreTestCase):
         # now we should not see it because we are in a microsite
         self._check_linkedin_visibility(False)
 
-    def _check_linkedin_visibility(self, is_visible):
+
+@ddt.ddt
+@unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
+class CertificateDisplayTestHtmlView(CertificateDisplayTestBase):
     """
-        Performs assertions on the Dashboard
+    Tests of webview certificate display
     """
-        response = self.client.get(reverse('dashboard'))
-        if is_visible:
-            self.assertContains(response, u'Add Certificate to LinkedIn Profile')
-        else:
-            self.assertNotContains(response, u'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,
-            download_url=self.DOWNLOAD_URL,
-            status="downloadable",
-            grade=0.98,
-        )
 
-    def _check_can_download_certificate(self):
-        response = self.client.get(reverse('dashboard'))
-        self.assertContains(response, u'Download Your ID Verified')
-        self.assertContains(response, self.DOWNLOAD_URL)
+    @classmethod
+    def setUpClass(cls):
+        super(CertificateDisplayTestHtmlView, cls).setUpClass()
+        cls.course.cert_html_view_enabled = True
+        cls.course.save()
+        cls.store.update_item(cls.course, cls.USERNAME)
 
-    def _check_can_download_certificate_no_id(self):
+    @ddt.data('verified', 'honor')
+    @override_settings(CERT_NAME_SHORT='Test_Certificate')
+    @patch.dict('django.conf.settings.FEATURES', {'CERTIFICATES_HTML_VIEW': True})
+    def test_display_download_certificate_button(self, enrollment_mode):
         """
-        Inspects the dashboard to see if a certificate for a non verified course enrollment
-        is present
+        Tests if CERTIFICATES_HTML_VIEW is True
+        and course has enabled web certificates via cert_html_view_enabled setting
+        and no active certificate configuration available
+        then any of the Download certificate button should not be visible.
         """
-        response = self.client.get(reverse('dashboard'))
-        self.assertContains(response, u'Download')
-        self.assertContains(response, u'(PDF)')
-        self.assertContains(response, self.DOWNLOAD_URL)
+        self._create_certificate(enrollment_mode)
+        self._check_can_not_download_certificate()
 
-    def _check_can_not_download_certificate(self):
+
+@ddt.ddt
+@unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
+class CertificateDisplayTestLinkedHtmlView(CertificateDisplayTestBase):
     """
-        Make sure response does not have any of the download certificate buttons
+    Tests of linked student certificates.
     """
+
+    @classmethod
+    def setUpClass(cls):
+        super(CertificateDisplayTestLinkedHtmlView, cls).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.assertNotContains(response, u'View Test_Certificate')
-        self.assertNotContains(response, u'Download Your Test_Certificate (PDF)')
-        self.assertNotContains(response, u'Download Test_Certificate (PDF)')
-        self.assertNotContains(response, self.DOWNLOAD_URL)
+
+        self.assertContains(response, u'View Test_Certificate')
+        self.assertContains(response, test_url)