Development: Improve metrics integration test coverage

build.gradle

@@ -185,7 +185,7 @@ jacocoTestCoverageVerification {
                 counter = "CLASS"
                 value = "MISSEDCOUNT"
                 // TODO: in the future the following value should become less than 10
-                maximum = 40
+                maximum = 39
             }
         }
     }

src/main/java/de/tum/cit/aet/artemis/exercise/repository/ExerciseRepository.java

@@ -322,6 +322,9 @@ AND EXISTS (
             """)
     Set<String> findAllCategoryNames(@Param("courseId") Long courseId);
 
+    @EntityGraph(attributePaths = "categories")
+    List<Exercise> findAllWithCategoriesByCourseId(Long courseId);
+
     @Query("""
             SELECT DISTINCT e
             FROM Exercise e

src/test/java/de/tum/cit/aet/artemis/AbstractArtemisIntegrationTest.java

@@ -47,6 +47,7 @@
 import de.tum.cit.aet.artemis.exercise.ExerciseUtilService;
 import de.tum.cit.aet.artemis.exercise.programming.MockDelegate;
 import de.tum.cit.aet.artemis.exercise.repository.ExerciseRepository;
+import de.tum.cit.aet.artemis.exercise.service.LearningMetricsService;
 import de.tum.cit.aet.artemis.lti.service.Lti13Service;
 import de.tum.cit.aet.artemis.modeling.service.ModelingSubmissionService;
 import de.tum.cit.aet.artemis.programming.domain.VcsRepositoryUri;
@@ -164,6 +165,9 @@ public abstract class AbstractArtemisIntegrationTest implements MockDelegate {
     @SpyBean
     protected CompetencyProgressService competencyProgressService;
 
+    @SpyBean
+    protected LearningMetricsService learningMetricsService;
+
     @Autowired
     protected RequestUtilService request;
 

src/test/java/de/tum/cit/aet/artemis/MetricsIntegrationTest.java

@@ -1,5 +1,6 @@
 package de.tum.cit.aet.artemis;
 
+import static de.tum.cit.aet.artemis.core.config.Constants.MIN_SCORE_GREEN;
 import static de.tum.cit.aet.artemis.core.util.TimeUtil.toRelativeTime;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.awaitility.Awaitility.await;
@@ -26,11 +27,14 @@
 import de.tum.cit.aet.artemis.assessment.service.ParticipantScoreScheduleService;
 import de.tum.cit.aet.artemis.atlas.dto.metrics.ResourceTimestampDTO;
 import de.tum.cit.aet.artemis.atlas.dto.metrics.StudentMetricsDTO;
+import de.tum.cit.aet.artemis.atlas.repository.CompetencyMetricsRepository;
 import de.tum.cit.aet.artemis.core.domain.Course;
 import de.tum.cit.aet.artemis.exercise.domain.Exercise;
 import de.tum.cit.aet.artemis.exercise.domain.Submission;
 import de.tum.cit.aet.artemis.exercise.dto.ExerciseInformationDTO;
 import de.tum.cit.aet.artemis.exercise.repository.ExerciseMetricsRepository;
+import de.tum.cit.aet.artemis.lecture.repository.LectureUnitMetricsRepository;
+import de.tum.cit.aet.artemis.team.TeamFactory;
 
 class MetricsIntegrationTest extends AbstractSpringIntegrationIndependentTest {
 
@@ -39,25 +43,41 @@
     @Autowired
     private ExerciseMetricsRepository exerciseMetricsRepository;
 
+    @Autowired
+    private CompetencyMetricsRepository competencyMetricsRepository;
+
+    @Autowired
+    private LectureUnitMetricsRepository lectureUnitMetricsRepository;
+
     private Course course;
 
     private Course courseWithTestRuns;
 
+    private Course courseWithCompetencies;
+
+    private long userID;
+
     private static final String STUDENT_OF_COURSE = TEST_PREFIX + "student1";
 
     @BeforeEach
-    void setupTestScenario() {
+    void setupTestScenario() throws Exception {
         // Prevents the ParticipantScoreScheduleService from scheduling tasks related to prior results
         ReflectionTestUtils.setField(participantScoreScheduleService, "lastScheduledRun", Optional.of(Instant.now()));
         ParticipantScoreScheduleService.DEFAULT_WAITING_TIME_FOR_SCHEDULED_TASKS = 100;
         participantScoreScheduleService.activate();
 
         userUtilService.addUsers(TEST_PREFIX, 3, 1, 1, 1);
 
-        course = courseUtilService.createCourseWithAllExerciseTypesAndParticipationsAndSubmissionsAndResults(TEST_PREFIX, true);
+        course = courseUtilService.createCourseWithAllExerciseTypesAndParticipationsAndSubmissionsAndResultsAndScores(TEST_PREFIX, true);
         courseWithTestRuns = courseUtilService.createCourseWithAllExerciseTypesAndParticipationsAndSubmissionsAndResultsAndTestRunsAndTwoUsers(TEST_PREFIX, true);
+        courseWithCompetencies = courseUtilService.createCoursesWithExercisesAndLecturesAndLectureUnitsAndCompetencies(TEST_PREFIX, true, true, 1).getFirst();
 
         userUtilService.createAndSaveUser(TEST_PREFIX + "user1337");
+        userID = userUtilService.getUserByLogin(TEST_PREFIX + "student1").getId();
+
+        // course.getExercises().forEach(exercise -> studentScoreUtilService.createStudentScore(exercise, userUtilService.getUserByLogin(STUDENT_OF_COURSE), 0.5));
+        course.getExercises().forEach(
+                exercise -> exercise.setTeams(Set.of(TeamFactory.generateTeamForExercise(exercise, "testTeam", "test", 3, userUtilService.getUserByLogin(STUDENT_OF_COURSE)))));
     }
 
     @AfterEach
@@ -93,7 +113,20 @@
             assertThat(exerciseInformation).allSatisfy((id, dto) -> assertThat(id).isEqualTo(dto.id()));
         }
 
-        @Disabled // TODO: reduce jacoco missing by one after enabled
+        @Test
+        @WithMockUser(username = STUDENT_OF_COURSE, roles = "USER")
+        void shouldReturnCategories() throws Exception {
+            final var result = request.get("/api/metrics/course/" + course.getId() + "/student", HttpStatus.OK, StudentMetricsDTO.class);
+            assertThat(result).isNotNull();
+            assertThat(result.exerciseMetrics()).isNotNull();
+            final var categories = result.exerciseMetrics().categories();
+
+            final var expectedCategories = exerciseRepository.findAllWithCategoriesByCourseId(course.getId()).stream()
+                    .collect(Collectors.toMap(Exercise::getId, Exercise::getCategories));
+
+            assertThat(categories).isEqualTo(expectedCategories);
+        }
+
         @Test
         @WithMockUser(username = STUDENT_OF_COURSE, roles = "USER")
         void shouldReturnAverageScores() throws Exception {
@@ -111,9 +144,24 @@
             final var expectedMap = exercises.stream().map(Exercise::getId).collect(
                     Collectors.toMap(Function.identity(), id -> resultRepository.findAllByParticipationExerciseId(id).stream().mapToDouble(Result::getScore).average().orElse(0)));
 
             assertThat(averageScores).isEqualTo(expectedMap);
         }
 
+        @Test
+        @WithMockUser(username = STUDENT_OF_COURSE, roles = "USER")
+        void shouldReturnScore() throws Exception {
+            final var result = request.get("/api/metrics/course/" + course.getId() + "/student", HttpStatus.OK, StudentMetricsDTO.class);
+            assertThat(result).isNotNull();
+            assertThat(result.exerciseMetrics()).isNotNull();
+            final var score = result.exerciseMetrics().score();
+
+            final var exercises = exerciseRepository.findAllExercisesByCourseId(course.getId());
+            final var expectedScores = exercises.stream().collect(Collectors.toMap(Exercise::getId, exercise -> resultRepository
+                    .getRatedResultsOrderedByParticipationIdLegalSubmissionIdResultIdDescForStudent(exercise.getId(), userID).stream().mapToDouble(Result::getScore).sum()));
+
+            assertThat(score).isEqualTo(expectedScores);
+        }
+
         @Test
         @WithMockUser(username = STUDENT_OF_COURSE, roles = "USER")
         void shouldReturnAverageLatestSubmission() throws Exception {
@@ -181,7 +229,6 @@
             Set<Long> exerciseIds = new HashSet<Long>();
             final var exercises = exerciseRepository.findAllExercisesByCourseId(courseWithTestRuns.getId()).stream()
                     .map(exercise -> exerciseRepository.findWithEagerStudentParticipationsStudentAndSubmissionsById(exercise.getId()).orElseThrow());
-            final var userID = userUtilService.getUserByLogin(TEST_PREFIX + "student1").getId();
 
             Set<ResourceTimestampDTO> expectedSet = exercises.flatMap(exercise -> {
                 exerciseIds.add(exercise.getId());
@@ -195,5 +242,64 @@
             Set<ResourceTimestampDTO> result = exerciseMetricsRepository.findLatestSubmissionDatesForUser(exerciseIds, userID);
             assertThat(result).isEqualTo(expectedSet);
         }
+
+        @Disabled
+        @Test
+        @WithMockUser(username = STUDENT_OF_COURSE, roles = "USER")
+        void shouldReturnCompleted() throws Exception {
+
+            final var result = request.get("/api/metrics/course/" + course.getId() + "/student", HttpStatus.OK, StudentMetricsDTO.class);
+            assertThat(result).isNotNull();
+            assertThat(result.exerciseMetrics()).isNotNull();
+            final var completed = result.exerciseMetrics().completed();
+
+            final var exercises = exerciseRepository.getAllExercisesUserParticipatedInWithEagerParticipationsSubmissionsResultsFeedbacksTestCasesByUserId(userID);
+
+            final var expectedCompleted = exercises.stream().map(Exercise::getId)
+                    .filter(id -> resultRepository.getRatedResultsOrderedByParticipationIdLegalSubmissionIdResultIdDescForStudent(id, userID).stream()
+                            .anyMatch(result1 -> result1.getScore() != null && result1.getScore() >= MIN_SCORE_GREEN))
+                    .collect(Collectors.toSet());
+
+            assertThat(completed).isEqualTo(expectedCompleted);
+        }
+    }
+
+    @Nested
+    class CompetencyMetrics {
+
+        @Disabled
+        @Test
+        @WithMockUser(username = STUDENT_OF_COURSE, roles = "USER")
+        void shouldReturnCompetencyInformation() throws Exception {
+            final var result = request.get("/api/metrics/course/" + courseWithCompetencies.getId() + "/student", HttpStatus.OK, StudentMetricsDTO.class);
+            assertThat(result).isNotNull();
+            assertThat(result.competencyMetrics()).isNotNull();
+
+            final var competencyInformation = result.competencyMetrics().competencyInformation();
+
+            final var expectedCompetencies = competencyMetricsRepository.findAllCompetencyInformationByCourseId(courseWithCompetencies.getId());
+
+            assertThat(competencyInformation.values()).containsExactlyInAnyOrderElementsOf(expectedCompetencies);
+            assertThat(competencyInformation).allSatisfy((id, dto) -> assertThat(id).isEqualTo(dto.id()));
+        }
+    }
+
+    @Nested
+    class LectureMetrics {
+
+        @Disabled
+        @Test
+        @WithMockUser(username = STUDENT_OF_COURSE, roles = "USER")
+        void shouldReturnLectureUnitInformation() throws Exception {
+            final var result = request.get("/api/metrics/course/" + courseWithCompetencies.getId() + "/student", HttpStatus.OK, StudentMetricsDTO.class);
+            assertThat(result).isNotNull();
+            assertThat(result.lectureUnitStudentMetricsDTO()).isNotNull();
+            final var lectureUnitInformation = result.lectureUnitStudentMetricsDTO().lectureUnitInformation();
+
+            final var expectedLectureUnits = lectureUnitMetricsRepository.findAllLectureUnitInformationByCourseId(courseWithCompetencies.getId());
+
+            assertThat(lectureUnitInformation.values()).containsExactlyInAnyOrderElementsOf(expectedLectureUnits);
+            assertThat(lectureUnitInformation).allSatisfy((id, dto) -> assertThat(id).isEqualTo(dto.id()));
+        }
     }
 }