feat!: Remove Legacy Preview Functionality

cms/envs/common.py

@@ -367,7 +367,6 @@
     # Prevent auto auth from creating superusers or modifying existing users
     'RESTRICT_AUTOMATIC_AUTH': True,
 
-    'PREVIEW_LMS_BASE': "preview.localhost:18000",
     'ENABLE_GRADE_DOWNLOADS': True,
     'ENABLE_MKTG_SITE': False,
     'ENABLE_DISCUSSION_HOME_PANEL': True,

cms/envs/devstack-experimental.yml

@@ -324,7 +324,6 @@ FEATURES:
     ENABLE_SYSADMIN_DASHBOARD: false
     ENABLE_THIRD_PARTY_AUTH: true
     ENABLE_VIDEO_UPLOAD_PIPELINE: false
-    PREVIEW_LMS_BASE: preview.localhost:18000
     SHOW_FOOTER_LANGUAGE_SELECTOR: false
     SHOW_HEADER_LANGUAGE_SELECTOR: false
 FEEDBACK_SUBMISSION_EMAIL: ''

cms/envs/devstack.py

@@ -45,7 +45,6 @@
 
 LMS_BASE = 'localhost:18000'
 LMS_ROOT_URL = f'http://{LMS_BASE}'
-FEATURES['PREVIEW_LMS_BASE'] = "preview." + LMS_BASE
 
 FRONTEND_REGISTER_URL = LMS_ROOT_URL + '/register'
 

cms/envs/mock.yml

@@ -455,7 +455,6 @@ FEATURES:
   LTI_1P3_ENABLED: true
   MILESTONES_APP: true
   PREVENT_CONCURRENT_LOGINS: true
-  PREVIEW_LMS_BASE: preview.courses.localhost
   SEGMENT_IO_LMS: true
   SEPARATE_VERIFICATION_FROM_PAYMENT: true
   SHOW_FOOTER_LANGUAGE_SELECTOR: true

cms/envs/test.py

@@ -131,7 +131,6 @@
 
 LMS_BASE = "localhost:8000"
 LMS_ROOT_URL = f"http://{LMS_BASE}"
-FEATURES["PREVIEW_LMS_BASE"] = "preview.localhost"
 
 CMS_BASE = "localhost:8001"
 CMS_ROOT_URL = f"http://{CMS_BASE}"

lms/djangoapps/courseware/access.py

@@ -34,7 +34,6 @@
     check_course_open_for_learner,
     check_start_date,
     debug,
-    in_preview_mode
 )
 from lms.djangoapps.courseware.masquerade import get_masquerade_role, is_masquerading_as_student
 from lms.djangoapps.ccx.custom_exception import CCXLocatorValidationException
@@ -158,11 +157,6 @@ def has_access(user, action, obj, course_key=None):
     if not user:
         user = AnonymousUser()
 
-    # Preview mode is only accessible by staff.
-    if in_preview_mode() and course_key:
-        if not has_staff_access_to_preview_mode(user, course_key):
-            return ACCESS_DENIED
-
     # delegate the work to type-specific functions.
     # (start with more specific types, then get more general)
     if isinstance(obj, CourseBlock):

lms/djangoapps/courseware/access_utils.py

@@ -25,7 +25,6 @@
 from lms.djangoapps.courseware.masquerade import get_course_masquerade, is_masquerading_as_student
 from openedx.features.course_experience import COURSE_ENABLE_UNENROLLED_ACCESS_FLAG, COURSE_PRE_START_ACCESS_FLAG
 from xmodule.course_block import COURSE_VISIBILITY_PUBLIC  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.util.xmodule_django import get_current_request_hostname  # lint-amnesty, pylint: disable=wrong-import-order
 
 DEBUG_ACCESS = False
 log = getLogger(__name__)
