Light, fluffy, and always free - The AWS Local Emulator alternative
feat(docdb): add Amazon DocumentDB service emulation (#1341)
Ahmed khaledbd96d4e86688
diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 5f25f33f3d..1c137659ce 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -365,6 +365,7 @@ public interface EmulatorConfig {AutoScalingServiceConfig autoscaling();BackupServiceConfig backup();NeptuneServiceConfig neptune();+ DocDbServiceConfig docdb();Route53ServiceConfig route53();TransferServiceConfig transfer();TextractServiceConfig textract();@@ -582,6 +583,19 @@ public interface EmulatorConfig {Optional<String> dockerNetwork();}+ interface DocDbServiceConfig {+ @WithDefault("true")+ boolean enabled();++ @WithDefault("false")+ boolean mock();++ @WithDefault("mongo:7.0")+ String defaultImage();++ Optional<String> dockerNetwork();+ }+interface EventBridgeServiceConfig {@WithDefault("true")boolean enabled();diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.javaindex 4f97b5c293..152ef96aaa 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java@@ -2,6 +2,8 @@ package io.github.hectorvent.floci.core.common;import io.github.hectorvent.floci.services.neptune.NeptuneQueryHandler;import io.github.hectorvent.floci.services.neptune.NeptuneService;+import io.github.hectorvent.floci.services.docdb.DocDbQueryHandler;+import io.github.hectorvent.floci.services.docdb.DocDbService;import io.github.hectorvent.floci.services.autoscaling.AutoScalingQueryHandler;import io.github.hectorvent.floci.services.cloudformation.CloudFormationQueryHandler;import io.github.hectorvent.floci.services.ec2.Ec2QueryHandler;@@ -174,6 +176,8 @@ public class AwsQueryController {private final RdsQueryHandler rdsQueryHandler;private final NeptuneQueryHandler neptuneQueryHandler;private final NeptuneService neptuneService;+ private final DocDbQueryHandler docDbQueryHandler;+ private final DocDbService docDbService;private final SqsQueryHandler sqsQueryHandler;private final SnsQueryHandler snsQueryHandler;private final SesQueryHandler sesQueryHandler;@@ -193,6 +197,8 @@ public class AwsQueryController {RdsQueryHandler rdsQueryHandler,NeptuneQueryHandler neptuneQueryHandler,NeptuneService neptuneService,+ DocDbQueryHandler docDbQueryHandler,+ DocDbService docDbService,SqsQueryHandler sqsQueryHandler, SnsQueryHandler snsQueryHandler,SesQueryHandler sesQueryHandler,IamQueryHandler iamQueryHandler, StsQueryHandler stsQueryHandler,@@ -208,6 +214,8 @@ public class AwsQueryController {this.rdsQueryHandler = rdsQueryHandler;this.neptuneQueryHandler = neptuneQueryHandler;this.neptuneService = neptuneService;+ this.docDbQueryHandler = docDbQueryHandler;+ this.docDbService = docDbService;this.sqsQueryHandler = sqsQueryHandler;this.snsQueryHandler = snsQueryHandler;this.sesQueryHandler = sesQueryHandler;@@ -246,7 +254,7 @@ public class AwsQueryController {case "iam" -> iamQueryHandler.handle(action, formParams);case "sts" -> stsQueryHandler.handle(action, formParams);case "elasticache" -> elastiCacheQueryHandler.handle(action, formParams);- case "rds" -> {+ case "rds" -> {// Neptune signs requests with "rds" credential scope (same wire protocol).// Route to Neptune when Engine=neptune (create ops) or when the cluster/instance// already exists in Neptune storage (describe/modify/delete ops).@@ -258,9 +266,16 @@ public class AwsQueryController {|| neptuneService.hasInstance(instanceId)) {yield neptuneQueryHandler.handle(action, formParams);}++ if ("docdb".equalsIgnoreCase(engine)+ || docDbService.hasCluster(clusterId)+ || docDbService.hasInstance(instanceId)) {+ yield docDbQueryHandler.handle(action, formParams);+ }yield rdsQueryHandler.handle(action, formParams);}case "neptune" -> neptuneQueryHandler.handle(action, formParams);+ case "docdb" -> docDbQueryHandler.handle(action, formParams);case "email" -> sesQueryHandler.handle(action, formParams, region);case "monitoring" -> cloudWatchMetricsQueryHandler.handle(action, formParams, region);case "cloudformation" -> cloudFormationQueryHandler.handle(action, formParams, region);diff --git a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.javaindex 2e2c838c70..5ca506234d 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java@@ -101,6 +101,12 @@ public class ResolvedServiceCatalog {5000L, AwsNamespaces.RDS, ServiceProtocol.QUERY,protocols(ServiceProtocol.QUERY),Set.of(), Set.of("neptune"), Set.of(), Set.of()),+ descriptor("docdb", "docdb", config.services().docdb().enabled(), true,+ "docdb", config.storage().mode(),+ 5000L, AwsNamespaces.RDS, ServiceProtocol.QUERY,+ protocols(ServiceProtocol.QUERY),+ Set.of(), Set.of("docdb"), Set.of(), Set.of()),+descriptor("events", "eventbridge", config.services().eventbridge().enabled(), true,"eventbridge", config.storage().mode(), 5000L, null, ServiceProtocol.JSON,protocols(ServiceProtocol.JSON),diff --git a/src/main/java/io/github/hectorvent/floci/services/docdb/DocDbQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/docdb/DocDbQueryHandler.javanew file mode 100644index 0000000000..17b392796b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/docdb/DocDbQueryHandler.java@@ -0,0 +1,266 @@+package io.github.hectorvent.floci.services.docdb;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.AwsNamespaces;+import io.github.hectorvent.floci.core.common.AwsQueryResponse;+import io.github.hectorvent.floci.core.common.XmlBuilder;+import io.github.hectorvent.floci.services.docdb.model.DocDbCluster;+import io.github.hectorvent.floci.services.docdb.model.DocDbInstance;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import jakarta.ws.rs.core.MultivaluedMap;+import jakarta.ws.rs.core.Response;+import org.jboss.logging.Logger;++import java.util.Collection;++@ApplicationScoped+public class DocDbQueryHandler {++ private static final Logger LOG = Logger.getLogger(DocDbQueryHandler.class);++ private final DocDbService service;+ private final EmulatorConfig config;++ @Inject+ public DocDbQueryHandler(DocDbService service, EmulatorConfig config) {+ this.service = service;+ this.config = config;+ }++ public Response handle(String action, MultivaluedMap<String, String> params) {+ LOG.infov("DocDB action: {0}", action);+ try {+ return switch (action) {+ case "CreateDBCluster" -> handleCreateDbCluster(params);+ case "DescribeDBClusters" -> handleDescribeDbClusters(params);+ case "DeleteDBCluster" -> handleDeleteDbCluster(params);+ case "ModifyDBCluster" -> handleModifyDbCluster(params);+ case "CreateDBInstance" -> handleCreateDbInstance(params);+ case "DescribeDBInstances"-> handleDescribeDbInstances(params);+ case "DeleteDBInstance" -> handleDeleteDbInstance(params);+ case "ModifyDBInstance" -> handleModifyDbInstance(params);+ default -> AwsQueryResponse.error("UnsupportedOperation",+ "Operation " + action + " is not supported by DocDB.", AwsNamespaces.RDS, 400);+ };+ } catch (AwsException e) {+ return AwsQueryResponse.error(e.getErrorCode(), e.getMessage(), AwsNamespaces.RDS, e.getHttpStatus());+ } catch (Exception e) {+ LOG.errorv(e, "Unexpected error in DocDB {0}", action);+ return AwsQueryResponse.error("InternalFailure",+ "An internal error occurred while processing the request.",+ AwsNamespaces.RDS, 500);+ }+ }++ // ── Clusters ──────────────────────────────────────────────────────────────++ private Response handleCreateDbCluster(MultivaluedMap<String, String> params) {+ String id = params.getFirst("DBClusterIdentifier");+ if (id == null || id.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue",+ "DBClusterIdentifier is required.", AwsNamespaces.RDS, 400);+ }+ String engineVersion = params.getFirst("EngineVersion");+ String masterUsername = params.getFirst("MasterUsername");+ String masterPassword = params.getFirst("MasterUserPassword");+ boolean iamEnabled = "true".equalsIgnoreCase(params.getFirst("EnableIAMDatabaseAuthentication"));++ DocDbCluster cluster = service.createDbCluster(id, engineVersion,+ masterUsername, masterPassword, iamEnabled);+ return Response.ok(AwsQueryResponse.envelope("CreateDBCluster", AwsNamespaces.RDS,+ clusterXml(cluster))).build();+ }++ private Response handleDescribeDbClusters(MultivaluedMap<String, String> params) {+ String filterId = params.getFirst("DBClusterIdentifier");+ if (filterId == null || filterId.isBlank()) {+ filterId = extractFilterValue(params, "db-cluster-id");+ }++ // When a specific cluster ID is requested, AWS returns 404 if not found+ if (filterId != null && !filterId.isBlank()) {+ service.getDbCluster(filterId); // throws DBClusterNotFoundFault if absent+ }++ Collection<DocDbCluster> result = service.listDbClusters(filterId);++ XmlBuilder xml = new XmlBuilder().start("DBClusters");+ for (DocDbCluster c : result) {+ xml.start("DBCluster").raw(clusterInnerXml(c)).end("DBCluster");+ }+ xml.end("DBClusters").start("Marker").end("Marker");+ return Response.ok(AwsQueryResponse.envelope("DescribeDBClusters", AwsNamespaces.RDS, xml.build())).build();+ }++ private Response handleDeleteDbCluster(MultivaluedMap<String, String> params) {+ String id = params.getFirst("DBClusterIdentifier");+ if (id == null || id.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue",+ "DBClusterIdentifier is required.", AwsNamespaces.RDS, 400);+ }+ DocDbCluster cluster = service.getDbCluster(id);+ service.deleteDbCluster(id);+ return Response.ok(AwsQueryResponse.envelope("DeleteDBCluster", AwsNamespaces.RDS,+ clusterXml(cluster))).build();+ }++ private Response handleModifyDbCluster(MultivaluedMap<String, String> params) {+ String id = params.getFirst("DBClusterIdentifier");+ if (id == null || id.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue",+ "DBClusterIdentifier is required.", AwsNamespaces.RDS, 400);+ }+ String engineVersion = params.getFirst("EngineVersion");+ String iamStr = params.getFirst("EnableIAMDatabaseAuthentication");+ Boolean iamEnabled = iamStr != null ? Boolean.parseBoolean(iamStr) : null;++ DocDbCluster cluster = service.modifyDbCluster(id, engineVersion, iamEnabled);+ return Response.ok(AwsQueryResponse.envelope("ModifyDBCluster", AwsNamespaces.RDS,+ clusterXml(cluster))).build();+ }++ // ── Instances ─────────────────────────────────────────────────────────────++ private Response handleCreateDbInstance(MultivaluedMap<String, String> params) {+ String id = params.getFirst("DBInstanceIdentifier");+ if (id == null || id.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue",+ "DBInstanceIdentifier is required.", AwsNamespaces.RDS, 400);+ }+ String dbClusterIdentifier = params.getFirst("DBClusterIdentifier");+ if (dbClusterIdentifier == null || dbClusterIdentifier.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue",+ "DBClusterIdentifier is required for DocDB instances.", AwsNamespaces.RDS, 400);+ }+ String dbInstanceClass = params.getFirst("DBInstanceClass");+ String engineVersion = params.getFirst("EngineVersion");+ boolean iamEnabled = "true".equalsIgnoreCase(params.getFirst("EnableIAMDatabaseAuthentication"));++ DocDbInstance instance = service.createDbInstance(id, dbClusterIdentifier,+ dbInstanceClass, engineVersion, iamEnabled);+ return Response.ok(AwsQueryResponse.envelope("CreateDBInstance", AwsNamespaces.RDS,+ instanceXml(instance))).build();+ }++ private Response handleDescribeDbInstances(MultivaluedMap<String, String> params) {+ String filterId = params.getFirst("DBInstanceIdentifier");+ if (filterId == null || filterId.isBlank()) {+ filterId = extractFilterValue(params, "db-instance-id");+ }++ if (filterId != null && !filterId.isBlank()) {+ service.getDbInstance(filterId); // throws DBInstanceNotFound if absent+ }++ Collection<DocDbInstance> result = service.listDbInstances(filterId);++ XmlBuilder xml = new XmlBuilder().start("DBInstances");+ for (DocDbInstance i : result) {+ xml.start("DBInstance").raw(instanceInnerXml(i)).end("DBInstance");+ }+ xml.end("DBInstances").start("Marker").end("Marker");+ return Response.ok(AwsQueryResponse.envelope("DescribeDBInstances", AwsNamespaces.RDS, xml.build())).build();+ }++ private Response handleDeleteDbInstance(MultivaluedMap<String, String> params) {+ String id = params.getFirst("DBInstanceIdentifier");+ if (id == null || id.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue",+ "DBInstanceIdentifier is required.", AwsNamespaces.RDS, 400);+ }+ DocDbInstance instance = service.getDbInstance(id);+ service.deleteDbInstance(id);+ return Response.ok(AwsQueryResponse.envelope("DeleteDBInstance", AwsNamespaces.RDS,+ instanceXml(instance))).build();+ }++ private Response handleModifyDbInstance(MultivaluedMap<String, String> params) {+ String id = params.getFirst("DBInstanceIdentifier");+ if (id == null || id.isBlank()) {+ return AwsQueryResponse.error("InvalidParameterValue",+ "DBInstanceIdentifier is required.", AwsNamespaces.RDS, 400);+ }+ String dbInstanceClass = params.getFirst("DBInstanceClass");+ String iamStr = params.getFirst("EnableIAMDatabaseAuthentication");+ Boolean iamEnabled = iamStr != null ? Boolean.parseBoolean(iamStr) : null;++ DocDbInstance instance = service.modifyDbInstance(id, dbInstanceClass, iamEnabled);+ return Response.ok(AwsQueryResponse.envelope("ModifyDBInstance", AwsNamespaces.RDS,+ instanceXml(instance))).build();+ }++ // ── XML builders ──────────────────────────────────────────────────────────++ private String clusterXml(DocDbCluster c) {+ return new XmlBuilder().start("DBCluster").raw(clusterInnerXml(c)).end("DBCluster").build();+ }++ private String clusterInnerXml(DocDbCluster c) {+ XmlBuilder xml = new XmlBuilder()+ .elem("DBClusterIdentifier", c.getDbClusterIdentifier())+ .elem("Status", c.getStatus())+ .elem("Engine", "docdb")+ .elem("EngineVersion", c.getEngineVersion())+ .elem("Endpoint", c.getEndpoint())+ .elem("ReaderEndpoint", c.getReaderEndpoint())+ .elem("Port", c.getPort())+ .elem("MasterUsername", c.getMasterUsername())+ .elem("IAMDatabaseAuthenticationEnabled", c.isIamDatabaseAuthenticationEnabled())+ .elem("MultiAZ", false)+ .elem("StorageEncrypted", true)+ .elem("AvailabilityZone", config.defaultAvailabilityZone())+ .elem("DbClusterResourceId", c.getDbClusterResourceId())+ .elem("DBClusterArn", c.getDbClusterArn())+ .start("DBClusterMembers");+ if (c.getDbClusterMembers() != null) {+ for (String memberId : c.getDbClusterMembers()) {+ xml.start("member")+ .elem("DBInstanceIdentifier", memberId)+ .elem("IsClusterWriter", true)+ .end("member");+ }+ }+ xml.end("DBClusterMembers");+ return xml.build();+ }++ private String instanceXml(DocDbInstance i) {+ return new XmlBuilder().start("DBInstance").raw(instanceInnerXml(i)).end("DBInstance").build();+ }++ private String instanceInnerXml(DocDbInstance i) {+ return new XmlBuilder()+ .elem("DBInstanceIdentifier", i.getDbInstanceIdentifier())+ .elem("DBClusterIdentifier", i.getDbClusterIdentifier())+ .elem("DBInstanceClass", i.getDbInstanceClass())+ .elem("DBInstanceStatus", i.getStatus())+ .elem("Engine", "docdb")+ .elem("EngineVersion", i.getEngineVersion())+ .start("Endpoint")+ .elem("Address", i.getEndpoint())+ .elem("Port", i.getPort())+ .end("Endpoint")+ .elem("IAMDatabaseAuthenticationEnabled", i.isIamDatabaseAuthenticationEnabled())+ .elem("MultiAZ", false)+ .elem("StorageEncrypted", true)+ .elem("AvailabilityZone", config.defaultAvailabilityZone())+ .elem("DbiResourceId", i.getDbiResourceId())+ .elem("DBInstanceArn", i.getDbInstanceArn())+ .build();+ }++ private static String extractFilterValue(MultivaluedMap<String, String> params, String filterName) {+ for (int i = 1; ; i++) {+ String name = params.getFirst("Filters.Filter." + i + ".Name");+ if (name == null) {+ break;+ }+ if (filterName.equals(name)) {+ return params.getFirst("Filters.Filter." + i + ".Values.Value.1");+ }+ }+ return null;+ }+}\ No newline at end of filediff --git a/src/main/java/io/github/hectorvent/floci/services/docdb/DocDbService.java b/src/main/java/io/github/hectorvent/floci/services/docdb/DocDbService.javanew file mode 100644index 0000000000..82ede0b73b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/docdb/DocDbService.java@@ -0,0 +1,242 @@+package io.github.hectorvent.floci.services.docdb;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.docdb.container.DocDbContainerHandle;+import io.github.hectorvent.floci.services.docdb.container.DocDbContainerManager;+import io.github.hectorvent.floci.services.docdb.model.DocDbCluster;+import io.github.hectorvent.floci.services.docdb.model.DocDbInstance;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.time.Instant;+import java.util.ArrayList;+import java.util.Collection;+import java.util.Map;+import java.util.UUID;++@ApplicationScoped+public class DocDbService {++ private static final Logger LOG = Logger.getLogger(DocDbService.class);+ private static final String ENGINE_VERSION_DEFAULT = "5.0.0";+ private static final int MONGO_PORT = 27017;++ private final StorageBackend<String, DocDbCluster> clusters;+ private final StorageBackend<String, DocDbInstance> instances;+ private final EmulatorConfig config;+ private final RegionResolver regionResolver;+ private final DocDbContainerManager containerManager;++ @Inject+ public DocDbService(EmulatorConfig config,+ RegionResolver regionResolver,+ DocDbContainerManager containerManager,+ StorageFactory storageFactory) {+ this.config = config;+ this.regionResolver = regionResolver;+ this.containerManager = containerManager;+ this.clusters = storageFactory.create("docdb", "docdb-clusters.json",+ new TypeReference<Map<String, DocDbCluster>>() {});+ this.instances = storageFactory.create("docdb", "docdb-instances.json",+ new TypeReference<Map<String, DocDbInstance>>() {});+ }++ // ── Clusters ──────────────────────────────────────────────────────────────++ public DocDbCluster createDbCluster(String id, String engineVersion,+ String masterUsername, String masterPassword,+ boolean iamEnabled) {+ if (clusters.get(id).isPresent()) {+ throw new AwsException("DBClusterAlreadyExistsFault",+ "DocDB cluster " + id + " already exists.", 400);+ }++ String region = regionResolver.getDefaultRegion();++ DocDbCluster cluster = new DocDbCluster();+ cluster.setDbClusterIdentifier(id);+ cluster.setStatus("available");+ cluster.setEngineVersion(engineVersion != null ? engineVersion : ENGINE_VERSION_DEFAULT);+ cluster.setMasterUsername(masterUsername);+ cluster.setIamDatabaseAuthenticationEnabled(iamEnabled);+ cluster.setDbClusterArn(regionResolver.buildArn("rds", region, "cluster:" + id));+ cluster.setDbClusterResourceId("cluster-" + UUID.randomUUID().toString()+ .replace("-", "").substring(0, 24).toUpperCase());+ cluster.setCreatedAt(Instant.now());+ cluster.setDbClusterMembers(new ArrayList<>());++ if (config.services().docdb().mock()) {+ LOG.infov("Creating DocDB cluster {0} in mock mode (no container)", id);+ cluster.setEndpoint("localhost");+ cluster.setReaderEndpoint("localhost");+ cluster.setPort(MONGO_PORT);+ } else {+ String image = config.services().docdb().defaultImage();+ LOG.infov("Creating DocDB cluster {0}, image={1}", id, image);+ DocDbContainerHandle handle = containerManager.start(id, image, masterUsername, masterPassword);+ cluster.setEndpoint(handle.getHost());+ cluster.setReaderEndpoint(handle.getHost());+ cluster.setPort(handle.getPort());+ cluster.setContainerId(handle.getContainerId());+ cluster.setContainerHost(handle.getHost());+ cluster.setContainerPort(handle.getPort());+ }++ clusters.put(id, cluster);+ LOG.infov("DocDB cluster {0} created, endpoint={1}:{2}",+ id, cluster.getEndpoint(), String.valueOf(cluster.getPort()));+ return cluster;+ }++ public DocDbCluster getDbCluster(String id) {+ return clusters.get(id).orElseThrow(() ->+ new AwsException("DBClusterNotFoundFault",+ "DocDB cluster " + id + " not found.", 404));+ }++ public boolean hasCluster(String id) {+ if (id == null || id.isBlank()) {+ return false;+ }+ return clusters.get(id).isPresent();+ }++ public boolean hasInstance(String id) {+ if (id == null || id.isBlank()) {+ return false;+ }+ return instances.get(id).isPresent();+ }++ public Collection<DocDbCluster> listDbClusters(String filterId) {+ if (filterId != null && !filterId.isBlank()) {+ return clusters.scan(k -> k.equalsIgnoreCase(filterId));+ }+ return clusters.scan(k -> true);+ }++ public DocDbCluster modifyDbCluster(String id, String engineVersion, Boolean iamEnabled) {+ DocDbCluster cluster = getDbCluster(id);+ if (engineVersion != null && !engineVersion.isBlank()) {+ cluster.setEngineVersion(engineVersion);+ }+ if (iamEnabled != null) {+ cluster.setIamDatabaseAuthenticationEnabled(iamEnabled);+ }+ clusters.put(id, cluster);+ LOG.infov("DocDB cluster {0} modified", id);+ return cluster;+ }++ public void deleteDbCluster(String id) {+ DocDbCluster cluster = clusters.get(id).orElseThrow(() ->+ new AwsException("DBClusterNotFoundFault",+ "DocDB cluster " + id + " not found.", 404));++ if (cluster.getDbClusterMembers() != null && !cluster.getDbClusterMembers().isEmpty()) {+ throw new AwsException("InvalidDBClusterStateFault",+ "Cannot delete DocDB cluster " + id + " — it still has DB instances.", 400);+ }++ cluster.setStatus("deleting");+ clusters.put(id, cluster);++ if (cluster.getContainerId() != null) {+ containerManager.stop(new DocDbContainerHandle(+ cluster.getContainerId(), id,+ cluster.getContainerHost(), cluster.getContainerPort()));+ }++ clusters.delete(id);+ LOG.infov("DocDB cluster {0} deleted", id);+ }++ // ── Instances ─────────────────────────────────────────────────────────────++ public DocDbInstance createDbInstance(String id, String dbClusterIdentifier,+ String dbInstanceClass, String engineVersion,+ boolean iamEnabled) {+ if (instances.get(id).isPresent()) {+ throw new AwsException("DBInstanceAlreadyExists",+ "DocDB instance " + id + " already exists.", 400);+ }++ DocDbCluster cluster = getDbCluster(dbClusterIdentifier);+ String region = regionResolver.getDefaultRegion();++ DocDbInstance instance = new DocDbInstance();+ instance.setDbInstanceIdentifier(id);+ instance.setDbClusterIdentifier(dbClusterIdentifier);+ instance.setDbInstanceClass(dbInstanceClass != null ? dbInstanceClass : "db.r5.large");+ instance.setEngineVersion(engineVersion != null ? engineVersion : cluster.getEngineVersion());+ instance.setStatus("available");+ instance.setEndpoint(cluster.getEndpoint());+ instance.setPort(cluster.getPort());+ instance.setIamDatabaseAuthenticationEnabled(iamEnabled);+ instance.setDbInstanceArn(regionResolver.buildArn("rds", region, "db:" + id));+ instance.setDbiResourceId("db-" + UUID.randomUUID().toString()+ .replace("-", "").substring(0, 24).toUpperCase());+ instance.setCreatedAt(Instant.now());++ cluster.getDbClusterMembers().add(id);+ clusters.put(dbClusterIdentifier, cluster);++ instances.put(id, instance);+ LOG.infov("DocDB instance {0} created in cluster {1}", id, dbClusterIdentifier);+ return instance;+ }++ public DocDbInstance getDbInstance(String id) {+ return instances.get(id).orElseThrow(() ->+ new AwsException("DBInstanceNotFound",+ "DocDB instance " + id + " not found.", 404));+ }++ public Collection<DocDbInstance> listDbInstances(String filterId) {+ if (filterId != null && !filterId.isBlank()) {+ return instances.scan(k -> k.equalsIgnoreCase(filterId));+ }+ return instances.scan(k -> true);+ }++ public DocDbInstance modifyDbInstance(String id, String dbInstanceClass, Boolean iamEnabled) {+ DocDbInstance instance = getDbInstance(id);+ if (dbInstanceClass != null && !dbInstanceClass.isBlank()) {+ instance.setDbInstanceClass(dbInstanceClass);+ }+ if (iamEnabled != null) {+ instance.setIamDatabaseAuthenticationEnabled(iamEnabled);+ }+ instances.put(id, instance);+ LOG.infov("DocDB instance {0} modified", id);+ return instance;+ }++ public void deleteDbInstance(String id) {+ DocDbInstance instance = instances.get(id).orElseThrow(() ->+ new AwsException("DBInstanceNotFound",+ "DocDB instance " + id + " not found.", 404));++ String clusterId = instance.getDbClusterIdentifier();+ DocDbCluster cluster = clusters.get(clusterId).orElse(null);+ if (cluster != null) {+ cluster.getDbClusterMembers().remove(id);+ clusters.put(clusterId, cluster);+ }++ instances.delete(id);+ LOG.infov("DocDB instance {0} deleted", id);+ }++ // ── Helpers ───────────────────────────────────────────────────────────────++ private String resolveEndpointHost() {+ return config.hostname().orElse("localhost");+ }+}\ No newline at end of filediff --git a/src/main/java/io/github/hectorvent/floci/services/docdb/container/DocDbContainerHandle.java b/src/main/java/io/github/hectorvent/floci/services/docdb/container/DocDbContainerHandle.javanew file mode 100644index 0000000000..a07902620d--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/docdb/container/DocDbContainerHandle.java@@ -0,0 +1,26 @@+package io.github.hectorvent.floci.services.docdb.container;++import java.io.Closeable;++public class DocDbContainerHandle {++ private final String containerId;+ private final String clusterId;+ private final String host;+ private final int port;+ private Closeable logStream;++ public DocDbContainerHandle(String containerId, String clusterId, String host, int port) {+ this.containerId = containerId;+ this.clusterId = clusterId;+ this.host = host;+ this.port = port;+ }++ public String getContainerId() { return containerId; }+ public String getClusterId() { return clusterId; }+ public String getHost() { return host; }+ public int getPort() { return port; }+ public Closeable getLogStream() { return logStream; }+ public void setLogStream(Closeable logStream) { this.logStream = logStream; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/docdb/container/DocDbContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/docdb/container/DocDbContainerManager.javanew file mode 100644index 0000000000..75d8352ffc--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/docdb/container/DocDbContainerManager.java@@ -0,0 +1,156 @@+package io.github.hectorvent.floci.services.docdb.container;+++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;+import io.github.hectorvent.floci.core.common.docker.ContainerDetector;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.ContainerInfo;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.EndpointInfo;+import io.github.hectorvent.floci.core.common.docker.ContainerLogStreamer;+import io.github.hectorvent.floci.core.common.docker.ContainerSpec;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.io.Closeable;+import java.io.IOException;+import java.net.InetSocketAddress;+import java.net.Socket;+import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.concurrent.ConcurrentHashMap;++@ApplicationScoped+public class DocDbContainerManager {++ private static final Logger LOG = Logger.getLogger(DocDbContainerManager.class);+ private static final int MONGO_PORT = 27017;+ private static final int BACKEND_READY_DEADLINE_MS = 60_000;+ private static final int BACKEND_READY_RETRY_MS = 200;+ private static final int BACKEND_PROBE_CONNECT_MS = 2_000;++ private final ContainerBuilder containerBuilder;+ private final ContainerLifecycleManager lifecycleManager;+ private final ContainerLogStreamer logStreamer;+ private final ContainerDetector containerDetector;+ private final EmulatorConfig config;+ private final RegionResolver regionResolver;+ private final Map<String, DocDbContainerHandle> activeContainers = new ConcurrentHashMap<>();++ @Inject+ public DocDbContainerManager(ContainerBuilder containerBuilder,+ ContainerLifecycleManager lifecycleManager,+ ContainerLogStreamer logStreamer,+ ContainerDetector containerDetector,+ EmulatorConfig config,+ RegionResolver regionResolver) {+ this.containerBuilder = containerBuilder;+ this.lifecycleManager = lifecycleManager;+ this.logStreamer = logStreamer;+ this.containerDetector = containerDetector;+ this.config = config;+ this.regionResolver = regionResolver;+ }++ public DocDbContainerHandle start(String clusterId, String image, String masterUsername, String masterPassword) {+ LOG.infov("Starting DocumentDB container for cluster: {0}", clusterId);++ String containerName = "floci-docdb-" + clusterId;+ lifecycleManager.removeIfExists(containerName);++ List<String> envVars = List.of(+ "MONGO_INITDB_ROOT_USERNAME=" + masterUsername,+ "MONGO_INITDB_ROOT_PASSWORD=" + masterPassword+ );++ ContainerBuilder.Builder specBuilder = containerBuilder.newContainer(image)+ .withName(containerName)+ .withDockerNetwork(config.services().docdb().dockerNetwork())+ .withLogRotation()+ .withEnv(envVars);++ if (!containerDetector.isRunningInContainer()) {+ specBuilder.withDynamicPort(MONGO_PORT);+ } else {+ specBuilder.withExposedPort(MONGO_PORT);+ }+++ ContainerSpec spec = specBuilder.build();+ ContainerInfo info = lifecycleManager.createAndStart(spec);+ EndpointInfo endpoint = info.getEndpoint(MONGO_PORT);++ LOG.infov("DocumentDB container for cluster {0}: {1}", clusterId, endpoint);++ DocDbContainerHandle handle = new DocDbContainerHandle(+ info.containerId(), clusterId, endpoint.host(), endpoint.port());+ activeContainers.put(clusterId, handle);++ String shortId = info.containerId().length() >= 8+ ? info.containerId().substring(0, 8)+ : info.containerId();+ String logGroup = "/aws/docdb/cluster/" + clusterId + "/audit";+ String logStream = logStreamer.generateLogStreamName(shortId);+ String region = regionResolver.getDefaultRegion();++ Closeable logHandle = logStreamer.attach(+ info.containerId(), logGroup, logStream, region, "docdb:" + clusterId);+ handle.setLogStream(logHandle);++ waitForBackendReady(clusterId, endpoint.host(), endpoint.port());++ return handle;+ }++ public void stop(DocDbContainerHandle handle) {+ if (handle == null) {+ return;+ }+ activeContainers.remove(handle.getClusterId());+ lifecycleManager.stopAndRemove(handle.getContainerId(), handle.getLogStream());+ }++ public void stopAll() {+ List<DocDbContainerHandle> handles = new ArrayList<>(activeContainers.values());+ if (!handles.isEmpty()) {+ LOG.infov("Stopping {0} DocumentDB container(s) on shutdown", handles.size());+ }+ for (DocDbContainerHandle handle : handles) {+ stop(handle);+ }+ }++ private static void waitForBackendReady(String clusterId, String host, int port) {+ long deadline = System.currentTimeMillis() + BACKEND_READY_DEADLINE_MS;+ int attempt = 0;+ while (System.currentTimeMillis() < deadline) {+ attempt++;+ try (Socket s = new Socket()) {+ s.connect(new InetSocketAddress(host, port), BACKEND_PROBE_CONNECT_MS);+ if (attempt > 1) {+ LOG.infov("MongoDB backend ready for cluster {0} after {1} probe attempt(s)",+ clusterId, attempt);+ }+ return;+ } catch (IOException e) {+ if (LOG.isDebugEnabled()) {+ LOG.debugv("MongoDB probe for cluster {0} attempt {1}: {2}",+ clusterId, attempt, e.getMessage());+ }+ }+ try {+ Thread.sleep(BACKEND_READY_RETRY_MS);+ } catch (InterruptedException ie) {+ Thread.currentThread().interrupt();+ throw new RuntimeException(+ "Interrupted while waiting for MongoDB backend " + clusterId, ie);+ }+ }+ throw new RuntimeException(+ "MongoDB backend for cluster " + clusterId + " did not become ready on "+ + host + ":" + port + " within " + BACKEND_READY_DEADLINE_MS + "ms");+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/docdb/model/DocDbCluster.java b/src/main/java/io/github/hectorvent/floci/services/docdb/model/DocDbCluster.javanew file mode 100644index 0000000000..98e074720e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/docdb/model/DocDbCluster.java@@ -0,0 +1,82 @@+package io.github.hectorvent.floci.services.docdb.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.ArrayList;+import java.util.List;++@RegisterForReflection+public class DocDbCluster {+ private String masterUsername;++ private String dbClusterIdentifier;+ private String status;+ private String engineVersion;+ private String endpoint;+ private int port;+ private String readerEndpoint;+ private boolean iamDatabaseAuthenticationEnabled;+ private String dbClusterArn;+ private String dbClusterResourceId;+ private List<String> dbClusterMembers = new ArrayList<>();+ private Instant createdAt;++ // Docker / proxy runtime fields — persisted so cleanup works across restarts+ private String containerId;+ private String containerHost;+ private int containerPort;++ public DocDbCluster (){}++ public String getMasterUsername(){return masterUsername;}+ public void setMasterUsername(String masterUsername){this.masterUsername = masterUsername;}++ public String getDbClusterIdentifier() { return dbClusterIdentifier; }+ public void setDbClusterIdentifier(String dbClusterIdentifier) { this.dbClusterIdentifier = dbClusterIdentifier; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public String getEngineVersion() { return engineVersion; }+ public void setEngineVersion(String engineVersion) { this.engineVersion = engineVersion; }++ public String getEndpoint() { return endpoint; }+ public void setEndpoint(String endpoint) { this.endpoint = endpoint; }++ public int getPort() { return port; }+ public void setPort(int port) { this.port = port; }++ public String getReaderEndpoint() { return readerEndpoint; }+ public void setReaderEndpoint(String readerEndpoint) { this.readerEndpoint = readerEndpoint; }++ public boolean isIamDatabaseAuthenticationEnabled() { return iamDatabaseAuthenticationEnabled; }+ public void setIamDatabaseAuthenticationEnabled(boolean iamDatabaseAuthenticationEnabled) {+ this.iamDatabaseAuthenticationEnabled = iamDatabaseAuthenticationEnabled;+ }++ public String getDbClusterArn() { return dbClusterArn; }+ public void setDbClusterArn(String dbClusterArn) { this.dbClusterArn = dbClusterArn; }++ public String getDbClusterResourceId() { return dbClusterResourceId; }+ public void setDbClusterResourceId(String dbClusterResourceId) { this.dbClusterResourceId = dbClusterResourceId; }++ public List<String> getDbClusterMembers() { return dbClusterMembers; }+ public void setDbClusterMembers(List<String> dbClusterMembers) {+ this.dbClusterMembers = dbClusterMembers != null ? new ArrayList<>(dbClusterMembers) : new ArrayList<>();+ }++ public Instant getCreatedAt() { return createdAt; }+ public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }++ public String getContainerId() { return containerId; }+ public void setContainerId(String containerId) { this.containerId = containerId; }++ public String getContainerHost() { return containerHost; }+ public void setContainerHost(String containerHost) { this.containerHost = containerHost; }++ public int getContainerPort() { return containerPort; }+ public void setContainerPort(int containerPort) { this.containerPort = containerPort; }+++}\ No newline at end of filediff --git a/src/main/java/io/github/hectorvent/floci/services/docdb/model/DocDbInstance.java b/src/main/java/io/github/hectorvent/floci/services/docdb/model/DocDbInstance.javanew file mode 100644index 0000000000..81eb57332a--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/docdb/model/DocDbInstance.java@@ -0,0 +1,58 @@+package io.github.hectorvent.floci.services.docdb.model;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+@RegisterForReflection+public class DocDbInstance {++ private String dbInstanceIdentifier;+ private String dbClusterIdentifier;+ private String dbInstanceClass;+ private String engineVersion;+ private String status;+ private String endpoint;+ private int port;+ private boolean iamDatabaseAuthenticationEnabled;+ private String dbInstanceArn;+ private String dbiResourceId;+ private Instant createdAt;++ public DocDbInstance(){}++ public String getDbInstanceIdentifier() { return dbInstanceIdentifier; }+ public void setDbInstanceIdentifier(String dbInstanceIdentifier) { this.dbInstanceIdentifier = dbInstanceIdentifier; }++ public String getDbClusterIdentifier() { return dbClusterIdentifier; }+ public void setDbClusterIdentifier(String dbClusterIdentifier) { this.dbClusterIdentifier = dbClusterIdentifier; }++ public String getDbInstanceClass() { return dbInstanceClass; }+ public void setDbInstanceClass(String dbInstanceClass) { this.dbInstanceClass = dbInstanceClass; }++ public String getEngineVersion() { return engineVersion; }+ public void setEngineVersion(String engineVersion) { this.engineVersion = engineVersion; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public String getEndpoint() { return endpoint; }+ public void setEndpoint(String endpoint) { this.endpoint = endpoint; }++ public int getPort() { return port; }+ public void setPort(int port) { this.port = port; }++ public boolean isIamDatabaseAuthenticationEnabled() { return iamDatabaseAuthenticationEnabled; }+ public void setIamDatabaseAuthenticationEnabled(boolean iamDatabaseAuthenticationEnabled) {+ this.iamDatabaseAuthenticationEnabled = iamDatabaseAuthenticationEnabled;+ }++ public String getDbInstanceArn() { return dbInstanceArn; }+ public void setDbInstanceArn(String dbInstanceArn) { this.dbInstanceArn = dbInstanceArn; }++ public String getDbiResourceId() { return dbiResourceId; }+ public void setDbiResourceId(String dbiResourceId) { this.dbiResourceId = dbiResourceId; }++ public Instant getCreatedAt() { return createdAt; }+ public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }+++}\ No newline at end of filediff --git a/src/test/java/io/github/hectorvent/floci/services/docdb/DocDbIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/docdb/DocDbIntegrationTest.javanew file mode 100644index 0000000000..7dc0db4b96--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/docdb/DocDbIntegrationTest.java@@ -0,0 +1,323 @@+package io.github.hectorvent.floci.services.docdb;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.not;++@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class DocDbIntegrationTest {++ private static final String FORM = "application/x-www-form-urlencoded";+ private static final String CLUSTER_ID = "my-docdb-cluster";+ private static final String INSTANCE_ID = "my-docdb-instance";+ private static final String MASTER_USERNAME = "docdbadmin";+ private static final String MASTER_PASSWORD = "secret99password";++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260615/us-east-1/docdb/aws4_request, " ++ "SignedHeaders=content-type;host, Signature=test";++ private static final String AUTH_RDS_SCOPE =+ "AWS4-HMAC-SHA256 Credential=test/20260615/us-east-1/rds/aws4_request, " ++ "SignedHeaders=content-type;host, Signature=test";++ @Test+ @Order(1)+ void createCluster() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "CreateDBCluster")+ .formParam("DBClusterIdentifier", CLUSTER_ID)+ .formParam("Engine", "docdb")+ .formParam("MasterUsername", MASTER_USERNAME)+ .formParam("MasterUserPassword", MASTER_PASSWORD)+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(CLUSTER_ID))+ .body(containsString("available"))+ .body(containsString("docdb"))+ .body(containsString("5.0.0"))+ .body(containsString(MASTER_USERNAME))+ .body(not(containsString(MASTER_PASSWORD)));+ }++ @Test+ @Order(2)+ void createClusterDuplicateFails() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "CreateDBCluster")+ .formParam("DBClusterIdentifier", CLUSTER_ID)+ .formParam("Engine", "docdb")+ .formParam("MasterUsername", MASTER_USERNAME)+ .formParam("MasterUserPassword", MASTER_PASSWORD)+ .when().post("/")+ .then()+ .statusCode(400)+ .body(containsString("DBClusterAlreadyExistsFault"));+ }++ @Test+ @Order(3)+ void describeClusters() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "DescribeDBClusters")+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(CLUSTER_ID));+ }++ @Test+ @Order(4)+ void describeClusterById() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "DescribeDBClusters")+ .formParam("DBClusterIdentifier", CLUSTER_ID)+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(CLUSTER_ID))+ .body(containsString("docdb"));+ }++ @Test+ @Order(5)+ void describeClusterNotFound() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "DescribeDBClusters")+ .formParam("DBClusterIdentifier", "nonexistent-cluster")+ .when().post("/")+ .then()+ .statusCode(404)+ .body(containsString("DBClusterNotFoundFault"));+ }++ @Test+ @Order(6)+ void modifyCluster() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "ModifyDBCluster")+ .formParam("DBClusterIdentifier", CLUSTER_ID)+ .formParam("EngineVersion", "6.0.0")+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(CLUSTER_ID))+ .body(containsString("6.0.0"));+ }++ @Test+ @Order(7)+ void createInstance() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "CreateDBInstance")+ .formParam("DBInstanceIdentifier", INSTANCE_ID)+ .formParam("DBClusterIdentifier", CLUSTER_ID)+ .formParam("DBInstanceClass", "db.r5.large")+ .formParam("Engine", "docdb")+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(INSTANCE_ID))+ .body(containsString(CLUSTER_ID))+ .body(containsString("available"))+ .body(containsString("db.r5.large"));+ }++ @Test+ @Order(8)+ void clusterHasInstanceMember() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "DescribeDBClusters")+ .formParam("DBClusterIdentifier", CLUSTER_ID)+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(INSTANCE_ID));+ }++ @Test+ @Order(9)+ void describeInstances() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "DescribeDBInstances")+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(INSTANCE_ID));+ }++ @Test+ @Order(10)+ void createInstanceRequiresCluster() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "CreateDBInstance")+ .formParam("DBInstanceIdentifier", "orphan-instance")+ .formParam("DBInstanceClass", "db.r5.large")+ .formParam("Engine", "docdb")+ .when().post("/")+ .then()+ .statusCode(400)+ .body(containsString("DBClusterIdentifier is required"));+ }++ @Test+ @Order(11)+ void deleteClusterWithInstanceFails() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "DeleteDBCluster")+ .formParam("DBClusterIdentifier", CLUSTER_ID)+ .when().post("/")+ .then()+ .statusCode(400)+ .body(containsString("InvalidDBClusterStateFault"));+ }++ @Test+ @Order(12)+ void deleteInstance() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "DeleteDBInstance")+ .formParam("DBInstanceIdentifier", INSTANCE_ID)+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(INSTANCE_ID));+ }++ @Test+ @Order(13)+ void clusterHasNoMembersAfterInstanceDelete() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "DescribeDBClusters")+ .formParam("DBClusterIdentifier", CLUSTER_ID)+ .when().post("/")+ .then()+ .statusCode(200)+ .body(not(containsString(INSTANCE_ID)));+ }++ @Test+ @Order(14)+ void deleteCluster() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "DeleteDBCluster")+ .formParam("DBClusterIdentifier", CLUSTER_ID)+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(CLUSTER_ID));+ }++ @Test+ @Order(15)+ void describeAfterDeleteReturnsNotFound() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "DescribeDBClusters")+ .formParam("DBClusterIdentifier", CLUSTER_ID)+ .when().post("/")+ .then()+ .statusCode(404)+ .body(containsString("DBClusterNotFoundFault"));+ }++ @Test+ @Order(16)+ void unsupportedAction() {+ given()+ .header("Authorization", AUTH)+ .contentType(FORM)+ .formParam("Action", "RestoreDBClusterFromSnapshot")+ .when().post("/")+ .then()+ .statusCode(400)+ .body(containsString("UnsupportedOperation"));+ }++ private static final String RDS_SCOPE_CLUSTER_ID = "rds-scope-docdb-cluster";++ @Test+ @Order(17)+ void realSdkPathCreateRoutesToDocDbViaEngine() {+ given()+ .header("Authorization", AUTH_RDS_SCOPE)+ .contentType(FORM)+ .formParam("Action", "CreateDBCluster")+ .formParam("DBClusterIdentifier", RDS_SCOPE_CLUSTER_ID)+ .formParam("Engine", "docdb")+ .formParam("MasterUsername", MASTER_USERNAME)+ .formParam("MasterUserPassword", MASTER_PASSWORD)+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(RDS_SCOPE_CLUSTER_ID))+ .body(containsString("available"))+ .body(containsString("docdb"));+ }++ @Test+ @Order(18)+ void realSdkPathDescribeByIdRoutesToDocDbViaExistingCluster() {+ given()+ .header("Authorization", AUTH_RDS_SCOPE)+ .contentType(FORM)+ .formParam("Action", "DescribeDBClusters")+ .formParam("DBClusterIdentifier", RDS_SCOPE_CLUSTER_ID)+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(RDS_SCOPE_CLUSTER_ID))+ .body(containsString("docdb"));+ }++ @Test+ @Order(19)+ void realSdkPathDeleteCleansUp() {+ given()+ .header("Authorization", AUTH_RDS_SCOPE)+ .contentType(FORM)+ .formParam("Action", "DeleteDBCluster")+ .formParam("DBClusterIdentifier", RDS_SCOPE_CLUSTER_ID)+ .when().post("/")+ .then()+ .statusCode(200)+ .body(containsString(RDS_SCOPE_CLUSTER_ID));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/docdb/DocDbServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/docdb/DocDbServiceTest.javanew file mode 100644index 0000000000..02d5870657--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/docdb/DocDbServiceTest.java@@ -0,0 +1,94 @@+package io.github.hectorvent.floci.services.docdb;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.docdb.container.DocDbContainerManager;+import io.github.hectorvent.floci.services.docdb.model.DocDbCluster;+import io.github.hectorvent.floci.services.docdb.model.DocDbInstance;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.mockito.Mockito;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++class DocDbServiceTest {++ private DocDbService docDbService;+ private DocDbContainerManager containerManager;++ @BeforeEach+ void setUp() {+ StorageFactory storageFactory = Mockito.mock(StorageFactory.class);+ when(storageFactory.create(anyString(), anyString(), any()))+ .thenAnswer(invocation -> new InMemoryStorage<>());++ EmulatorConfig config = Mockito.mock(EmulatorConfig.class);+ var servicesConfig = Mockito.mock(EmulatorConfig.ServicesConfig.class);+ var docdbConfig = Mockito.mock(EmulatorConfig.DocDbServiceConfig.class);+ when(config.services()).thenReturn(servicesConfig);+ when(servicesConfig.docdb()).thenReturn(docdbConfig);+ when(docdbConfig.mock()).thenReturn(true);++ containerManager = Mockito.mock(DocDbContainerManager.class);+ RegionResolver regionResolver = new RegionResolver("us-east-1", "000000000000");+ docDbService = new DocDbService(config, regionResolver, containerManager, storageFactory);+ }++ @Test+ void createClusterInMockModeSkipsContainer() {+ DocDbCluster cluster = docDbService.createDbCluster(+ "mock-cluster", null, "admin", "secret", false);++ assertNotNull(cluster);+ assertEquals("mock-cluster", cluster.getDbClusterIdentifier());+ assertEquals("available", cluster.getStatus());+ assertEquals("localhost", cluster.getEndpoint());+ assertEquals(27017, cluster.getPort());+ assertTrue(cluster.getDbClusterArn().contains("mock-cluster"));++ verify(containerManager, never()).start(anyString(), anyString(), anyString(), anyString());+ }++ @Test+ void describeClusterInMockMode() {+ docDbService.createDbCluster("mock-cluster", null, "admin", "secret", false);++ DocDbCluster described = docDbService.getDbCluster("mock-cluster");+ assertEquals("mock-cluster", described.getDbClusterIdentifier());+ assertEquals("available", described.getStatus());+ }++ @Test+ void createInstanceInMockMode() {+ docDbService.createDbCluster("mock-cluster", null, "admin", "secret", false);++ DocDbInstance instance = docDbService.createDbInstance(+ "mock-instance", "mock-cluster", "db.r5.large", null, false);++ assertNotNull(instance);+ assertEquals("mock-instance", instance.getDbInstanceIdentifier());+ assertEquals("mock-cluster", instance.getDbClusterIdentifier());+ assertEquals("available", instance.getStatus());+ assertEquals("localhost", instance.getEndpoint());+ assertEquals(27017, instance.getPort());+ }++ @Test+ void deleteClusterInMockModeSkipsContainerStop() {+ docDbService.createDbCluster("mock-cluster", null, "admin", "secret", false);++ docDbService.deleteDbCluster("mock-cluster");++ assertTrue(docDbService.listDbClusters(null).isEmpty());+ verify(containerManager, never()).stop(any());+ }+}