Remove microsites from certificates

DEPR-26

lms/djangoapps/certificates/tests/factories.py

@@ -76,13 +76,6 @@ class CertificateHtmlViewConfigurationFactory(DjangoModelFactory):
             "xseries": {
                 "certificate_title": "XSeries Certificate of Achievement",
                 "certificate_type": "XSeries"
-            },
-            "microsites": {
-                "test-site": {
-                    "company_about_url": "http://www.test-site.org/about-us",
-                    "company_privacy_url": "http://www.test-site.org/edx-privacy-policy",
-                    "company_tos_url": "http://www.test-site.org/edx-terms-service"
-                }
             }
         }"""
 

lms/djangoapps/certificates/tests/test_api.py

@@ -18,6 +18,9 @@ from opaque_keys.edx.keys import CourseKey
 from opaque_keys.edx.locator import CourseLocator
 import pytz
 
+from course_modes.models import CourseMode
+from course_modes.tests.factories import CourseModeFactory
+from courseware.tests.factories import GlobalStaffFactory
 from lms.djangoapps.certificates import api as certs_api
 from lms.djangoapps.certificates.models import (
     CertificateGenerationConfiguration,
@@ -28,11 +31,8 @@ from lms.djangoapps.certificates.models import (
 )
 from lms.djangoapps.certificates.queue import XQueueAddToQueueError, XQueueCertInterface
 from lms.djangoapps.certificates.tests.factories import CertificateInvalidationFactory, GeneratedCertificateFactory
-from course_modes.models import CourseMode
-from course_modes.tests.factories import CourseModeFactory
-from courseware.tests.factories import GlobalStaffFactory
 from lms.djangoapps.grades.tests.utils import mock_passing_grade
-from microsite_configuration import microsite
+from openedx.core.djangoapps.site_configuration.tests.test_util import with_site_configuration
 from student.models import CourseEnrollment
 from student.tests.factories import UserFactory
 from util.testing import EventTestMixin
@@ -735,36 +735,22 @@ class GenerateExampleCertificatesTest(TestCase):
         self.assertEqual(list(expected_statuses), actual_status)
 
 
-def set_microsite(domain):
-    """
-    returns a decorator that can be used on a test_case to set a specific microsite for the current test case.
-    :param domain: Domain of the new microsite
-    """
-    def decorator(func):
-        """
-        Decorator to set current microsite according to domain
-        """
-        @wraps(func)
-        def inner(request, *args, **kwargs):
-            """
-            Execute the function after setting up the microsite.
-            """
-            try:
-                microsite.set_by_domain(domain)
-                return func(request, *args, **kwargs)
-            finally:
-                microsite.clear()
-        return inner
-    return decorator
-
-
 @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
 class CertificatesBrandingTest(TestCase):
     """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',
+        },
+    }
 
-    @set_microsite(settings.MICROSITE_CONFIGURATION['test_site']['domain_prefix'])
+    @with_site_configuration(configuration=configuration)
     def test_certificate_header_data(self):
         """
         Test that get_certificate_header_context from lms.djangoapps.certificates api
@@ -780,16 +766,16 @@ class CertificatesBrandingTest(TestCase):
             ['logo_src', 'logo_url']
         )
         self.assertIn(
-            settings.MICROSITE_CONFIGURATION['test_site']['logo_image_url'],
+            self.configuration['logo_image_url'],
             data['logo_src']
         )
 
         self.assertIn(
-            settings.MICROSITE_CONFIGURATION['test_site']['SITE_NAME'],
+            self.configuration['SITE_NAME'],
             data['logo_url']
         )
 
-    @set_microsite(settings.MICROSITE_CONFIGURATION['test_site']['domain_prefix'])
+    @with_site_configuration(configuration=configuration)
     def test_certificate_footer_data(self):
         """
         Test that get_certificate_footer_context from lms.djangoapps.certificates api returns
@@ -804,22 +790,15 @@ class CertificatesBrandingTest(TestCase):
             data.keys(),
             ['company_about_url', 'company_privacy_url', 'company_tos_url']
         )
-
-        # ABOUT is present in MICROSITE_CONFIGURATION['test_site']["urls"] so web certificate will use that url
         self.assertIn(
-            settings.MICROSITE_CONFIGURATION['test_site']["urls"]['ABOUT'],
+            self.configuration['urls']['ABOUT'],
             data['company_about_url']
         )
