test_api_v2.py

"""
Tests for Instructor API v2 endpoints.
"""
import json
from unittest.mock import MagicMock, patch
from uuid import uuid4

from django.urls import reverse
from rest_framework import status
from rest_framework.test import APIClient

from common.djangoapps.student.models import CourseEnrollment
from common.djangoapps.student.tests.factories import InstructorFactory, UserFactory
from lms.djangoapps.courseware.models import StudentModule
from lms.djangoapps.instructor_task.models import InstructorTask
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
from xmodule.modulestore.tests.factories import BlockFactory, CourseFactory


class LearnerViewTestCase(ModuleStoreTestCase):
    """
    Tests for GET /api/instructor/v2/courses/{course_key}/learners/{email_or_username}
    """

    def setUp(self):
        super().setUp()
        self.client = APIClient()
        self.course = CourseFactory.create()
        self.instructor = InstructorFactory.create(course_key=self.course.id)
        self.student = UserFactory(
            username='john_harvard',
            email='john@example.com',
        )
        self.student.profile.name = 'John Harvard'
        self.student.profile.save()
        self.client.force_authenticate(user=self.instructor)

    def test_get_learner_by_username(self):
        """Test retrieving learner info by username"""
        url = reverse('instructor_api_v2:learner_detail', kwargs={
            'course_id': str(self.course.id),
            'email_or_username': self.student.username
        })
        response = self.client.get(url)

        expected_progress_url = reverse('student_progress', kwargs={
            'course_id': str(self.course.id),
            'student_id': self.student.id,
        })

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertEqual(data['username'], 'john_harvard')
        self.assertEqual(data['email'], 'john@example.com')
        self.assertEqual(data['full_name'], 'John Harvard')
        self.assertEqual(data['progress_url'], expected_progress_url)

    def test_get_learner_by_email(self):
        """Test retrieving learner info by email"""
        url = reverse('instructor_api_v2:learner_detail', kwargs={
            'course_id': str(self.course.id),
            'email_or_username': self.student.email
        })
        response = self.client.get(url)

        expected_progress_url = reverse('student_progress', kwargs={
            'course_id': str(self.course.id),
            'student_id': self.student.id,
        })

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertEqual(data['username'], 'john_harvard')
        self.assertEqual(data['email'], 'john@example.com')
        self.assertEqual(data['progress_url'], expected_progress_url)

    def test_get_learner_requires_authentication(self):
        """Test that endpoint requires authentication"""
        self.client.force_authenticate(user=None)

        url = reverse('instructor_api_v2:learner_detail', kwargs={
            'course_id': str(self.course.id),
            'email_or_username': self.student.username
        })
        response = self.client.get(url)

        self.assertIn(response.status_code, [status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN])