@@ -138,7 +137,7 @@ def check_start_date(user, days_early_for_beta, start, course_key, display_error
     if start_dates_disabled and not masquerading_as_student:
         return ACCESS_GRANTED
     else:
-        if start is None or in_preview_mode() or get_course_masquerade(user, course_key):
+        if start is None or get_course_masquerade(user, course_key):
             return ACCESS_GRANTED
 
         if now is None:
@@ -158,15 +157,6 @@ def check_start_date(user, days_early_for_beta, start, course_key, display_error
         return StartDateError(start, display_error_to_user=display_error_to_user)
 
 
-def in_preview_mode():
-    """
-    Returns whether the user is in preview mode or not.
-    """
-    hostname = get_current_request_hostname()
-    preview_lms_base = settings.FEATURES.get("PREVIEW_LMS_BASE", None)
-    return bool(preview_lms_base and hostname and hostname.split(":")[0] == preview_lms_base.split(":")[0])
-
-
 def check_course_open_for_learner(user, course):
     """
     Check if the course is open for learners based on the start date.

lms/djangoapps/courseware/tests/helpers.py

@@ -8,9 +8,8 @@
 import json
 from collections import OrderedDict
 from datetime import timedelta
-from unittest.mock import Mock, patch
+from unittest.mock import Mock
 
-from django.conf import settings
 from django.contrib import messages
 from django.contrib.auth.models import User  # lint-amnesty, pylint: disable=imported-auth-user
 from django.test import TestCase
@@ -20,7 +19,6 @@
 from xblock.field_data import DictFieldData
 
 from common.djangoapps.edxmako.shortcuts import render_to_string
-from lms.djangoapps.courseware import access_utils
 from lms.djangoapps.courseware.access import has_access
 from lms.djangoapps.courseware.utils import verified_upgrade_deadline_link
 from lms.djangoapps.courseware.masquerade import MasqueradeView
@@ -460,11 +458,3 @@ def get_context_dict_from_string(data):
         sorted(json.loads(validated_data['metadata']).items(), key=lambda t: t[0])
     )
     return validated_data
-
-
-def set_preview_mode(preview_mode: bool):
-    """
-    A decorator to force the preview mode on or off.
-    """
-    hostname = settings.FEATURES.get('PREVIEW_LMS_BASE') if preview_mode else None
-    return patch.object(access_utils, 'get_current_request_hostname', new=lambda: hostname)

lms/djangoapps/courseware/tests/test_access.py

@@ -49,8 +49,10 @@
     CATALOG_VISIBILITY_CATALOG_AND_ABOUT,
     CATALOG_VISIBILITY_NONE
 )
+
 from xmodule.modulestore import ModuleStoreEnum  # lint-amnesty, pylint: disable=wrong-import-order
 from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.modulestore.exceptions import ItemNotFoundError
 from xmodule.modulestore.tests.django_utils import (  # lint-amnesty, pylint: disable=wrong-import-order
     ModuleStoreTestCase,
     SharedModuleStoreTestCase
@@ -245,46 +247,64 @@ def test_student_has_access(self):
         course_key = self.course.id
         chapter = BlockFactory.create(category="chapter", parent_location=self.course.location)
         overview = CourseOverview.get_from_id(course_key)
+        subsection = BlockFactory.create(category="sequential", parent_location=chapter.location)
+        unit = BlockFactory.create(category="vertical", parent_location=subsection.location)
+
+        with self.store.branch_setting(ModuleStoreEnum.Branch.draft_preferred):
+            html_block = BlockFactory.create(
+                category="html",
+                parent_location=unit.location,
+                display_name="Unpublished Block",
+                data='<p>This block should not be published.</p>',
+                publish_item=False,
+            )
 
         # Enroll student to the course
         CourseEnrollmentFactory(user=self.student, course_id=self.course.id)
 
         modules = [
             self.course,
-            overview,
             chapter,
+            overview,
+            subsection,
+            unit,
+
         ]
-        with patch('lms.djangoapps.courseware.access.in_preview_mode') as mock_preview:
-            mock_preview.return_value = False
-            for obj in modules:
-                assert bool(access.has_access(self.student, 'load', obj, course_key=self.course.id))
+        # Student should have access to modules they're enrolled in
+        for obj in modules:
+            assert bool(access.has_access(
+                self.student,
+                'load',
+                self.store.get_item(obj.location),
+                course_key=self.course.id)
+            )
 
-        with patch('lms.djangoapps.courseware.access.in_preview_mode') as mock_preview:
-            mock_preview.return_value = True
-            for obj in modules:
-                assert not bool(access.has_access(self.student, 'load', obj, course_key=self.course.id))
+        # If the document is not published yet, it should return an error when we try to fetch
+        # it from the store.  This check confirms that the student would not be able to access it.
+        with pytest.raises(ItemNotFoundError):
+            self.store.get_item(html_block.location)
 
-    @patch('lms.djangoapps.courseware.access.in_preview_mode', Mock(return_value=True))
-    def test_has_access_with_preview_mode(self):
+    def test_has_access_based_on_roles(self):
         """
-        Tests particular user's can access content via has_access in preview mode.
+        Tests user access to content based on their role.
         """
         assert bool(access.has_access(self.global_staff, 'staff', self.course, course_key=self.course.id))
         assert bool(access.has_access(self.course_staff, 'staff', self.course, course_key=self.course.id))
         assert bool(access.has_access(self.course_instructor, 'staff', self.course, course_key=self.course.id))
         assert not bool(access.has_access(self.student, 'staff', self.course, course_key=self.course.id))
-        assert not bool(access.has_access(self.student, 'load', self.course, course_key=self.course.id))
+
+        # Student should be able to load the course even if they don't have staff access.
+        assert bool(access.has_access(self.student, 'load', self.course, course_key=self.course.id))
 
         # When masquerading is true, user should not be able to access staff content
         with patch('lms.djangoapps.courseware.access.is_masquerading_as_student') as mock_masquerade:
             mock_masquerade.return_value = True
             assert not bool(access.has_access(self.global_staff, 'staff', self.course, course_key=self.course.id))
             assert not bool(access.has_access(self.student, 'staff', self.course, course_key=self.course.id))
 
-    @patch('lms.djangoapps.courseware.access_utils.in_preview_mode', Mock(return_value=True))
-    def test_has_access_in_preview_mode_with_group(self):
+    def test_has_access_with_content_groups(self):
         """
-        Test that a user masquerading as a member of a group sees appropriate content in preview mode.
+        Test that a user masquerading as a member of a group sees appropriate content.
         """
         # Note about UserPartition and UserPartition Group IDs: these must not conflict with IDs used
         # by dynamic user partitions.
@@ -423,35 +443,18 @@ def test__has_access_to_block_beta_user(self):
 
         assert bool(access._has_access_to_block(self.beta_user, 'load', mock_unit, course_key=self.course.id))
 
-    @ddt.data(None, YESTERDAY, TOMORROW)
-    @patch.dict('django.conf.settings.FEATURES', {'DISABLE_START_DATES': False})
-    @patch(
-        'lms.djangoapps.courseware.access_utils.get_current_request_hostname',
-        Mock(return_value='preview.localhost')
-    )
-    def test__has_access_to_block_in_preview_mode(self, start):
-        """
-        Tests that block has access in preview mode.
-        """
-        mock_unit = Mock(location=self.course.location, user_partitions=[])
-        mock_unit._class_tags = {}  # Needed for detached check in _has_access_to_block
-        mock_unit.visible_to_staff_only = False
-        mock_unit.start = self.DATES[start]
-        mock_unit.merged_group_access = {}
-
-        self.verify_access(mock_unit, True)
-
     @ddt.data(
         (TOMORROW, access_response.StartDateError),
         (None, None),
         (YESTERDAY, None)
     )  # ddt throws an error if I don't put the None argument there
     @ddt.unpack
     @patch.dict('django.conf.settings.FEATURES', {'DISABLE_START_DATES': False})
-    @patch('lms.djangoapps.courseware.access_utils.get_current_request_hostname', Mock(return_value='localhost'))
-    def test__has_access_to_block_when_not_in_preview_mode(self, start, expected_error_type):
+    def test__has_access_to_block_with_start_date(self, start, expected_error_type):
         """
-        Tests that block has no access when start date in future & without preview.
+        Tests that block access follows start date rules.
+        Access should be denied when start date is in the future and granted when
+        start date is in the past or not set.
         """
         expected_access = expected_error_type is None
         mock_unit = Mock(location=self.course.location, user_partitions=[])

lms/djangoapps/courseware/tests/test_masquerade.py

@@ -26,7 +26,7 @@
 )
 
 from lms.djangoapps.courseware.tests.helpers import (
-    LoginEnrollmentTestCase, MasqueradeMixin, masquerade_as_group_member, set_preview_mode,
+    LoginEnrollmentTestCase, MasqueradeMixin, masquerade_as_group_member
 )
 from lms.djangoapps.courseware.tests.test_submitting_problems import ProblemSubmissionTestMixin
 from openedx.core.djangoapps.lang_pref import LANGUAGE_KEY
@@ -244,14 +244,20 @@ def testMasqueradeCohortAvailable(self, target, expected):
         assert is_target_available == expected
 
 
-@set_preview_mode(True)
+# These tests are testing a capability of the old courseware page.  We have to not
+# force redirect to the new MFE in order to be able to load the old pages which are
+# being tested by this page.
+#
+# This is a temporary change, until we can remove the old courseware pages
+# all together.
+@patch('lms.djangoapps.courseware.views.index.CoursewareIndex._redirect_to_learning_mfe', return_value=None)
 class TestStaffMasqueradeAsStudent(StaffMasqueradeTestCase):
     """
     Check for staff being able to masquerade as student.
     """
 
     @patch.dict('django.conf.settings.FEATURES', {'DISABLE_START_DATES': False})
-    def test_staff_debug_with_masquerade(self):
+    def test_staff_debug_with_masquerade(self, mock_redirect):
         """
         Tests that staff debug control is not visible when masquerading as a student.
         """
@@ -267,7 +273,7 @@ def test_staff_debug_with_masquerade(self):
         self.verify_staff_debug_present(True)
 
     @patch.dict('django.conf.settings.FEATURES', {'DISABLE_START_DATES': False})
-    def test_show_answer_for_staff(self):
+    def test_show_answer_for_staff(self, mock_redirect):
         """
         Tests that "Show Answer" is not visible when masquerading as a student.
         """

lms/djangoapps/courseware/tests/test_navigation.py

@@ -15,12 +15,11 @@
 from xmodule.modulestore.tests.factories import CourseFactory, BlockFactory
 
 from common.djangoapps.student.tests.factories import GlobalStaffFactory
-from lms.djangoapps.courseware.tests.helpers import LoginEnrollmentTestCase, set_preview_mode
+from lms.djangoapps.courseware.tests.helpers import LoginEnrollmentTestCase
 from openedx.features.course_experience import DISABLE_COURSE_OUTLINE_PAGE_FLAG
 from openedx.features.course_experience.url_helpers import make_learning_mfe_courseware_url
 
 
-@set_preview_mode(True)
 class TestNavigation(SharedModuleStoreTestCase, LoginEnrollmentTestCase):
     """
     Check that navigation state is saved properly.
@@ -73,6 +72,13 @@ def setUpTestData(cls):  # lint-amnesty, pylint: disable=super-method-not-called
     def setUp(self):
         super().setUp()
         self.login(self.user.email, 'test')
+        self.patcher = patch(
+            'lms.djangoapps.courseware.views.index.CoursewareIndex._redirect_to_learning_mfe', return_value=None)
+        self.mock_redirect = self.patcher.start()
+
+    def tearDown(self):
+        self.patcher.stop()
+        super().tearDown()
 
     def assertTabActive(self, tabname, response):
         ''' Check if the progress tab is active in the tab set '''