-
-        # PRIVACY is present in MICROSITE_CONFIGURATION['test_site']["urls"] so web certificate will use that url
         self.assertIn(
-            settings.MICROSITE_CONFIGURATION['test_site']["urls"]['PRIVACY'],
+            self.configuration['urls']['PRIVACY'],
             data['company_privacy_url']
         )
-
-        # TOS_AND_HONOR is present in MICROSITE_CONFIGURATION['test_site']["urls"],
-        # so web certificate will use that url
         self.assertIn(
-            settings.MICROSITE_CONFIGURATION['test_site']["urls"]['TOS_AND_HONOR'],
+            self.configuration['urls']['TOS_AND_HONOR'],
             data['company_tos_url']
         )

lms/djangoapps/certificates/tests/test_views.py

@@ -19,6 +19,7 @@ from lms.djangoapps.certificates.models import (
     ExampleCertificateSet,
     GeneratedCertificate
 )
+from openedx.core.djangoapps.site_configuration.tests.test_util import with_site_configuration
 from openedx.core.djangolib.testing.utils import CacheIsolationTestCase
 from student.tests.factories import UserFactory
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
@@ -179,13 +180,30 @@ class UpdateExampleCertificateViewTest(CacheIsolationTestCase):
         self.assertEqual(content['return_code'], 0)
 
 
-class MicrositeCertificatesViewsTests(ModuleStoreTestCase):
+class CertificatesViewsSiteTests(ModuleStoreTestCase):
     """
-    Tests for the microsite certificates web/html views
+    Tests for the certificates web/html views
     """
+    test_configuration_string = """{
+        "default": {
+            "accomplishment_class_append": "accomplishment-certificate",
+            "platform_name": "edX",
+            "company_about_url": "http://www.edx.org/about-us",
+            "company_privacy_url": "http://www.edx.org/edx-privacy-policy",
+            "company_tos_url": "http://www.edx.org/edx-terms-service",
+            "company_verified_certificate_url": "http://www.edx.org/verified-certificate",
+            "document_stylesheet_url_application": "/static/certificates/sass/main-ltr.css",
+            "logo_src": "/static/certificates/images/logo-edx.svg",
+            "logo_url": "http://www.edx.org",
+            "company_about_description": "This should not survive being overwritten by static content"
+        },
+        "honor": {
+            "certificate_type": "Honor Code"
+        }
+    }"""
 
     def setUp(self):
-        super(MicrositeCertificatesViewsTests, self).setUp()
+        super(CertificatesViewsSiteTests, self).setUp()
         self.client = Client()
         self.course = CourseFactory.create(
             org='testorg',
@@ -216,12 +234,13 @@ class MicrositeCertificatesViewsTests(ModuleStoreTestCase):
             mode='honor',
             name=self.user.profile.name,
         )
+        self._setup_configuration()
 
-    def _certificate_html_view_configuration(self, configuration_string, enabled=True):
+    def _setup_configuration(self, enabled=True):
         """
         This will create a certificate html configuration
         """
-        config = CertificateHtmlViewConfiguration(enabled=enabled, configuration=configuration_string)
+        config = CertificateHtmlViewConfiguration(enabled=enabled, configuration=self.test_configuration_string)
         config.save()
         return config
 
@@ -258,82 +277,26 @@ class MicrositeCertificatesViewsTests(ModuleStoreTestCase):
         self.store.update_item(self.course, self.user.id)
 
     @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
