feat: rl dashboard competences test

server/vbv_lernwelt/dashboard/graphql/types/competence.py

@@ -46,19 +46,19 @@ def competences(course_id: graphene.String(), user: User) -> Competences:
                 success_count=0,  # noqa
                 fail_count=0,  # noqa
             )
-        if c.completion_status == CourseCompletionStatus.SUCCESS:
+        if c.completion_status == CourseCompletionStatus.SUCCESS.value:
             competence_performances[circle.id].success_count += 1
-        elif c.completion_status == CourseCompletionStatus.FAIL:
+        elif c.completion_status == CourseCompletionStatus.FAIL.value:
             competence_performances[circle.id].fail_count += 1
 
-        return Competences(
+    return Competences(
-            performances=competence_performances.values(),  # noqa
+        performances=competence_performances.values(),  # noqa
-            summary=CompletionSummary(  # noqa
+        summary=CompletionSummary(  # noqa
-                success_total=sum(  # noqa
+            success_total=sum(  # noqa
-                    [c.success_count for c in competence_performances.values()]
+                [c.success_count for c in competence_performances.values()]
-                ),
-                fail_total=sum(  # noqa
-                    [c.fail_count for c in competence_performances.values()]
-                ),
             ),
-        )
+            fail_total=sum(  # noqa
+                [c.fail_count for c in competence_performances.values()]
+            ),
+        ),
+    )

server/vbv_lernwelt/dashboard/tests/graphql/test_competence.py

@@ -1,11 +1,13 @@
 from graphene_django.utils import GraphQLTestCase
 
 from vbv_lernwelt.course.models import CourseSessionUser
+from vbv_lernwelt.course.services import mark_course_completion
 from vbv_lernwelt.dashboard.tests.graphql.utils import (
     add_course_session_user,
     create_circle,
     create_course,
     create_course_session,
+    create_performance_criteria_page,
     create_user,
 )
 
@@ -26,15 +28,39 @@ class DashboardCompetenceTestCase(GraphQLTestCase):
             role=CourseSessionUser.Role.SESSION_SUPERVISOR,
         )
 
-        member = create_user("member")
+        member_one = create_user("member one")
         add_course_session_user(
             course_session=course_session,
-            user=member,
+            user=member_one,
             role=CourseSessionUser.Role.MEMBER,
         )
 
-        circle1, _ = create_circle(title="Test Circle 1", course_page=course_page)
+        member_two = create_user("member two")
-        circle2, _ = create_circle(title="Test Circle 2", course_page=course_page)
+        add_course_session_user(
+            course_session=course_session,
+            user=member_two,
+            role=CourseSessionUser.Role.MEMBER,
+        )
+
+        circle, _ = create_circle(title="Test Circle", course_page=course_page)
+
+        pc = create_performance_criteria_page(
+            course=course, course_page=course_page, circle=circle
+        )
+
+        mark_course_completion(
+            page=pc,
+            user=member_one,
+            course_session=course_session,
+            completion_status="SUCCESS",
+        )
+
+        mark_course_completion(
+            page=pc,
+            user=member_two,
+            course_session=course_session,
+            completion_status="FAIL",
+        )
 
         self.client.force_login(supervisor)
 
@@ -64,3 +90,17 @@ class DashboardCompetenceTestCase(GraphQLTestCase):
 
         # THEN
         self.assertResponseNoErrors(response)
+
+        competences = response.json()["data"]["course_dashboard"][0]["competences"]
+
+        performances = competences["performances"]
+
+        self.assertEqual(performances[0]["success_count"], 1)
+        self.assertEqual(performances[0]["fail_count"], 1)
+        self.assertEqual(performances[0]["circle_id"], str(circle.id))
+        self.assertEqual(performances[0]["course_session_id"], str(course_session.id))
+        self.assertEqual(performances[0]["generation"], "2023")
+
+        summary = competences["summary"]
+        self.assertEqual(summary["success_total"], 1)
+        self.assertEqual(summary["fail_total"], 1)

server/vbv_lernwelt/dashboard/tests/graphql/utils.py

@@ -4,10 +4,18 @@ from typing import List, Tuple
 from django.contrib.auth.hashers import make_password
 from django.utils import timezone
 
+from vbv_lernwelt.competence.factories import (
+    ActionCompetenceFactory,
+    ActionCompetenceListPageFactory,
+    CompetenceNaviPageFactory,
+    PerformanceCriteriaFactory,
+)
+from vbv_lernwelt.competence.models import PerformanceCriteria
 from vbv_lernwelt.core.models import User
 from vbv_lernwelt.course.factories import CoursePageFactory
 from vbv_lernwelt.course.models import (
     Course,
+    CourseCategory,
     CoursePage,
     CourseSession,
     CourseSessionUser,
@@ -20,6 +28,7 @@ from vbv_lernwelt.learnpath.tests.learning_path_factories import (
     CircleFactory,
     LearningContentAttendanceCourseFactory,
     LearningPathFactory,
+    LearningUnitFactory,
     TopicFactory,
 )
 
@@ -105,3 +114,37 @@ def create_attendance_course(
             end=due_date_end,
         ),
     )
+
+
+def create_performance_criteria_page(
+    course: Course, course_page: CoursePage, circle: Circle
+) -> PerformanceCriteria:
+    competence_navi_page = CompetenceNaviPageFactory(
+        title="Competence Navi",
+        parent=course_page,
+    )
+
+    competence_profile_page = ActionCompetenceListPageFactory(
+        title="Action Competence Page",
+        parent=competence_navi_page,
+    )
+
+    action_competence = ActionCompetenceFactory(
+        parent=competence_profile_page,
+        competence_id="X1",
+        title="Action Competence",
+        items=[("item", "Action Competence Item")],
+    )
+
+    cat, _ = CourseCategory.objects.get_or_create(
+        course=course, title="Course Category"
+    )
+
+    lu = LearningUnitFactory(title="Learning Unit", parent=circle, course_category=cat)
+
+    return PerformanceCriteriaFactory(
+        parent=action_competence,
+        competence_id="X1.1",
+        title="Performance Criteria",
+        learning_unit=lu,
+    )