class ProblemViewTestCase(ModuleStoreTestCase):
    """
    Tests for GET /api/instructor/v2/courses/{course_key}/problems/{location}
    """

    def setUp(self):
        super().setUp()
        self.client = APIClient()
        self.course = CourseFactory.create(display_name='Test Course')
        self.instructor = InstructorFactory.create(course_key=self.course.id)
        self.chapter = BlockFactory.create(
            parent=self.course,
            category='chapter',
            display_name='Week 1'
        )
        self.sequential = BlockFactory.create(
            parent=self.chapter,
            category='sequential',
            display_name='Homework 1'
        )
        self.problem = BlockFactory.create(
            parent=self.sequential,
            category='problem',
            display_name='Sample Problem'
        )
        self.client.force_authenticate(user=self.instructor)

    def test_get_problem_metadata(self):
        """Test retrieving problem metadata"""
        url = reverse('instructor_api_v2:problem_detail', kwargs={
            'course_id': str(self.course.id),
            'location': str(self.problem.location)
        })
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertEqual(data['id'], str(self.problem.location))
        self.assertEqual(data['name'], 'Sample Problem')
        self.assertIn('breadcrumbs', data)
        self.assertIsInstance(data['breadcrumbs'], list)

    def test_get_problem_with_breadcrumbs(self):
        """Test that breadcrumbs contain the full course hierarchy"""
        url = reverse('instructor_api_v2:problem_detail', kwargs={
            'course_id': str(self.course.id),
            'location': str(self.problem.location)
        })
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        breadcrumbs = data['breadcrumbs']

        # Should contain: course → chapter → sequential → problem
        self.assertEqual(len(breadcrumbs), 4)
        self.assertEqual(breadcrumbs[0]['display_name'], self.course.display_name)
        self.assertIsNone(breadcrumbs[0]['usage_key'])  # course-level has no usage_key
        self.assertEqual(breadcrumbs[1]['display_name'], 'Week 1')
        self.assertEqual(breadcrumbs[2]['display_name'], 'Homework 1')
        self.assertEqual(breadcrumbs[3]['display_name'], 'Sample Problem')

    def test_get_problem_invalid_location(self):
        """Test 400 with invalid problem location"""
        url = reverse('instructor_api_v2:problem_detail', kwargs={
            'course_id': str(self.course.id),
            'location': 'invalid-location'
        })
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertIn('error', response.json())

    def test_get_problem_without_learner_has_null_score_and_attempts(self):
        """Test that current_score and attempts are null when no learner is specified"""
        url = reverse('instructor_api_v2:problem_detail', kwargs={
            'course_id': str(self.course.id),
            'location': str(self.problem.location)
        })
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertIsNone(data['current_score'])
        self.assertIsNone(data['attempts'])

    def test_get_problem_with_learner_returns_score_and_attempts(self):
        """Test that current_score and attempts are returned when learner has a StudentModule"""
        student = UserFactory()
        StudentModule.objects.create(
            student=student,
            course_id=self.course.id,
            module_state_key=self.problem.location,
            module_type='problem',
            grade=7.0,
            max_grade=10.0,
            state=json.dumps({'attempts': 3}),
        )

        url = reverse('instructor_api_v2:problem_detail', kwargs={
            'course_id': str(self.course.id),
            'location': str(self.problem.location)
        })
        response = self.client.get(url, {'email_or_username': student.username})

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertEqual(data['current_score']['score'], 7.0)
        self.assertEqual(data['current_score']['total'], 10.0)
        self.assertEqual(data['attempts']['current'], 3)

    def test_get_problem_with_learner_no_submission_returns_nulls(self):
        """Test that current_score and attempts are null when learner has no StudentModule"""
        student = UserFactory()
        url = reverse('instructor_api_v2:problem_detail', kwargs={
            'course_id': str(self.course.id),
            'location': str(self.problem.location)
        })
        response = self.client.get(url, {'email_or_username': student.username})

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertIsNone(data['current_score'])
        self.assertIsNone(data['attempts'])

    def test_get_problem_with_unknown_learner_returns_404(self):
        """Test that a 404 is returned when learner does not exist"""
        url = reverse('instructor_api_v2:problem_detail', kwargs={
            'course_id': str(self.course.id),
            'location': str(self.problem.location)
        })
        response = self.client.get(url, {'email_or_username': 'nonexistent_user'})

        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

    def test_get_problem_requires_authentication(self):
        """Test that endpoint requires authentication"""
        self.client.force_authenticate(user=None)

        url = reverse('instructor_api_v2:problem_detail', kwargs={
            'course_id': str(self.course.id),
            'location': str(self.problem.location)
        })
        response = self.client.get(url)

        self.assertIn(response.status_code, [status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN])