-    def test_html_view_for_microsite(self):
-        test_configuration_string = """{
-            "default": {
-                "accomplishment_class_append": "accomplishment-certificate",
-                "platform_name": "edX",
-                "company_about_url": "http://www.edx.org/about-us",
-                "company_privacy_url": "http://www.edx.org/edx-privacy-policy",
-                "company_tos_url": "http://www.edx.org/edx-terms-service",
-                "company_verified_certificate_url": "http://www.edx.org/verified-certificate",
-                "document_stylesheet_url_application": "/static/certificates/sass/main-ltr.css",
-                "logo_src": "/static/certificates/images/logo-edx.svg",
-                "logo_url": "http://www.edx.org"
-            },
-            "microsites": {
-                "test-site": {
-                    "accomplishment_class_append": "accomplishment-certificate",
-                    "platform_name": "platform_microsite",
-                    "company_about_url": "http://www.microsite.org/about-us",
-                    "company_privacy_url": "http://www.microsite.org/edx-privacy-policy",
-                    "company_tos_url": "http://www.microsite.org/microsite-terms-service",
-                    "company_verified_certificate_url": "http://www.microsite.org/verified-certificate",
-                    "document_stylesheet_url_application": "/static/certificates/sass/main-ltr.css",
-                    "logo_src": "/static/certificates/images/logo-microsite.svg",
-                    "logo_url": "http://www.microsite.org",
-                    "company_about_description": "This is special microsite aware company_about_description content",
-                    "company_about_title": "Microsite title"
-                }
-            },
-            "honor": {
-                "certificate_type": "Honor Code"
-            }
-        }"""
-
-        config = self._certificate_html_view_configuration(configuration_string=test_configuration_string)
-        self.assertEquals(config.configuration, test_configuration_string)
+    @with_site_configuration(configuration={'platform_name': 'My Platform Site'})
+    def test_html_view_for_site(self):
         test_url = get_certificate_url(
             user_id=self.user.id,
             course_id=unicode(self.course.id)
         )
         self._add_course_certificates(count=1, signatory_count=2)
-        response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
-        self.assertIn('platform_microsite', response.content)
-
-        # logo url is taken from microsite configuration setting
-        self.assertIn('http://test_site.localhost', response.content)
-        self.assertIn('This is special microsite aware company_about_description content', response.content)
-        self.assertIn('Microsite title', response.content)
+        response = self.client.get(test_url)
+        self.assertIn('awarded this My Platform Site Honor Code Certificate of Completion', response.content)
+        self.assertIn('My Platform Site offers interactive online classes and MOOCs.', response.content)
+        self.assertIn('About My Platform Site', response.content)
 
     @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
-    def test_html_view_microsite_configuration_missing(self):
-        test_configuration_string = """{
-            "default": {
-                "accomplishment_class_append": "accomplishment-certificate",
-                "platform_name": "edX",
-                "company_about_url": "http://www.edx.org/about-us",
-                "company_privacy_url": "http://www.edx.org/edx-privacy-policy",
-                "company_tos_url": "http://www.edx.org/edx-terms-service",
-                "company_verified_certificate_url": "http://www.edx.org/verified-certificate",
-                "document_stylesheet_url_application": "/static/certificates/sass/main-ltr.css",
-                "logo_src": "/static/certificates/images/logo-edx.svg",
-                "logo_url": "http://www.edx.org",
-                "company_about_description": "This should not survive being overwritten by static content"
-            },
-            "honor": {
-                "certificate_type": "Honor Code"
-            }
-        }"""
-        config = self._certificate_html_view_configuration(configuration_string=test_configuration_string)
-        self.assertEquals(config.configuration, test_configuration_string)
+    def test_html_view_site_configuration_missing(self):
         test_url = get_certificate_url(
             user_id=self.user.id,
             course_id=unicode(self.course.id)
         )
         self._add_course_certificates(count=1, signatory_count=2)
-        response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
+        response = self.client.get(test_url)
         self.assertIn('edX', response.content)
-        self.assertNotIn('platform_microsite', response.content)
-        self.assertNotIn('http://www.microsite.org', response.content)
+        self.assertNotIn('My Platform Site', response.content)
         self.assertNotIn('This should not survive being overwritten by static content', response.content)

lms/djangoapps/certificates/tests/test_webview_views.py

