Merge pull request #17 from hmcts/fix/fix-get-subscription

Fix/fix get subscription

Author: coling01

docs/debugging.md

@@ -0,0 +1,25 @@
+# Debugging
+
+The command below will post to create a subscription and return a clientSubscriptionId which can then be queried with GET
+```
+export PORT=4550
+export HOST="localhost:$PORT"
+curl -XPOST http://$HOST/client-subscriptions \
+    -H "Content-Type: application/json" \
+    -d '{"eventTypes":["PCR","CUSTODIAL_RESULT"],"notificationEndpoint":{"webhookUrl":"https://my-callback-url"}}'
+```
+
+... Creates and returns a subscription with a clientSubscriptionId 
+ie.
+```
+{"clientSubscriptionId":"585fde62-44df-4b3d-ac38-5e1f4d7669e3",
+    "createdAt":"2025-12-19T15:16:38.456506Z",
+    "eventTypes":["CUSTODIAL_RESULT","PCR"],
+    "notificationEndpoint":{"webhookUrl":"https://my-callback-url"},"updatedAt":"2025-12-19T15:16:38.456772Z"}
+```
+
+Query
+```
+export SUBSCRIPTION_ID="585fde62-44df-4b3d-ac38-5e1f4d7669e3"
+curl http://$HOST/client-subscriptions/$SUBSCRIPTION_ID
+```

src/apiTest/java/uk/gov/hmcts/cp/subscription/http/ActuatorApiTest.java