class TaskStatusViewTestCase(ModuleStoreTestCase):
    """
    Tests for GET /api/instructor/v2/courses/{course_key}/tasks/{task_id}
    """

    def setUp(self):
        super().setUp()
        self.client = APIClient()
        self.course = CourseFactory.create()
        self.instructor = InstructorFactory.create(course_key=self.course.id)
        self.client.force_authenticate(user=self.instructor)

    def test_get_task_status_completed(self):
        """Test retrieving completed task status"""
        # Create a completed task
        task_id = str(uuid4())
        task_output = json.dumps({
            'current': 150,
            'total': 150,
            'message': 'Reset attempts for 150 learners'
        })
        InstructorTask.objects.create(
            course_id=self.course.id,
            task_type='rescore_problem',
            task_key='',
            task_input='{}',
            task_id=task_id,
            task_state='SUCCESS',
            task_output=task_output,
            requester=self.instructor
        )

        url = reverse('instructor_api_v2:task_status', kwargs={
            'course_id': str(self.course.id),
            'task_id': task_id
        })
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertEqual(data['task_id'], task_id)
        self.assertEqual(data['state'], 'completed')
        self.assertIn('progress', data)
        self.assertEqual(data['progress']['current'], 150)
        self.assertEqual(data['progress']['total'], 150)
        self.assertIn('result', data)
        self.assertTrue(data['result']['success'])

    def test_get_task_status_running(self):
        """Test retrieving running task status"""
        # Create a running task
        task_id = str(uuid4())
        task_output = json.dumps({'current': 75, 'total': 150})
        InstructorTask.objects.create(
            course_id=self.course.id,
            task_type='rescore_problem',
            task_key='',
            task_input='{}',
            task_id=task_id,
            task_state='PROGRESS',
            task_output=task_output,
            requester=self.instructor
        )

        url = reverse('instructor_api_v2:task_status', kwargs={
            'course_id': str(self.course.id),
            'task_id': task_id
        })
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertEqual(data['state'], 'running')
        self.assertIn('progress', data)
        self.assertEqual(data['progress']['current'], 75)
        self.assertEqual(data['progress']['total'], 150)

    def test_get_task_status_failed(self):
        """Test retrieving failed task status"""
        # Create a failed task
        task_id = str(uuid4())
        InstructorTask.objects.create(
            course_id=self.course.id,
            task_type='rescore_problem',
            task_key='',
            task_input='{}',
            task_id=task_id,
            task_state='FAILURE',
            task_output='Task execution failed',
            requester=self.instructor
        )

        url = reverse('instructor_api_v2:task_status', kwargs={
            'course_id': str(self.course.id),
            'task_id': task_id
        })
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertEqual(data['state'], 'failed')
        self.assertIn('error', data)
        self.assertIn('code', data['error'])
        self.assertIn('message', data['error'])

    def test_get_task_requires_authentication(self):
        """Test that endpoint requires authentication"""
        self.client.force_authenticate(user=None)

        url = reverse('instructor_api_v2:task_status', kwargs={
            'course_id': str(self.course.id),
            'task_id': 'some-task-id'
        })
        response = self.client.get(url)

        self.assertIn(response.status_code, [status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN])


class GradingConfigViewTestCase(ModuleStoreTestCase):
    """
    Tests for GET /api/instructor/v2/courses/{course_key}/grading-config
    """

    def setUp(self):
        super().setUp()
        self.client = APIClient()
        self.course = CourseFactory.create()
        self.instructor = InstructorFactory.create(course_key=self.course.id)
        self.client.force_authenticate(user=self.instructor)

    def test_get_grading_config(self):
        """Test retrieving grading configuration returns graders and grade cutoffs"""
        url = reverse('instructor_api_v2:grading_config', kwargs={
            'course_id': str(self.course.id),
        })
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertIn('graders', data)
        self.assertIn('grade_cutoffs', data)
        self.assertIsInstance(data['graders'], list)
        self.assertIsInstance(data['grade_cutoffs'], dict)

    def test_get_grading_config_grader_fields(self):
        """Test that each grader entry has the expected fields"""
        url = reverse('instructor_api_v2:grading_config', kwargs={
            'course_id': str(self.course.id),
        })
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        for grader in data['graders']:
            self.assertIn('type', grader)
            self.assertIn('min_count', grader)
            self.assertIn('drop_count', grader)
            self.assertIn('weight', grader)

    def test_get_grading_config_requires_authentication(self):
        """Test that endpoint requires authentication"""
        self.client.force_authenticate(user=None)

        url = reverse('instructor_api_v2:grading_config', kwargs={
            'course_id': str(self.course.id),
        })
        response = self.client.get(url)

        self.assertIn(response.status_code, [status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN])


