Merge branch 'master' into pwnage101/ENT-11569

Author: kiram15

cms/envs/common.py

@@ -256,9 +256,6 @@
 
 MARKETING_EMAILS_OPT_IN = False
 
-############################# MICROFRONTENDS ###################################
-COURSE_AUTHORING_MICROFRONTEND_URL = None
-
 ############################# SET PATH INFORMATION #############################
 PROJECT_ROOT = path(__file__).abspath().dirname().dirname()  # /edx-platform/cms
 CMS_ROOT = REPO_ROOT / "cms"  # noqa: F405

lms/djangoapps/instructor/tests/test_api_v2.py

@@ -81,6 +81,7 @@ def setUp(self):
         self.admin = AdminFactory.create()
         self.instructor = InstructorFactory.create(course_key=self.course_key)
         self.staff = StaffFactory.create(course_key=self.course_key)
+        self.django_staff_user = UserFactory.create(is_staff=True)
         self.data_researcher = UserFactory.create()
         CourseDataResearcherRole(self.course_key).add_users(self.data_researcher)
         CourseInstructorRole(self.proctored_course.id).add_users(self.instructor)
@@ -118,60 +119,93 @@ def _get_url(self, course_id=None):
             course_id = str(self.course_key)
         return reverse('instructor_api_v2:course_metadata', kwargs={'course_id': course_id})
 
+    @override_settings(COURSE_AUTHORING_MICROFRONTEND_URL='http://localhost:2001/authoring')
+    @override_settings(ADMIN_CONSOLE_MICROFRONTEND_URL='http://localhost:2025/admin-console')
     def test_get_course_metadata_as_instructor(self):
         """
         Test that an instructor can retrieve comprehensive course metadata.
         """
         self.client.force_authenticate(user=self.instructor)
         response = self.client.get(self._get_url())
 
-        self.assertEqual(response.status_code, status.HTTP_200_OK)  # noqa: PT009
+        assert response.status_code == status.HTTP_200_OK
         data = response.data
 
         # Verify basic course information
-        self.assertEqual(data['course_id'], str(self.course_key))  # noqa: PT009
-        self.assertEqual(data['display_name'], 'Demonstration Course')  # noqa: PT009
-        self.assertEqual(data['org'], 'edX')  # noqa: PT009
-        self.assertEqual(data['course_number'], 'DemoX')  # noqa: PT009
-        self.assertEqual(data['course_run'], 'Demo_Course')  # noqa: PT009
-        self.assertEqual(data['pacing'], 'instructor')  # noqa: PT009
+        assert data['course_id'] == str(self.course_key)
+        assert data['display_name'] == 'Demonstration Course'
+        assert data['org'] == 'edX'
+        assert data['course_number'] == 'DemoX'
+        assert data['course_run'] == 'Demo_Course'
+        assert data['pacing'] == 'instructor'
 
         # Verify enrollment counts structure
-        self.assertIn('enrollment_counts', data)  # noqa: PT009
-        self.assertIn('total', data['enrollment_counts'])  # noqa: PT009
-        self.assertIn('total_enrollment', data)  # noqa: PT009
-        self.assertGreaterEqual(data['total_enrollment'], 3)  # noqa: PT009
+        assert 'enrollment_counts' in data
+        assert 'total' in data['enrollment_counts']
+        assert 'total_enrollment' in data
+        assert data['total_enrollment'] >= 3
 
         # Verify role-based enrollment counts are present
-        self.assertIn('learner_count', data)  # noqa: PT009
-        self.assertIn('staff_count', data)  # noqa: PT009
-        self.assertEqual(data['total_enrollment'], data['learner_count'] + data['staff_count'])  # noqa: PT009
+        assert 'learner_count' in data
+        assert 'staff_count' in data
+        assert data['total_enrollment'] == data['learner_count'] + data['staff_count']
 
         # Verify permissions structure
-        self.assertIn('permissions', data)  # noqa: PT009
+        assert 'permissions' in data
         permissions_data = data['permissions']
-        self.assertIn('admin', permissions_data)  # noqa: PT009
-        self.assertIn('instructor', permissions_data)  # noqa: PT009
-        self.assertIn('staff', permissions_data)  # noqa: PT009
-        self.assertIn('forum_admin', permissions_data)  # noqa: PT009
-        self.assertIn('finance_admin', permissions_data)  # noqa: PT009
-        self.assertIn('sales_admin', permissions_data)  # noqa: PT009
-        self.assertIn('data_researcher', permissions_data)  # noqa: PT009
+        assert 'admin' in permissions_data
+        assert 'instructor' in permissions_data
+        assert 'staff' in permissions_data
+        assert 'forum_admin' in permissions_data
+        assert 'finance_admin' in permissions_data
+        assert 'sales_admin' in permissions_data
+        assert 'data_researcher' in permissions_data
 
         # Verify sections structure
