feat: standardize serializer usage in other enrollment apis

Author: Taimoor Ahmed

openedx/core/djangoapps/enrollments/serializers.py

@@ -137,3 +137,22 @@ class Meta:
         model = CourseEnrollmentAllowed
         exclude = ["id"]
         lookup_field = "user"
+
+
+class UserRoleSerializer(serializers.Serializer):  # pylint: disable=abstract-method
+    """Serializes a single course-level role entry for a user."""
+
+    org = serializers.CharField()
+    course_id = serializers.SerializerMethodField()
+    role = serializers.CharField()
+
+    def get_course_id(self, obj):
+        """Return course_id as a string."""
+        return str(obj.course_id)
+
+
+class UserRolesResponseSerializer(serializers.Serializer):  # pylint: disable=abstract-method
+    """Serializes the full response payload for EnrollmentUserRolesView."""
+
+    roles = UserRoleSerializer(many=True)
+    is_staff = serializers.BooleanField()

openedx/core/djangoapps/enrollments/tests/test_views.py

@@ -2187,3 +2187,191 @@ def test_get_no_enrollment_returns_null(self):
         )
         assert resp.status_code == status.HTTP_200_OK
         assert resp.json() is None
+
+
+@skip_unless_lms
+class EnrollmentCourseDetailViewResponseShapeTest(ModuleStoreTestCase, APITestCase):
+    """
+    Tests that verify EnrollmentCourseDetailView (GET /enrollment/v1/course/{course_id})
+    response structure is preserved after migrating to CourseSerializer + direct ORM (ADR 0025).
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.course = CourseFactory.create(emit_signals=True)
+        CourseModeFactory.create(
+            course_id=self.course.id,
+            mode_slug=CourseMode.DEFAULT_MODE_SLUG,
+            mode_display_name=CourseMode.DEFAULT_MODE_SLUG,
+        )
+
+    def _get_course_details(self, course_id=None, include_expired=False):
+        url = reverse('courseenrollmentdetails', kwargs={'course_id': course_id or str(self.course.id)})
+        if include_expired:
+            url += '?include_expired=1'
+        return self.client.get(url)
+
+    def test_returns_200(self):
+        assert self._get_course_details().status_code == status.HTTP_200_OK
+
+    def test_response_top_level_fields(self):
+        """Response contains the expected top-level CourseSerializer fields."""
+        body = self._get_course_details().json()
+        for field in ('course_id', 'course_name', 'enrollment_start', 'enrollment_end',
+                      'course_start', 'course_end', 'invite_only', 'course_modes', 'pacing_type'):
+            assert field in body, f"Missing field: {field}"
+
+    def test_course_id_matches_requested_course(self):
+        body = self._get_course_details().json()
+        assert body['course_id'] == str(self.course.id)
+
+    def test_course_modes_is_list(self):
+        body = self._get_course_details().json()
+        assert isinstance(body['course_modes'], list)
+
+    def test_course_mode_fields(self):
+        """Each mode entry contains the expected fields."""
+        body = self._get_course_details().json()
+        mode = body['course_modes'][0]
+        for field in ('slug', 'name', 'min_price', 'suggested_prices', 'currency',
+                      'expiration_datetime', 'description', 'sku', 'bulk_sku'):
+            assert field in mode, f"Missing course_mode field: {field}"
+
+    def test_invalid_course_id_returns_400(self):
+        resp = self._get_course_details(course_id='not/a/real/course')
+        assert resp.status_code == status.HTTP_400_BAD_REQUEST
+
+    def test_nonexistent_course_returns_400(self):
+        resp = self._get_course_details(course_id='course-v1:Org+NonExistent+2099')
+        assert resp.status_code == status.HTTP_400_BAD_REQUEST
+
+
+@skip_unless_lms
+class EnrollmentListViewResponseShapeTest(ModuleStoreTestCase, APITestCase):
+    """
+    Tests that verify EnrollmentListView (GET /enrollment/v1/enrollment)
+    response structure is preserved after migrating to CourseEnrollmentSerializer + ORM (ADR 0025).
+    """
+
+    USERNAME = "TestLearner"
+    PASSWORD = "edx"
+
+    def setUp(self):
+        super().setUp()
+        self.course = CourseFactory.create(emit_signals=True)
+        CourseModeFactory.create(
+            course_id=self.course.id,
+            mode_slug=CourseMode.DEFAULT_MODE_SLUG,
+            mode_display_name=CourseMode.DEFAULT_MODE_SLUG,
+        )
+        self.user = UserFactory.create(username=self.USERNAME, password=self.PASSWORD)
+        self.client.login(username=self.USERNAME, password=self.PASSWORD)
+        CourseEnrollment.enroll(self.user, self.course.id)
+
+    def _get_enrollments(self, user=None):
+        url = reverse('courseenrollments')
+        if user:
+            url += f'?user={user}'
+        return self.client.get(url)
+
+    def test_returns_200(self):
+        assert self._get_enrollments().status_code == status.HTTP_200_OK
+
+    def test_response_is_list(self):
+        body = self._get_enrollments().json()
+        assert isinstance(body, list)
+
+    def test_enrollment_top_level_fields(self):
+        """Each enrollment entry contains the expected top-level fields."""
+        body = self._get_enrollments().json()
+        assert len(body) >= 1
+        entry = body[0]
+        for field in ('created', 'mode', 'is_active', 'user', 'course_details'):
+            assert field in entry, f"Missing top-level field: {field}"
+
+    def test_enrollment_user_and_mode_values(self):
+        body = self._get_enrollments().json()
+        entry = body[0]
+        assert entry['user'] == self.USERNAME
+        assert entry['mode'] == CourseMode.DEFAULT_MODE_SLUG
+        assert entry['is_active'] is True
+
+    def test_enrollment_course_details_fields(self):
+        """course_details nested object contains the expected fields."""
+        body = self._get_enrollments().json()
+        course_details = body[0]['course_details']
+        for field in ('course_id', 'course_name', 'enrollment_start', 'enrollment_end',
+                      'course_start', 'course_end', 'invite_only', 'course_modes'):
+            assert field in course_details, f"Missing course_details field: {field}"
+
+    def test_no_enrollments_returns_empty_list(self):
+        """A user with no enrollments gets an empty list, not null or an error."""
+        new_user = UserFactory.create(password=self.PASSWORD)
+        self.client.login(username=new_user.username, password=self.PASSWORD)
+        body = self.client.get(reverse('courseenrollments')).json()
+        assert body == []
+
+
+@skip_unless_lms
+class UserRoleViewResponseShapeTest(ModuleStoreTestCase):
+    """
+    Tests that verify EnrollmentUserRolesView (GET /enrollment/v1/roles/)
+    response structure is preserved after migrating to UserRolesResponseSerializer (ADR 0025).
+    """
+
+    USERNAME = "RoleTester"
+    PASSWORD = "edx"
+
+    def setUp(self):
+        super().setUp()
+        self.course = CourseFactory.create(emit_signals=True, org="testorg", course="c1", run="r1")
+        self.user = UserFactory.create(username=self.USERNAME, password=self.PASSWORD)
+        self.client.login(username=self.USERNAME, password=self.PASSWORD)
+
+    def _get_roles(self, course_id=None):
+        url = reverse('roles')
+        if course_id:
+            url += f'?course_id={course_id}'
+        return self.client.get(url)
+
+    def test_returns_200(self):
+        assert self._get_roles().status_code == status.HTTP_200_OK
+
+    def test_response_top_level_keys(self):
+        """Response always contains 'roles' (list) and 'is_staff' (bool)."""
+        body = self._get_roles().json()
+        assert 'roles' in body
+        assert 'is_staff' in body
+        assert isinstance(body['roles'], list)
+        assert isinstance(body['is_staff'], bool)
+
+    def test_no_roles_returns_empty_list(self):
+        body = self._get_roles().json()
+        assert body['roles'] == []
+        assert body['is_staff'] is False
+
+    def test_role_entry_shape(self):
+        """A role entry contains org, course_id, and role fields."""
+        role = CourseStaffRole(self.course.id)
+        role.add_users(self.user)
+        body = self._get_roles().json()
+        assert len(body['roles']) == 1
+        entry = body['roles'][0]
+        for field in ('org', 'course_id', 'role'):
+            assert field in entry, f"Missing role field: {field}"
+        assert entry['org'] == self.course.org
+        assert entry['course_id'] == str(self.course.id)
+
+    def test_is_staff_true_for_staff_user(self):
+        staff_user = UserFactory.create(password=self.PASSWORD, is_staff=True)
+        self.client.login(username=staff_user.username, password=self.PASSWORD)
+        body = self._get_roles().json()
+        assert body['is_staff'] is True
+
+    def test_filter_by_course_id(self):
+        """course_id query param filters roles to that course only."""
+        course2 = CourseFactory.create(emit_signals=True, org="other", course="c2", run="r2")
+        CourseStaffRole(self.course.id).add_users(self.user)
+        CourseStaffRole(course2.id).add_users(self.user)
+        body = self._get_roles(course_id=str(self.course.id)).json()
+        assert all(r['course_id'] == str(self.course.id) for r in body['roles'])