class GradingEndpointTestBase(ModuleStoreTestCase):
    """
    Base test class for grading endpoints with real course structures,
    real permissions, and real StudentModule records.
    """

    def setUp(self):
        super().setUp()
        self.client = APIClient()
        self.course = CourseFactory.create(display_name='Test Course')
        self.chapter = BlockFactory.create(
            parent=self.course,
            category='chapter',
            display_name='Week 1'
        )
        self.sequential = BlockFactory.create(
            parent=self.chapter,
            category='sequential',
            display_name='Homework 1'
        )
        self.problem = BlockFactory.create(
            parent=self.sequential,
            category='problem',
            display_name='Test Problem'
        )

        # Real instructor with real course permissions
        self.instructor = InstructorFactory(course_key=self.course.id)
        self.client.force_authenticate(user=self.instructor)

        # Real enrolled student with real module state
        self.student = UserFactory(username='test_student', email='student@example.com')
        CourseEnrollment.enroll(self.student, self.course.id)
        self.student_module = StudentModule.objects.create(
            student=self.student,
            course_id=self.course.id,
            module_state_key=self.problem.location,
            state=json.dumps({'attempts': 10}),
        )


class ResetAttemptsViewTestCase(GradingEndpointTestBase):
    """
    Tests for POST /api/instructor/v2/courses/{course_key}/{problem}/grading/attempts/reset
    """

    def _get_url(self, problem=None):
        return reverse('instructor_api_v2:reset_attempts', kwargs={
            'course_id': str(self.course.id),
            'problem': problem or str(self.problem.location),
        })

    def test_reset_single_learner(self):
        """Single learner reset zeroes attempt count and returns 200."""
        response = self.client.post(self._get_url() + '?learner=test_student')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertTrue(data['success'])
        self.assertEqual(data['learner'], 'test_student')
        self.assertEqual(data['message'], 'Attempts reset successfully')

        # Verify the actual StudentModule was modified
        self.student_module.refresh_from_db()
        self.assertEqual(json.loads(self.student_module.state)['attempts'], 0)

    @patch('lms.djangoapps.instructor_task.api.submit_reset_problem_attempts_for_all_students')
    def test_reset_all_learners(self, mock_submit):
        """Bulk reset queues a background task and returns 202."""
        mock_task = MagicMock()
        mock_task.task_id = str(uuid4())
        mock_submit.return_value = mock_task

        response = self.client.post(self._get_url())
        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
        data = response.json()
        self.assertEqual(data['task_id'], mock_task.task_id)
        self.assertIn('status_url', data)
        self.assertEqual(data['scope']['learners'], 'all')
        mock_submit.assert_called_once()


class DeleteStateViewTestCase(GradingEndpointTestBase):
    """
    Tests for DELETE /api/instructor/v2/courses/{course_key}/{problem}/grading/state
    """

    def _get_url(self, problem=None):
        return reverse('instructor_api_v2:delete_state', kwargs={
            'course_id': str(self.course.id),
            'problem': problem or str(self.problem.location),
        })

    @patch('lms.djangoapps.grades.signals.handlers.PROBLEM_WEIGHTED_SCORE_CHANGED.send')
    def test_delete_state(self, _mock_signal):
        """Delete state removes the StudentModule record and returns 200."""
        response = self.client.delete(self._get_url() + '?learner=test_student')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        data = response.json()
        self.assertTrue(data['success'])
        self.assertEqual(data['learner'], 'test_student')
        self.assertEqual(data['message'], 'State deleted successfully')

        # Verify the StudentModule was actually deleted
        self.assertFalse(
            StudentModule.objects.filter(pk=self.student_module.pk).exists()
        )

    def test_delete_state_requires_learner_param(self):
        """DELETE without learner query param returns 400."""
        response = self.client.delete(self._get_url())
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)


