Add tests

Author: BartChris

Kitodo/src/test/java/org/kitodo/production/services/data/ProcessServiceIT.java

@@ -28,6 +28,10 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import java.util.stream.Collectors;
 
 import org.apache.commons.lang3.SystemUtils;
 import org.junit.jupiter.api.AfterAll;
@@ -730,4 +734,21 @@ public void shouldReturnCorrectProcessExportDTOWithCorrectStats() throws Excepti
         // cleanup
         ProcessTestUtils.removeTestProcess(testProcessId);
     }
+
+    @Test
+    public void shouldFindProcessIdsWithChildren() throws Exception {
+        ProcessService processService = ServiceManager.getProcessService();
+        List<Process> processes = processService.getAll();
+        List<Integer> allIds = processes.stream()
+                .map(Process::getId)
+                .collect(Collectors.toList());
+        Set<Integer> expected = processes.stream()
+                .filter(p -> Objects.nonNull(p.getChildren()) && !p.getChildren().isEmpty())
+                .map(Process::getId)
+                .collect(Collectors.toSet());
+        Set<Integer> actual = processService.findProcessIdsWithChildren(allIds);
+
+        assertEquals(expected.size(), actual.size(), "Unexpected number of parent processes");
+        assertTrue(actual.containsAll(expected), "Returned parent process IDs do not match expected");
+    }
 }

Kitodo/src/test/java/org/kitodo/production/services/data/TaskServiceIT.java

@@ -13,18 +13,26 @@
 
 import static org.awaitility.Awaitility.await;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.util.EnumMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.kitodo.MockDatabase;
+import org.kitodo.data.database.beans.Process;
 import org.kitodo.data.database.beans.Task;
+import org.kitodo.data.database.beans.User;
 import org.kitodo.data.database.enums.TaskStatus;
 import org.kitodo.data.database.exceptions.DAOException;
+import org.kitodo.data.database.persistence.TaskDAO;
 import org.kitodo.production.helper.Helper;
 import org.kitodo.production.services.ServiceManager;
 
@@ -272,4 +280,72 @@ public void shouldFindDistinctTitles() throws Exception {
         title = taskTitlesDistinct.get(2);
         assertEquals("Closed", title, "Incorrect sorting of distinct titles for tasks!");
     }
+
+    @Test
+    public void shouldLoadTaskTitlesForProcesses() throws Exception {
+        List<Integer> ids = List.of(1, 2);
+        Map<Integer, Map<TaskStatus, List<String>>> actualMap = taskService.loadTaskTitlesForProcesses(ids);
+
+        for (Integer id : ids) {
+            Process p = ServiceManager.getProcessService().getById(id);
+            Map<TaskStatus, List<String>> processResults = actualMap.get(id);
+
+            for (TaskStatus status : List.of(TaskStatus.OPEN, TaskStatus.INWORK)) {
+                List<String> expected = p.getTasks().stream()
+                        .filter(t -> t.getProcessingStatus() == status)
+                        .map(Task::getTitle)
+                        .collect(Collectors.toList());
+
+                List<String> actual = processResults.getOrDefault(status, List.of());
+
+                assertEquals(expected.size(), actual.size(), "Size mismatch for " + status);
+                assertTrue(actual.containsAll(expected), "Content mismatch for " + status);
+            }
+        }
+    }
+
+    @Test
+    public void shouldLoadTaskStatusCountsForProcesses() throws Exception {
+        TaskDAO dao = new TaskDAO();
+        List<Process> processes = ServiceManager.getProcessService().getAll();
+
+        List<Integer> rootIds = processes.stream()
+                .map(Process::getId)
+                .collect(Collectors.toList());
+
+        Map<Integer, EnumMap<TaskStatus, Integer>> actual =
+                dao.loadTaskStatusCountsForProcesses(rootIds);
+
+        for (Process root : processes) {
+            EnumMap<TaskStatus, Integer> expected = new EnumMap<>(TaskStatus.class);
+            for (TaskStatus s : TaskStatus.values()) {
+                expected.put(s, 0);
+            }
+            collectCounts(root, expected);
+            EnumMap<TaskStatus, Integer> actualCounts = actual.get(root.getId());
+            assertNotNull(actualCounts, "No result returned for process " + root.getId());
+
+            for (TaskStatus status : TaskStatus.values()) {
+                assertEquals(
+                        expected.get(status),
+                        actualCounts.get(status),
+                        "Mismatch for process " + root.getId() + " and status " + status
+                );
+            }
+        }
+    }
+
+    private void collectCounts(Process process, EnumMap<TaskStatus, Integer> counts) {
+        if (Objects.isNull(process)) {
+            return;
+        }
+        for (Task task : process.getTasks()) {
+            counts.merge(task.getProcessingStatus(), 1, Integer::sum);
+        }
+        if (Objects.nonNull(process.getChildren())) {
+            for (Process child : process.getChildren()) {
+                collectCounts(child, counts);
+            }
+        }
+    }
 }