@@ -39,6 +39,9 @@ from lms.djangoapps.badges.tests.factories import (
 from lms.djangoapps.grades.tests.utils import mock_passing_grade
 from openedx.core.djangoapps.certificates.config import waffle
 from openedx.core.djangoapps.dark_lang.models import DarkLangConfig
+from openedx.core.djangoapps.site_configuration.tests.test_util import (
+    with_site_configuration, with_site_configuration_context,
+)
 from openedx.core.lib.tests.assertions.events import assert_event_matches
 from openedx.core.djangolib.js_utils import js_escaped_string
 from openedx.core.djangolib.testing.utils import CacheIsolationTestCase
@@ -64,13 +67,6 @@ FEATURES_WITH_CUSTOM_CERTS_ENABLED = {
 FEATURES_WITH_CUSTOM_CERTS_ENABLED.update(FEATURES_WITH_CERTS_ENABLED)
 
 
-def _fake_is_request_in_microsite():
-    """
-    Mocked version of microsite helper method to always return true
-    """
-    return True
-
-
 class CommonCertificatesTestCase(ModuleStoreTestCase):
     """
     Common setUp and utility methods for Certificate tests
@@ -278,22 +274,26 @@ class CertificatesViewsTests(CommonCertificatesTestCase, CacheIsolationTestCase)
         )
 
     @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
-    def test_linkedin_share_microsites(self):
+    @with_site_configuration(
+        configuration={
+            'platform_name': 'My Platform Site', 'LINKEDIN_COMPANY_ID': 'test_linkedin_my_site',
+        },
+    )
+    def test_linkedin_share_url_site(self):
         """
-        Test: LinkedIn share URL should be visible when called from within a microsite.
+        Test: LinkedIn share URL should be visible when called from within a site.
         """
         self._add_course_certificates(count=1, signatory_count=1, is_active=True)
         test_url = get_certificate_url(course_id=self.cert.course_id, uuid=self.cert.verify_uuid)
-        response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
+        response = self.client.get(test_url, HTTP_HOST='test.localhost')
         self.assertEqual(response.status_code, 200)
         # the linkedIn share URL with appropriate parameters should be present
         params = OrderedDict([
-            ('_ed', settings.MICROSITE_CONFIGURATION['test_site']['LINKEDIN_COMPANY_ID'],),
-            ('pfCertificationName', u'{platform_name} Honor Code Certificate for {course_name}'.format(
-                platform_name=settings.MICROSITE_CONFIGURATION['test_site']['platform_name'],
+            ('_ed', 'test_linkedin_my_site',),
+            ('pfCertificationName', u'My Platform Site Honor Code Certificate for {course_name}'.format(
                 course_name=self.course.display_name,
             ).encode('utf-8'),),
-            ('pfCertificationUrl', 'http://' + settings.MICROSITE_TEST_HOSTNAME + test_url,),
+            ('pfCertificationUrl', 'http://test.localhost' + test_url,),
         ])
         self.assertIn(
             js_escaped_string(self.linkedin_url.format(params=urlencode(params))),
@@ -302,17 +302,20 @@ class CertificatesViewsTests(CommonCertificatesTestCase, CacheIsolationTestCase)
 
     @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
     @patch.dict("django.conf.settings.SOCIAL_SHARING_SETTINGS", {"CERTIFICATE_FACEBOOK": True})
-    def test_facebook_share_microsites(self):
+    @with_site_configuration(
+        configuration={'FACEBOOK_APP_ID': 'test_facebook_my_site'},
+    )
+    def test_facebook_share_url_site(self):
         """
         Test: Facebook share URL should be visible when web cert called from within a white label
         site and it should use white label site's FACEBOOK_APP_ID.
         """
         self._add_course_certificates(count=1, signatory_count=1, is_active=True)
         test_url = get_certificate_url(course_id=self.cert.course_id, uuid=self.cert.verify_uuid)
-        response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
+        response = self.client.get(test_url, HTTP_HOST='test.localhost')
         self.assertEqual(response.status_code, 200)
         self.assertIn("Post on Facebook", response.content)
-        self.assertIn(settings.MICROSITE_CONFIGURATION['test_site']['FACEBOOK_APP_ID'], response.content)
+        self.assertIn('test_facebook_my_site', response.content)
 
     @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
     @ddt.data(
@@ -323,9 +326,9 @@ class CertificatesViewsTests(CommonCertificatesTestCase, CacheIsolationTestCase)
         (True, True, False),
     )
     @ddt.unpack
-    def test_social_sharing_availablity_microsites(self, facebook_sharing, twitter_sharing, linkedin_sharing):
+    def test_social_sharing_availability_site(self, facebook_sharing, twitter_sharing, linkedin_sharing):
         """
-        Test: Facebook, Twitter and LinkedIn sharing availability for microsites.
+        Test: Facebook, Twitter and LinkedIn sharing availability for sites.
         """
         self._add_course_certificates(count=1, signatory_count=1, is_active=True)
         test_url = get_certificate_url(course_id=self.cert.course_id, uuid=self.cert.verify_uuid)
@@ -334,22 +337,22 @@ class CertificatesViewsTests(CommonCertificatesTestCase, CacheIsolationTestCase)
             CERTIFICATE_TWITTER=twitter_sharing,
             CERTIFICATE_LINKEDIN=linkedin_sharing,
         )
-        with patch("django.conf.settings.MICROSITE_CONFIGURATION", {
-            "test_site": dict(
-                settings.MICROSITE_CONFIGURATION['test_site'],
-                SOCIAL_SHARING_SETTINGS=social_sharing_settings,
-            )
-        }):
-            response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
+        with with_site_configuration_context(
+            configuration={
+                'platform_name': 'My Platform Site',
+                'SOCIAL_SHARING_SETTINGS': social_sharing_settings,
+            },
+        ):
+            response = self.client.get(test_url, HTTP_HOST='test.localhost')
             self.assertEqual(response.status_code, 200)
             self.assertEqual("Post on Facebook" in response.content, facebook_sharing)
             self.assertEqual("Share on Twitter" in response.content, twitter_sharing)
             self.assertEqual("Add to LinkedIn Profile" in response.content, linkedin_sharing)
 
     @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
-    def test_facebook_default_text_microsites(self):
+    def test_facebook_default_text_site(self):
         """
-        Test: Facebook sharing default text for microsites.
+        Test: Facebook sharing default text for sites.
         """
         self._add_course_certificates(count=1, signatory_count=1, is_active=True)
         test_url = get_certificate_url(course_id=self.cert.course_id, uuid=self.cert.verify_uuid)
@@ -358,19 +361,18 @@ class CertificatesViewsTests(CommonCertificatesTestCase, CacheIsolationTestCase)
             CERTIFICATE_FACEBOOK=True,
             CERTIFICATE_FACEBOOK_TEXT=facebook_text,
         )
-        with patch("django.conf.settings.MICROSITE_CONFIGURATION", {
-            "test_site": dict(
-                settings.MICROSITE_CONFIGURATION['test_site'],
-                SOCIAL_SHARING_SETTINGS=social_sharing_settings,
-            )
-        }):
-            response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
+        with with_site_configuration_context(
+            configuration={
+                'SOCIAL_SHARING_SETTINGS': social_sharing_settings,
+            },
+        ):
+            response = self.client.get(test_url, HTTP_HOST='test.localhost')
             self.assertContains(response, facebook_text)
 
     @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
-    def test_twitter_default_text_microsites(self):
+    def test_twitter_default_text_site(self):
         """
-        Test: Twitter sharing default text for microsites.
+        Test: Twitter sharing default text for sites.
         """
         self._add_course_certificates(count=1, signatory_count=1, is_active=True)
         test_url = get_certificate_url(course_id=self.cert.course_id, uuid=self.cert.verify_uuid)
@@ -379,13 +381,12 @@ class CertificatesViewsTests(CommonCertificatesTestCase, CacheIsolationTestCase)
             CERTIFICATE_TWITTER=True,
             CERTIFICATE_TWITTER_TEXT=twitter_text,
         )
-        with patch("django.conf.settings.MICROSITE_CONFIGURATION", {
-            "test_site": dict(
-                settings.MICROSITE_CONFIGURATION['test_site'],
-                SOCIAL_SHARING_SETTINGS=social_sharing_settings,
-            )
-        }):
-            response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
+        with with_site_configuration_context(
+            configuration={
+                'SOCIAL_SHARING_SETTINGS': social_sharing_settings,
+            },
+        ):
+            response = self.client.get(test_url, HTTP_HOST='test.localhost')
             self.assertContains(response, twitter_text)
 
     @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
@@ -448,21 +449,15 @@ class CertificatesViewsTests(CommonCertificatesTestCase, CacheIsolationTestCase)
         "CERTIFICATE_TWITTER": True,
         "CERTIFICATE_FACEBOOK": True,
     })
-    @patch.dict("django.conf.settings.MICROSITE_CONFIGURATION", {
-        "test_site": dict(
-            settings.MICROSITE_CONFIGURATION['test_site'],
+    @with_site_configuration(
+        configuration=dict(
+            platform_name='My Platform Site',
+            SITE_NAME='test_site.localhost',
             urls=dict(
-                ABOUT=None,
-                PRIVACY=None,
-                TOS_AND_HONOR=None,
+                ABOUT='http://www.test-site.org/about-us',
             ),
-        )
-    })
-    @patch.dict("django.conf.settings.MKTG_URL_LINK_MAP", {
-        'ABOUT': None,
-        'PRIVACY': None,
-        'TOS_AND_HONOR': None,
-    })
+        ),
+    )
     def test_rendering_maximum_data(self):
         """
         Tests at least one data item from different context update methods to
@@ -495,7 +490,7 @@ class CertificatesViewsTests(CommonCertificatesTestCase, CacheIsolationTestCase)
             user_id=self.user.id,
             course_id=unicode(self.course.id)
         )
-        response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
+        response = self.client.get(test_url, HTTP_HOST='test.localhost')
 
         # Test an item from basic info
         self.assertIn(
@@ -545,7 +540,7 @@ class CertificatesViewsTests(CommonCertificatesTestCase, CacheIsolationTestCase)
             "Add to Mozilla Backpack",
             response.content
         )
-        # Test item from microsite info
+        # Test item from site configuration
         self.assertIn(
             "http://www.test-site.org/about-us",
             response.content
@@ -1595,141 +1590,6 @@ class CertificatesViewsTests(CommonCertificatesTestCase, CacheIsolationTestCase)
                 )
             )
 
