Revising TaskHandlerRegistry unit tests and remaining handler etc tests

Author: timan-z

springqpro-backend/src/test/java/com/springqprobackend/springqpro/handlers/DefaultHandlerTests.java

@@ -14,44 +14,46 @@
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
 
 /* NOTE: I basically only have two types of Handlers defined as of this moment.
 The variation you see in DefaultHandler mimicked across other Handlers w/ different sleep times.
 -- Picking DefaultHandler specifically since it's the *default* Handler I'll always have regardless of refactoring, etc.
 */
 @ExtendWith(MockitoExtension.class)
-public class DefaultHandlerTests {
-    private Sleeper fastSleeper;
-    private DefaultHandler handler;
-    private Task t;
+class DefaultHandlerTests {
+
+    @Mock
+    private Sleeper sleeper;
 
     @Mock
     private TaskHandlerProperties props;
 
+    private DefaultHandler handler;
+
+    private Task task;
+
     @BeforeEach
     void setUp() {
-        /* NOTE: Very important is the line of code beneath this comment!
-        We're basically overriding the "RealSleeper" implementation of the Sleeper interface here
-        by using fastSleeper instead. Below is a lambda expression that implements Sleeper (functional interface),
-        which says that this Sleeper implementation takes some "long" var and just does nothing (doesn't actually sleep).
-        So we essentially skip the .sleep part of the Handler execution and skip straight to the followup logic. */
-        fastSleeper = millis -> {};
         when(props.getDefaultSleepTime()).thenReturn(2000L);
-        handler = new DefaultHandler(fastSleeper, props);
-        t = new Task();
-        t.setId("Task-ArbitraryTaskId");
-        t.setType(TaskType.valueOf("TEST"));
+        handler = new DefaultHandler(sleeper, props);
+
+        task = new Task();
+        task.setId("Task-ArbitraryTaskId");
+        task.setType(TaskType.EMAIL);
+    }
+
+    @Test
+    void handle_shouldInvokeSleeperWithConfiguredDelay() throws InterruptedException {
+        handler.handle(task);
+
+        verify(sleeper).sleep(2000L);
     }
 
-    /* 2025-11-20-EDIT: This file and DefaultHandlerTests.java is outdated, relying on the old project architecture
-    before any of the refactoring related to ProcessingService.java */
-    @Disabled
     @Test
-    void handle_shouldSet_TaskCompleted() throws InterruptedException {
-        handler.handle(t);
-        assertEquals(TaskStatus.COMPLETED, t.getStatus());
+    void handle_shouldNotThrow() {
+        assertDoesNotThrow(() -> handler.handle(task));
     }
 }

springqpro-backend/src/test/java/com/springqprobackend/springqpro/handlers/FailHandlerTests.java

@@ -1,5 +1,7 @@
 package com.springqprobackend.springqpro.handlers;
 
+// 2026-01-16-NOTE: Reinforcing the comment below; handlers just simulate worktime nothing else (deprecating this file).
+
 // 2025-11-30-NOTE: Basically shouldn't be testing Handlers anymore. This is kept for my documentation stuff.
 
 /* NOTE: Testing my FailHandler implementation of the TaskHandler class is a little bit tricky.
@@ -30,6 +32,7 @@ Now, instead of declaring a new Random() variable in function, it's a class fiel
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.Mockito.*;
 
+@Deprecated
 @ExtendWith(MockitoExtension.class)
 public class FailHandlerTests {
     @Mock

springqpro-backend/src/test/java/com/springqprobackend/springqpro/models/TaskHandlerRegistryTests.java

@@ -7,10 +7,13 @@ implement the interface are injected. That means that no mocks are needed here (
 import com.springqprobackend.springqpro.handlers.TaskHandler;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 
 import java.util.HashMap;
 import java.util.Map;
 
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.Mockito.mock;
 
@@ -19,44 +22,48 @@ implement the interface are injected. That means that no mocks are needed here (
 - Returns DefaultHandler if type is missing.
 - getAllHandlers() exposes all of the handlers.
 */
-public class TaskHandlerRegistryTests {
+class TaskHandlerRegistryTests {
+
+    @Mock
     private TaskHandler defaultHandler;
-    private Map<String, TaskHandler> map;
 
     @BeforeEach
     void setUp() {
-        defaultHandler = mock(TaskHandler.class);
-        //map = Map.of("DEFAULT", defaultHandler);
-        map = new HashMap<>();
-        map.put("DEFAULT", defaultHandler);
+        MockitoAnnotations.openMocks(this);
     }
 
     @Test
-    void getHandler_returns_correctHandler() {
+    void getHandler_returnsCorrectHandler_whenHandlerExists() {
         TaskHandler emailHandler = mock(TaskHandler.class);
-        /*TaskHandler defaultHandler = mock(TaskHandler.class);
-        Map<String, TaskHandler> map = Map.of(
-                "EMAIL", emailHandler,
-                "DEFAULT", defaultHandler
-        );*/
-        map.put("EMAIL", emailHandler);
-        TaskHandlerRegistry registry = new TaskHandlerRegistry(map);
-        assertEquals(emailHandler, registry.getHandler("EMAIL"));
+
+        Map<String, TaskHandler> handlers = new HashMap<>();
+        handlers.put("DEFAULT", defaultHandler);
+        handlers.put("EMAIL", emailHandler);
+
+        TaskHandlerRegistry registry = new TaskHandlerRegistry(handlers);
+
+        assertThat(registry.getHandler("EMAIL")).isEqualTo(emailHandler);
     }
 
     @Test
-    void unknownHandler_defaultsTo_defaultHandler() {
-        /*TaskHandler defaultHandler = mock(TaskHandler.class);
-        Map<String, TaskHandler> map = Map.of(
+    void getHandler_fallsBackToDefault_whenHandlerIsUnknown() {
+        Map<String, TaskHandler> handlers = Map.of(
                 "DEFAULT", defaultHandler
-        );*/
-        TaskHandlerRegistry registry = new TaskHandlerRegistry(map);
-        assertEquals(defaultHandler, registry.getHandler("IDONTKNOW"));
+        );
+
+        TaskHandlerRegistry registry = new TaskHandlerRegistry(handlers);
+
+        assertThat(registry.getHandler("IDONTKNOW")).isEqualTo(defaultHandler);
     }
 
     @Test
-    void getAllHandlers_returns_injectedMap() {
-        TaskHandlerRegistry registry = new TaskHandlerRegistry(map);
-        assertEquals(map, registry.getAllHandlers());
+    void getAllHandlers_returnsInjectedHandlerMap() {
+        Map<String, TaskHandler> handlers = Map.of(
+                "DEFAULT", defaultHandler
+        );
+
+        TaskHandlerRegistry registry = new TaskHandlerRegistry(handlers);
+
+        assertThat(registry.getAllHandlers()).isEqualTo(handlers);
     }
 }

springqpro-backend/src/test/java/com/springqprobackend/springqpro/runtime/WorkerTests.java

@@ -14,13 +14,16 @@
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
+// 2026-01-16-NOTE: Completely outdated.
+
 /* NOTE: This function got much simpler after adding the TaskHandlerRegistry and global exception
 handler. Writing tests should be relatively simple.
 Again:
 - More on different assert methods: https://www.baeldung.com/junit-assertions
 */
 // commit test
 
+@Deprecated
 @ExtendWith(MockitoExtension.class)
 public class WorkerTests {
     @Mock

springqpro-backend/src/test/java/com/springqprobackend/springqpro/service/QueueServiceTests.java

@@ -35,6 +35,7 @@
 - HandlerRegistry fallback — test that when no handler exists, the default handler runs.
 */
 
+@Deprecated
 @ExtendWith(MockitoExtension.class)
 public class QueueServiceTests {