RWA-4836 Adjust delay‑until calculation to count working days only. Update unit/integration tests and holiday stubs to match new behavior (#963)

* RWA-4836 Adjust delay‑until calculation to count working days only. Update unit/integration tests and holiday stubs to match new behavior

* RWA-4836 Increased test coverage.

* RWA-4836 Reworked code to make it SonaCloud compliant.

---------

Co-authored-by: Martin Spasov <martin.y.spasov@gmail.com>

Author: JasonPittockHMCTS

src/integrationTest/java/uk/gov/hmcts/reform/wacaseeventhandler/handlers/InitiationCaseEventHandlerTest.java

@@ -112,12 +112,10 @@ void should_handle_and_process_delay_until_set_to_holiday_as_next_working_day()
         when(isoDateFormatter.formatToZone(LocalDateTime.parse(EVENT_DATE)))
             .thenReturn(eventDateTime);
 
+        when(holidayService.isHoliday(any(ZonedDateTime.class))).thenReturn(false);
         when(holidayService.isHoliday(eventDateTime.plusDays(delayDuration)))
             .thenReturn(true);
 
-        when(holidayService.isHoliday(eventDateTime.plusDays(delayDuration + 1)))
-            .thenReturn(false);
-
         when(serviceAuthGenerator.generate())
             .thenReturn(SERVICE_AUTH_TOKEN);
 

src/integrationTest/java/uk/gov/hmcts/reform/wacaseeventhandler/services/DueDateServiceTest.java

@@ -42,6 +42,7 @@ void should_return_next_working_day_4_pm_when_calculated_due_date_matches_holida
 
         int workingDaysAllowed = 2;
 
+        when(holidayService.isHoliday(any(ZonedDateTime.class))).thenReturn(false);
         when(holidayService.isHoliday(eventDateTime.plusDays(1)))
             .thenReturn(true);
 
@@ -66,6 +67,7 @@ void should_return_next_working_day_4_pm_when_delay_date_matches_holiday() {
 
         int delayDuration = 2;
 
+        when(holidayService.isHoliday(any(ZonedDateTime.class))).thenReturn(false);
         when(holidayService.isHoliday(eventDateTime.plusDays(delayDuration)))
             .thenReturn(true);
 
@@ -74,9 +76,8 @@ void should_return_next_working_day_4_pm_when_delay_date_matches_holiday() {
         ZonedDateTime actualDateTime = dueDateService.calculateDelayUntil(eventDateTime, delayDuration);
 
         assertThat(actualDateTime, is(expectedDelayDateTime));
-        verify(holidayService, times(2)).isHoliday(any(ZonedDateTime.class));
+        verify(holidayService, times(3)).isHoliday(any(ZonedDateTime.class));
     }
 
 
 }
-

src/main/java/uk/gov/hmcts/reform/wacaseeventhandler/services/DueDateService.java

@@ -45,11 +45,13 @@ private ZonedDateTime addWorkingDays(ZonedDateTime dueDate, int numberOfDays) {
     }
 
     private ZonedDateTime addWorkingDaysForDelayDuration(ZonedDateTime eventDate, int delayDuration) {
-
-        ZonedDateTime newDate = eventDate.plusDays(delayDuration);
-
-        if (holidayService.isWeekend(newDate) || holidayService.isHoliday(newDate)) {
-            return addWorkingDaysForDelayDuration(eventDate, delayDuration + 1);
+        ZonedDateTime newDate = eventDate;
+        int remaining = delayDuration;
+        while (remaining > 0) {
+            newDate = newDate.plusDays(1);
+            if (!(holidayService.isWeekend(newDate) || holidayService.isHoliday(newDate))) {
+                remaining--;
+            }
         }
 
         return newDate;

src/test/java/uk/gov/hmcts/reform/wacaseeventhandler/services/DueDateServiceTest.java

@@ -19,6 +19,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
 @SuppressWarnings("PMD.JUnitAssertionsShouldIncludeMessage")
@@ -145,17 +146,46 @@ void should_return_event_date_when_delay_duration_is_0() {
         assertEquals(eventDate, actualDelayUntil);
     }
 
+    @Test
+    void should_not_call_holiday_service_when_delay_duration_is_0() {
+        ZonedDateTime eventDate = ZonedDateTime.of(2022, 7, 1, 9, 0, 0, 0, ZoneId.systemDefault());
+
+        ZonedDateTime actualDelayUntil = underTest.calculateDelayUntil(eventDate, 0);
+
+        assertEquals(eventDate, actualDelayUntil);
+        verifyNoInteractions(holidayService);
+    }
+
+    @Test
+    void should_return_event_date_when_add_working_days_for_delay_duration_is_0() throws Exception {
+        ZonedDateTime eventDate = ZonedDateTime.of(2022, 7, 1, 9, 0, 0, 0, ZoneId.systemDefault());
+
+        var method = DueDateService.class.getDeclaredMethod(
+            "addWorkingDaysForDelayDuration",
+            ZonedDateTime.class,
+            int.class
+        );
+        method.setAccessible(true);
+
+        ZonedDateTime actual = (ZonedDateTime) method.invoke(underTest, eventDate, 0);
+
+        assertEquals(eventDate, actual);
+        verifyNoInteractions(holidayService);
+    }
+
     @ParameterizedTest
     @ValueSource(ints = {1, 2, 3})
     void should_return_next_working_day_when_event_date_is_friday_and_has_delay_duration(int delayDuration) {
 
         ZonedDateTime eventDate = ZonedDateTime.of(2022, 7, 1, 9, 0, 0, 0, ZoneId.systemDefault());
 
-        ZonedDateTime expectedDueDateMonday = ZonedDateTime.of(2022, 7, 4, 16, 0, 0, 0, ZoneId.systemDefault());
+        ZonedDateTime expectedDelayUntilDate = eventDate
+            .plusDays(3 + (delayDuration - 1))
+            .withHour(16).withMinute(0).withSecond(0).withNano(0);
 
         ZonedDateTime actualDelayUntilDate = underTest.calculateDelayUntil(eventDate, delayDuration);
 
-        assertEquals(expectedDueDateMonday, actualDelayUntilDate);
+        assertEquals(expectedDelayUntilDate, actualDelayUntilDate);
     }
 
     @ParameterizedTest
@@ -166,11 +196,27 @@ void should_return_next_working_day_when_event_date_plus_delay_duration_matches_
         when(holidayService.isHoliday(eventDate.plusDays(3)))
             .thenReturn(true);
 
-        ZonedDateTime expectedDueDateMonday = ZonedDateTime.of(2022, 8, 30, 16, 0, 0, 0, ZoneId.systemDefault());
+        ZonedDateTime expectedDelayUntilDate = ZonedDateTime.of(2022, 8, 30, 16, 0, 0, 0, ZoneId.systemDefault())
+            .plusDays(delayDuration - 1L);
 
         ZonedDateTime actualDelayUntilDate = underTest.calculateDelayUntil(eventDate, delayDuration);
 
-        assertEquals(expectedDueDateMonday, actualDelayUntilDate);
+        assertEquals(expectedDelayUntilDate, actualDelayUntilDate);
+    }
+
+    @Test
+    void should_skip_weekend_and_holiday_when_calculating_delay_duration() {
+        ZonedDateTime eventDate = ZonedDateTime.of(2022, 8, 25, 9, 0, 0, 0, ZoneId.systemDefault());
+
+        when(holidayService.isHoliday(any(ZonedDateTime.class))).thenReturn(false);
+        when(holidayService.isHoliday(ZonedDateTime.of(2022, 8, 29, 9, 0, 0, 0, ZoneId.systemDefault())))
+            .thenReturn(true);
+
+        ZonedDateTime expectedDelayUntilDate = ZonedDateTime.of(2022, 8, 31, 16, 0, 0, 0, ZoneId.systemDefault());
+
+        ZonedDateTime actualDelayUntilDate = underTest.calculateDelayUntil(eventDate, 3);
+
+        assertEquals(expectedDelayUntilDate, actualDelayUntilDate);
     }
 
     private void checkWorkingDays(ZonedDateTime startDay, int leadTimeDays, ZonedDateTime expectedDueDate) {
@@ -202,7 +248,7 @@ private static Stream<ZonedDateTimeScenario> scenarioProvider() {
                     ZonedDateTime.of(2021, 3, 1, 16, 0, 0, 0, ZoneId.systemDefault()))
                 .days(18)
                 .expectedDateTime(
-                    ZonedDateTime.of(2021, 3, 19, 16, 0, 0, 0, ZoneId.systemDefault()))
+                    ZonedDateTime.of(2021, 3, 25, 16, 0, 0, 0, ZoneId.systemDefault()))
                 .build(),
 
             ZonedDateTimeScenario.builder()
@@ -226,15 +272,15 @@ private static Stream<ZonedDateTimeScenario> scenarioProvider() {
                     ZonedDateTime.of(2021, 3, 1, 16, 0, 0, 0, ZoneId.systemDefault()))
                 .days(30)
                 .expectedDateTime(
-                    ZonedDateTime.of(2021, 3, 31, 16, 0, 0, 0, ZoneId.systemDefault()))
+                    ZonedDateTime.of(2021, 4, 12, 16, 0, 0, 0, ZoneId.systemDefault()))
                 .build(),
 
             ZonedDateTimeScenario.builder()
                 .actualDateTime(
                     ZonedDateTime.of(2021, 3, 1, 16, 0, 0, 0, ZoneId.systemDefault()))
                 .days(31)
                 .expectedDateTime(
-                    ZonedDateTime.of(2021, 4, 1, 16, 0, 0, 0, ZoneId.systemDefault()))
+                    ZonedDateTime.of(2021, 4, 13, 16, 0, 0, 0, ZoneId.systemDefault()))
                 .build()
         );
     }