class RescoreViewTestCase(GradingEndpointTestBase):
    """
    Tests for POST /api/instructor/v2/courses/{course_key}/{problem}/grading/scores/rescore
    """

    def _get_url(self, problem=None):
        return reverse('instructor_api_v2:rescore', kwargs={
            'course_id': str(self.course.id),
            'problem': problem or str(self.problem.location),
        })

    @patch('lms.djangoapps.instructor_task.api.submit_rescore_problem_for_student')
    def test_rescore_single_learner(self, mock_submit):
        """Single learner rescore queues a task and returns 202."""
        mock_task = MagicMock()
        mock_task.task_id = str(uuid4())
        mock_submit.return_value = mock_task

        response = self.client.post(self._get_url() + '?learner=test_student')
        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
        data = response.json()
        self.assertEqual(data['task_id'], mock_task.task_id)
        self.assertEqual(data['scope']['learners'], 'test_student')
        mock_submit.assert_called_once()
        # Default only_if_higher should be False
        self.assertFalse(mock_submit.call_args[0][3])

    @patch('lms.djangoapps.instructor_task.api.submit_rescore_problem_for_student')
    def test_rescore_only_if_higher(self, mock_submit):
        """Rescore with only_if_higher=true passes the flag through."""
        mock_task = MagicMock()
        mock_task.task_id = str(uuid4())
        mock_submit.return_value = mock_task

        response = self.client.post(self._get_url() + '?learner=test_student&only_if_higher=true')
        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
        self.assertTrue(mock_submit.call_args[0][3])

    @patch('lms.djangoapps.instructor_task.api.submit_rescore_problem_for_all_students')
    def test_rescore_all_learners(self, mock_submit):
        """Bulk rescore queues a task and returns 202."""
        mock_task = MagicMock()
        mock_task.task_id = str(uuid4())
        mock_submit.return_value = mock_task

        response = self.client.post(self._get_url())
        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
        data = response.json()
        self.assertEqual(data['scope']['learners'], 'all')
        mock_submit.assert_called_once()


class ScoreOverrideViewTestCase(GradingEndpointTestBase):
    """
    Tests for PUT /api/instructor/v2/courses/{course_key}/{problem}/grading/scores
    """

    def _get_url(self, problem=None):
        return reverse('instructor_api_v2:score_override', kwargs={
            'course_id': str(self.course.id),
            'problem': problem or str(self.problem.location),
        })

    @patch('lms.djangoapps.instructor_task.api.submit_override_score')
    def test_override_score(self, mock_submit):
        """Score override queues a task and returns 202."""
        mock_task = MagicMock()
        mock_task.task_id = str(uuid4())
        mock_submit.return_value = mock_task

        response = self.client.put(
            self._get_url() + '?learner=test_student',
            data={'score': 8.5},
            format='json',
        )
        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
        data = response.json()
        self.assertEqual(data['task_id'], mock_task.task_id)
        self.assertEqual(data['scope']['learners'], 'test_student')
        # Verify the score value was passed through
        self.assertEqual(mock_submit.call_args[0][3], 8.5)

    def test_override_requires_learner_param(self):
        """PUT without learner query param returns 400."""
        response = self.client.put(
            self._get_url(),
            data={'score': 8.5},
            format='json',
        )
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_override_requires_score_in_body(self):
        """PUT without score in body returns 400."""
        response = self.client.put(
            self._get_url() + '?learner=test_student',
            data={},
            format='json',
        )
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_override_rejects_negative_score(self):
        """PUT with negative score returns 400."""
        response = self.client.put(
            self._get_url() + '?learner=test_student',
            data={'score': -1},
            format='json',
        )
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)