NOTE: My DefaultHandlerTests.java and FailHandlerTests.java file are outdated and need to be tweaked (they rely on the logic of the old architecture pre-ProcessingService.java refactor, they still check to see if the Handlers change Task status but that functionality has been moved to ProcessingService.java).

Author: timan-z

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

@@ -44,9 +44,12 @@ by using fastSleeper instead. Below is a lambda expression that implements Sleep
         t.setType(TaskType.valueOf("TEST"));
     }
 
-    @Test
+    /* 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 */
+
+    /*@Test
     void handle_shouldSet_TaskCompleted() throws InterruptedException {
         handler.handle(t);
         assertEquals(TaskStatus.COMPLETED, t.getStatus());
-    }
+    }*/
 }

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

@@ -54,10 +54,13 @@ void setUp() {
         mockSleeper = mock(Sleeper.class);  // both mock sleepers will be used for different methods.
     }
 
-    @Test
+    /* 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 */
+
+    /*@Test
     void failHandler_completes_failedTask() throws InterruptedException {
-        /* In my FailHandler.java class, I define successOdds as 0.25, so if I guarantee fixedRandom.nextDouble returns 0.1
-        (which obv <= 0.25, so I'm in the % interval where my random odds succeeded), then I can let failHandler complete this task: */
+         In my FailHandler.java class, I define successOdds as 0.25, so if I guarantee fixedRandom.nextDouble returns 0.1
+        (which obv <= 0.25, so I'm in the % interval where my random odds succeeded), then I can let failHandler complete this task:
         when(props.getFailSuccSleepTime()).thenReturn(2000L);
         when(fixedRandom.nextDouble()).thenReturn(0.1);
         FailHandler failHandler = new FailHandler(queue, fastSleeper, fixedRandom, props);
@@ -66,10 +69,10 @@ void failHandler_completes_failedTask() throws InterruptedException {
         // Assertions:
         assertEquals(TaskStatus.COMPLETED, t.getStatus());
         verify(queue, never()).retry(any(Task.class), anyInt());
-    }
+    }*/
 
     // This test case basically verifies that queue.retry(...) was called (when t.getAttempts() < t.getMaxRetries() and odds indicate no success).
-    @Test
+    /*@Test
     void failHandler_retries_failedTask() throws InterruptedException {
         when(props.getFailSleepTime()).thenReturn(1000L);
         when(fixedRandom.nextDouble()).thenReturn(0.9);
@@ -80,10 +83,10 @@ void failHandler_retries_failedTask() throws InterruptedException {
         failHandler.handle(t);
         assertEquals(TaskStatus.FAILED, t.getStatus());
         verify(queue, times(1)).retry(eq(t), eq(1000L));
-    }
+    }*/
 
     // This test case confirms that queue.retry(...) is not ran when (t.getAttempts >= t.getMaxRetries() and odds indicate no success).
-    @Test
+    /*@Test
     void failHandler_retires_maxFailedTask() throws InterruptedException {
         when(props.getFailSleepTime()).thenReturn(1000L);
         t.setAttempts(3);   // So, it goes straight to the failed if-condition branch.
@@ -92,26 +95,26 @@ void failHandler_retires_maxFailedTask() throws InterruptedException {
         failHandler.handle(t);
         assertEquals(TaskStatus.FAILED, t.getStatus());
         verify(queue, never()).retry(eq(t), eq(1000L));
-    }
+    }*/
 
     // More misc Tests:
     // Verify that the Sleeper.sleep(2000) call was invoked for a successful attempt:
-    @Test
+    /*@Test
     void failHandler_callsSleep_onSuccess() throws InterruptedException {
         when(props.getFailSuccSleepTime()).thenReturn(2000L);
         when(fixedRandom.nextDouble()).thenReturn(0.1);
         FailHandler failHandler = new FailHandler(queue, mockSleeper, fixedRandom, props);
         failHandler.handle(t);
         verify(mockSleeper, times(1)).sleep(2000L);
-    }
+    }*/
     // Verify that the Sleeper.sleep(1000) call happened on permanent failure branch:
-    @Test
+    /*@Test
     void failHandler_callsSleep_onPermFail() throws InterruptedException {
         when(props.getFailSleepTime()).thenReturn(1000L);
         t.setAttempts(3);
         when(fixedRandom.nextDouble()).thenReturn(0.9);
         FailHandler failHandler = new FailHandler(queue, mockSleeper, fixedRandom, props);
         failHandler.handle(t);
         verify(mockSleeper, times(1)).sleep(1000L);
-    }
+    }*/
 }