mutableDecorators = new ArrayList<>(decorators);
+ boolean removed = mutableDecorators.removeIf(
+ decoratorEntry -> Integer.valueOf(id).equals(decoratorEntry.get(DECORATOR_ID_FIELD, Integer.class)));
+ if (!removed) {
+ throw new DecoratorNotFoundException();
+ }
+
+ namespaceDoc.put(DECORATORS_FIELD, mutableDecorators);
+ decoratorCollection.update(namespaceDoc);
+ LOG.debug("Deleted decorator with ID {} in namespace '{}'", id, namespace);
+ } finally {
+ lock.unlock();
+ }
+ }
+
/**
* Fetches the namespace document from NitriteDB
*/
diff --git a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteFlowStore.java b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteFlowStore.java
index 2e4dec496..ebfe0786b 100644
--- a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteFlowStore.java
+++ b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteFlowStore.java
@@ -168,4 +168,13 @@ private void requireFlow(Flow flow) throws NamespaceNotFoundException, FlowNotFo
namespaceStore.requireNamespace(flow.getNamespace());
requireFlowExists(flow);
}
+
+ @Override
+ public void deleteFlow(String namespace, int flowId) throws NamespaceNotFoundException, FlowNotFoundException {
+ namespaceStore.requireNamespace(namespace);
+ if (!documentStore.deleteResource(namespace, flowId)) {
+ throw new FlowNotFoundException();
+ }
+ LOG.info("Deleted flow with ID {} from namespace '{}'", flowId, namespace);
+ }
}
diff --git a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteInterfaceStore.java b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteInterfaceStore.java
index ee3f1c0ad..b27b43ec4 100644
--- a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteInterfaceStore.java
+++ b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteInterfaceStore.java
@@ -157,4 +157,13 @@ private void requireInterface(String namespace, Integer interfaceId) throws Name
namespaceStore.requireNamespace(namespace);
requireInterfaceExists(namespace, interfaceId);
}
+
+ @Override
+ public void deleteInterface(String namespace, Integer interfaceId) throws NamespaceNotFoundException, InterfaceNotFoundException {
+ namespaceStore.requireNamespace(namespace);
+ if (!documentStore.deleteResource(namespace, interfaceId)) {
+ throw new InterfaceNotFoundException();
+ }
+ LOG.info("Deleted interface with ID {} from namespace '{}'", interfaceId, namespace);
+ }
}
diff --git a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitritePatternStore.java b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitritePatternStore.java
index d674fee70..58c1d644d 100644
--- a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitritePatternStore.java
+++ b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitritePatternStore.java
@@ -186,4 +186,13 @@ private void requirePattern(Pattern pattern) throws NamespaceNotFoundException,
namespaceStore.requireNamespace(pattern.getNamespace());
requirePatternExists(pattern);
}
+
+ @Override
+ public void deletePattern(String namespace, int patternId) throws NamespaceNotFoundException, PatternNotFoundException {
+ namespaceStore.requireNamespace(namespace);
+ if (!documentStore.deleteResource(namespace, patternId)) {
+ throw new PatternNotFoundException();
+ }
+ LOG.info("Deleted pattern with ID {} from namespace '{}'", patternId, namespace);
+ }
}
diff --git a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteResourceMappingStore.java b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteResourceMappingStore.java
index cd704b7e1..c9716fba7 100644
--- a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteResourceMappingStore.java
+++ b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteResourceMappingStore.java
@@ -215,4 +215,22 @@ public void deleteMapping(String namespace, ResourceType type, String customId)
lock.unlock();
}
}
+
+ @Override
+ public void deleteMappingByNumericId(String namespace, ResourceType type, int numericId) throws NamespaceNotFoundException {
+ namespaceStore.requireNamespace(namespace);
+
+ lock.lock();
+ try {
+ Filter filter = Filter.and(where(NAMESPACE_FIELD).eq(namespace),
+ where(RESOURCE_TYPE_FIELD).eq(type.name()),
+ where(NUMERIC_ID_FIELD).eq(numericId));
+ Document existing = mappingCollection.find(filter).firstOrNull();
+ if (existing != null) {
+ mappingCollection.remove(existing);
+ }
+ } finally {
+ lock.unlock();
+ }
+ }
}
diff --git a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteStandardStore.java b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteStandardStore.java
index 84d6420bf..37e3cb3cc 100644
--- a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteStandardStore.java
+++ b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteStandardStore.java
@@ -153,4 +153,13 @@ private void requireStandard(String namespace, Integer standardId) throws Namesp
namespaceStore.requireNamespace(namespace);
requireStandardExists(namespace, standardId);
}
+
+ @Override
+ public void deleteStandard(String namespace, Integer standardId) throws NamespaceNotFoundException, StandardNotFoundException {
+ namespaceStore.requireNamespace(namespace);
+ if (!documentStore.deleteResource(namespace, standardId)) {
+ throw new StandardNotFoundException();
+ }
+ LOG.info("Deleted standard with ID {} from namespace '{}'", standardId, namespace);
+ }
}
diff --git a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteTimelineStore.java b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteTimelineStore.java
index 352b9f634..0782123d0 100644
--- a/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteTimelineStore.java
+++ b/calm-hub/src/main/java/org/finos/calm/store/nitrite/NitriteTimelineStore.java
@@ -181,4 +181,13 @@ private void requireTimeline(Timeline timeline) throws NamespaceNotFoundExceptio
namespaceStore.requireNamespace(timeline.getNamespace());
requireTimelineExists(timeline);
}
+
+ @Override
+ public void deleteTimeline(String namespace, int timelineId) throws NamespaceNotFoundException, TimelineNotFoundException {
+ namespaceStore.requireNamespace(namespace);
+ if (!documentStore.deleteResource(namespace, timelineId)) {
+ throw new TimelineNotFoundException();
+ }
+ LOG.info("Deleted timeline with ID {} from namespace '{}'", timelineId, namespace);
+ }
}
diff --git a/calm-hub/src/main/java/org/finos/calm/store/util/MongoVersionDocumentStore.java b/calm-hub/src/main/java/org/finos/calm/store/util/MongoVersionDocumentStore.java
index c042d1104..91ea2fa6f 100644
--- a/calm-hub/src/main/java/org/finos/calm/store/util/MongoVersionDocumentStore.java
+++ b/calm-hub/src/main/java/org/finos/calm/store/util/MongoVersionDocumentStore.java
@@ -10,6 +10,7 @@
import com.mongodb.client.model.Sorts;
import com.mongodb.client.model.UpdateOptions;
import com.mongodb.client.model.Updates;
+import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.bson.Document;
import org.bson.conversions.Bson;
@@ -156,8 +157,9 @@ public void createHeader(String namespace, int resourceId, String name, String d
*
* The old shape pushed the resource and its first version in one document write, so
* a failure left nothing behind. Splitting them means a failed version write can strand
- * a header that no API can remove — there is no delete endpoint for these types — and it
- * would show up in listings and search with {@code versionCount: 0} forever.
+ * a header that no API can remove — this is a narrower operation than
+ * {@link #deleteResource}, the general-purpose delete — and it would show up in listings
+ * and search with {@code versionCount: 0} forever.
*
* Not a general-purpose delete: nothing else calls this, and it deliberately does not
* touch the version collection, because the only caller has just failed to write the
@@ -175,6 +177,31 @@ public void deleteHeader(String namespace, int resourceId) {
}
}
+ /**
+ * Deletes a resource entirely: its header and every version document. This is the
+ * general-purpose delete backing a DELETE endpoint — unlike {@link #deleteHeader}, a
+ * failure here is translated and thrown rather than swallowed, and the version
+ * collection is cleared too.
+ *
+ *
Versions are removed before the header, not after: if the version delete fails,
+ * the header is still there as evidence the resource exists, rather than leaving
+ * unreachable version documents behind under a header that's already gone.
+ *
+ * @return {@code true} if a header was actually deleted, {@code false} if none existed
+ * at this (namespace, resourceId) — lets the caller distinguish "already gone" from
+ * "removed".
+ */
+ public boolean deleteResource(String namespace, int resourceId) {
+ try {
+ versionCollection.deleteMany(headerFilter(namespace, resourceId));
+ DeleteResult result = headerCollection.deleteOne(headerFilter(namespace, resourceId));
+ return result.getDeletedCount() > 0;
+ } catch (MongoException e) {
+ LOG.error("Failed to delete resource [namespace={}, {}={}]", namespace, idField, resourceId, e);
+ throw StorageWriteException.writeFailed(e);
+ }
+ }
+
/**
* Writes the first version of a newly created resource, removing the header again if
* that fails, so a half-created resource never survives the request.
diff --git a/calm-hub/src/main/java/org/finos/calm/store/util/NitriteVersionDocumentStore.java b/calm-hub/src/main/java/org/finos/calm/store/util/NitriteVersionDocumentStore.java
index 44234f116..3f7d8a89f 100644
--- a/calm-hub/src/main/java/org/finos/calm/store/util/NitriteVersionDocumentStore.java
+++ b/calm-hub/src/main/java/org/finos/calm/store/util/NitriteVersionDocumentStore.java
@@ -156,6 +156,38 @@ public void deleteHeader(String namespace, int resourceId) {
}
}
+ /**
+ * Deletes a resource entirely: its header and every version document, under a single
+ * write lock so no concurrent read observes a header with no versions or vice versa.
+ * See {@link MongoVersionDocumentStore#deleteResource} — this is the general-purpose
+ * delete backing a DELETE endpoint, unlike {@link #deleteHeader}.
+ *
+ * @return {@code true} if a header was actually removed, {@code false} if none existed.
+ */
+ public boolean deleteResource(String namespace, int resourceId) {
+ lock.writeLock().lock();
+ try {
+ Filter filter = headerFilter(namespace, resourceId);
+ Document header = headerCollection.find(filter).firstOrNull();
+ if (header == null) {
+ return false;
+ }
+ // Materialize matches before removing — mutating the collection while its
+ // cursor is still being iterated is unsafe.
+ List versions = new ArrayList<>();
+ for (Document versionDocument : versionCollection.find(filter)) {
+ versions.add(versionDocument);
+ }
+ for (Document versionDocument : versions) {
+ versionCollection.remove(versionDocument);
+ }
+ headerCollection.remove(header);
+ return true;
+ } finally {
+ lock.writeLock().unlock();
+ }
+ }
+
/**
* Writes the first version of a newly created resource, removing the header again if
* that fails. See {@link MongoVersionDocumentStore#createFirstVersion} — the reasoning
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java
index f01a33301..ccd399b77 100644
--- a/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestAdrResourceShould.java
@@ -393,4 +393,27 @@ private void verifyExpectedGetAdr(String namespace) throws NamespaceNotFoundExce
verify(mockAdrStore, times(1)).getAdr(expectedAdrToRetrieveMeta);
}
+ static Stream provideParametersForDeleteAdrTests() {
+ return Stream.of(
+ Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+ Arguments.of("valid", new AdrNotFoundException(), 404),
+ Arguments.of("valid", null, 204)
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideParametersForDeleteAdrTests")
+ void respond_correctly_to_delete_adr(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws NamespaceNotFoundException, AdrNotFoundException {
+ if (exceptionToThrow != null) {
+ doThrow(exceptionToThrow).when(mockAdrStore).deleteAdr(namespace, 12);
+ }
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/" + namespace + "/adrs/12")
+ .then()
+ .statusCode(expectedStatusCode);
+
+ verify(mockAdrStore, times(1)).deleteAdr(namespace, 12);
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestArchitectureResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestArchitectureResourceShould.java
index 78a3ad1a1..837302150 100644
--- a/calm-hub/src/test/java/org/finos/calm/resources/TestArchitectureResourceShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestArchitectureResourceShould.java
@@ -7,6 +7,7 @@
import io.quarkus.test.security.TestSecurity;
import org.bson.json.JsonParseException;
import org.finos.calm.domain.Architecture;
+import org.finos.calm.domain.ResourceType;
import org.finos.calm.domain.architecture.ArchitectureRequest;
import org.finos.calm.domain.namespaces.NamespaceResourceSummary;
import org.finos.calm.domain.exception.ArchitectureNotFoundException;
@@ -485,6 +486,64 @@ void return_a_400_when_an_invalid_format_of_namespace_is_provided_on_get_archite
.body(containsString(NAMESPACE_MESSAGE));
}
+ @Test
+ void return_a_400_when_an_invalid_format_of_namespace_is_provided_on_delete_architecture() {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/fin_os/architectures/12")
+ .then()
+ .statusCode(400)
+ .body(containsString(NAMESPACE_MESSAGE));
+ }
+
+ static Stream provideParametersForDeleteArchitectureTests() {
+ return Stream.of(
+ Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+ Arguments.of("valid", new ArchitectureNotFoundException(), 404),
+ Arguments.of("valid", null, 204)
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideParametersForDeleteArchitectureTests")
+ void respond_correctly_to_delete_architecture(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws ArchitectureNotFoundException, NamespaceNotFoundException {
+ if (exceptionToThrow != null) {
+ doThrow(exceptionToThrow).when(mockArchitectureStore).deleteArchitecture(namespace, 12);
+ }
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/" + namespace + "/architectures/12")
+ .then()
+ .statusCode(expectedStatusCode);
+
+ verify(mockArchitectureStore, times(1)).deleteArchitecture(namespace, 12);
+ }
+
+ @Test
+ void delete_architecture_also_cleans_up_its_resource_mapping() throws Exception {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/valid/architectures/12")
+ .then()
+ .statusCode(204);
+
+ verify(mockResourceMappingStore, times(1)).deleteMappingByNumericId("valid", ResourceType.ARCHITECTURE, 12);
+ }
+
+ @Test
+ void not_clean_up_the_resource_mapping_when_deleting_a_missing_architecture() throws Exception {
+ doThrow(new ArchitectureNotFoundException()).when(mockArchitectureStore).deleteArchitecture("valid", 12);
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/valid/architectures/12")
+ .then()
+ .statusCode(404);
+
+ verifyNoInteractions(mockResourceMappingStore);
+ }
+
@Test
void return_an_implied_timeline_projection_when_architecture_has_versions() throws NamespaceNotFoundException, ArchitectureNotFoundException {
when(mockTimelineStore.getTimelinesForNamespace(any())).thenReturn(List.of());
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestControlResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestControlResourceShould.java
index c440a8a3b..2e8e39934 100644
--- a/calm-hub/src/test/java/org/finos/calm/resources/TestControlResourceShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestControlResourceShould.java
@@ -620,4 +620,74 @@ void respond_correctly_to_create_configuration_version(Throwable exceptionToThro
.statusCode(expectedStatusCode);
}
}
+
+ @Test
+ void return_a_400_when_an_invalid_format_of_domain_is_provided_on_delete_control_requirement() {
+ given()
+ .when()
+ .delete("/api/calm/domains/invalid_domain/controls/1")
+ .then()
+ .statusCode(400)
+ .body(containsString(DOMAIN_MESSAGE));
+ }
+
+ static Stream provideParametersForDeleteControlRequirementTests() {
+ return Stream.of(
+ Arguments.of(new DomainNotFoundException(INVALID_DOMAIN), 404),
+ Arguments.of(new ControlNotFoundException(), 404),
+ Arguments.of(new ControlHasConfigurationsException(1, 2), 409),
+ Arguments.of(null, 204)
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideParametersForDeleteControlRequirementTests")
+ void respond_correctly_to_delete_control_requirement(Throwable exceptionToThrow, int expectedStatusCode) throws Exception {
+ if (exceptionToThrow != null) {
+ doThrow(exceptionToThrow).when(mockControlStore).deleteControlRequirement(VALID_DOMAIN, 1);
+ }
+
+ given()
+ .when()
+ .delete("/api/calm/domains/" + VALID_DOMAIN + "/controls/1")
+ .then()
+ .statusCode(expectedStatusCode);
+
+ verify(mockControlStore, times(1)).deleteControlRequirement(VALID_DOMAIN, 1);
+ }
+
+ @Test
+ void return_a_400_when_an_invalid_format_of_domain_is_provided_on_delete_control_configuration() {
+ given()
+ .when()
+ .delete("/api/calm/domains/invalid_domain/controls/1/configurations/10")
+ .then()
+ .statusCode(400)
+ .body(containsString(DOMAIN_MESSAGE));
+ }
+
+ static Stream provideParametersForDeleteControlConfigurationTests() {
+ return Stream.of(
+ Arguments.of(new DomainNotFoundException(INVALID_DOMAIN), 404),
+ Arguments.of(new ControlNotFoundException(), 404),
+ Arguments.of(new ControlConfigurationNotFoundException(), 404),
+ Arguments.of(null, 204)
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideParametersForDeleteControlConfigurationTests")
+ void respond_correctly_to_delete_control_configuration(Throwable exceptionToThrow, int expectedStatusCode) throws Exception {
+ if (exceptionToThrow != null) {
+ doThrow(exceptionToThrow).when(mockControlStore).deleteControlConfiguration(VALID_DOMAIN, 1, 10);
+ }
+
+ given()
+ .when()
+ .delete("/api/calm/domains/" + VALID_DOMAIN + "/controls/1/configurations/10")
+ .then()
+ .statusCode(expectedStatusCode);
+
+ verify(mockControlStore, times(1)).deleteControlConfiguration(VALID_DOMAIN, 1, 10);
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestDecoratorResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestDecoratorResourceShould.java
index aaf617c2e..90456200e 100644
--- a/calm-hub/src/test/java/org/finos/calm/resources/TestDecoratorResourceShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestDecoratorResourceShould.java
@@ -676,4 +676,62 @@ void return_400_when_put_id_is_negative() {
.statusCode(400)
.body(containsString("ID must be a positive integer"));
}
+
+ // ---- DELETE /api/calm/namespaces/{namespace}/decorators/{id} ----
+
+ @Test
+ void return_204_when_decorator_deleted_successfully() throws Exception {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/finos/decorators/1")
+ .then()
+ .statusCode(204);
+
+ verify(decoratorStore, times(1)).deleteDecorator("finos", 1);
+ }
+
+ @Test
+ void return_404_when_decorator_not_found_for_delete() throws Exception {
+ doThrow(new DecoratorNotFoundException())
+ .when(decoratorStore).deleteDecorator(anyString(), anyInt());
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/finos/decorators/999")
+ .then()
+ .statusCode(404)
+ .body(containsString("Decorator with ID 999 does not exist in namespace: finos"));
+ }
+
+ @Test
+ void return_404_when_namespace_does_not_exist_for_delete_decorator() throws Exception {
+ doThrow(new NamespaceNotFoundException())
+ .when(decoratorStore).deleteDecorator(anyString(), anyInt());
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/invalid-namespace/decorators/1")
+ .then()
+ .statusCode(404);
+ }
+
+ @Test
+ void return_400_when_namespace_has_invalid_characters_for_delete_decorator() {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/invalid@namespace/decorators/1")
+ .then()
+ .statusCode(400)
+ .body(containsString("namespace must match pattern"));
+ }
+
+ @Test
+ void return_400_when_delete_id_is_zero() {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/test-namespace/decorators/0")
+ .then()
+ .statusCode(400)
+ .body(containsString("ID must be a positive integer"));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestFlowResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestFlowResourceShould.java
index 2dc4a522d..45e11d488 100644
--- a/calm-hub/src/test/java/org/finos/calm/resources/TestFlowResourceShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestFlowResourceShould.java
@@ -5,6 +5,7 @@
import io.quarkus.test.security.TestSecurity;
import org.bson.json.JsonParseException;
import org.finos.calm.domain.Flow;
+import org.finos.calm.domain.ResourceType;
import org.finos.calm.domain.exception.FlowNotFoundException;
import org.finos.calm.domain.exception.FlowVersionExistsException;
import org.finos.calm.domain.exception.FlowVersionNotFoundException;
@@ -23,6 +24,7 @@
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;
@@ -371,4 +373,62 @@ void return_forbidden_for_put_operations_on_flows_default_and_when_configured()
.then()
.statusCode(403);
}
+
+ @Test
+ void return_a_400_when_an_invalid_format_of_namespace_is_provided_on_delete_flow() {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/fin_os/flows/12")
+ .then()
+ .statusCode(400)
+ .body(containsString(NAMESPACE_MESSAGE));
+ }
+
+ static Stream provideParametersForDeleteFlowTests() {
+ return Stream.of(
+ Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+ Arguments.of("valid", new FlowNotFoundException(), 404),
+ Arguments.of("valid", null, 204)
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideParametersForDeleteFlowTests")
+ void respond_correctly_to_delete_flow(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws FlowNotFoundException, NamespaceNotFoundException {
+ if (exceptionToThrow != null) {
+ doThrow(exceptionToThrow).when(mockFlowStore).deleteFlow(namespace, 12);
+ }
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/" + namespace + "/flows/12")
+ .then()
+ .statusCode(expectedStatusCode);
+
+ verify(mockFlowStore, times(1)).deleteFlow(namespace, 12);
+ }
+
+ @Test
+ void delete_flow_also_cleans_up_its_resource_mapping() throws Exception {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/valid/flows/12")
+ .then()
+ .statusCode(204);
+
+ verify(mockResourceMappingStore, times(1)).deleteMappingByNumericId("valid", ResourceType.FLOW, 12);
+ }
+
+ @Test
+ void not_clean_up_the_resource_mapping_when_deleting_a_missing_flow() throws Exception {
+ doThrow(new FlowNotFoundException()).when(mockFlowStore).deleteFlow("valid", 12);
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/valid/flows/12")
+ .then()
+ .statusCode(404);
+
+ verifyNoInteractions(mockResourceMappingStore);
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestInterfaceResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestInterfaceResourceShould.java
index f92c7cc55..34e11e8ec 100644
--- a/calm-hub/src/test/java/org/finos/calm/resources/TestInterfaceResourceShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestInterfaceResourceShould.java
@@ -393,4 +393,62 @@ void respond_correctly_to_create_interfaces(String namespace, Throwable exceptio
verify(mockInterfaceStore, times(1)).createInterfaceForVersion(createInterfaceRequest, namespace, 5, "1.0.1");
}
+
+ @Test
+ void return_a_400_when_an_invalid_format_of_namespace_is_provided_on_delete_interface() {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/fin_os/interfaces/12")
+ .then()
+ .statusCode(400)
+ .body(containsString(NAMESPACE_MESSAGE));
+ }
+
+ static Stream provideParametersForDeleteInterfaceTests() {
+ return Stream.of(
+ Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+ Arguments.of("valid", new InterfaceNotFoundException(), 404),
+ Arguments.of("valid", null, 204)
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideParametersForDeleteInterfaceTests")
+ void respond_correctly_to_delete_interface(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws InterfaceNotFoundException, NamespaceNotFoundException {
+ if (exceptionToThrow != null) {
+ doThrow(exceptionToThrow).when(mockInterfaceStore).deleteInterface(namespace, 12);
+ }
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/" + namespace + "/interfaces/12")
+ .then()
+ .statusCode(expectedStatusCode);
+
+ verify(mockInterfaceStore, times(1)).deleteInterface(namespace, 12);
+ }
+
+ @Test
+ void delete_interface_also_cleans_up_its_resource_mapping() throws Exception {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/valid/interfaces/12")
+ .then()
+ .statusCode(204);
+
+ verify(mockResourceMappingStore, times(1)).deleteMappingByNumericId("valid", ResourceType.INTERFACE, 12);
+ }
+
+ @Test
+ void not_clean_up_the_resource_mapping_when_deleting_a_missing_interface() throws Exception {
+ doThrow(new InterfaceNotFoundException()).when(mockInterfaceStore).deleteInterface("valid", 12);
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/valid/interfaces/12")
+ .then()
+ .statusCode(404);
+
+ verifyNoInteractions(mockResourceMappingStore);
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestMappingCleanupShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestMappingCleanupShould.java
new file mode 100644
index 000000000..4ab29650e
--- /dev/null
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestMappingCleanupShould.java
@@ -0,0 +1,57 @@
+package org.finos.calm.resources;
+
+import org.finos.calm.domain.ResourceType;
+import org.finos.calm.domain.exception.NamespaceNotFoundException;
+import org.finos.calm.store.ResourceMappingStore;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.slf4j.Logger;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class TestMappingCleanupShould {
+
+ @Mock
+ private ResourceMappingStore mappingStore;
+
+ @Mock
+ private Logger logger;
+
+ @Test
+ void delete_the_mapping_by_numeric_id() throws NamespaceNotFoundException {
+ MappingCleanup.deleteMapping(mappingStore, logger, "finos", ResourceType.ARCHITECTURE, 42);
+
+ verify(mappingStore).deleteMappingByNumericId("finos", ResourceType.ARCHITECTURE, 42);
+ }
+
+ @Test
+ void log_rather_than_throw_when_the_namespace_has_vanished_mid_request() throws NamespaceNotFoundException {
+ // The resource is already deleted by the time this runs, so a failure to clean up its
+ // mapping must not fail the delete response over cleanup that can't be undone anyway.
+ doThrow(new NamespaceNotFoundException())
+ .when(mappingStore).deleteMappingByNumericId("finos", ResourceType.ARCHITECTURE, 42);
+
+ assertDoesNotThrow(() ->
+ MappingCleanup.deleteMapping(mappingStore, logger, "finos", ResourceType.ARCHITECTURE, 42));
+
+ verify(mappingStore).deleteMappingByNumericId("finos", ResourceType.ARCHITECTURE, 42);
+ }
+
+ @Test
+ void log_rather_than_throw_when_the_mapping_store_fails_at_runtime() throws NamespaceNotFoundException {
+ // A driver/DB failure (MongoException, a Nitrite lock/store error, ...) must not
+ // surface as an unhandled 500 for a delete that has already succeeded.
+ doThrow(new RuntimeException("connection reset"))
+ .when(mappingStore).deleteMappingByNumericId("finos", ResourceType.ARCHITECTURE, 42);
+
+ assertDoesNotThrow(() ->
+ MappingCleanup.deleteMapping(mappingStore, logger, "finos", ResourceType.ARCHITECTURE, 42));
+
+ verify(mappingStore).deleteMappingByNumericId("finos", ResourceType.ARCHITECTURE, 42);
+ }
+}
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestPatternResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestPatternResourceShould.java
index c2d8eac17..4dba94e64 100644
--- a/calm-hub/src/test/java/org/finos/calm/resources/TestPatternResourceShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestPatternResourceShould.java
@@ -474,4 +474,62 @@ void return_forbidden_for_put_operations_on_patterns_by_default_and_when_configu
.then()
.statusCode(403);
}
+
+ @Test
+ void return_a_400_when_an_invalid_format_of_namespace_is_provided_on_delete_pattern() {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/fin_os/patterns/12")
+ .then()
+ .statusCode(400)
+ .body(containsString(NAMESPACE_MESSAGE));
+ }
+
+ static Stream provideParametersForDeletePatternTests() {
+ return Stream.of(
+ Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+ Arguments.of("valid", new PatternNotFoundException(), 404),
+ Arguments.of("valid", null, 204)
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideParametersForDeletePatternTests")
+ void respond_correctly_to_delete_pattern(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws PatternNotFoundException, NamespaceNotFoundException {
+ if (exceptionToThrow != null) {
+ doThrow(exceptionToThrow).when(mockPatternStore).deletePattern(namespace, 12);
+ }
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/" + namespace + "/patterns/12")
+ .then()
+ .statusCode(expectedStatusCode);
+
+ verify(mockPatternStore, times(1)).deletePattern(namespace, 12);
+ }
+
+ @Test
+ void delete_pattern_also_cleans_up_its_resource_mapping() throws Exception {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/valid/patterns/12")
+ .then()
+ .statusCode(204);
+
+ verify(mockResourceMappingStore, times(1)).deleteMappingByNumericId("valid", ResourceType.PATTERN, 12);
+ }
+
+ @Test
+ void not_clean_up_the_resource_mapping_when_deleting_a_missing_pattern() throws Exception {
+ doThrow(new PatternNotFoundException()).when(mockPatternStore).deletePattern("valid", 12);
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/valid/patterns/12")
+ .then()
+ .statusCode(404);
+
+ verifyNoInteractions(mockResourceMappingStore);
+ }
}
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
index 7ecfd924a..7efb1c5c5 100644
--- a/calm-hub/src/test/java/org/finos/calm/resources/TestStandardResourceShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestStandardResourceShould.java
@@ -5,6 +5,7 @@
import io.quarkus.test.InjectMock;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.security.TestSecurity;
+import org.finos.calm.domain.ResourceType;
import org.finos.calm.domain.Standard;
import org.finos.calm.domain.exception.NamespaceNotFoundException;
import org.finos.calm.domain.exception.StandardNotFoundException;
@@ -349,4 +350,62 @@ void respond_correctly_to_create_standards(String namespace, Throwable exception
verify(mockStandardStore, times(1)).createStandardForVersion(createStandardRequest, namespace, 5, "1.0.1");
}
+
+ @Test
+ void return_a_400_when_an_invalid_format_of_namespace_is_provided_on_delete_standard() {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/fin_os/standards/12")
+ .then()
+ .statusCode(400)
+ .body(containsString(NAMESPACE_MESSAGE));
+ }
+
+ static Stream provideParametersForDeleteStandardTests() {
+ return Stream.of(
+ Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+ Arguments.of("valid", new StandardNotFoundException(), 404),
+ Arguments.of("valid", null, 204)
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideParametersForDeleteStandardTests")
+ void respond_correctly_to_delete_standard(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws StandardNotFoundException, NamespaceNotFoundException {
+ if (exceptionToThrow != null) {
+ doThrow(exceptionToThrow).when(mockStandardStore).deleteStandard(namespace, 12);
+ }
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/" + namespace + "/standards/12")
+ .then()
+ .statusCode(expectedStatusCode);
+
+ verify(mockStandardStore, times(1)).deleteStandard(namespace, 12);
+ }
+
+ @Test
+ void delete_standard_also_cleans_up_its_resource_mapping() throws Exception {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/valid/standards/12")
+ .then()
+ .statusCode(204);
+
+ verify(mockResourceMappingStore, times(1)).deleteMappingByNumericId("valid", ResourceType.STANDARD, 12);
+ }
+
+ @Test
+ void not_clean_up_the_resource_mapping_when_deleting_a_missing_standard() throws Exception {
+ doThrow(new StandardNotFoundException()).when(mockStandardStore).deleteStandard("valid", 12);
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/valid/standards/12")
+ .then()
+ .statusCode(404);
+
+ verifyNoInteractions(mockResourceMappingStore);
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/resources/TestTimelineResourceShould.java b/calm-hub/src/test/java/org/finos/calm/resources/TestTimelineResourceShould.java
index 747ea5c64..e3630f748 100644
--- a/calm-hub/src/test/java/org/finos/calm/resources/TestTimelineResourceShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/resources/TestTimelineResourceShould.java
@@ -326,4 +326,38 @@ void return_forbidden_for_put_operations_on_timelines_by_default() {
.then()
.statusCode(403);
}
+
+ @Test
+ void return_a_400_when_an_invalid_format_of_namespace_is_provided_on_delete_timeline() {
+ given()
+ .when()
+ .delete("/api/calm/namespaces/fin_os/timelines/12")
+ .then()
+ .statusCode(400)
+ .body(containsString(NAMESPACE_MESSAGE));
+ }
+
+ static Stream provideParametersForDeleteTimelineTests() {
+ return Stream.of(
+ Arguments.of("invalid", new NamespaceNotFoundException(), 404),
+ Arguments.of("valid", new TimelineNotFoundException(), 404),
+ Arguments.of("valid", null, 204)
+ );
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideParametersForDeleteTimelineTests")
+ void respond_correctly_to_delete_timeline(String namespace, Throwable exceptionToThrow, int expectedStatusCode) throws TimelineNotFoundException, NamespaceNotFoundException {
+ if (exceptionToThrow != null) {
+ doThrow(exceptionToThrow).when(mockTimelineStore).deleteTimeline(namespace, 12);
+ }
+
+ given()
+ .when()
+ .delete("/api/calm/namespaces/" + namespace + "/timelines/12")
+ .then()
+ .statusCode(expectedStatusCode);
+
+ verify(mockTimelineStore, times(1)).deleteTimeline(namespace, 12);
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/security/TestAuditRequestFilterShould.java b/calm-hub/src/test/java/org/finos/calm/security/TestAuditRequestFilterShould.java
index 4b9e62583..4e1ad1106 100644
--- a/calm-hub/src/test/java/org/finos/calm/security/TestAuditRequestFilterShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/security/TestAuditRequestFilterShould.java
@@ -429,6 +429,45 @@ void resolve_control_requirement_version_directly_from_path_params() {
assertThat(entry.getAction(), is(AuditAction.UPDATE));
}
+ @Test
+ void resolve_control_requirement_deletion_directly_from_path_params() {
+ when(resourceInfo.getResourceClass()).thenReturn((Class) ControlResource.class);
+ when(resourceInfo.getResourceMethod()).thenReturn(mockMethod(ControlResource.class, "deleteControlRequirement"));
+ MultivaluedMap pathParams = new MultivaluedHashMap<>();
+ pathParams.putSingle("domain", "payments");
+ pathParams.putSingle("controlId", "11");
+ ContainerRequestContext requestContext = mockRequest("DELETE", pathParams);
+ ContainerResponseContext responseContext = mockResponse(204, null);
+
+ filter.filter(requestContext, responseContext);
+
+ AuditLogEntry entry = captureRecordedEntry();
+ assertThat(entry.getEntityType(), is(AuditEntityType.CONTROL_REQUIREMENT));
+ assertThat(entry.getDomain(), is("payments"));
+ assertThat(entry.getEntityId(), is("11"));
+ assertThat(entry.getAction(), is(AuditAction.DELETE));
+ }
+
+ @Test
+ void resolve_control_configuration_deletion_directly_from_path_params() {
+ when(resourceInfo.getResourceClass()).thenReturn((Class) ControlResource.class);
+ when(resourceInfo.getResourceMethod()).thenReturn(mockMethod(ControlResource.class, "deleteControlConfiguration"));
+ MultivaluedMap pathParams = new MultivaluedHashMap<>();
+ pathParams.putSingle("domain", "payments");
+ pathParams.putSingle("controlId", "11");
+ pathParams.putSingle("configId", "3");
+ ContainerRequestContext requestContext = mockRequest("DELETE", pathParams);
+ ContainerResponseContext responseContext = mockResponse(204, null);
+
+ filter.filter(requestContext, responseContext);
+
+ AuditLogEntry entry = captureRecordedEntry();
+ assertThat(entry.getEntityType(), is(AuditEntityType.CONTROL_CONFIGURATION));
+ assertThat(entry.getDomain(), is("payments"));
+ assertThat(entry.getEntityId(), is("3"));
+ assertThat(entry.getAction(), is(AuditAction.DELETE));
+ }
+
// --- MappingControllerResource dispatch --------------------------------------
@Test
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java
index 385b65bc6..6021b7314 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoAdrStoreShould.java
@@ -8,6 +8,7 @@
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import io.quarkus.test.InjectMock;
import io.quarkus.test.junit.QuarkusTest;
@@ -455,4 +456,30 @@ void report_the_revision_already_exists_when_two_writers_race() throws Exception
assertThrows(AdrRevisionExistsException.class,
() -> store.updateAdrStatus(adrMeta(1, null), Status.accepted));
}
+
+ // --- deleteAdr ---
+
+ @Test
+ void throw_a_namespace_exception_when_deleting_an_adr_in_a_missing_namespace() {
+ when(namespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteAdr(NAMESPACE, ADR_ID));
+ }
+
+ @Test
+ void delete_the_header_and_all_revisions_when_the_adr_exists() throws Exception {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+
+ store.deleteAdr(NAMESPACE, ADR_ID);
+
+ verify(versionCollection).deleteMany(any(Bson.class));
+ verify(headerCollection).deleteOne(any(Bson.class));
+ }
+
+ @Test
+ void throw_an_adr_exception_when_deleting_a_missing_adr() {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(0));
+
+ assertThrows(AdrNotFoundException.class, () -> store.deleteAdr(NAMESPACE, ADR_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoArchitectureStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoArchitectureStoreShould.java
index 227913340..9e32c04f7 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoArchitectureStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoArchitectureStoreShould.java
@@ -7,6 +7,7 @@
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.UpdateOptions;
+import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import io.quarkus.test.InjectMock;
import io.quarkus.test.junit.QuarkusTest;
@@ -431,6 +432,32 @@ void report_a_plain_write_failure_for_other_version_write_errors() {
assertThat(exception.isCapacityExceeded(), is(false));
}
+ // --- deleteArchitecture ---
+
+ @Test
+ void throw_a_namespace_exception_when_deleting_an_architecture_in_a_missing_namespace() {
+ when(namespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteArchitecture(NAMESPACE, ARCHITECTURE_ID));
+ }
+
+ @Test
+ void delete_the_header_and_all_versions_when_the_architecture_exists() throws Exception {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+
+ store.deleteArchitecture(NAMESPACE, ARCHITECTURE_ID);
+
+ verify(versionCollection).deleteMany(any(Bson.class));
+ verify(headerCollection).deleteOne(any(Bson.class));
+ }
+
+ @Test
+ void throw_an_architecture_exception_when_deleting_a_missing_architecture() {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(0));
+
+ assertThrows(ArchitectureNotFoundException.class, () -> store.deleteArchitecture(NAMESPACE, ARCHITECTURE_ID));
+ }
+
@Test
void page_the_summary_window_at_the_database() throws NamespaceNotFoundException {
FindIterable iterable = stubFind(headerCollection, List.of());
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoControlStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoControlStoreShould.java
index 027010ed5..7c5555995 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoControlStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoControlStoreShould.java
@@ -6,6 +6,7 @@
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import io.quarkus.test.InjectMock;
import io.quarkus.test.junit.QuarkusTest;
@@ -19,6 +20,7 @@
import org.finos.calm.domain.exception.ControlConfigurationNotFoundException;
import org.finos.calm.domain.exception.ControlConfigurationVersionExistsException;
import org.finos.calm.domain.exception.ControlConfigurationVersionNotFoundException;
+import org.finos.calm.domain.exception.ControlHasConfigurationsException;
import org.finos.calm.domain.exception.ControlNotFoundException;
import org.finos.calm.domain.exception.ControlRequirementVersionExistsException;
import org.finos.calm.domain.exception.ControlRequirementVersionNotFoundException;
@@ -38,6 +40,7 @@
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -581,4 +584,78 @@ void create_configuration_for_version_never_syncs_name_or_description_onto_the_h
verify(configHeaders, Mockito.times(1)).updateOne(any(Bson.class), any(Bson.class));
}
+
+ // --- deleteControlRequirement ---
+
+ @Test
+ void throw_a_domain_exception_when_deleting_a_control_requirement_in_a_missing_domain() {
+ assertThrows(DomainNotFoundException.class, () -> store.deleteControlRequirement("invalid", CONTROL_ID));
+ }
+
+ @Test
+ void throw_a_control_exception_when_deleting_a_missing_control_requirement() {
+ controlDoesNotExist();
+
+ assertThrows(ControlNotFoundException.class, () -> store.deleteControlRequirement(DOMAIN, CONTROL_ID));
+ }
+
+ @Test
+ void refuse_to_delete_a_control_requirement_that_still_has_configurations() {
+ controlExists();
+ when(configHeaders.countDocuments(any(Bson.class))).thenReturn(2L);
+
+ ControlHasConfigurationsException exception = assertThrows(ControlHasConfigurationsException.class,
+ () -> store.deleteControlRequirement(DOMAIN, CONTROL_ID));
+ assertThat(exception.getControlId(), is(CONTROL_ID));
+ assertThat(exception.getConfigurationCount(), is(2));
+ verify(controlHeaders, never()).deleteOne(any(Bson.class));
+ }
+
+ @Test
+ void delete_the_requirement_header_and_all_versions_when_it_has_no_configurations() throws Exception {
+ controlExists();
+ when(configHeaders.countDocuments(any(Bson.class))).thenReturn(0L);
+ when(controlHeaders.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+
+ store.deleteControlRequirement(DOMAIN, CONTROL_ID);
+
+ verify(controlVersions).deleteMany(any(Bson.class));
+ verify(controlHeaders).deleteOne(any(Bson.class));
+ }
+
+ // --- deleteControlConfiguration ---
+
+ @Test
+ void throw_a_domain_exception_when_deleting_a_configuration_in_a_missing_domain() {
+ assertThrows(DomainNotFoundException.class,
+ () -> store.deleteControlConfiguration("invalid", CONTROL_ID, CONFIGURATION_ID));
+ }
+
+ @Test
+ void throw_a_control_exception_when_deleting_a_configuration_for_a_missing_control() {
+ controlDoesNotExist();
+
+ assertThrows(ControlNotFoundException.class,
+ () -> store.deleteControlConfiguration(DOMAIN, CONTROL_ID, CONFIGURATION_ID));
+ }
+
+ @Test
+ void throw_a_configuration_exception_when_deleting_a_missing_configuration() {
+ controlExists();
+ stubFind(configHeaders, List.of());
+
+ assertThrows(ControlConfigurationNotFoundException.class,
+ () -> store.deleteControlConfiguration(DOMAIN, CONTROL_ID, CONFIGURATION_ID));
+ }
+
+ @Test
+ void delete_the_configuration_header_and_all_versions_when_it_exists() throws Exception {
+ configurationExists();
+ when(configHeaders.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+
+ store.deleteControlConfiguration(DOMAIN, CONTROL_ID, CONFIGURATION_ID);
+
+ verify(configVersions).deleteMany(any(Bson.class));
+ verify(configHeaders).deleteOne(any(Bson.class));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoDecoratorStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoDecoratorStoreShould.java
index 31ba3de82..85f9c0452 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoDecoratorStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoDecoratorStoreShould.java
@@ -728,4 +728,58 @@ void should_throw_namespace_not_found_when_updating_decorator_in_unknown_namespa
verify(namespaceStore).namespaceExists(namespace);
verify(decoratorCollection, never()).updateOne(any(Bson.class), any(Bson.class));
}
+
+ @Test
+ void should_delete_decorator_successfully() throws Exception {
+ // Given
+ String namespace = "finos";
+ int decoratorId = 1;
+
+ when(namespaceStore.namespaceExists(namespace)).thenReturn(true);
+
+ UpdateResult updateResult = mock(UpdateResult.class);
+ when(updateResult.getModifiedCount()).thenReturn(1L);
+ when(decoratorCollection.updateOne(any(Bson.class), any(Bson.class))).thenReturn(updateResult);
+
+ // When
+ decoratorStore.deleteDecorator(namespace, decoratorId);
+
+ // Then
+ verify(namespaceStore).namespaceExists(namespace);
+ verify(decoratorCollection).updateOne(any(Bson.class), any(Bson.class));
+ }
+
+ @Test
+ void should_throw_decorator_not_found_when_delete_matches_nothing() {
+ // Given
+ String namespace = "finos";
+ int decoratorId = 99;
+
+ when(namespaceStore.namespaceExists(namespace)).thenReturn(true);
+
+ UpdateResult updateResult = mock(UpdateResult.class);
+ when(updateResult.getModifiedCount()).thenReturn(0L);
+ when(decoratorCollection.updateOne(any(Bson.class), any(Bson.class))).thenReturn(updateResult);
+
+ // When & Then
+ assertThrows(DecoratorNotFoundException.class,
+ () -> decoratorStore.deleteDecorator(namespace, decoratorId));
+
+ verify(namespaceStore).namespaceExists(namespace);
+ verify(decoratorCollection).updateOne(any(Bson.class), any(Bson.class));
+ }
+
+ @Test
+ void should_throw_namespace_not_found_when_deleting_decorator_in_unknown_namespace() {
+ // Given
+ String namespace = "unknown-namespace";
+ when(namespaceStore.namespaceExists(namespace)).thenReturn(false);
+
+ // When & Then
+ assertThrows(NamespaceNotFoundException.class,
+ () -> decoratorStore.deleteDecorator(namespace, 1));
+
+ verify(namespaceStore).namespaceExists(namespace);
+ verify(decoratorCollection, never()).updateOne(any(Bson.class), any(Bson.class));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoFlowStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoFlowStoreShould.java
index a66401bca..0db7f214d 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoFlowStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoFlowStoreShould.java
@@ -7,6 +7,7 @@
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.UpdateOptions;
+import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import io.quarkus.test.InjectMock;
import io.quarkus.test.junit.QuarkusTest;
@@ -412,4 +413,30 @@ void report_a_plain_write_failure_for_other_version_write_errors() {
() -> store.updateFlowForVersion(flow("1.0.1")));
assertThat(exception.isCapacityExceeded(), is(false));
}
+
+ // --- deleteFlow ---
+
+ @Test
+ void throw_a_namespace_exception_when_deleting_a_flow_in_a_missing_namespace() {
+ when(namespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteFlow(NAMESPACE, FLOW_ID));
+ }
+
+ @Test
+ void delete_the_header_and_all_versions_when_the_flow_exists() throws Exception {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+
+ store.deleteFlow(NAMESPACE, FLOW_ID);
+
+ verify(versionCollection).deleteMany(any(Bson.class));
+ verify(headerCollection).deleteOne(any(Bson.class));
+ }
+
+ @Test
+ void throw_a_flow_exception_when_deleting_a_missing_flow() {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(0));
+
+ assertThrows(FlowNotFoundException.class, () -> store.deleteFlow(NAMESPACE, FLOW_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoInterfaceStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoInterfaceStoreShould.java
index 3d293fcc6..5ca717515 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoInterfaceStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoInterfaceStoreShould.java
@@ -6,6 +6,7 @@
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import io.quarkus.test.InjectMock;
import io.quarkus.test.junit.QuarkusTest;
@@ -294,4 +295,30 @@ void overwrite_the_header_details_even_when_blank() throws Exception {
// which guarded them. Preserved rather than harmonised — see the store's javadoc.
verify(headerCollection, Mockito.times(2)).updateOne(any(Bson.class), any(Bson.class));
}
+
+ // --- deleteInterface ---
+
+ @Test
+ void throw_a_namespace_exception_when_deleting_an_interface_in_a_missing_namespace() {
+ when(namespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteInterface(NAMESPACE, INTERFACE_ID));
+ }
+
+ @Test
+ void delete_the_header_and_all_versions_when_the_interface_exists() throws Exception {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+
+ store.deleteInterface(NAMESPACE, INTERFACE_ID);
+
+ verify(versionCollection).deleteMany(any(Bson.class));
+ verify(headerCollection).deleteOne(any(Bson.class));
+ }
+
+ @Test
+ void throw_an_interface_exception_when_deleting_a_missing_interface() {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(0));
+
+ assertThrows(InterfaceNotFoundException.class, () -> store.deleteInterface(NAMESPACE, INTERFACE_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoPatternStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoPatternStoreShould.java
index 5c6ef6d0b..72bd0c527 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoPatternStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoPatternStoreShould.java
@@ -7,6 +7,7 @@
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.UpdateOptions;
+import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import io.quarkus.test.InjectMock;
import io.quarkus.test.junit.QuarkusTest;
@@ -178,6 +179,32 @@ void fall_back_to_a_generated_name_for_headers_missing_one() throws NamespaceNot
new NamespaceResourceSummary("Pattern 7", "", 7, 0)));
}
+ // --- deletePattern ---
+
+ @Test
+ void throw_a_namespace_exception_when_deleting_a_pattern_in_a_missing_namespace() {
+ when(namespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deletePattern(NAMESPACE, PATTERN_ID));
+ }
+
+ @Test
+ void delete_the_header_and_all_versions_when_the_pattern_exists() throws Exception {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+
+ store.deletePattern(NAMESPACE, PATTERN_ID);
+
+ verify(versionCollection).deleteMany(any(Bson.class));
+ verify(headerCollection).deleteOne(any(Bson.class));
+ }
+
+ @Test
+ void throw_a_pattern_exception_when_deleting_a_missing_pattern() {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(0));
+
+ assertThrows(PatternNotFoundException.class, () -> store.deletePattern(NAMESPACE, PATTERN_ID));
+ }
+
@Test
void page_the_summary_window_at_the_database() throws NamespaceNotFoundException {
FindIterable iterable = stubFind(headerCollection, List.of());
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoResourceMappingStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoResourceMappingStoreShould.java
index 737090354..6967e2c26 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoResourceMappingStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoResourceMappingStoreShould.java
@@ -365,6 +365,44 @@ void throw_namespace_not_found_on_delete_when_namespace_does_not_exist() {
() -> store.deleteMapping("invalid", ResourceType.PATTERN, "test"));
}
+ // --- deleteMappingByNumericId ---
+
+ @Test
+ void delete_mapping_by_numeric_id_successfully() throws NamespaceNotFoundException {
+ when(namespaceStore.namespaceExists("finos")).thenReturn(true);
+
+ var deleteResult = Mockito.mock(com.mongodb.client.result.DeleteResult.class);
+ when(deleteResult.getDeletedCount()).thenReturn(1L);
+ when(mappingCollection.deleteOne(any(org.bson.conversions.Bson.class))).thenReturn(deleteResult);
+
+ store.deleteMappingByNumericId("finos", ResourceType.PATTERN, 42);
+
+ verify(mappingCollection).deleteOne(any(org.bson.conversions.Bson.class));
+ }
+
+ @Test
+ void not_throw_when_deleting_a_mapping_by_numeric_id_that_does_not_exist() throws NamespaceNotFoundException {
+ // Most resources have no custom-id mapping at all — this must be a silent no-op, not
+ // an error, so a resource delete can call it unconditionally.
+ when(namespaceStore.namespaceExists("finos")).thenReturn(true);
+
+ var deleteResult = Mockito.mock(com.mongodb.client.result.DeleteResult.class);
+ when(deleteResult.getDeletedCount()).thenReturn(0L);
+ when(mappingCollection.deleteOne(any(org.bson.conversions.Bson.class))).thenReturn(deleteResult);
+
+ store.deleteMappingByNumericId("finos", ResourceType.PATTERN, 999);
+
+ verify(mappingCollection).deleteOne(any(org.bson.conversions.Bson.class));
+ }
+
+ @Test
+ void throw_namespace_not_found_when_deleting_a_mapping_by_numeric_id_in_a_missing_namespace() {
+ when(namespaceStore.namespaceExists("invalid")).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class,
+ () -> store.deleteMappingByNumericId("invalid", ResourceType.PATTERN, 42));
+ }
+
// --- Helper interfaces for Mockito generics ---
private interface DocumentMongoCollection extends MongoCollection {
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoStandardStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoStandardStoreShould.java
index dfc7703cb..c8a64ddd4 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoStandardStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoStandardStoreShould.java
@@ -6,6 +6,7 @@
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import io.quarkus.test.InjectMock;
import io.quarkus.test.junit.QuarkusTest;
@@ -294,4 +295,30 @@ void overwrite_the_header_details_even_when_blank() throws Exception {
// which guarded them. Preserved rather than harmonised — see the store's javadoc.
verify(headerCollection, Mockito.times(2)).updateOne(any(Bson.class), any(Bson.class));
}
+
+ // --- deleteStandard ---
+
+ @Test
+ void throw_a_namespace_exception_when_deleting_a_standard_in_a_missing_namespace() {
+ when(namespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteStandard(NAMESPACE, STANDARD_ID));
+ }
+
+ @Test
+ void delete_the_header_and_all_versions_when_the_standard_exists() throws Exception {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+
+ store.deleteStandard(NAMESPACE, STANDARD_ID);
+
+ verify(versionCollection).deleteMany(any(Bson.class));
+ verify(headerCollection).deleteOne(any(Bson.class));
+ }
+
+ @Test
+ void throw_a_standard_exception_when_deleting_a_missing_standard() {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(0));
+
+ assertThrows(StandardNotFoundException.class, () -> store.deleteStandard(NAMESPACE, STANDARD_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoTimelineStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoTimelineStoreShould.java
index 971051c43..6b0f760b9 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoTimelineStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/mongo/TestMongoTimelineStoreShould.java
@@ -7,6 +7,7 @@
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.UpdateOptions;
+import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import io.quarkus.test.InjectMock;
import io.quarkus.test.junit.QuarkusTest;
@@ -412,4 +413,30 @@ void report_a_plain_write_failure_for_other_version_write_errors() {
() -> store.updateTimelineForVersion(timeline("1.0.1")));
assertThat(exception.isCapacityExceeded(), is(false));
}
+
+ // --- deleteTimeline ---
+
+ @Test
+ void throw_a_namespace_exception_when_deleting_a_timeline_in_a_missing_namespace() {
+ when(namespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteTimeline(NAMESPACE, TIMELINE_ID));
+ }
+
+ @Test
+ void delete_the_header_and_all_versions_when_the_timeline_exists() throws Exception {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+
+ store.deleteTimeline(NAMESPACE, TIMELINE_ID);
+
+ verify(versionCollection).deleteMany(any(Bson.class));
+ verify(headerCollection).deleteOne(any(Bson.class));
+ }
+
+ @Test
+ void throw_a_timeline_exception_when_deleting_a_missing_timeline() {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(0));
+
+ assertThrows(TimelineNotFoundException.class, () -> store.deleteTimeline(NAMESPACE, TIMELINE_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteAdrStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteAdrStoreShould.java
index e0deb388d..0cf931f63 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteAdrStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteAdrStoreShould.java
@@ -382,4 +382,33 @@ public void report_the_revision_already_exists_when_two_writers_race() throws Ex
assertThrows(AdrRevisionExistsException.class,
() -> store.updateAdrStatus(adrMeta(1, null), Status.accepted));
}
+
+ // --- deleteAdr ---
+
+ @Test
+ void throw_a_namespace_exception_when_deleting_an_adr_in_a_missing_namespace() {
+ when(mockNamespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteAdr(NAMESPACE, ADR_ID));
+ }
+
+ @Test
+ void delete_the_header_and_all_revisions_when_the_adr_exists() throws Exception {
+ adrExists();
+ stubFind(versionCollection, List.of(
+ Document.createDocument().put("version", "1"),
+ Document.createDocument().put("version", "2")));
+
+ store.deleteAdr(NAMESPACE, ADR_ID);
+
+ verify(versionCollection, org.mockito.Mockito.times(2)).remove(any(Document.class));
+ verify(headerCollection).remove(any(Document.class));
+ }
+
+ @Test
+ void throw_an_adr_exception_when_deleting_a_missing_adr() {
+ adrDoesNotExist();
+
+ assertThrows(AdrNotFoundException.class, () -> store.deleteAdr(NAMESPACE, ADR_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteArchitectureStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteArchitectureStoreShould.java
index 169d5d23a..454a3f491 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteArchitectureStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteArchitectureStoreShould.java
@@ -428,4 +428,33 @@ public void create_the_version_when_updating_one_that_does_not_exist() throws Ex
verify(versionCollection).insert(any(Document.class));
}
+
+ // --- deleteArchitecture ---
+
+ @Test
+ public void throw_a_namespace_exception_when_deleting_an_architecture_in_a_missing_namespace() {
+ when(mockNamespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteArchitecture(NAMESPACE, ARCHITECTURE_ID));
+ }
+
+ @Test
+ public void delete_the_header_and_all_versions_when_the_architecture_exists() throws Exception {
+ architectureExists();
+ stubFind(versionCollection, List.of(
+ Document.createDocument().put("version", "1.0.0"),
+ Document.createDocument().put("version", "1.0.1")));
+
+ store.deleteArchitecture(NAMESPACE, ARCHITECTURE_ID);
+
+ verify(versionCollection, org.mockito.Mockito.times(2)).remove(any(Document.class));
+ verify(headerCollection).remove(any(Document.class));
+ }
+
+ @Test
+ public void throw_an_architecture_exception_when_deleting_a_missing_architecture() {
+ architectureDoesNotExist();
+
+ assertThrows(ArchitectureNotFoundException.class, () -> store.deleteArchitecture(NAMESPACE, ARCHITECTURE_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteControlStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteControlStoreShould.java
index f870fa53b..638a3576c 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteControlStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteControlStoreShould.java
@@ -12,6 +12,7 @@
import org.finos.calm.domain.exception.ControlConfigurationNotFoundException;
import org.finos.calm.domain.exception.ControlConfigurationVersionExistsException;
import org.finos.calm.domain.exception.ControlConfigurationVersionNotFoundException;
+import org.finos.calm.domain.exception.ControlHasConfigurationsException;
import org.finos.calm.domain.exception.ControlNotFoundException;
import org.finos.calm.domain.exception.ControlRequirementVersionExistsException;
import org.finos.calm.domain.exception.ControlRequirementVersionNotFoundException;
@@ -32,6 +33,7 @@
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -113,6 +115,13 @@ private void configurationDoesNotExist() {
stubFind(configHeaders, List.of());
}
+ /** Stubs the count query {@code countHeaders} runs against the configuration namespace. */
+ private void configurationCountIs(long count) {
+ DocumentCursor countCursor = mock(DocumentCursor.class);
+ when(configHeaders.find(any(Filter.class))).thenReturn(countCursor);
+ when(countCursor.size()).thenReturn(count);
+ }
+
// --- getControlsForDomain ---
@Test
@@ -502,4 +511,73 @@ void create_configuration_for_version_never_syncs_name_or_description_onto_the_h
verify(configHeaders, times(1)).update(any(Filter.class), any(Document.class));
}
+
+ // --- deleteControlRequirement ---
+
+ @Test
+ void throw_a_domain_exception_when_deleting_a_control_requirement_in_a_missing_domain() {
+ assertThrows(DomainNotFoundException.class, () -> store.deleteControlRequirement("invalid", CONTROL_ID));
+ }
+
+ @Test
+ void throw_a_control_exception_when_deleting_a_missing_control_requirement() {
+ controlDoesNotExist();
+
+ assertThrows(ControlNotFoundException.class, () -> store.deleteControlRequirement(DOMAIN, CONTROL_ID));
+ }
+
+ @Test
+ void refuse_to_delete_a_control_requirement_that_still_has_configurations() {
+ controlExists();
+ configurationCountIs(2);
+
+ ControlHasConfigurationsException exception = assertThrows(ControlHasConfigurationsException.class,
+ () -> store.deleteControlRequirement(DOMAIN, CONTROL_ID));
+ assertThat(exception.getControlId(), is(CONTROL_ID));
+ assertThat(exception.getConfigurationCount(), is(2));
+ verify(controlHeaders, never()).remove(any(Document.class));
+ }
+
+ @Test
+ void delete_the_requirement_header_and_all_versions_when_it_has_no_configurations() throws Exception {
+ controlExists();
+ configurationCountIs(0);
+
+ store.deleteControlRequirement(DOMAIN, CONTROL_ID);
+
+ verify(controlHeaders).remove(any(Document.class));
+ }
+
+ // --- deleteControlConfiguration ---
+
+ @Test
+ void throw_a_domain_exception_when_deleting_a_configuration_in_a_missing_domain() {
+ assertThrows(DomainNotFoundException.class,
+ () -> store.deleteControlConfiguration("invalid", CONTROL_ID, CONFIGURATION_ID));
+ }
+
+ @Test
+ void throw_a_control_exception_when_deleting_a_configuration_for_a_missing_control() {
+ controlDoesNotExist();
+
+ assertThrows(ControlNotFoundException.class,
+ () -> store.deleteControlConfiguration(DOMAIN, CONTROL_ID, CONFIGURATION_ID));
+ }
+
+ @Test
+ void throw_a_configuration_exception_when_deleting_a_missing_configuration() {
+ configurationDoesNotExist();
+
+ assertThrows(ControlConfigurationNotFoundException.class,
+ () -> store.deleteControlConfiguration(DOMAIN, CONTROL_ID, CONFIGURATION_ID));
+ }
+
+ @Test
+ void delete_the_configuration_header_and_all_versions_when_it_exists() throws Exception {
+ configurationExists();
+
+ store.deleteControlConfiguration(DOMAIN, CONTROL_ID, CONFIGURATION_ID);
+
+ verify(configHeaders).remove(any(Document.class));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteDecoratorStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteDecoratorStoreShould.java
index 33c259e96..89a1a21f8 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteDecoratorStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteDecoratorStoreShould.java
@@ -678,4 +678,74 @@ void should_handle_multiple_decorators_in_order() throws NamespaceNotFoundExcept
assertEquals(1, decoratorIds.get(2));
verify(namespaceStore).namespaceExists(namespace);
}
+
+ @Test
+ void should_delete_decorator_successfully() throws NamespaceNotFoundException, DecoratorNotFoundException {
+ // Given
+ String namespace = "finos";
+ when(namespaceStore.namespaceExists(namespace)).thenReturn(true);
+
+ Document decorator1 = Document.createDocument("decoratorId", 1)
+ .put("decorator", Document.createDocument("unique-id", "decorator-1"));
+ Document decorator2 = Document.createDocument("decoratorId", 2)
+ .put("decorator", Document.createDocument("unique-id", "decorator-2"));
+ Document namespaceDocument = Document.createDocument("namespace", namespace)
+ .put("decorators", List.of(decorator1, decorator2));
+
+ when(decoratorCollection.find(any(Filter.class))).thenReturn(cursor);
+ when(cursor.firstOrNull()).thenReturn(namespaceDocument);
+
+ // When
+ decoratorStore.deleteDecorator(namespace, 1);
+
+ // Then
+ verify(namespaceStore).namespaceExists(namespace);
+ verify(decoratorCollection).update(any(Document.class));
+ }
+
+ @Test
+ void should_throw_decorator_not_found_when_deleting_an_id_not_present() {
+ // Given
+ String namespace = "finos";
+ when(namespaceStore.namespaceExists(namespace)).thenReturn(true);
+
+ Document decorator1 = Document.createDocument("decoratorId", 1)
+ .put("decorator", Document.createDocument("unique-id", "decorator-1"));
+ Document namespaceDocument = Document.createDocument("namespace", namespace)
+ .put("decorators", List.of(decorator1));
+
+ when(decoratorCollection.find(any(Filter.class))).thenReturn(cursor);
+ when(cursor.firstOrNull()).thenReturn(namespaceDocument);
+
+ // When & Then
+ assertThrows(DecoratorNotFoundException.class, () -> decoratorStore.deleteDecorator(namespace, 99));
+
+ verify(decoratorCollection, never()).update(any(Document.class));
+ }
+
+ @Test
+ void should_throw_decorator_not_found_when_deleting_from_a_namespace_with_no_document() {
+ // Given
+ String namespace = "finos";
+ when(namespaceStore.namespaceExists(namespace)).thenReturn(true);
+ when(decoratorCollection.find(any(Filter.class))).thenReturn(cursor);
+ when(cursor.firstOrNull()).thenReturn(null);
+
+ // When & Then
+ assertThrows(DecoratorNotFoundException.class, () -> decoratorStore.deleteDecorator(namespace, 1));
+
+ verify(decoratorCollection, never()).update(any(Document.class));
+ }
+
+ @Test
+ void should_throw_namespace_not_found_when_deleting_decorator_in_unknown_namespace() {
+ // Given
+ String namespace = "unknown-namespace";
+ when(namespaceStore.namespaceExists(namespace)).thenReturn(false);
+
+ // When & Then
+ assertThrows(NamespaceNotFoundException.class, () -> decoratorStore.deleteDecorator(namespace, 1));
+
+ verify(decoratorCollection, never()).find(any(Filter.class));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteFlowStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteFlowStoreShould.java
index c056f6313..349db831e 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteFlowStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteFlowStoreShould.java
@@ -389,4 +389,33 @@ public void create_the_version_when_updating_one_that_does_not_exist() throws Ex
verify(versionCollection).insert(any(Document.class));
}
+
+ // --- deleteFlow ---
+
+ @Test
+ public void throw_a_namespace_exception_when_deleting_a_flow_in_a_missing_namespace() {
+ when(mockNamespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteFlow(NAMESPACE, FLOW_ID));
+ }
+
+ @Test
+ public void delete_the_header_and_all_versions_when_the_flow_exists() throws Exception {
+ flowExists();
+ stubFind(versionCollection, List.of(
+ Document.createDocument().put("version", "1.0.0"),
+ Document.createDocument().put("version", "1.0.1")));
+
+ store.deleteFlow(NAMESPACE, FLOW_ID);
+
+ verify(versionCollection, org.mockito.Mockito.times(2)).remove(any(Document.class));
+ verify(headerCollection).remove(any(Document.class));
+ }
+
+ @Test
+ public void throw_a_flow_exception_when_deleting_a_missing_flow() {
+ flowDoesNotExist();
+
+ assertThrows(FlowNotFoundException.class, () -> store.deleteFlow(NAMESPACE, FLOW_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteInterfaceStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteInterfaceStoreShould.java
index ed5e48c7a..4c26068df 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteInterfaceStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteInterfaceStoreShould.java
@@ -263,4 +263,33 @@ public void overwrite_the_header_details_even_when_blank() throws Exception {
// Unconditional, unlike Pattern and Flow — Interface's old shape did not guard these.
verify(headerCollection, times(2)).update(any(Filter.class), any(Document.class));
}
+
+ // --- deleteInterface ---
+
+ @Test
+ public void throw_a_namespace_exception_when_deleting_an_interface_in_a_missing_namespace() {
+ when(mockNamespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteInterface(NAMESPACE, INTERFACE_ID));
+ }
+
+ @Test
+ public void delete_the_header_and_all_versions_when_the_interface_exists() throws Exception {
+ interfaceExists();
+ stubFind(versionCollection, List.of(
+ Document.createDocument().put("version", "1.0.0"),
+ Document.createDocument().put("version", "1.0.1")));
+
+ store.deleteInterface(NAMESPACE, INTERFACE_ID);
+
+ verify(versionCollection, times(2)).remove(any(Document.class));
+ verify(headerCollection).remove(any(Document.class));
+ }
+
+ @Test
+ public void throw_an_interface_exception_when_deleting_a_missing_interface() {
+ interfaceDoesNotExist();
+
+ assertThrows(InterfaceNotFoundException.class, () -> store.deleteInterface(NAMESPACE, INTERFACE_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitritePatternStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitritePatternStoreShould.java
index 114445775..e0787b0d4 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitritePatternStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitritePatternStoreShould.java
@@ -431,4 +431,33 @@ public void create_the_version_when_updating_one_that_does_not_exist() throws Ex
verify(versionCollection).insert(any(Document.class));
}
+
+ // --- deletePattern ---
+
+ @Test
+ public void throw_a_namespace_exception_when_deleting_a_pattern_in_a_missing_namespace() {
+ when(mockNamespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deletePattern(NAMESPACE, PATTERN_ID));
+ }
+
+ @Test
+ public void delete_the_header_and_all_versions_when_the_pattern_exists() throws Exception {
+ patternExists();
+ stubFind(versionCollection, List.of(
+ Document.createDocument().put("version", "1.0.0"),
+ Document.createDocument().put("version", "1.0.1")));
+
+ store.deletePattern(NAMESPACE, PATTERN_ID);
+
+ verify(versionCollection, org.mockito.Mockito.times(2)).remove(any(Document.class));
+ verify(headerCollection).remove(any(Document.class));
+ }
+
+ @Test
+ public void throw_a_pattern_exception_when_deleting_a_missing_pattern() {
+ patternDoesNotExist();
+
+ assertThrows(PatternNotFoundException.class, () -> store.deletePattern(NAMESPACE, PATTERN_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteResourceMappingStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteResourceMappingStoreShould.java
index 986a291ab..27540c717 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteResourceMappingStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteResourceMappingStoreShould.java
@@ -410,4 +410,48 @@ void throw_mapping_not_found_on_delete_when_mapping_does_not_exist() {
assertThrows(MappingNotFoundException.class,
() -> store.deleteMapping(NAMESPACE, ResourceType.PATTERN, "nonexistent"));
}
+
+ // --- deleteMappingByNumericId ---
+
+ @Test
+ void delete_mapping_by_numeric_id_successfully() throws NamespaceNotFoundException {
+ when(mockNamespaceStore.namespaceExists(NAMESPACE)).thenReturn(true);
+
+ Document existing = Document.createDocument()
+ .put("namespace", NAMESPACE)
+ .put("customId", "api-gateway")
+ .put("resourceType", "PATTERN")
+ .put("numericId", 42);
+
+ DocumentCursor cursor = mock(DocumentCursor.class);
+ when(cursor.firstOrNull()).thenReturn(existing);
+ when(mockCollection.find(any(Filter.class))).thenReturn(cursor);
+
+ store.deleteMappingByNumericId(NAMESPACE, ResourceType.PATTERN, 42);
+
+ verify(mockCollection).remove(existing);
+ }
+
+ @Test
+ void not_throw_when_deleting_a_mapping_by_numeric_id_that_does_not_exist() throws NamespaceNotFoundException {
+ // Most resources have no custom-id mapping at all — this must be a silent no-op, not
+ // an error, so a resource delete can call it unconditionally.
+ when(mockNamespaceStore.namespaceExists(NAMESPACE)).thenReturn(true);
+
+ DocumentCursor cursor = mock(DocumentCursor.class);
+ when(cursor.firstOrNull()).thenReturn(null);
+ when(mockCollection.find(any(Filter.class))).thenReturn(cursor);
+
+ store.deleteMappingByNumericId(NAMESPACE, ResourceType.PATTERN, 999);
+
+ verify(mockCollection, never()).remove(any(Document.class));
+ }
+
+ @Test
+ void throw_namespace_not_found_when_deleting_a_mapping_by_numeric_id_in_a_missing_namespace() {
+ when(mockNamespaceStore.namespaceExists("invalid")).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class,
+ () -> store.deleteMappingByNumericId("invalid", ResourceType.PATTERN, 42));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteStandardStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteStandardStoreShould.java
index 6024b8e64..358dea793 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteStandardStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteStandardStoreShould.java
@@ -263,4 +263,33 @@ public void overwrite_the_header_details_even_when_blank() throws Exception {
// Unconditional, unlike Pattern and Flow — Standard's old shape did not guard these.
verify(headerCollection, times(2)).update(any(Filter.class), any(Document.class));
}
+
+ // --- deleteStandard ---
+
+ @Test
+ public void throw_a_namespace_exception_when_deleting_a_standard_in_a_missing_namespace() {
+ when(mockNamespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteStandard(NAMESPACE, STANDARD_ID));
+ }
+
+ @Test
+ public void delete_the_header_and_all_versions_when_the_standard_exists() throws Exception {
+ standardExists();
+ stubFind(versionCollection, List.of(
+ Document.createDocument().put("version", "1.0.0"),
+ Document.createDocument().put("version", "1.0.1")));
+
+ store.deleteStandard(NAMESPACE, STANDARD_ID);
+
+ verify(versionCollection, times(2)).remove(any(Document.class));
+ verify(headerCollection).remove(any(Document.class));
+ }
+
+ @Test
+ public void throw_a_standard_exception_when_deleting_a_missing_standard() {
+ standardDoesNotExist();
+
+ assertThrows(StandardNotFoundException.class, () -> store.deleteStandard(NAMESPACE, STANDARD_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteTimelineStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteTimelineStoreShould.java
index df5af265d..10e5a0166 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteTimelineStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/nitrite/TestNitriteTimelineStoreShould.java
@@ -389,4 +389,33 @@ public void create_the_version_when_updating_one_that_does_not_exist() throws Ex
verify(versionCollection).insert(any(Document.class));
}
+
+ // --- deleteTimeline ---
+
+ @Test
+ public void throw_a_namespace_exception_when_deleting_a_timeline_in_a_missing_namespace() {
+ when(mockNamespaceStore.namespaceExists(NAMESPACE)).thenReturn(false);
+
+ assertThrows(NamespaceNotFoundException.class, () -> store.deleteTimeline(NAMESPACE, TIMELINE_ID));
+ }
+
+ @Test
+ public void delete_the_header_and_all_versions_when_the_timeline_exists() throws Exception {
+ timelineExists();
+ stubFind(versionCollection, List.of(
+ Document.createDocument().put("version", "1.0.0"),
+ Document.createDocument().put("version", "1.0.1")));
+
+ store.deleteTimeline(NAMESPACE, TIMELINE_ID);
+
+ verify(versionCollection, org.mockito.Mockito.times(2)).remove(any(Document.class));
+ verify(headerCollection).remove(any(Document.class));
+ }
+
+ @Test
+ public void throw_a_timeline_exception_when_deleting_a_missing_timeline() {
+ timelineDoesNotExist();
+
+ assertThrows(TimelineNotFoundException.class, () -> store.deleteTimeline(NAMESPACE, TIMELINE_ID));
+ }
}
diff --git a/calm-hub/src/test/java/org/finos/calm/store/util/TestMongoVersionDocumentStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/util/TestMongoVersionDocumentStoreShould.java
index efe03ab6b..e2576c426 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/util/TestMongoVersionDocumentStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/util/TestMongoVersionDocumentStoreShould.java
@@ -7,6 +7,7 @@
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.UpdateOptions;
+import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.bson.BsonDocument;
import org.bson.BsonObjectId;
@@ -179,6 +180,39 @@ void swallow_a_failure_to_delete_a_header() {
assertDoesNotThrow(() -> store.deleteHeader(NAMESPACE, RESOURCE_ID));
}
+ // --- deleteResource ---
+
+ @Test
+ void delete_the_header_and_all_versions_of_a_resource() {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+
+ boolean deleted = store.deleteResource(NAMESPACE, RESOURCE_ID);
+
+ assertThat(deleted, is(true));
+ ArgumentCaptor versionFilterCaptor = ArgumentCaptor.forClass(Bson.class);
+ verify(versionCollection).deleteMany(versionFilterCaptor.capture());
+ assertThat(asJson(versionFilterCaptor.getValue()), containsString(NAMESPACE));
+ ArgumentCaptor headerFilterCaptor = ArgumentCaptor.forClass(Bson.class);
+ verify(headerCollection).deleteOne(headerFilterCaptor.capture());
+ assertThat(asJson(headerFilterCaptor.getValue()), containsString(NAMESPACE));
+ }
+
+ @Test
+ void report_false_when_deleting_a_resource_that_does_not_exist() {
+ when(headerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(0));
+
+ assertThat(store.deleteResource(NAMESPACE, RESOURCE_ID), is(false));
+ }
+
+ @Test
+ void translate_a_write_failure_when_deleting_a_resource() {
+ when(headerCollection.deleteOne(any(Bson.class))).thenThrow(new MongoTimeoutException("no server"));
+
+ // Unlike deleteHeader, this backs a real DELETE endpoint — a failure here must be
+ // reported, not swallowed as best-effort cleanup.
+ assertThrows(StorageWriteException.class, () -> store.deleteResource(NAMESPACE, RESOURCE_ID));
+ }
+
// --- createVersion ---
@Test
diff --git a/calm-hub/src/test/java/org/finos/calm/store/util/TestNitriteVersionDocumentStoreShould.java b/calm-hub/src/test/java/org/finos/calm/store/util/TestNitriteVersionDocumentStoreShould.java
index fdaa2678c..b5ea0c77e 100644
--- a/calm-hub/src/test/java/org/finos/calm/store/util/TestNitriteVersionDocumentStoreShould.java
+++ b/calm-hub/src/test/java/org/finos/calm/store/util/TestNitriteVersionDocumentStoreShould.java
@@ -28,6 +28,7 @@
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
@@ -125,6 +126,30 @@ void swallow_a_failure_to_delete_a_header() {
assertDoesNotThrow(() -> store.deleteHeader(NAMESPACE, RESOURCE_ID));
}
+ // --- deleteResource ---
+
+ @Test
+ void delete_the_header_and_all_versions_of_a_resource() {
+ Document header = header(RESOURCE_ID, "name", "description", 2);
+ stubFind(headerCollection, List.of(header));
+ stubFind(versionCollection, List.of(versionDocument("1.0.0"), versionDocument("2.0.0")));
+
+ boolean deleted = store.deleteResource(NAMESPACE, RESOURCE_ID);
+
+ assertThat(deleted, is(true));
+ verify(versionCollection, times(2)).remove(any(Document.class));
+ verify(headerCollection).remove(header);
+ }
+
+ @Test
+ void report_false_when_deleting_a_resource_that_does_not_exist() {
+ stubFind(headerCollection, List.of());
+
+ assertThat(store.deleteResource(NAMESPACE, RESOURCE_ID), is(false));
+ verify(headerCollection, never()).remove(any(Document.class));
+ verifyNoInteractions(versionCollection);
+ }
+
// --- createVersion ---
@Test