vbv/server/vbv_lernwelt/learning_mentor/tests/test_api.py

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

from vbv_lernwelt.assignment.models import (
    AssignmentCompletion,
    AssignmentCompletionStatus,
    AssignmentType,
)
from vbv_lernwelt.course.creators.test_utils import (
    add_course_session_user,
    create_assignment,
    create_assignment_learning_content,
    create_circle,
    create_course,
    create_course_session,
    create_course_session_assignment,
    create_user,
)
from vbv_lernwelt.course.models import CourseSessionUser
from vbv_lernwelt.learning_mentor.models import LearningMentor


class LearningMentorAPITest(APITestCase):
    def setUp(self) -> None:
        self.course, self.course_page = create_course("Test Course")
        self.course_session = create_course_session(course=self.course, title="Test VV")

        self.circle, _ = create_circle(title="Circle", course_page=self.course_page)

        self.assignment = create_assignment(
            course=self.course, assignment_type=AssignmentType.PRAXIS_ASSIGNMENT
        )

        lca = create_assignment_learning_content(self.circle, self.assignment)
        create_course_session_assignment(
            course_session=self.course_session, learning_content_assignment=lca
        )

        self.mentor = create_user("mentor")
        self.participant_1 = add_course_session_user(
            self.course_session,
            create_user("participant_1"),
            role=CourseSessionUser.Role.MEMBER,
        )
        self.participant_2 = add_course_session_user(
            self.course_session,
            create_user("participant_2"),
            role=CourseSessionUser.Role.MEMBER,
        )
        self.participant_3 = add_course_session_user(
            self.course_session,
            create_user("participant_3"),
            role=CourseSessionUser.Role.MEMBER,
        )

        self.url = reverse(
            "mentor_summary", kwargs={"course_session_id": self.course_session.id}
        )

    def test_api_no_mentor(self) -> None:
        # GIVEN
        self.client.force_login(self.mentor)

        # WHEN
        response = self.client.get(self.url)

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

    def test_api_no_participants(self) -> None:
        # GIVEN
        self.client.force_login(self.mentor)
        LearningMentor.objects.create(
            mentor=self.mentor, course=self.course_session.course
        )

        # WHEN
        response = self.client.get(self.url)

        # THEN
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data["participants"], [])
        self.assertEqual(response.data["praxis_assignments"], [])

    def test_api_participants(self) -> None:
        # GIVEN
        participants = [self.participant_1, self.participant_2, self.participant_3]
        self.client.force_login(self.mentor)
        mentor = LearningMentor.objects.create(
            mentor=self.mentor,
            course=self.course_session.course,
        )
        mentor.participants.set(participants)

        # WHEN
        response = self.client.get(self.url)

        # THEN
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data["participants"]), len(participants))

        participant_1 = [
            p
            for p in response.data["participants"]
            if p["id"] == str(self.participant_1.user.id)
        ][0]
        self.assertEqual(participant_1["email"], "participant_1@example.com")
        self.assertEqual(participant_1["first_name"], "Test")
        self.assertEqual(participant_1["last_name"], "Participant_1")

    def test_api_praxis_assignments(self) -> None:
        # GIVEN
        participants = [self.participant_1, self.participant_2, self.participant_3]
        self.client.force_login(self.mentor)

        mentor = LearningMentor.objects.create(
            mentor=self.mentor,
            course=self.course_session.course,
        )
        mentor.participants.set(participants)

        AssignmentCompletion.objects.create(
            assignment_user=self.participant_1.user,
            course_session=self.course_session,
            assignment=self.assignment,
            completion_status=AssignmentCompletionStatus.EVALUATION_SUBMITTED.value,
        )

        AssignmentCompletion.objects.create(
            assignment_user=self.participant_3.user,
            course_session=self.course_session,
            assignment=self.assignment,
            completion_status=AssignmentCompletionStatus.SUBMITTED.value,
        )

        # WHEN
        response = self.client.get(self.url)

        # THEN
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data["praxis_assignments"]), 1)

        self.assertEqual(
            response.data["circles"],
            [{"id": self.circle.id, "title": self.circle.title}],
        )

        assignment = response.data["praxis_assignments"][0]
        self.assertEqual(assignment["pending_evaluations"], 1)

        self.assertEqual(
            assignment["completions"][0]["last_name"], self.participant_3.user.last_name
        )
        self.assertEqual(
            assignment["completions"][1]["last_name"], self.participant_1.user.last_name
        )
        self.assertEqual(
            assignment["completions"][2]["last_name"], self.participant_2.user.last_name
        )