fix: added clock service to allow easy injection of clock now()

Discussed with Samir last week who agreed that it was a sensible thing to do to make testing easier
( Dont think it will fix the resolution issue on int test though )

Author: coling01

src/main/java/uk/gov/hmcts/cp/subscription/config/AppConfig.java

@@ -0,0 +1,16 @@
+package uk.gov.hmcts.cp.subscription.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import uk.gov.hmcts.cp.subscription.services.ClockService;
+
+import java.time.Clock;
+
+@Configuration
+public class AppConfig {
+
+    @Bean
+    ClockService clockService() {
+        return new ClockService(Clock.systemDefaultZone());
+    }
+}

src/main/java/uk/gov/hmcts/cp/subscription/mappers/SubscriptionMapper.java

@@ -1,5 +1,6 @@
 package uk.gov.hmcts.cp.subscription.mappers;
 
+import org.mapstruct.Context;
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
 import org.mapstruct.Named;
@@ -9,6 +10,7 @@
 import uk.gov.hmcts.cp.openapi.model.NotificationEndpoint;
 import uk.gov.hmcts.cp.subscription.entities.ClientSubscriptionEntity;
 import uk.gov.hmcts.cp.subscription.model.EntityEventType;
+import uk.gov.hmcts.cp.subscription.services.ClockService;
 
 import java.util.List;
 
