diff --git a/lms/djangoapps/discussion/rest_api/tests/test_views_v2.py b/lms/djangoapps/discussion/rest_api/tests/test_views_v2.py
index 6b4fc5b7b034..75e939fb4625 100644
--- a/lms/djangoapps/discussion/rest_api/tests/test_views_v2.py
+++ b/lms/djangoapps/discussion/rest_api/tests/test_views_v2.py
@@ -1575,6 +1575,10 @@ def setUp(self):
         self.mock_mark_thread_as_read = mock.patch(
             "openedx.core.djangoapps.django_comment_common.comment_client.user.forum_api.mark_thread_as_read"
         ).start()
+        self.mock_update_comment_flag = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.comment.forum_api.update_comment_flag",
+            return_value=str(self.course.id),
+        ).start()
         self.addCleanup(mock.patch.stopall)
 
     def test_basic(self):
@@ -3173,3 +3177,998 @@ def test_closed_thread_error(self, field, value):
         request_data = {field: value}
         response = self.request_patch(request_data)
         assert response.status_code == 400
+
+
+@httpretty.activate
+@mock.patch.dict("django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
+class ThreadViewSetRetrieveTest(
+    DiscussionAPIViewTestMixin, ModuleStoreTestCase, ProfileImageTestMixin
+):
+    """Tests for ThreadViewSet Retrieve"""
+
+    def setUp(self):
+        super().setUp()
+        self.url = reverse("thread-detail", kwargs={"thread_id": "test_thread"})
+        self.thread_id = "test_thread"
+        mock.patch(
+            "lms.djangoapps.discussion.toggles.ENABLE_FORUM_V2.is_enabled",
+            return_value=True,
+        ).start()
+        self.mock_get_user = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.user.forum_api.get_user"
+        ).start()
+        self.mock_get_course_id_by_thread = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.thread.forum_api.get_course_id_by_thread",
+            return_value=str(self.course.id),
+        ).start()
+        self.mock_get_course_id_by_comment = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.models.forum_api.get_course_id_by_comment",
+            return_value=str(self.course.id),
+        ).start()
+        self.mock_get_thread = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.thread.forum_api.get_thread"
+        ).start()
+        self.addCleanup(mock.patch.stopall)
+
+    def test_basic(self):
+        self.register_get_user_response(self.user)
+        cs_thread = make_minimal_cs_thread(
+            {
+                "id": self.thread_id,
+                "course_id": str(self.course.id),
+                "commentable_id": "test_topic",
+                "username": self.user.username,
+                "user_id": str(self.user.id),
+                "title": "Test Title",
+                "body": "Test body",
+            }
+        )
+        self.register_get_thread_response(cs_thread)
+        response = self.client.get(self.url)
+        assert response.status_code == 200
+        assert json.loads(
+            response.content.decode("utf-8")
+        ) == self.expected_thread_data({"unread_comment_count": 1})
+
+        params = {
+            "with_responses": True,
+            "user_id": "2",
+            "mark_as_read": False,
+            "reverse_order": False,
+            "merge_question_type_responses": False,
+        }
+        self.mock_get_thread.assert_called_once_with(
+            thread_id="test_thread", params=params, course_id=str(self.course.id)
+        )
+
+    def test_profile_image_requested_field(self):
+        """
+        Tests thread has user profile image details if called in requested_fields
+        """
+        self.register_get_user_response(self.user)
+        cs_thread = make_minimal_cs_thread(
+            {
+                "id": self.thread_id,
+                "course_id": str(self.course.id),
+                "username": self.user.username,
+                "user_id": str(self.user.id),
+            }
+        )
+        self.register_get_thread_response(cs_thread)
+        self.create_profile_image(self.user, get_profile_image_storage())
+        response = self.client.get(self.url, {"requested_fields": "profile_image"})
+        assert response.status_code == 200
+        expected_profile_data = self.get_expected_user_profile(self.user.username)
+        response_users = json.loads(response.content.decode("utf-8"))["users"]
+        assert expected_profile_data == response_users[self.user.username]
+
+
+@httpretty.activate
+@mock.patch.dict("django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
+class CommentViewSetRetrieveTest(
+    DiscussionAPIViewTestMixin, ModuleStoreTestCase, ProfileImageTestMixin
+):
+    """Tests for CommentViewSet Retrieve"""
+
+    def setUp(self):
+        super().setUp()
+        self.url = reverse("comment-detail", kwargs={"comment_id": "test_comment"})
+        self.thread_id = "test_thread"
+        self.comment_id = "test_comment"
+        mock.patch(
+            "lms.djangoapps.discussion.toggles.ENABLE_FORUM_V2.is_enabled",
+            return_value=True,
+        ).start()
+        self.mock_get_user = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.user.forum_api.get_user"
+        ).start()
+        self.mock_get_course_id_by_thread = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.thread.forum_api.get_course_id_by_thread",
+            return_value=str(self.course.id),
+        ).start()
+        self.mock_get_course_id_by_comment = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.models.forum_api.get_course_id_by_comment",
+            return_value=str(self.course.id),
+        ).start()
+        self.mock_get_thread = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.thread.forum_api.get_thread"
+        ).start()
+        self.mock_get_parent_comment = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.models.forum_api.get_parent_comment"
+        ).start()
+        self.addCleanup(mock.patch.stopall)
+
+    def make_comment_data(
+        self, comment_id, parent_id=None, children=[]
+    ):  # pylint: disable=W0102
+        """
+        Returns comment dict object as returned by comments service
+        """
+        return make_minimal_cs_comment(
+            {
+                "id": comment_id,
+                "parent_id": parent_id,
+                "course_id": str(self.course.id),
+                "thread_id": self.thread_id,
+                "thread_type": "discussion",
+                "username": self.user.username,
+                "user_id": str(self.user.id),
+                "created_at": "2015-06-03T00:00:00Z",
+                "updated_at": "2015-06-03T00:00:00Z",
+                "body": "Original body",
+                "children": children,
+            }
+        )
+
+    def test_basic(self):
+        self.register_get_user_response(self.user)
+        cs_comment_child = self.make_comment_data(
+            "test_child_comment", self.comment_id, children=[]
+        )
+        cs_comment = self.make_comment_data(self.comment_id, None, [cs_comment_child])
+        cs_thread = make_minimal_cs_thread(
+            {
+                "id": self.thread_id,
+                "course_id": str(self.course.id),
+                "children": [cs_comment],
+            }
+        )
+        self.register_get_thread_response(cs_thread)
+        self.register_get_comment_response(cs_comment)
+
+        expected_response_data = {
+            "id": "test_child_comment",
+            "parent_id": self.comment_id,
+            "thread_id": self.thread_id,
+            "author": self.user.username,
+            "author_label": None,
+            "raw_body": "Original body",
+            "rendered_body": "<p>Original body</p>",
+            "created_at": "2015-06-03T00:00:00Z",
+            "updated_at": "2015-06-03T00:00:00Z",
+            "children": [],
+            "endorsed_at": None,
+            "endorsed": False,
+            "endorsed_by": None,
+            "endorsed_by_label": None,
+            "voted": False,
+            "vote_count": 0,
+            "abuse_flagged": False,
+            "abuse_flagged_any_user": None,
+            "editable_fields": ["abuse_flagged", "anonymous", "raw_body"],
+            "child_count": 0,
+            "can_delete": True,
+            "anonymous": False,
+            "anonymous_to_peers": False,
+            "last_edit": None,
+            "edit_by_label": None,
+            "profile_image": {
+                "has_image": False,
+                "image_url_full": "http://testserver/static/default_500.png",
+                "image_url_large": "http://testserver/static/default_120.png",
+                "image_url_medium": "http://testserver/static/default_50.png",
+                "image_url_small": "http://testserver/static/default_30.png",
+            },
+        }
+
+        response = self.client.get(self.url)
+        assert response.status_code == 200
+        assert (
+            json.loads(response.content.decode("utf-8"))["results"][0]
+            == expected_response_data
+        )
+        self.mock_get_parent_comment.assert_called_once_with(
+            comment_id="test_comment", course_id=str(self.course.id)
+        )
+
+    def test_pagination(self):
+        """
+        Test that pagination parameters are correctly plumbed through to the
+        comments service and that a 404 is correctly returned if a page past the
+        end is requested
+        """
+        self.register_get_user_response(self.user)
+        cs_comment_child = self.make_comment_data(
+            "test_child_comment", self.comment_id, children=[]
+        )
+        cs_comment = self.make_comment_data(self.comment_id, None, [cs_comment_child])
+        cs_thread = make_minimal_cs_thread(
+            {
+                "id": self.thread_id,
+                "course_id": str(self.course.id),
+                "children": [cs_comment],
+            }
+        )
+        self.register_get_thread_response(cs_thread)
+        self.register_get_comment_response(cs_comment)
+        response = self.client.get(
+            self.url, {"comment_id": self.comment_id, "page": "18", "page_size": "4"}
+        )
+        self.assert_response_correct(
+            response,
+            404,
+            {"developer_message": "Page not found (No results on this page)."},
+        )
+        self.mock_get_parent_comment.assert_called_once_with(
+            comment_id="test_comment", course_id=str(self.course.id)
+        )
+
+    def test_profile_image_requested_field(self):
+        """
+        Tests all comments retrieved have user profile image details if called in requested_fields
+        """
+        self.register_get_user_response(self.user)
+        cs_comment_child = self.make_comment_data(
+            "test_child_comment", self.comment_id, children=[]
+        )
+        cs_comment = self.make_comment_data(self.comment_id, None, [cs_comment_child])
+        cs_thread = make_minimal_cs_thread(
+            {
+                "id": self.thread_id,
+                "course_id": str(self.course.id),
+                "children": [cs_comment],
+            }
+        )
+        self.register_get_thread_response(cs_thread)
+        self.register_get_comment_response(cs_comment)
+        self.create_profile_image(self.user, get_profile_image_storage())
+
+        response = self.client.get(self.url, {"requested_fields": "profile_image"})
+        assert response.status_code == 200
+        response_comments = json.loads(response.content.decode("utf-8"))["results"]
+
+        for response_comment in response_comments:
+            expected_profile_data = self.get_expected_user_profile(
+                response_comment["author"]
+            )
+            response_users = response_comment["users"]
+            assert expected_profile_data == response_users[response_comment["author"]]
+
+
+@ddt.ddt
+class CourseDiscussionSettingsAPIViewTest(
+    APITestCase, UrlResetMixin, ModuleStoreTestCase
+):
+    """
+    Test the course discussion settings handler API endpoint.
+    """
+
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def setUp(self):
+        super().setUp()
+        self.course = CourseFactory.create(
+            org="x",
+            course="y",
+            run="z",
+            start=datetime.now(UTC),
+            discussion_topics={"Test Topic": {"id": "test_topic"}},
+        )
+        self.path = reverse(
+            "discussion_course_settings", kwargs={"course_id": str(self.course.id)}
+        )
+        self.password = self.TEST_PASSWORD
+        self.user = UserFactory(username="staff", password=self.password, is_staff=True)
+        mock.patch(
+            "lms.djangoapps.discussion.toggles.ENABLE_FORUM_V2.is_enabled",
+            return_value=True,
+        ).start()
+        self.addCleanup(mock.patch.stopall)
+
+    def _get_oauth_headers(self, user):
+        """Return the OAuth headers for testing OAuth authentication"""
+        access_token = AccessTokenFactory.create(
+            user=user, application=ApplicationFactory()
+        ).token
+        headers = {"HTTP_AUTHORIZATION": "Bearer " + access_token}
+        return headers
+
+    def _login_as_staff(self):
+        """Log the client in as the staff."""
+        self.client.login(username=self.user.username, password=self.password)
+
+    def _login_as_discussion_staff(self):
+        user = UserFactory(username="abc", password="abc")
+        role = Role.objects.create(name="Administrator", course_id=self.course.id)
+        role.users.set([user])
+        self.client.login(username=user.username, password="abc")
+
+    def _create_divided_discussions(self):
+        """Create some divided discussions for testing."""
+        divided_inline_discussions = [
+            "Topic A",
+        ]
+        divided_course_wide_discussions = [
+            "Topic B",
+        ]
+        divided_discussions = (
+            divided_inline_discussions + divided_course_wide_discussions
+        )
+
+        BlockFactory.create(
+            parent=self.course,
+            category="discussion",
+            discussion_id=topic_name_to_id(self.course, "Topic A"),
+            discussion_category="Chapter",
+            discussion_target="Discussion",
+            start=datetime.now(),
+        )
+        discussion_topics = {
+            "Topic B": {"id": "Topic B"},
+        }
+        config_course_cohorts(self.course, is_cohorted=True)
+        config_course_discussions(
+            self.course,
+            discussion_topics=discussion_topics,
+            divided_discussions=divided_discussions,
+        )
+        return divided_inline_discussions, divided_course_wide_discussions
+
+    def _get_expected_response(self):
+        """Return the default expected response before any changes to the discussion settings."""
+        return {
+            "always_divide_inline_discussions": False,
+            "divided_inline_discussions": [],
+            "divided_course_wide_discussions": [],
+            "id": 1,
+            "division_scheme": "cohort",
+            "available_division_schemes": ["cohort"],
+            "reported_content_email_notifications": False,
+        }
+
+    def patch_request(self, data, headers=None):
+        headers = headers if headers else {}
+        return self.client.patch(
+            self.path,
+            json.dumps(data),
+            content_type="application/merge-patch+json",
+            **headers,
+        )
+
+    def _assert_current_settings(self, expected_response):
+        """Validate the current discussion settings against the expected response."""
+        response = self.client.get(self.path)
+        assert response.status_code == 200
+        content = json.loads(response.content.decode("utf-8"))
+        assert content == expected_response
+
+    def _assert_patched_settings(self, data, expected_response):
+        """Validate the patched settings against the expected response."""
+        response = self.patch_request(data)
+        assert response.status_code == 204
+        self._assert_current_settings(expected_response)
+
+    @ddt.data("get", "patch")
+    def test_authentication_required(self, method):
+        """Test and verify that authentication is required for this endpoint."""
+        self.client.logout()
+        response = getattr(self.client, method)(self.path)
+        assert response.status_code == 401
+
+    @ddt.data(
+        {"is_staff": False, "get_status": 403, "put_status": 403},
+        {"is_staff": True, "get_status": 200, "put_status": 204},
+    )
+    @ddt.unpack
+    def test_oauth(self, is_staff, get_status, put_status):
+        """Test that OAuth authentication works for this endpoint."""
+        user = UserFactory(is_staff=is_staff)
+        headers = self._get_oauth_headers(user)
+        self.client.logout()
+
+        response = self.client.get(self.path, **headers)
+        assert response.status_code == get_status
+
+        response = self.patch_request(
+            {"always_divide_inline_discussions": True}, headers
+        )
+        assert response.status_code == put_status
+
+    def test_non_existent_course_id(self):
+        """Test the response when this endpoint is passed a non-existent course id."""
+        self._login_as_staff()
+        response = self.client.get(
+            reverse(
+                "discussion_course_settings", kwargs={"course_id": "course-v1:a+b+c"}
+            )
+        )
+        assert response.status_code == 404
+
+    def test_patch_request_by_discussion_staff(self):
+        """Test the response when patch request is sent by a user with discussions staff role."""
+        self._login_as_discussion_staff()
+        response = self.patch_request({"always_divide_inline_discussions": True})
+        assert response.status_code == 403
+
+    def test_get_request_by_discussion_staff(self):
+        """Test the response when get request is sent by a user with discussions staff role."""
+        self._login_as_discussion_staff()
+        divided_inline_discussions, divided_course_wide_discussions = (
+            self._create_divided_discussions()
+        )
+        response = self.client.get(self.path)
+        assert response.status_code == 200
+        expected_response = self._get_expected_response()
+        expected_response["divided_course_wide_discussions"] = [
+            topic_name_to_id(self.course, name)
+            for name in divided_course_wide_discussions
+        ]
+        expected_response["divided_inline_discussions"] = [
+            topic_name_to_id(self.course, name) for name in divided_inline_discussions
+        ]
+        content = json.loads(response.content.decode("utf-8"))
+        assert content == expected_response
+
+    def test_get_request_by_non_staff_user(self):
+        """Test the response when get request is sent by a regular user with no staff role."""
+        user = UserFactory(username="abc", password="abc")
+        self.client.login(username=user.username, password="abc")
+        response = self.client.get(self.path)
+        assert response.status_code == 403
+
+    def test_patch_request_by_non_staff_user(self):
+        """Test the response when patch request is sent by a regular user with no staff role."""
+        user = UserFactory(username="abc", password="abc")
+        self.client.login(username=user.username, password="abc")
+        response = self.patch_request({"always_divide_inline_discussions": True})
+        assert response.status_code == 403
+
+    def test_get_settings(self):
+        """Test the current discussion settings against the expected response."""
+        divided_inline_discussions, divided_course_wide_discussions = (
+            self._create_divided_discussions()
+        )
+        self._login_as_staff()
+        response = self.client.get(self.path)
+        assert response.status_code == 200
+        expected_response = self._get_expected_response()
+        expected_response["divided_course_wide_discussions"] = [
+            topic_name_to_id(self.course, name)
+            for name in divided_course_wide_discussions
+        ]
+        expected_response["divided_inline_discussions"] = [
+            topic_name_to_id(self.course, name) for name in divided_inline_discussions
+        ]
+        content = json.loads(response.content.decode("utf-8"))
+        assert content == expected_response
+
+    def test_available_schemes(self):
+        """Test the available division schemes against the expected response."""
+        config_course_cohorts(self.course, is_cohorted=False)
+        self._login_as_staff()
+        expected_response = self._get_expected_response()
+        expected_response["available_division_schemes"] = []
+        self._assert_current_settings(expected_response)
+
+        CourseModeFactory.create(course_id=self.course.id, mode_slug=CourseMode.AUDIT)
+        CourseModeFactory.create(
+            course_id=self.course.id, mode_slug=CourseMode.VERIFIED
+        )
+
+        expected_response["available_division_schemes"] = [
+            CourseDiscussionSettings.ENROLLMENT_TRACK
+        ]
+        self._assert_current_settings(expected_response)
+
+        config_course_cohorts(self.course, is_cohorted=True)
+        expected_response["available_division_schemes"] = [
+            CourseDiscussionSettings.COHORT,
+            CourseDiscussionSettings.ENROLLMENT_TRACK,
+        ]
+        self._assert_current_settings(expected_response)
+
+    def test_empty_body_patch_request(self):
+        """Test the response status code on sending a PATCH request with an empty body or missing fields."""
+        self._login_as_staff()
+        response = self.patch_request("")
+        assert response.status_code == 400
+
+        response = self.patch_request({})
+        assert response.status_code == 400
+
+    @ddt.data(
+        {"abc": 123},
+        {"divided_course_wide_discussions": 3},
+        {"divided_inline_discussions": "a"},
+        {"always_divide_inline_discussions": ["a"]},
+        {"division_scheme": True},
+    )
+    def test_invalid_body_parameters(self, body):
+        """Test the response status code on sending a PATCH request with parameters having incorrect types."""
+        self._login_as_staff()
+        response = self.patch_request(body)
+        assert response.status_code == 400
+
+    def test_update_always_divide_inline_discussion_settings(self):
+        """Test whether the 'always_divide_inline_discussions' setting is updated."""
+        config_course_cohorts(self.course, is_cohorted=True)
+        self._login_as_staff()
+        expected_response = self._get_expected_response()
+        self._assert_current_settings(expected_response)
+        expected_response["always_divide_inline_discussions"] = True
+
+        self._assert_patched_settings(
+            {"always_divide_inline_discussions": True}, expected_response
+        )
+
+    def test_update_course_wide_discussion_settings(self):
+        """Test whether the 'divided_course_wide_discussions' setting is updated."""
+        discussion_topics = {"Topic B": {"id": "Topic B"}}
+        config_course_cohorts(self.course, is_cohorted=True)
+        config_course_discussions(self.course, discussion_topics=discussion_topics)
+        expected_response = self._get_expected_response()
+        self._login_as_staff()
+        self._assert_current_settings(expected_response)
+        expected_response["divided_course_wide_discussions"] = [
+            topic_name_to_id(self.course, "Topic B")
+        ]
+        self._assert_patched_settings(
+            {
+                "divided_course_wide_discussions": [
+                    topic_name_to_id(self.course, "Topic B")
+                ]
+            },
+            expected_response,
+        )
+        expected_response["divided_course_wide_discussions"] = []
+        self._assert_patched_settings(
+            {"divided_course_wide_discussions": []}, expected_response
+        )
+
+    def test_update_inline_discussion_settings(self):
+        """Test whether the 'divided_inline_discussions' setting is updated."""
+        config_course_cohorts(self.course, is_cohorted=True)
+        self._login_as_staff()
+        expected_response = self._get_expected_response()
+        self._assert_current_settings(expected_response)
+
+        now = datetime.now()
+        BlockFactory.create(
+            parent_location=self.course.location,
+            category="discussion",
+            discussion_id="Topic_A",
+            discussion_category="Chapter",
+            discussion_target="Discussion",
+            start=now,
+        )
+        expected_response["divided_inline_discussions"] = [
+            "Topic_A",
+        ]
+        self._assert_patched_settings(
+            {"divided_inline_discussions": ["Topic_A"]}, expected_response
+        )
+
+        expected_response["divided_inline_discussions"] = []
+        self._assert_patched_settings(
+            {"divided_inline_discussions": []}, expected_response
+        )
+
+    def test_update_division_scheme(self):
+        """Test whether the 'division_scheme' setting is updated."""
+        config_course_cohorts(self.course, is_cohorted=True)
+        self._login_as_staff()
+        expected_response = self._get_expected_response()
+        self._assert_current_settings(expected_response)
+        expected_response["division_scheme"] = "none"
+        self._assert_patched_settings({"division_scheme": "none"}, expected_response)
+
+    def test_update_reported_content_email_notifications(self):
+        """Test whether the 'reported_content_email_notifications' setting is updated."""
+        config_course_cohorts(self.course, is_cohorted=True)
+        config_course_discussions(
+            self.course, reported_content_email_notifications=True
+        )
+        expected_response = self._get_expected_response()
+        expected_response["reported_content_email_notifications"] = True
+        self._login_as_staff()
+        self._assert_current_settings(expected_response)
+
+
+@ddt.ddt
+class CourseDiscussionRolesAPIViewTest(APITestCase, UrlResetMixin, ModuleStoreTestCase):
+    """
+    Test the course discussion roles management endpoint.
+    """
+
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def setUp(self):
+        super().setUp()
+        mock.patch(
+            "lms.djangoapps.discussion.toggles.ENABLE_FORUM_V2.is_enabled",
+            return_value=True,
+        ).start()
+        self.addCleanup(mock.patch.stopall)
+        self.course = CourseFactory.create(
+            org="x",
+            course="y",
+            run="z",
+            start=datetime.now(UTC),
+        )
+        self.password = self.TEST_PASSWORD
+        self.user = UserFactory(username="staff", password=self.password, is_staff=True)
+        course_key = CourseKey.from_string("course-v1:x+y+z")
+        seed_permissions_roles(course_key)
+
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def path(self, course_id=None, role=None):
+        """Return the URL path to the endpoint based on the provided arguments."""
+        course_id = str(self.course.id) if course_id is None else course_id
+        role = "Moderator" if role is None else role
+        return reverse(
+            "discussion_course_roles", kwargs={"course_id": course_id, "rolename": role}
+        )
+
+    def _get_oauth_headers(self, user):
+        """Return the OAuth headers for testing OAuth authentication."""
+        access_token = AccessTokenFactory.create(
+            user=user, application=ApplicationFactory()
+        ).token
+        headers = {"HTTP_AUTHORIZATION": "Bearer " + access_token}
+        return headers
+
+    def _login_as_staff(self):
+        """Log the client is as the staff user."""
+        self.client.login(username=self.user.username, password=self.password)
+
+    def _create_and_enroll_users(self, count):
+        """Create 'count' number of users and enroll them in self.course."""
+        users = []
+        for _ in range(count):
+            user = UserFactory()
+            CourseEnrollmentFactory.create(user=user, course_id=self.course.id)
+            users.append(user)
+        return users
+
+    def _add_users_to_role(self, users, rolename):
+        """Add the given users to the given role."""
+        role = Role.objects.get(name=rolename, course_id=self.course.id)
+        for user in users:
+            role.users.add(user)
+
+    def post(self, role, user_id, action):
+        """Make a POST request to the endpoint using the provided parameters."""
+        self._login_as_staff()
+        return self.client.post(
+            self.path(role=role), {"user_id": user_id, "action": action}
+        )
+
+    @ddt.data("get", "post")
+    def test_authentication_required(self, method):
+        """Test and verify that authentication is required for this endpoint."""
+        self.client.logout()
+        response = getattr(self.client, method)(self.path())
+        assert response.status_code == 401
+
+    def test_oauth(self):
+        """Test that OAuth authentication works for this endpoint."""
+        oauth_headers = self._get_oauth_headers(self.user)
+        self.client.logout()
+        response = self.client.get(self.path(), **oauth_headers)
+        assert response.status_code == 200
+        body = {"user_id": "staff", "action": "allow"}
+        response = self.client.post(self.path(), body, format="json", **oauth_headers)
+        assert response.status_code == 200
+
+    @ddt.data(
+        {"username": "u1", "is_staff": False, "expected_status": 403},
+        {"username": "u2", "is_staff": True, "expected_status": 200},
+    )
+    @ddt.unpack
+    def test_staff_permission_required(self, username, is_staff, expected_status):
+        """Test and verify that only users with staff permission can access this endpoint."""
+        UserFactory(username=username, password="edx", is_staff=is_staff)
+        self.client.login(username=username, password="edx")
+        response = self.client.get(self.path())
+        assert response.status_code == expected_status
+
+        response = self.client.post(
+            self.path(), {"user_id": username, "action": "allow"}, format="json"
+        )
+        assert response.status_code == expected_status
+
+    def test_non_existent_course_id(self):
+        """Test the response when the endpoint URL contains a non-existent course id."""
+        self._login_as_staff()
+        path = self.path(course_id="course-v1:a+b+c")
+        response = self.client.get(path)
+
+        assert response.status_code == 404
+
+        response = self.client.post(path)
+        assert response.status_code == 404
+
+    def test_non_existent_course_role(self):
+        """Test the response when the endpoint URL contains a non-existent role."""
+        self._login_as_staff()
+        path = self.path(role="A")
+        response = self.client.get(path)
+
+        assert response.status_code == 400
+
+        response = self.client.post(path)
+        assert response.status_code == 400
+
+    @ddt.data(
+        {"role": "Moderator", "count": 0},
+        {"role": "Moderator", "count": 1},
+        {"role": "Group Moderator", "count": 2},
+        {"role": "Community TA", "count": 3},
+    )
+    @ddt.unpack
+    def test_get_role_members(self, role, count):
+        """Test the get role members endpoint response."""
+        config_course_cohorts(self.course, is_cohorted=True)
+        users = self._create_and_enroll_users(count=count)
+
+        self._add_users_to_role(users, role)
+        self._login_as_staff()
+        response = self.client.get(self.path(role=role))
+
+        assert response.status_code == 200
+
+        content = json.loads(response.content.decode("utf-8"))
+        assert content["course_id"] == "course-v1:x+y+z"
+        assert len(content["results"]) == count
+        expected_fields = ("username", "email", "first_name", "last_name", "group_name")
+        for item in content["results"]:
+            for expected_field in expected_fields:
+                assert expected_field in item
+        assert content["division_scheme"] == "cohort"
+
+    def test_post_missing_body(self):
+        """Test the response with a POST request without a body."""
+        self._login_as_staff()
+        response = self.client.post(self.path())
+        assert response.status_code == 400
+
+    @ddt.data(
+        {"a": 1},
+        {"user_id": "xyz", "action": "allow"},
+        {"user_id": "staff", "action": 123},
+    )
+    def test_missing_or_invalid_parameters(self, body):
+        """
+        Test the response when the POST request has missing required parameters or
+        invalid values for the required parameters.
+        """
+        self._login_as_staff()
+        response = self.client.post(self.path(), body)
+        assert response.status_code == 400
+
+        response = self.client.post(self.path(), body, format="json")
+        assert response.status_code == 400
+
+    @ddt.data(
+        {"action": "allow", "user_in_role": False},
+        {"action": "allow", "user_in_role": True},
+        {"action": "revoke", "user_in_role": False},
+        {"action": "revoke", "user_in_role": True},
+    )
+    @ddt.unpack
+    def test_post_update_user_role(self, action, user_in_role):
+        """Test the response when updating the user's role"""
+        users = self._create_and_enroll_users(count=1)
+        user = users[0]
+        role = "Moderator"
+        if user_in_role:
+            self._add_users_to_role(users, role)
+
+        response = self.post(role, user.username, action)
+        assert response.status_code == 200
+        content = json.loads(response.content.decode("utf-8"))
+        assertion = self.assertTrue if action == "allow" else self.assertFalse
+        assertion(any(user.username in x["username"] for x in content["results"]))
+
+
+@ddt.ddt
+@httpretty.activate
+@override_waffle_flag(ENABLE_DISCUSSIONS_MFE, True)
+class CourseActivityStatsTest(
+    ForumsEnableMixin,
+    UrlResetMixin,
+    CommentsServiceMockMixin,
+    APITestCase,
+    SharedModuleStoreTestCase,
+):
+    """
+    Tests for the course stats endpoint
+    """
+
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def setUp(self) -> None:
+        super().setUp()
+        mock.patch(
+            "lms.djangoapps.discussion.toggles.ENABLE_FORUM_V2.is_enabled",
+            return_value=True,
+        ).start()
+        self.mock_get_user_course_stats = mock.patch(
+            "openedx.core.djangoapps.django_comment_common.comment_client.course.forum_api.get_user_course_stats",
+        ).start()
+        self.addCleanup(mock.patch.stopall)
+        self.course = CourseFactory.create()
+        self.course_key = str(self.course.id)
+        seed_permissions_roles(self.course.id)
+        self.user = UserFactory(username="user")
+        self.moderator = UserFactory(username="moderator")
+        moderator_role = Role.objects.get(name="Moderator", course_id=self.course.id)
+        moderator_role.users.add(self.moderator)
+        self.stats = [
+            {
+                "active_flags": random.randint(0, 3),
+                "inactive_flags": random.randint(0, 2),
+                "replies": random.randint(0, 30),
+                "responses": random.randint(0, 100),
+                "threads": random.randint(0, 10),
+                "username": f"user-{idx}",
+            }
+            for idx in range(10)
+        ]
+
+        for stat in self.stats:
+            user = UserFactory.create(
+                username=stat["username"],
+                email=f"{stat['username']}@example.com",
+                password=self.TEST_PASSWORD,
+            )
+            CourseEnrollment.enroll(user, self.course.id, mode="audit")
+
+        CourseEnrollment.enroll(self.moderator, self.course.id, mode="audit")
+        self.stats_without_flags = [
+            {**stat, "active_flags": None, "inactive_flags": None}
+            for stat in self.stats
+        ]
+        self.register_course_stats_response(self.course_key, self.stats, 1, 3)
+        self.url = reverse(
+            "discussion_course_activity_stats",
+            kwargs={"course_key_string": self.course_key},
+        )
+
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def test_regular_user(self):
+        """
+        Tests that for a regular user stats are returned without flag counts
+        """
+        self.client.login(username=self.user.username, password=self.TEST_PASSWORD)
+        response = self.client.get(self.url)
+        data = response.json()
+        assert data["results"] == self.stats_without_flags
+        self.mock_get_user_course_stats.assert_called_once_with(
+            self.course_key, sort_key="activity", page=1, per_page=10
+        )
+
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def test_moderator_user(self):
+        """
+        Tests that for a moderator user stats are returned with flag counts
+        """
+        self.client.login(username=self.moderator.username, password=self.TEST_PASSWORD)
+        response = self.client.get(self.url)
+        data = response.json()
+        assert data["results"] == self.stats
+        self.mock_get_user_course_stats.assert_called_once_with(
+            self.course_key, sort_key="flagged", page=1, per_page=10
+        )
+
+    @ddt.data(
+        ("moderator", "flagged", "flagged"),
+        ("moderator", "activity", "activity"),
+        ("moderator", "recency", "recency"),
+        ("moderator", None, "flagged"),
+        ("user", None, "activity"),
+        ("user", "activity", "activity"),
+        ("user", "recency", "recency"),
+    )
+    @ddt.unpack
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def test_sorting(self, username, ordering_requested, ordering_performed):
+        """
+        Test valid sorting options and defaults
+        """
+        self.client.login(username=username, password=self.TEST_PASSWORD)
+        params = {}
+        if ordering_requested:
+            params = {"order_by": ordering_requested}
+        self.client.get(self.url, params)
+        self.mock_get_user_course_stats.assert_called_once_with(
+            self.course_key, sort_key=ordering_performed, page=1, per_page=10
+        )
+
+    @ddt.data("flagged", "xyz")
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def test_sorting_error_regular_user(self, order_by):
+        """
+        Test for invalid sorting options for regular users.
+        """
+        self.client.login(username=self.user.username, password=self.TEST_PASSWORD)
+        response = self.client.get(self.url, {"order_by": order_by})
+        assert "order_by" in response.json()["field_errors"]
+
+    @ddt.data(
+        (
+            "user",
+            "user-0,user-1,user-2,user-3,user-4,user-5,user-6,user-7,user-8,user-9",
+        ),
+        ("moderator", "moderator"),
+    )
+    @ddt.unpack
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def test_with_username_param(
+        self, username_search_string, comma_separated_usernames
+    ):
+        """
+        Test for endpoint with username param.
+        """
+        params = {"username": username_search_string}
+        self.client.login(username=self.moderator.username, password=self.TEST_PASSWORD)
+        self.client.get(self.url, params)
+        self.mock_get_user_course_stats.assert_called_once_with(
+            self.course_key,
+            sort_key="flagged",
+            page=1,
+            per_page=10,
+            usernames=comma_separated_usernames,
+        )
+
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def test_with_username_param_with_no_matches(self):
+        """
+        Test for endpoint with username param with no matches.
+        """
+        params = {"username": "unknown"}
+        self.client.login(username=self.moderator.username, password=self.TEST_PASSWORD)
+        response = self.client.get(self.url, params)
+        data = response.json()
+        self.assertFalse(data["results"])
+        assert data["pagination"]["count"] == 0
+
+    @ddt.data("user-0", "USER-1", "User-2", "UsEr-3")
+    @mock.patch.dict(
+        "django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True}
+    )
+    def test_with_username_param_case(self, username_search_string):
+        """
+        Test user search function is case-insensitive.
+        """
+        response = get_usernames_from_search_string(
+            self.course_key, username_search_string, 1, 1
+        )
+        assert response == (username_search_string.lower(), 1, 1)
diff --git a/lms/djangoapps/discussion/rest_api/tests/utils_v2.py b/lms/djangoapps/discussion/rest_api/tests/utils_v2.py
index 3f63f77b2828..d164a19e233e 100644
--- a/lms/djangoapps/discussion/rest_api/tests/utils_v2.py
+++ b/lms/djangoapps/discussion/rest_api/tests/utils_v2.py
@@ -239,20 +239,12 @@ def register_subscribed_threads_response(self, user, threads, page, num_pages):
 
     def register_course_stats_response(self, course_key, stats, page, num_pages):
         """Register a mock response for GET on the CS user course stats instance endpoint"""
-        assert httpretty.is_enabled(), "httpretty must be enabled to mock calls."
-        httpretty.register_uri(
-            httpretty.GET,
-            f"http://localhost:4567/api/v1/users/{course_key}/stats",
-            body=json.dumps(
-                {
-                    "user_stats": stats,
-                    "page": page,
-                    "num_pages": num_pages,
-                    "count": len(stats),
-                }
-            ),
-            status=200,
-        )
+        self.mock_get_user_course_stats.return_value = {
+            "user_stats": stats,
+            "page": page,
+            "num_pages": num_pages,
+            "count": len(stats),
+        }
 
     def register_subscription_response(self, user):
         """