-    @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
-    def test_certificate_branding(self):
-        """
-        Test that link urls in certificate web view are customized according to site branding and
-        microsite configuration.
-        """
-        self._add_course_certificates(count=1, signatory_count=1, is_active=True)
-
-        self.course.save()
-        self.store.update_item(self.course, self.user.id)
-
-        test_url = get_certificate_url(
-            user_id=self.user.id,
-            course_id=unicode(self.course.id)
-        )
-        response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
-        # logo_image_url Tis present in MICROSITE_CONFIGURATION['test_site']["urls"],
-        #  so web certificate will use that.
-        self.assertContains(
-            response,
-            settings.MICROSITE_CONFIGURATION['test_site']['logo_image_url'],
-        )
-        # ABOUT is present in MICROSITE_CONFIGURATION['test_site']["urls"] so web certificate will use that url.
-        self.assertContains(
-            response,
-            settings.MICROSITE_CONFIGURATION['test_site']["urls"]['ABOUT'],
-        )
-        # PRIVACY is present in MICROSITE_CONFIGURATION['test_site']["urls"] so web certificate will use that url.
-        self.assertContains(
-            response,
-            settings.MICROSITE_CONFIGURATION['test_site']["urls"]['PRIVACY'],
-        )
-        # TOS_AND_HONOR is present in MICROSITE_CONFIGURATION['test_site']["urls"],
-        #  so web certificate will use that url.
-        self.assertContains(
-            response,
-            settings.MICROSITE_CONFIGURATION['test_site']["urls"]['TOS_AND_HONOR'],
-        )
-
-    @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
-    @patch.dict("django.conf.settings.MICROSITE_CONFIGURATION", {
-        "test_site": dict(
-            settings.MICROSITE_CONFIGURATION['test_site'],
-            urls=dict(
-                ABOUT=None,
-                PRIVACY=None,
-                TOS_AND_HONOR=None,
-            ),
-        )
-    })
-    def test_certificate_branding_without_microsite_urls(self):
-        """
-        Test that links from MKTG_URL_LINK_MAP setting are used if corresponding microsite urls are not present.
-        microsite configuration.
-        """
-        self._add_course_certificates(count=1, signatory_count=1, is_active=True)
-        self.course.save()
-        self.store.update_item(self.course, self.user.id)
-        configuration = CertificateHtmlViewConfiguration.get_config()
-        test_url = get_certificate_url(
-            user_id=self.user.id,
-            course_id=unicode(self.course.id)
-        )
-        response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
-        # ABOUT is not present in MICROSITE_CONFIGURATION['test_site']["urls"],
-        #  so web certificate will use MKTG_URL_LINK_MAP['ABOUT'] url.
-        self.assertContains(
-            response,
-            settings.MKTG_URL_LINK_MAP['ABOUT'],
-        )
-        # PRIVACY is not present in MICROSITE_CONFIGURATION['test_site']["urls"],
-        # so web certificate will use MKTG_URL_LINK_MAP['PRIVACY'] url.
-        self.assertContains(
-            response,
-            settings.MKTG_URL_LINK_MAP['PRIVACY'],
-        )
-        # TOS_AND_HONOR is not present in MICROSITE_CONFIGURATION['test_site']["urls"] or MKTG_URL_LINK_MAP,
-        # so web certificate will use CertificateHtmlViewConfiguration url.
-        self.assertContains(
-            response,
-            configuration['microsites']['test-site']['company_tos_url'],
-        )
-
-    @override_settings(FEATURES=FEATURES_WITH_CERTS_ENABLED)
-    @patch.dict("django.conf.settings.MICROSITE_CONFIGURATION", {
-        "test_site": dict(
-            settings.MICROSITE_CONFIGURATION['test_site'],
-            urls=dict(
-                ABOUT=None,
-                PRIVACY=None,
-                TOS_AND_HONOR=None,
-            ),
-        )
-    })
-    @patch.dict("django.conf.settings.MKTG_URL_LINK_MAP", {
-        'ABOUT': None,
-        'PRIVACY': None,
-        'TOS_AND_HONOR': None,
-    })
-    def test_certificate_without_branding_urls(self):
-        """
-        Test that links from CertificateHtmlViewConfiguration are used if
-        corresponding microsite or marketing urls are not present.
-        """
-        self._add_course_certificates(count=1, signatory_count=1, is_active=True)
-
-        self.course.save()
-        self.store.update_item(self.course, self.user.id)
-        configuration = CertificateHtmlViewConfiguration.get_config()
-
-        test_url = get_certificate_url(
-            user_id=self.user.id,
-            course_id=unicode(self.course.id)
-        )
-        response = self.client.get(test_url, HTTP_HOST=settings.MICROSITE_TEST_HOSTNAME)
-
-        # ABOUT is not present in MICROSITE_CONFIGURATION['test_site']["urls"] or MKTG_URL_LINK_MAP,
-        #  so web certificate will use CertificateHtmlViewConfiguration url.
-        self.assertContains(
-            response,
-            configuration['microsites']['test-site']['company_about_url'],
-        )
-        # PRIVACY is not present in MICROSITE_CONFIGURATION['test_site']["urls"] or MKTG_URL_LINK_MAP,
-        # so web certificate will use CertificateHtmlViewConfiguration url.
-        self.assertContains(
-            response,
-            configuration['microsites']['test-site']['company_privacy_url'],
-        )
-        # TOS_AND_HONOR is not present in MICROSITE_CONFIGURATION['test_site']["urls"] or MKTG_URL_LINK_MAP,
-        # so web certificate will use CertificateHtmlViewConfiguration url.
-        self.assertContains(
-            response,
-            configuration['microsites']['test-site']['company_tos_url'],
-        )
-
 
 class CertificateEventTests(CommonCertificatesTestCase, EventTrackingTestCase):
     """

lms/djangoapps/certificates/views/webview.py

@@ -149,8 +149,7 @@ def _update_certificate_context(context, course, user_certificate, platform_name
                                                 u"certificates, which are awarded for course activities "
                                                 u"that {platform_name} students complete.").format(
         platform_name=platform_name,
-        tos_url=context.get('company_tos_url'),
-        verified_cert_url=context.get('company_verified_certificate_url'))
+    )
 
 
 def _update_context_with_basic_info(context, course_id, platform_name, configuration):
@@ -416,26 +415,6 @@ def _track_certificate_events(request, context, course, user, user_certificate):
         })
 
 
-def _update_configuration_context(context, configuration):
-    """
-    Site Configuration will need to be able to override any hard coded
-    content that was put into the context in the
-    _update_certificate_context() call above. For example the
-    'company_about_description' talks about edX, which we most likely
-    do not want to keep in configurations.
-    So we need to re-apply any configuration/content that
-    we are sourcing from the database. This is somewhat duplicative of
-    the code at the beginning of this method, but we
-    need the configuration at the top as some error code paths
-    require that to be set up early on in the pipeline
-    """
-
-    config_key = configuration_helpers.get_value('domain_prefix')
-    config = configuration.get("microsites", {})
-    if config_key and config:
-        context.update(config.get(config_key, {}))
-
-
 def _update_badge_context(context, course, user):
     """
     Updates context with badge info.
@@ -608,9 +587,6 @@ def render_html_view(request, user_id, course_id):
         # Append badge info
         _update_badge_context(context, course, user)
 
-        # Append site configuration overrides
-        _update_configuration_context(context, configuration)
-
         # Add certificate header/footer data to current context
         context.update(get_certificate_header_context(is_secure=request.is_secure()))
         context.update(get_certificate_footer_context())