Merge pull request finos#1463 from grahampacker-ms/add-constraints-to-standards

grahampacker-ms · web-flow · commit 7a9b55dfc198 · 2025-07-24T16:00:16.000+01:00
Adding constrainst to Standards resource (finos#761)
diff --git a/calm-hub/src/main/java/org/finos/calm/resources/StandardResource.java b/calm-hub/src/main/java/org/finos/calm/resources/StandardResource.java
@@ -1,5 +1,6 @@
 package org.finos.calm.resources;
 
+import jakarta.validation.constraints.Pattern;
 import jakarta.ws.rs.*;
 import jakarta.ws.rs.core.MediaType;
 import jakarta.ws.rs.core.Response;
@@ -19,12 +20,17 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 
+import static org.finos.calm.resources.ResourceValidationConstants.NAMESPACE_MESSAGE;
+import static org.finos.calm.resources.ResourceValidationConstants.NAMESPACE_REGEX;
+import static org.finos.calm.resources.ResourceValidationConstants.VERSION_MESSAGE;
+import static org.finos.calm.resources.ResourceValidationConstants.VERSION_REGEX;
+
 @Path("calm/namespaces")
 public class StandardResource {
 
     private final StandardStore standardStore;
 
-    private final Logger logger = LoggerFactory.getLogger(StandardStore.class);
+    private final Logger logger = LoggerFactory.getLogger(StandardResource.class);
 
     public StandardResource(StandardStore standardStore) {
         this.standardStore = standardStore;
@@ -34,7 +40,9 @@ public StandardResource(StandardStore standardStore) {
     @Path("{namespace}/standards")
     @Produces(MediaType.APPLICATION_JSON)
     @PermittedScopes({CalmHubScopes.ARCHITECTURES_ALL, CalmHubScopes.ARCHITECTURES_READ})
-    public Response getStandardsForNamespace(@PathParam("namespace") String namespace) {
+    public Response getStandardsForNamespace(
+            @PathParam("namespace") @Pattern(regexp = NAMESPACE_REGEX, message = NAMESPACE_MESSAGE) String namespace
+    ) {
         try {
             return Response.ok(new ValueWrapper<>(standardStore.getStandardsForNamespace(namespace))).build();
         } catch (NamespaceNotFoundException e) {
@@ -48,7 +56,10 @@ public Response getStandardsForNamespace(@PathParam("namespace") String namespac
     @Produces(MediaType.APPLICATION_JSON)
     @Consumes(MediaType.APPLICATION_JSON)
     @PermittedScopes({CalmHubScopes.ARCHITECTURES_ALL, CalmHubScopes.ARCHITECTURES_READ})
-    public Response createStandardForNamespace(@PathParam("namespace") String namespace, CreateStandardRequest standard) throws URISyntaxException {
+    public Response createStandardForNamespace(
+            @PathParam("namespace") @Pattern(regexp = NAMESPACE_REGEX, message = NAMESPACE_MESSAGE) String namespace,
+            CreateStandardRequest standard
+    ) throws URISyntaxException {
         try {
             Standard createdStandard = standardStore.createStandardForNamespace(standard, namespace);
             return Response.created(new URI("/calm/namespaces/" + namespace + "/standards/" + createdStandard.getId() + "/versions/1.0.0")).build();
@@ -62,7 +73,10 @@ public Response createStandardForNamespace(@PathParam("namespace") String namesp
     @Path("{namespace}/standards/{standardId}/versions")
     @Produces(MediaType.APPLICATION_JSON)
     @PermittedScopes({CalmHubScopes.ARCHITECTURES_ALL, CalmHubScopes.ARCHITECTURES_READ})
-    public Response getStandardVersions(@PathParam("namespace") String namespace, @PathParam("standardId") Integer standardId) {
+    public Response getStandardVersions(
+            @PathParam("namespace") @Pattern(regexp = NAMESPACE_REGEX, message = NAMESPACE_MESSAGE) String namespace,
+            @PathParam("standardId") Integer standardId
+    ) {
         try {
             return Response.ok(new ValueWrapper<>(standardStore.getStandardVersions(namespace, standardId))).build();
         } catch (NamespaceNotFoundException e) {
@@ -78,8 +92,11 @@ public Response getStandardVersions(@PathParam("namespace") String namespace, @P
     @Path("{namespace}/standards/{standardId}/versions/{version}")
     @Produces(MediaType.APPLICATION_JSON)
     @PermittedScopes({CalmHubScopes.ARCHITECTURES_ALL, CalmHubScopes.ARCHITECTURES_READ})
-    public Response getStandardForVersion(@PathParam("namespace") String namespace, @PathParam("standardId") Integer standardId,
-                                          @PathParam("version") String version) {
+    public Response getStandardForVersion(
+            @PathParam("namespace") @Pattern(regexp = NAMESPACE_REGEX, message = NAMESPACE_MESSAGE) String namespace,
+            @PathParam("standardId") Integer standardId,
+            @PathParam("version") @Pattern(regexp = VERSION_REGEX, message = VERSION_MESSAGE) String version
+    ) {
         try {
             return Response.ok(standardStore.getStandardForVersion(namespace, standardId, version)).build();
         } catch (StandardNotFoundException e) {
@@ -99,8 +116,12 @@ public Response getStandardForVersion(@PathParam("namespace") String namespace,
     @Produces(MediaType.APPLICATION_JSON)
     @Consumes(MediaType.APPLICATION_JSON)
     @PermittedScopes({CalmHubScopes.ARCHITECTURES_ALL, CalmHubScopes.ARCHITECTURES_READ})
-    public Response createStandardForVersion(@PathParam("namespace") String namespace, @PathParam("standardId") Integer standardId,
-                                             @PathParam("version") String version, CreateStandardRequest createStandardRequest) throws URISyntaxException {
+    public Response createStandardForVersion(
+            @PathParam("namespace") @Pattern(regexp = NAMESPACE_REGEX, message = NAMESPACE_MESSAGE) String namespace,
+            @PathParam("standardId") Integer standardId,
+            @PathParam("version") @Pattern(regexp = VERSION_REGEX, message = VERSION_MESSAGE) String version,
+            CreateStandardRequest createStandardRequest
+    ) throws URISyntaxException {
 
         try {
             standardStore.createStandardForVersion(createStandardRequest, namespace, standardId, version);
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestStandardResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestStandardResourceShould.java
@@ -25,6 +25,8 @@
 import java.util.stream.Stream;
 
 import static io.restassured.RestAssured.given;
+import static org.finos.calm.resources.ResourceValidationConstants.NAMESPACE_MESSAGE;
+import static org.finos.calm.resources.ResourceValidationConstants.VERSION_MESSAGE;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
 import static org.mockito.ArgumentMatchers.anyString;
@@ -49,7 +51,7 @@ void beforeEach() {
     }
 
     @Test
-    void return_a_404_when_an_invalid_namespace_is_provided_on_get_standards() throws NamespaceNotFoundException {
+    void return_a_404_when_a_namespace_is_provided_that_does_not_exist_on_get_standards() throws NamespaceNotFoundException {
         when(mockStandardStore.getStandardsForNamespace(anyString())).thenThrow(new NamespaceNotFoundException());
 
         given()
@@ -61,6 +63,16 @@ void return_a_404_when_an_invalid_namespace_is_provided_on_get_standards() throw
         verify(mockStandardStore).getStandardsForNamespace("invalid");
     }
 
+    @Test
+    void return_a_400_when_an_invalid_namespace_is_provided_on_get_standards() {
+        given()
+                .when()
+                .get("/calm/namespaces/$$$$$/standards")
+                .then()
+                .statusCode(400)
+                .body(containsString(NAMESPACE_MESSAGE));
+    }
+
     @Test
     void return_list_of_standards_response_when_valid_namespace_provided_on_get_standards() throws NamespaceNotFoundException, JsonProcessingException {
         List<NamespaceStandardSummary> expectedStandardSummary = List.of(this.nistStandardSummary, this.finosStandardSummary);
@@ -81,7 +93,7 @@ void return_list_of_standards_response_when_valid_namespace_provided_on_get_stan
     }
 
     @Test
-    void return_a_404_when_invalid_namespace_is_provided_on_create_standards() throws NamespaceNotFoundException, JsonProcessingException {
+    void return_a_404_when_namespace_is_provided_that_does_not_exist_on_create_standards() throws NamespaceNotFoundException, JsonProcessingException {
         when(mockStandardStore.createStandardForNamespace(any(CreateStandardRequest.class), eq("invalid"))).thenThrow(new NamespaceNotFoundException());
         CreateStandardRequest createStandardRequest = new CreateStandardRequest();
         createStandardRequest.setName("nist");
@@ -99,6 +111,23 @@ void return_a_404_when_invalid_namespace_is_provided_on_create_standards() throw
         verify(mockStandardStore).createStandardForNamespace(createStandardRequest, "invalid");
     }
 
+    @Test
+    void return_a_400_when_invalid_namespace_is_provided_on_create_standards() throws JsonProcessingException {
+        CreateStandardRequest createStandardRequest = new CreateStandardRequest();
+        createStandardRequest.setName("nist");
+        createStandardRequest.setDescription("NIST Standard");
+        createStandardRequest.setStandardJson("{}");
+
+        given()
+                .header("Content-Type", "application/json")
+                .body(objectMapper.writeValueAsString(createStandardRequest))
+                .when()
+                .post("/calm/namespaces/$$$$$/standards")
+                .then()
+                .statusCode(400)
+                .body(containsString(NAMESPACE_MESSAGE));
+    }
+
     @Test
     void return_a_created_status_code_with_location_of_standard_when_creating_a_standard() throws NamespaceNotFoundException, JsonProcessingException {
         Standard storedNist = new Standard("nist", "NIST Standard", "{ \"test\": \"json\" }", 5, "1.0.0");
@@ -120,6 +149,16 @@ void return_a_created_status_code_with_location_of_standard_when_creating_a_stan
         verify(mockStandardStore).createStandardForNamespace(createStandardRequest, "valid");
     }
 
+    @Test
+    void return_400_when_invalid_namespace_provided_when_getting_versions_of_standard() {
+        given()
+                .when()
+                .get("/calm/namespaces/$$$$$/standards/5/versions")
+                .then()
+                .statusCode(400)
+                .body(containsString(NAMESPACE_MESSAGE));
+    }
+
     static Stream<Arguments> provideParametersForStandardVersionTests() {
         return Stream.of(
             Arguments.of("invalid", new NamespaceNotFoundException(), 404, "Invalid namespace provided"),
@@ -157,6 +196,26 @@ void respond_correctly_to_get_standard_versions_query(String namespace, Throwabl
         verify(mockStandardStore).getStandardVersions(namespace, 5);
     }
 
+    @Test
+    void return_400_when_invalid_namespace_provided_when_getting_version_of_standard() {
+        given()
+                .when()
+                .get("/calm/namespaces/$$$$/standards/5/versions/1.0.0")
+                .then()
+                .statusCode(400)
+                .body(containsString(NAMESPACE_MESSAGE));
+    }
+
+    @Test
+    void return_400_when_invalid_version_provided_when_getting_version_of_standard() {
+        given()
+                .when()
+                .get("/calm/namespaces/finos/standards/5/versions/invalid_version")
+                .then()
+                .statusCode(400)
+                .body(containsString(VERSION_MESSAGE));
+    }
+
     static Stream<Arguments> provideParametersForGetStandardTests() {
         return Stream.of(
           Arguments.of("invalid", new NamespaceNotFoundException(), 404),
@@ -197,6 +256,40 @@ void respond_to_get_standard_for_a_specific_version_correctly(String namespace,
         }
     }
 
+    @Test
+    void return_400_when_invalid_namespace_provided_when_creating_new_version_of_standard() {
+        CreateStandardRequest createStandardRequest = new CreateStandardRequest();
+        createStandardRequest.setName("amazing-standard");
+        createStandardRequest.setDescription("An amazing standard");
+        createStandardRequest.setStandardJson("{}");
+
+        given()
+                .header("Content-Type", "application/json")
+                .body(createStandardRequest)
+                .when()
+                .post("/calm/namespaces/$$$$/standards/5/versions/1.0.1")
+                .then()
+                .statusCode(400)
+                .body(containsString(NAMESPACE_MESSAGE));
+    }
+
+    @Test
+    void return_400_when_invalid_version_provided_when_creating_new_version_of_standard() {
+        CreateStandardRequest createStandardRequest = new CreateStandardRequest();
+        createStandardRequest.setName("amazing-standard");
+        createStandardRequest.setDescription("An amazing standard");
+        createStandardRequest.setStandardJson("{}");
+
+        given()
+                .header("Content-Type", "application/json")
+                .body(createStandardRequest)
+                .when()
+                .post("/calm/namespaces/finos/standards/5/versions/invalid-version")
+                .then()
+                .statusCode(400)
+                .body(containsString(VERSION_MESSAGE));
+    }
+
     static Stream<Arguments> provideParametersForCreateStandardTests() {
         return Stream.of(
                 Arguments.of("invalid", new NamespaceNotFoundException(), 404),