@@ -20,16 +22,16 @@ public interface SubscriptionMapper {
     @Mapping(target = "id", expression = "java(null)")
     @Mapping(source = "request.eventTypes", target = "eventTypes", qualifiedByName = "mapWithSortedEventTypes")
     @Mapping(source = "request.notificationEndpoint", target = "notificationEndpoint", qualifiedByName = "mapFromNotificationEndpoint")
-    @Mapping(target = "createdAt", expression = "java(java.time.OffsetDateTime.now())")
-    @Mapping(target = "updatedAt", expression = "java(java.time.OffsetDateTime.now())")
-    ClientSubscriptionEntity mapCreateRequestToEntity(ClientSubscriptionRequest request);
+    @Mapping(target = "createdAt", expression = "java(clockService.now())")
+    @Mapping(target = "updatedAt", expression = "java(clockService.now())")
+    ClientSubscriptionEntity mapCreateRequestToEntity(@Context ClockService clockService, ClientSubscriptionRequest request);
 
     @Mapping(source = "existing.id", target = "id")
     @Mapping(source = "request.eventTypes", target = "eventTypes", qualifiedByName = "mapWithSortedEventTypes")
     @Mapping(source = "request.notificationEndpoint", target = "notificationEndpoint", qualifiedByName = "mapFromNotificationEndpoint")
     @Mapping(source = "existing.createdAt", target = "createdAt")
-    @Mapping(expression = "java(java.time.OffsetDateTime.now())", target = "updatedAt")
-    ClientSubscriptionEntity mapUpdateRequestToEntity(ClientSubscriptionEntity existing, ClientSubscriptionRequest request);
+    @Mapping(expression = "java(clockService.now())", target = "updatedAt")
+    ClientSubscriptionEntity mapUpdateRequestToEntity(@Context ClockService clockService, ClientSubscriptionEntity existing, ClientSubscriptionRequest request);
 
     @Mapping(source = "id", target = "clientSubscriptionId")
     ClientSubscription mapEntityToResponse(ClientSubscriptionEntity entity);

src/main/java/uk/gov/hmcts/cp/subscription/services/ClockService.java

@@ -0,0 +1,22 @@
+package uk.gov.hmcts.cp.subscription.services;
+
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.time.Clock;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+
+@Service
+@AllArgsConstructor
+/**
+ * We use a ClockService to expose the clock time in a simple method to allow mocking in Tests
+ */
+public class ClockService {
+
+    Clock clock;
+
+    public OffsetDateTime now() {
+        return clock.instant().atOffset(ZoneOffset.UTC);
+    }
+}

src/main/java/uk/gov/hmcts/cp/subscription/services/SubscriptionService.java

@@ -16,17 +16,18 @@
 @Slf4j
 public class SubscriptionService {
 
+    private final ClockService clockService;
     private final SubscriptionRepository subscriptionRepository;
     private final SubscriptionMapper mapper;
 
     public ClientSubscription saveSubscription(final ClientSubscriptionRequest request) {
-        final ClientSubscriptionEntity entity = mapper.mapCreateRequestToEntity(request);
+        final ClientSubscriptionEntity entity = mapper.mapCreateRequestToEntity(clockService, request);
         return mapper.mapEntityToResponse(subscriptionRepository.save(entity));
     }
 
     public ClientSubscription updateSubscription(final UUID clientSubscriptionId, final ClientSubscriptionRequest request) {
         final ClientSubscriptionEntity existing = subscriptionRepository.getReferenceById(clientSubscriptionId);
-        final ClientSubscriptionEntity entity = mapper.mapUpdateRequestToEntity(existing, request);
+        final ClientSubscriptionEntity entity = mapper.mapUpdateRequestToEntity(clockService, existing, request);
         return mapper.mapEntityToResponse(subscriptionRepository.save(entity));
     }
 

src/test/java/uk/gov/hmcts/cp/subscription/mappers/SubscriptionMapperTest.java

@@ -1,47 +1,59 @@
 package uk.gov.hmcts.cp.subscription.mappers;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
 import uk.gov.hmcts.cp.openapi.model.ClientSubscription;
 import uk.gov.hmcts.cp.openapi.model.ClientSubscriptionRequest;
 import uk.gov.hmcts.cp.openapi.model.NotificationEndpoint;
 import uk.gov.hmcts.cp.subscription.entities.ClientSubscriptionEntity;
 import uk.gov.hmcts.cp.subscription.model.EntityEventType;
+import uk.gov.hmcts.cp.subscription.services.ClockService;
 
 import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
 import static uk.gov.hmcts.cp.openapi.model.EventType.CUSTODIAL_RESULT;
 import static uk.gov.hmcts.cp.openapi.model.EventType.PCR;
 
+@ExtendWith(MockitoExtension.class)
 class SubscriptionMapperTest {
 
+    private final static OffsetDateTime MOCKCREATED = OffsetDateTime.of(2025, 12, 1, 11, 30, 50, 582007048, ZoneOffset.UTC);
+    private final static OffsetDateTime MOCKUPDATED = OffsetDateTime.of(2025, 12, 2, 12, 40, 55, 234567890, ZoneOffset.UTC);
+
+    @Mock
+    ClockService clockService;
+
     SubscriptionMapper mapper = new SubscriptionMapperImpl();
 
     UUID clientSubscriptionId = UUID.fromString("d730c6e1-66ba-4ef0-a3dd-0b9928faa76d");
     NotificationEndpoint notificationEndpoint = NotificationEndpoint.builder()
             .webhookUrl("https://example.com")
             .build();
-    OffsetDateTime createdAt = OffsetDateTime.now().minusDays(2);
-    OffsetDateTime updatedAt = OffsetDateTime.now().minusHours(2);
     ClientSubscriptionEntity existing = ClientSubscriptionEntity.builder()
             .id(clientSubscriptionId)
             .notificationEndpoint(notificationEndpoint.getWebhookUrl().toString())
             .eventTypes(mutableLisOfEventTypes())
-            .createdAt(createdAt)
-            .updatedAt(updatedAt)
+            .createdAt(MOCKCREATED)
+            .updatedAt(MOCKCREATED)
             .build();
 
     @Test
     void create_request_should_map_to_entity_with_sorted_types() {
+        when(clockService.now()).thenReturn(MOCKCREATED);
         ClientSubscriptionRequest request = ClientSubscriptionRequest.builder()
                 .notificationEndpoint(notificationEndpoint)
                 .eventTypes(List.of(PCR, CUSTODIAL_RESULT))
                 .build();
 
-        ClientSubscriptionEntity entity = mapper.mapCreateRequestToEntity(request);
+        ClientSubscriptionEntity entity = mapper.mapCreateRequestToEntity(clockService, request);
 
         assertThat(entity.getId()).isNull();
         assertThat(entity.getNotificationEndpoint()).isEqualTo("https://example.com");
@@ -59,14 +71,14 @@ void update_request_should_map_to_entity_with_sorted_types() {
                 .notificationEndpoint(updatedEndpoint)
                 .eventTypes(List.of(CUSTODIAL_RESULT))
                 .build();
-
-        ClientSubscriptionEntity entity = mapper.mapUpdateRequestToEntity(existing, request);
+        when(clockService.now()).thenReturn(MOCKUPDATED);
+        ClientSubscriptionEntity entity = mapper.mapUpdateRequestToEntity(clockService, existing, request);
 
         assertThat(entity.getId()).isEqualTo(clientSubscriptionId);
         assertThat(entity.getNotificationEndpoint()).isEqualTo("https://updated.com");
         assertThat(entity.getEventTypes().toString()).isEqualTo("[CUSTODIAL_RESULT]");
-        assertThat(entity.getCreatedAt()).isEqualTo(createdAt);
-        assertThat(entity.getUpdatedAt()).isAfter(updatedAt);
+        assertThat(entity.getCreatedAt()).isEqualTo(MOCKCREATED);
+        assertThat(entity.getUpdatedAt()).isEqualTo(MOCKUPDATED);
     }
 
     @Test
@@ -76,8 +88,8 @@ void entity_should_map_to_response() {
         assertThat(subscription.getClientSubscriptionId()).isEqualTo(clientSubscriptionId);
         assertThat(subscription.getNotificationEndpoint()).isEqualTo(notificationEndpoint);
         assertThat(subscription.getEventTypes().toString()).isEqualTo("[CUSTODIAL_RESULT, PCR]");
-        assertThat(subscription.getCreatedAt()).isEqualTo(createdAt);
-        assertThat(subscription.getUpdatedAt()).isEqualTo(updatedAt);
+        assertThat(subscription.getCreatedAt()).isEqualTo(MOCKCREATED);
+        assertThat(subscription.getUpdatedAt()).isEqualTo(MOCKCREATED);
     }
 
     private List<EntityEventType> mutableLisOfEventTypes() {

src/test/java/uk/gov/hmcts/cp/subscription/services/SubscriptionServiceTest.java

@@ -21,6 +21,7 @@
 @ExtendWith(MockitoExtension.class)
 class SubscriptionServiceTest {
 
+    @Mock ClockService clockService;
     @Mock
     SubscriptionRepository subscriptionRepository;
     @Mock
@@ -38,21 +39,21 @@ class SubscriptionServiceTest {
 
     @Test
     void save_request_should_save_new_entity() {
-        when(mapper.mapCreateRequestToEntity(request)).thenReturn(requestEntity);
+        when(mapper.mapCreateRequestToEntity(clockService, request)).thenReturn(requestEntity);
         when(subscriptionRepository.save(requestEntity)).thenReturn(savedEntity);
         when(mapper.mapEntityToResponse(savedEntity)).thenReturn(response);
 
         ClientSubscription result = subscriptionService.saveSubscription(request);
 
-        verify(mapper).mapCreateRequestToEntity(request);
+        verify(mapper).mapCreateRequestToEntity(clockService, request);
         verify(subscriptionRepository).save(requestEntity);
         assertThat(result).isEqualTo(response);
     }
 
     @Test
     void update_request_should_update_existing_entity() {
         when(subscriptionRepository.getReferenceById(subscriptionId)).thenReturn(savedEntity);
-        when(mapper.mapUpdateRequestToEntity(savedEntity, request)).thenReturn(requestEntity);
+        when(mapper.mapUpdateRequestToEntity(clockService, savedEntity, request)).thenReturn(requestEntity);
         when(subscriptionRepository.save(requestEntity)).thenReturn(updatedEntity);
         when(mapper.mapEntityToResponse(updatedEntity)).thenReturn(response);