@@ -15,17 +15,6 @@ class ActuatorApiTest {
     private final String baseUrl = System.getProperty("app.baseUrl", "http://localhost:8082");
     private final RestTemplate http = new RestTemplate();
 
-    @Test
-    void root_endpoint_should_be_ok() {
-        final ResponseEntity<String> res = http.exchange(
-                baseUrl + "/", HttpMethod.GET,
-                new HttpEntity<>(new HttpHeaders()),
-                String.class
-        );
-        assertThat(res.getStatusCode()).isEqualTo(HttpStatus.OK);
-        assertThat(res.getBody()).contains("DEPRECATED root endpoint");
-    }
-
     @Test
     void health_endpoint_should_be_up() {
         final ResponseEntity<String> res = http.exchange(

src/apiTest/java/uk/gov/hmcts/cp/subscription/http/RootApiTest.java

@@ -0,0 +1,28 @@
+package uk.gov.hmcts.cp.subscription.http;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class RootApiTest {
+
+    private final String baseUrl = System.getProperty("app.baseUrl", "http://localhost:8082");
+    private final RestTemplate http = new RestTemplate();
+
+    @Test
+    void root_endpoint_should_be_ok() throws InterruptedException {
+        final ResponseEntity<String> res = http.exchange(
+                baseUrl + "/", HttpMethod.GET,
+                new HttpEntity<>(new HttpHeaders()),
+                String.class
+        );
+        assertThat(res.getStatusCode()).isEqualTo(HttpStatus.OK);
+        assertThat(res.getBody()).contains("DEPRECATED root endpoint");
+    }
+}

src/apiTest/java/uk/gov/hmcts/cp/subscription/http/SubscriptionApiTest.java

@@ -0,0 +1,54 @@
+package uk.gov.hmcts.cp.subscription.http;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * This is a bit verbose and not using sensible plugins to log, parse response etc
+ * This is because these tests run inside the app context. But we dont want to bloat the app with configs or plugins
+ * that are needed for api-test
+ * We need to decide how to run api-tests against built docker file.
+ * Probably best as a separate app with its own gradle build
+ */
+class SubscriptionApiTest {
+    private final String baseUrl = System.getProperty("app.baseUrl", "http://localhost:8082");
+    private final RestTemplate http = new RestTemplate();
+
+    @Test
+    void round_trip_subscription_should_work_ok() throws InterruptedException {
+        final String postUrl = String.format("%s/client-subscriptions", baseUrl);
+        final HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        final String body = "{\"eventTypes\":[\"PCR\",\"CUSTODIAL_RESULT\"],\n" +
+                "\"notificationEndpoint\":{\"webhookUrl\":\"https://my-callback-url\"}}";
+        final ResponseEntity<String> postResult = http.exchange(
+                postUrl,
+                HttpMethod.POST,
+                new HttpEntity<>(body, headers),
+                String.class
+        );
+        assertThat(postResult.getStatusCode()).isEqualTo(HttpStatus.CREATED);
+        assertThat(postResult.getBody()).contains("clientSubscriptionId");
+        final String subscriptionId = postResult.getBody()
+                .replaceAll(".*clientSubscriptionId\":\"", "")
+                .replaceAll("\".*$", "");
+
+        final String getUrl = String.format("%s/client-subscriptions/%s", baseUrl, subscriptionId);
+        final ResponseEntity<String> getResult = http.exchange(
+                getUrl,
+                HttpMethod.GET,
+                new HttpEntity<>(new HttpHeaders()),
+                String.class
+        );
+        assertThat(getResult.getStatusCode()).isEqualTo(HttpStatus.OK);
+        assertThat(getResult.getBody()).contains("clientSubscriptionId\":\"" + subscriptionId);
+    }
+}

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
+    public ClockService clockService() {
+        return new ClockService(Clock.systemDefaultZone());
+    }
+}

src/main/java/uk/gov/hmcts/cp/subscription/controllers/GlobalExceptionHandler.java

@@ -0,0 +1,40 @@
+package uk.gov.hmcts.cp.subscription.controllers;
+
+import jakarta.persistence.EntityNotFoundException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.client.HttpClientErrorException;
+
+@RestControllerAdvice
+@Slf4j
+public class GlobalExceptionHandler {
+
+    private static final String NOT_FOUND_MESSAGE = "No row with the given identifier exists";
+
+    @ExceptionHandler(EntityNotFoundException.class)
+    public ResponseEntity<String> handleNotFoundException(final EntityNotFoundException exception) {
+        log.error("NotFoundException {}", exception.getMessage());
+        return ResponseEntity
+                .status(HttpStatus.NOT_FOUND)
+                .body(NOT_FOUND_MESSAGE);
+    }
+
+    @ExceptionHandler(HttpClientErrorException.class)
+    public ResponseEntity<String> handleClientException(final HttpClientErrorException exception) {
+        log.error("HttpClientErrorException {}", exception.getMessage());
+        return ResponseEntity
+                .status(exception.getStatusCode())
+                .body(exception.getMessage());
+    }
+
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<String> handleUnknownException(final Exception exception) {
+        log.error("Exception {}", exception.getMessage());
+        return ResponseEntity
+                .status(HttpStatus.INTERNAL_SERVER_ERROR)
+                .body(exception.getMessage());
+    }
+}

src/main/java/uk/gov/hmcts/cp/subscription/controllers/SubscriptionController.java

@@ -4,6 +4,7 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.bind.annotation.RestController;
 import uk.gov.hmcts.cp.openapi.api.SubscriptionApi;
 import uk.gov.hmcts.cp.openapi.model.ClientSubscription;
@@ -22,6 +23,7 @@ public class SubscriptionController implements SubscriptionApi {
     private static final String CLIENT_ID = "TODO";
 
     @Override
+    @Transactional
     public ResponseEntity<ClientSubscription> createClientSubscription(final ClientSubscriptionRequest request) {
         log.info("createClientSubscription clientId:{}", CLIENT_ID);
         final ClientSubscription response = subscriptionService.saveSubscription(request);
@@ -30,20 +32,23 @@ public ResponseEntity<ClientSubscription> createClientSubscription(final ClientS
     }
 
     @Override
+    @Transactional
     public ResponseEntity<ClientSubscription> updateClientSubscription(final UUID clientSubscriptionId, final ClientSubscriptionRequest request) {
         log.info("updateClientSubscription clientSubscriptionId:{} clientId:{}", clientSubscriptionId, CLIENT_ID);
         final ClientSubscription response = subscriptionService.updateSubscription(clientSubscriptionId, request);
         return new ResponseEntity<>(response, HttpStatus.OK);
     }
 
     @Override
+    @Transactional
     public ResponseEntity<ClientSubscription> getClientSubscription(final UUID clientSubscriptionId) {
         log.info("getClientSubscription clientSubscriptionId:{} clientId:{}", clientSubscriptionId, CLIENT_ID);
         final ClientSubscription response = subscriptionService.getSubscription(clientSubscriptionId);
         return new ResponseEntity<>(response, HttpStatus.OK);
     }
 
     @Override
+    @Transactional
     public ResponseEntity<Void> deleteClientSubscription(final UUID clientSubscriptionId) {
         log.info("deleteClientSubscription clientSubscriptionId:{} clientId:{}", clientSubscriptionId, CLIENT_ID);
         subscriptionService.deleteSubscription(clientSubscriptionId);

src/main/java/uk/gov/hmcts/cp/subscription/entities/ClientSubscriptionEntity.java

@@ -1,6 +1,8 @@
 package uk.gov.hmcts.cp.subscription.entities;
 
 import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
@@ -28,6 +30,7 @@ public class ClientSubscriptionEntity {
     private UUID id;
 
     private String notificationEndpoint;
+    @Enumerated(EnumType.STRING)
     private List<EntityEventType> eventTypes;
     private OffsetDateTime createdAt;
     private OffsetDateTime updatedAt;

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 {
+
+    private Clock clock;
+
+    public OffsetDateTime now() {
+        return clock.instant().atOffset(ZoneOffset.UTC);
+    }
+}