-        self.assertIn('tabs', data)  # noqa: PT009
-        self.assertIsInstance(data['tabs'], list)  # noqa: PT009
+        assert 'tabs' in data
+        assert isinstance(data['tabs'], list)
 
         # Verify other metadata fields
-        self.assertIn('num_sections', data)  # noqa: PT009
-        self.assertIn('tabs', data)  # noqa: PT009
-        self.assertIn('grade_cutoffs', data)  # noqa: PT009
-        self.assertIn('course_errors', data)  # noqa: PT009
-        self.assertIn('studio_url', data)  # noqa: PT009
-        self.assertIn('disable_buttons', data)  # noqa: PT009
-        self.assertIn('has_started', data)  # noqa: PT009
-        self.assertIn('has_ended', data)  # noqa: PT009
-        self.assertIn('analytics_dashboard_message', data)  # noqa: PT009
+        assert 'num_sections' in data
+        assert 'grade_cutoffs' in data
+        assert 'course_errors' in data
+        assert 'studio_url' in data
+        assert 'disable_buttons' in data
+        assert 'has_started' in data
+        assert 'has_ended' in data
+        assert 'analytics_dashboard_message' in data
+        assert 'studio_grading_url' in data
+        assert 'admin_console_url' in data
+
+        assert data['studio_grading_url'] == f'http://localhost:2001/authoring/course/{self.course.id}/settings/grading'
+        assert data['admin_console_url'] == 'http://localhost:2025/admin-console/authz'
+
+    @override_settings(ADMIN_CONSOLE_MICROFRONTEND_URL='http://localhost:2025/admin-console')
+    def test_admin_console_url_requires_instructor_access(self):
+        """
+        Test that the admin console URL is only available to users with instructor access.
+        """
+        # data researcher has access to course but is not an instructor
+        self.client.force_authenticate(user=self.data_researcher)
+        response = self.client.get(self._get_url())
+
+        assert response.status_code == status.HTTP_200_OK
+        assert 'admin_console_url' in response.data
+        data = response.data
+        assert data['admin_console_url'] is None
+
+    @override_settings(ADMIN_CONSOLE_MICROFRONTEND_URL='http://localhost:2025/admin-console')
+    def test_django_staff_user_without_instructor_access_can_see_admin_console_url(self):
+        """
+        Test that Django staff users without instructor access can see the admin console URL.
+        """
+        self.client.force_authenticate(user=self.django_staff_user)
+        response = self.client.get(self._get_url())
+
+        assert response.status_code == status.HTTP_200_OK
+        assert 'admin_console_url' in response.data
+        data = response.data
+        assert data['admin_console_url'] == 'http://localhost:2025/admin-console/authz'
 
     def test_get_course_metadata_as_staff(self):
         """

lms/djangoapps/instructor/views/api_v2.py

@@ -234,6 +234,8 @@ def get(self, request, course_id):
                 "grade_cutoffs": "A is 0.9, B is 0.8, C is 0.7, D is 0.6",
                 "course_errors": [],
                 "studio_url": "https://studio.example.com/course/course-v1:edX+DemoX+2024",
+                # May be null if user does not have access:
+                "admin_console_url": "http://apps.local.openedx.io:2025/admin-console/authz",
                 "permissions": {
                     "admin": false,
                     "instructor": true,

lms/djangoapps/instructor/views/serializers_v2.py

@@ -34,6 +34,7 @@
 from lms.djangoapps.instructor.access import FORUM_ROLES, ROLES
 from lms.djangoapps.instructor.views.instructor_dashboard import get_analytics_dashboard_message
 from openedx.core.djangoapps.django_comment_common.models import FORUM_ROLE_ADMINISTRATOR
+from openedx.core.djangoapps.site_configuration import helpers as configuration_helpers
 from xmodule.modulestore.django import modulestore
 
 from .tools import DashboardError, get_student_from_identifier, parse_datetime
@@ -77,6 +78,9 @@ class CourseInformationSerializerV2(serializers.Serializer):
     studio_grading_url = serializers.SerializerMethodField(
         help_text="URL to the Studio grading settings page for the course (null if not configured)"
     )
+    admin_console_url = serializers.SerializerMethodField(
+        help_text="URL to the admin console (requires instructor access and MFE configuration, null if not accessible)"
+    )
     permissions = serializers.SerializerMethodField(help_text="User permissions for instructor dashboard features")
     tabs = serializers.SerializerMethodField(help_text="List of course tabs with configuration and display information")
     disable_buttons = serializers.SerializerMethodField(
@@ -462,10 +466,27 @@ def get_gradebook_url(self, data):
     def get_studio_grading_url(self, data):
         """Get Studio MFE grading settings URL for the course."""
         course_key = data['course'].id
-        mfe_base_url = getattr(settings, 'COURSE_AUTHORING_MICROFRONTEND_URL', None)
-        if mfe_base_url:
-            return f'{mfe_base_url}/course/{course_key}/settings/grading'
-        return None
+        mfe_base_url = configuration_helpers.get_value(
+            'COURSE_AUTHORING_MICROFRONTEND_URL',
+            getattr(settings, 'COURSE_AUTHORING_MICROFRONTEND_URL', None)
+        )
+        if not mfe_base_url:
+            return None
+        return f'{mfe_base_url}/course/{course_key}/settings/grading'
+
+    def get_admin_console_url(self, data):
+        """Get admin console URL (requires instructor access and MFE configuration, null if not accessible)."""
+        request = data['request']
+        has_instructor_access = has_access(request.user, 'instructor', data['course'])
+        mfe_base_url = configuration_helpers.get_value(
+            'ADMIN_CONSOLE_MICROFRONTEND_URL',
+            getattr(settings, 'ADMIN_CONSOLE_MICROFRONTEND_URL', None)
+        )
+
+        has_permissions = request.user.is_staff or has_instructor_access
+        if not mfe_base_url or not has_permissions:
+            return None
+        return f'{mfe_base_url}/authz'
 
     def get_disable_buttons(self, data):
         """Check if buttons should be disabled for large courses."""

lms/djangoapps/mfe_config_api/tests/test_views.py

@@ -297,6 +297,45 @@ def side_effect(key, default=None):
         # Value in original MFE_CONFIG not overridden by catalog config should be preserved
         self.assertEqual(data["PRESERVED_SETTING"], "preserved")  # noqa: PT009
 
+    @patch("lms.djangoapps.mfe_config_api.views.configuration_helpers")
+    def test_legacy_overrides_instructor_dashboard(self, configuration_helpers_mock):
+        """Legacy help-tokens SUPPORT_URL is included for instructor-dashboard when no explicit override is set."""
+        def side_effect(key, default=None):
+            if key == "MFE_CONFIG":
+                return {"LMS_BASE_URL": "https://courses.example.com"}
+            if key == "MFE_CONFIG_OVERRIDES":
+                return {}
+            return default
+        configuration_helpers_mock.get_value.side_effect = side_effect
+
+        response = self.client.get(f"{self.mfe_config_api_url}?mfe=instructor-dashboard")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)  # noqa: PT009
+        data = response.json()
+        self.assertEqual(  # noqa: PT009
+            data["SUPPORT_URL"],
+            "https://docs.openedx.org/en/latest/educators/index.html",
+        )
+
+    @patch("lms.djangoapps.mfe_config_api.views.configuration_helpers")
+    def test_explicit_override_wins_over_legacy_overrides(self, configuration_helpers_mock):
+        """An explicit SUPPORT_URL in MFE_CONFIG_OVERRIDES wins over the help-tokens fallback."""
+        def side_effect(key, default=None):
+            if key == "MFE_CONFIG":
+                return {"LMS_BASE_URL": "https://courses.example.com"}
+            if key == "MFE_CONFIG_OVERRIDES":
+                return {
+                    "instructor-dashboard": {
+                        "SUPPORT_URL": "https://help.example.com/instructor",
+                    },
+                }
+            return default
+        configuration_helpers_mock.get_value.side_effect = side_effect
+
+        response = self.client.get(f"{self.mfe_config_api_url}?mfe=instructor-dashboard")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)  # noqa: PT009
+        data = response.json()
+        self.assertEqual(data["SUPPORT_URL"], "https://help.example.com/instructor")  # noqa: PT009
+
 
 class MfeNameToAppIdTests(SimpleTestCase):
     """Tests for the mfe_name_to_app_id helper."""
@@ -317,6 +356,12 @@ def test_mapped_alias(self):
             "org.openedx.frontend.app.authoring",
         )
 
+    def test_instructor_dashboard(self):
+        self.assertEqual(  # noqa: PT009
+            mfe_name_to_app_id("instructor-dashboard"),
+            "org.openedx.frontend.app.instructorDashboard",
+        )
+
     def test_fallback_for_unknown_name(self):
         """Unknown names fall back to programmatic kebab-to-camelCase conversion."""
         self.assertEqual(  # noqa: PT009
@@ -420,8 +465,9 @@ def side_effect(key, default=None):
         for legacy_key in default_legacy_config:
             self.assertIn(legacy_key, common)  # noqa: PT009
 
+    @patch("lms.djangoapps.mfe_config_api.views.get_legacy_config_overrides", return_value={})
     @patch("lms.djangoapps.mfe_config_api.views.configuration_helpers")
-    def test_apps_from_overrides(self, configuration_helpers_mock):
+    def test_apps_from_overrides(self, configuration_helpers_mock, _legacy_overrides_mock):  # noqa: PT019
         """Each MFE_CONFIG_OVERRIDES entry becomes an app with shared base config + overrides."""
         mfe_config_overrides = {
             "authn": {
@@ -521,9 +567,10 @@ def side_effect(key, default=None):
         self.assertNotIn("BASE_URL", data["commonAppConfig"])  # noqa: PT009
         self.assertNotIn("LOGIN_URL", data["commonAppConfig"])  # noqa: PT009
 
+    @patch("lms.djangoapps.mfe_config_api.views.get_legacy_config_overrides", return_value={})
     @patch("lms.djangoapps.mfe_config_api.views.configuration_helpers")
-    def test_no_apps_when_no_overrides(self, configuration_helpers_mock):
-        """The apps key is omitted when MFE_CONFIG_OVERRIDES is empty."""
+    def test_no_apps_when_no_overrides(self, configuration_helpers_mock, _legacy_overrides_mock):  # noqa: PT019
+        """The apps key is omitted when MFE_CONFIG_OVERRIDES is empty and no legacy overrides are present."""
         def side_effect(key, default=None):
             if key == "MFE_CONFIG":
                 return {"LMS_BASE_URL": "https://courses.example.com"}
@@ -566,8 +613,9 @@ def side_effect(key, default=None):
         self.assertEqual(common["CREDENTIALS_BASE_URL"], "https://credentials.example.com")  # noqa: PT009
         self.assertEqual(common["STUDIO_BASE_URL"], "https://studio.example.com")  # noqa: PT009
 
+    @patch("lms.djangoapps.mfe_config_api.views.get_legacy_config_overrides", return_value={})
     @patch("lms.djangoapps.mfe_config_api.views.configuration_helpers")
-    def test_invalid_override_entry_skipped(self, configuration_helpers_mock):
+    def test_invalid_override_entry_skipped(self, configuration_helpers_mock, _legacy_overrides_mock):  # noqa: PT019
         """Non-dict override entries are silently skipped."""
         mfe_config_overrides = {
             "authn": {"SOME_KEY": "value"},
@@ -720,3 +768,49 @@ def side_effect(key, default=None):
         # Brand new app from FRONTEND_SITE_CONFIG is appended
         brand_new = apps_by_id["org.openedx.frontend.app.brand.new"]["config"]
         self.assertEqual(brand_new["BRAND_NEW_KEY"], "value")  # noqa: PT009
+
+    @patch("lms.djangoapps.mfe_config_api.views.configuration_helpers")
+    def test_legacy_overrides_instructor_dashboard_support_url(self, configuration_helpers_mock):
+        """Instructor dashboard gets SUPPORT_URL from help-tokens when no explicit override is set."""
+        def side_effect(key, default=None):
+            if key == "MFE_CONFIG":
+                return {"LMS_BASE_URL": "https://courses.example.com"}
+            if key == "MFE_CONFIG_OVERRIDES":
+                return {}
+            return default
+        configuration_helpers_mock.get_value.side_effect = side_effect
+
+        response = self.client.get(self.url)
+        data = response.json()
+
+        apps_by_id = {app["appId"]: app for app in data["apps"]}
+        instructor = apps_by_id["org.openedx.frontend.app.instructorDashboard"]
+        self.assertEqual(  # noqa: PT009
+            instructor["config"]["SUPPORT_URL"],
+            "https://docs.openedx.org/en/latest/educators/index.html",
+        )
+
+    @patch("lms.djangoapps.mfe_config_api.views.configuration_helpers")
+    def test_explicit_override_wins_over_legacy_overrides(self, configuration_helpers_mock):
+        """An explicit SUPPORT_URL in MFE_CONFIG_OVERRIDES wins over the help-tokens fallback."""
+        def side_effect(key, default=None):
+            if key == "MFE_CONFIG":
+                return {"LMS_BASE_URL": "https://courses.example.com"}
+            if key == "MFE_CONFIG_OVERRIDES":
+                return {
+                    "instructor-dashboard": {
+                        "SUPPORT_URL": "https://help.example.com/instructor",
+                    },
+                }
+            return default
+        configuration_helpers_mock.get_value.side_effect = side_effect
+
+        response = self.client.get(self.url)
+        data = response.json()
+
+        apps_by_id = {app["appId"]: app for app in data["apps"]}
+        instructor = apps_by_id["org.openedx.frontend.app.instructorDashboard"]
+        self.assertEqual(  # noqa: PT009
+            instructor["config"]["SUPPORT_URL"],
+            "https://help.example.com/instructor",
+        )