Light, fluffy, and always free - The AWS Local Emulator alternative
feat(rds): DB proxy endpoints (#6062)
David1108bc75dcfb
diff --git a/compatibility-tests/sdk-test-awscli/test/rds.bats b/compatibility-tests/sdk-test-awscli/test/rds.batsindex 49c8189f72..00d7391359 100644--- a/compatibility-tests/sdk-test-awscli/test/rds.bats+++ b/compatibility-tests/sdk-test-awscli/test/rds.bats@@ -6,12 +6,14 @@ setup() {DB_ID="bats-rds-$(unique_name)"DB_ID_2="bats-rds-2-$(unique_name)"RDS_CLUSTER_ID="bats-rds-cluster-$(unique_name)"+ PROXY_NAME="bats-proxy-$(unique_name)"}teardown() {aws_cmd rds delete-db-instance --db-instance-identifier "$DB_ID" --skip-final-snapshot >/dev/null 2>&1 || trueaws_cmd rds delete-db-instance --db-instance-identifier "$DB_ID_2" --skip-final-snapshot >/dev/null 2>&1 || trueaws_cmd rds delete-db-cluster --db-cluster-identifier "$RDS_CLUSTER_ID" --skip-final-snapshot >/dev/null 2>&1 || true+ aws_cmd rds delete-db-proxy --db-proxy-name "$PROXY_NAME" >/dev/null 2>&1 || trueif [ -n "${MANAGED_SECRET_ARN:-}" ]; thenaws_cmd secretsmanager delete-secret --secret-id "$MANAGED_SECRET_ARN" \--force-delete-without-recovery >/dev/null 2>&1 || true@@ -432,3 +434,41 @@ teardown() {assert_failureassert_output --partial 'InvalidParameterValue'}++@test "rds: a proxy endpoint is added, renamed and deleted" {+ run aws_cmd ec2 describe-subnets --query 'Subnets[?DefaultForAz].SubnetId'+ assert_success+ subnet_a=$(json_get "$output" '.[0]')+ subnet_b=$(json_get "$output" '.[1]')++ run aws_cmd rds create-db-proxy --db-proxy-name "$PROXY_NAME" --engine-family POSTGRESQL \+ --role-arn arn:aws:iam::000000000000:role/rds-proxy \+ --vpc-subnet-ids "$subnet_a" "$subnet_b" \+ --auth AuthScheme=SECRETS,SecretArn=arn:aws:secretsmanager:us-east-1:000000000000:secret:db-AbCdEf+ assert_success++ reader="$PROXY_NAME-reader"+ run aws_cmd rds create-db-proxy-endpoint --db-proxy-name "$PROXY_NAME" \+ --db-proxy-endpoint-name "$reader" --vpc-subnet-ids "$subnet_a" "$subnet_b" --target-role READ_ONLY+ assert_success+ [ "$(json_get "$output" '.DBProxyEndpoint.TargetRole')" = "READ_ONLY" ]+ [ "$(json_get "$output" '.DBProxyEndpoint.IsDefault')" = "false" ]++ run aws_cmd rds describe-db-proxy-endpoints --db-proxy-name "$PROXY_NAME"+ assert_success+ [ "$(json_get "$output" '.DBProxyEndpoints[0].DBProxyEndpointName')" = "default" ]+ [ "$(json_get "$output" '.DBProxyEndpoints[0].IsDefault')" = "true" ]+ [ "$(json_get "$output" '.DBProxyEndpoints[1].DBProxyEndpointName')" = "$reader" ]++ renamed="$PROXY_NAME-analytics"+ run aws_cmd rds modify-db-proxy-endpoint --db-proxy-endpoint-name "$reader" \+ --new-db-proxy-endpoint-name "$renamed"+ assert_success+ [ "$(json_get "$output" '.DBProxyEndpoint.DBProxyEndpointName')" = "$renamed" ]++ run aws_cmd rds delete-db-proxy-endpoint --db-proxy-endpoint-name "$renamed"+ assert_success+ run aws_cmd rds delete-db-proxy-endpoint --db-proxy-endpoint-name "$renamed"+ assert_failure+ assert_output --partial 'DBProxyEndpointNotFoundFault'+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.javaindex f649c1598c..dccd65bba6 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsControlPlaneTest.java@@ -14,6 +14,7 @@ import software.amazon.awssdk.services.rds.model.ConnectionPoolConfigurationInfoimport software.amazon.awssdk.services.rds.model.CreateDbClusterEndpointResponse;import software.amazon.awssdk.services.rds.model.CreateDbClusterResponse;import software.amazon.awssdk.services.rds.model.CreateDbInstanceResponse;+import software.amazon.awssdk.services.rds.model.CreateDbProxyEndpointResponse;import software.amazon.awssdk.services.rds.model.CreateDbProxyResponse;import software.amazon.awssdk.services.rds.model.CreateDbSubnetGroupResponse;import software.amazon.awssdk.services.rds.model.CreateOptionGroupResponse;@@ -25,6 +26,7 @@ import software.amazon.awssdk.services.rds.model.DBClusterSnapshot;import software.amazon.awssdk.services.rds.model.DBEngineVersion;import software.amazon.awssdk.services.rds.model.DBInstance;import software.amazon.awssdk.services.rds.model.DBInstanceRole;+import software.amazon.awssdk.services.rds.model.DBProxyEndpointTargetRole;import software.amazon.awssdk.services.rds.model.DBProxyTarget;import software.amazon.awssdk.services.rds.model.DBSnapshot;import software.amazon.awssdk.services.rds.model.DbClusterEndpointAlreadyExistsException;@@ -35,10 +37,12 @@ import software.amazon.awssdk.services.rds.model.DbClusterSnapshotNotFoundExceptimport software.amazon.awssdk.services.rds.model.DbInstanceRoleAlreadyExistsException;import software.amazon.awssdk.services.rds.model.DbInstanceRoleNotFoundException;import software.amazon.awssdk.services.rds.model.DbLogFileNotFoundException;+import software.amazon.awssdk.services.rds.model.DbProxyEndpointNotFoundException;import software.amazon.awssdk.services.rds.model.DbSnapshotAlreadyExistsException;import software.amazon.awssdk.services.rds.model.DbSnapshotNotFoundException;import software.amazon.awssdk.services.rds.model.DescribeDBLogFilesDetails;import software.amazon.awssdk.services.rds.model.DescribeDbProxiesResponse;+import software.amazon.awssdk.services.rds.model.DescribeDbProxyEndpointsResponse;import software.amazon.awssdk.services.rds.model.DescribeDbProxyTargetGroupsResponse;import software.amazon.awssdk.services.rds.model.DescribeDbProxyTargetsResponse;import software.amazon.awssdk.services.rds.model.DescribeDbSubnetGroupsResponse;@@ -47,11 +51,13 @@ import software.amazon.awssdk.services.rds.model.DescribeOrderableDbInstanceOptiimport software.amazon.awssdk.services.rds.model.DownloadDbLogFilePortionResponse;import software.amazon.awssdk.services.rds.model.EngineDefaults;import software.amazon.awssdk.services.rds.model.InvalidDbInstanceStateException;+import software.amazon.awssdk.services.rds.model.InvalidDbProxyEndpointStateException;import software.amazon.awssdk.services.rds.model.InvalidOptionGroupStateException;import software.amazon.awssdk.services.rds.model.InvalidRestoreException;import software.amazon.awssdk.services.rds.model.ListTagsForResourceResponse;import software.amazon.awssdk.services.rds.model.ModifyDbClusterEndpointResponse;import software.amazon.awssdk.services.rds.model.ModifyDbClusterResponse;+import software.amazon.awssdk.services.rds.model.ModifyDbProxyEndpointResponse;import software.amazon.awssdk.services.rds.model.ModifyDbProxyResponse;import software.amazon.awssdk.services.rds.model.ModifyDbProxyTargetGroupResponse;import software.amazon.awssdk.services.rds.model.ModifyOptionGroupResponse;@@ -317,6 +323,56 @@ class RdsControlPlaneTest {}}+ @Test+ void sdkRoundTripsDbProxyEndpoints() {+ String proxyName = TestFixtures.uniqueName("rds-proxy-endpoints");+ String endpointName = TestFixtures.uniqueName("reader");+ String renamed = TestFixtures.uniqueName("analytics");+ try {+ CreateDbProxyResponse proxy = rds.createDBProxy(b -> b+ .dbProxyName(proxyName)+ .engineFamily("POSTGRESQL")+ .roleArn("arn:aws:iam::000000000000:role/rds-proxy")+ .vpcSubnetIds(subnetIds)+ .auth(a -> a.authScheme("SECRETS")+ .secretArn("arn:aws:secretsmanager:us-east-1:000000000000:secret:db-AbCdEf")));++ CreateDbProxyEndpointResponse created = rds.createDBProxyEndpoint(b -> b+ .dbProxyName(proxyName)+ .dbProxyEndpointName(endpointName)+ .vpcSubnetIds(subnetIds)+ .vpcSecurityGroupIds("sg-endpoint")+ .targetRole(DBProxyEndpointTargetRole.READ_ONLY)+ .tags(t -> t.key("team").value("data")));+ assertThat(created.dbProxyEndpoint().targetRole()).isEqualTo(DBProxyEndpointTargetRole.READ_ONLY);+ assertThat(created.dbProxyEndpoint().isDefault()).isFalse();+ assertThat(created.dbProxyEndpoint().endpoint()).isEqualTo(proxy.dbProxy().endpoint());+ assertThat(created.dbProxyEndpoint().createdDate()).isNotNull();+ assertThat(rds.listTagsForResource(b -> b.resourceName(created.dbProxyEndpoint().dbProxyEndpointArn()))+ .tagList()).extracting("key").containsExactly("team");++ DescribeDbProxyEndpointsResponse described = rds.describeDBProxyEndpoints(b -> b.dbProxyName(proxyName));+ assertThat(described.dbProxyEndpoints()).extracting("dbProxyEndpointName")+ .containsExactly("default", endpointName);+ assertThat(described.dbProxyEndpoints().get(0).isDefault()).isTrue();++ ModifyDbProxyEndpointResponse modified = rds.modifyDBProxyEndpoint(b -> b+ .dbProxyEndpointName(endpointName)+ .newDBProxyEndpointName(renamed)+ .vpcSecurityGroupIds("sg-other"));+ assertThat(modified.dbProxyEndpoint().dbProxyEndpointName()).isEqualTo(renamed);+ assertThat(modified.dbProxyEndpoint().vpcSecurityGroupIds()).containsExactly("sg-other");++ assertThatThrownBy(() -> rds.deleteDBProxyEndpoint(b -> b.dbProxyEndpointName("default")))+ .isInstanceOf(InvalidDbProxyEndpointStateException.class);+ rds.deleteDBProxyEndpoint(b -> b.dbProxyEndpointName(renamed));+ assertThatThrownBy(() -> rds.describeDBProxyEndpoints(b -> b.dbProxyEndpointName(renamed)))+ .isInstanceOf(DbProxyEndpointNotFoundException.class);+ } finally {+ deleteProxy(rds, proxyName);+ }+ }+@Testvoid sdkScopesTheSameDbProxyNameBySignedRegion() {String regionalProxyName = TestFixtures.uniqueName("rds-proxy-regional");diff --git a/docs/services/index.md b/docs/services/index.mdindex 86bcf83ffd..b518b7efaa 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -64,7 +64,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [ElastiCache](elasticache.md) | `POST /` with `Action=` param + TCP proxy | Query + RESP | 30 || [MemoryDB](memorydb.md) | `POST /` + `X-Amz-Target: AmazonMemoryDB.*` + TCP proxy | JSON 1.1 + RESP | 13 || [Aurora DSQL](dsql.md) | `/cluster`, `/cluster/{identifier}`, `/cluster/{identifier}/policy` | REST JSON | 9 |-| [RDS](rds.md) | `POST /` with `Action=` param + TCP proxy | Query + wire | 105 |+| [RDS](rds.md) | `POST /` with `Action=` param + TCP proxy | Query + wire | 109 || [RDS Data API](rds-data.md) | `/Execute`, `/BeginTransaction`, `/CommitTransaction`, `/RollbackTransaction` | REST JSON | 4 || [Timestream for InfluxDB](timestream-influxdb.md) | `POST /` + `X-Amz-Target: AmazonTimestreamInfluxDB.*` + InfluxDB container | JSON 1.0 + InfluxDB HTTP | 24 || [MSK](msk.md) | `/v1/clusters/...`, `/api/v2/clusters/...` + Redpanda broker | REST JSON + Kafka | 8 |diff --git a/docs/services/rds.md b/docs/services/rds.mdindex cc1d2ea22e..cfe4f20bcb 100644--- a/docs/services/rds.md+++ b/docs/services/rds.md@@ -126,7 +126,11 @@ RDS Data API (`rds-data`) is documented separately because it uses REST JSON rou| `DescribeDBProxies` | List DB proxies || `CreateDBProxy` | Create a DB proxy || `ModifyDBProxy` | Update mutable DB proxy authentication, logging, timeout, TLS, role, and security-group settings |-| `DeleteDBProxy` | Delete a DB proxy |+| `DeleteDBProxy` | Delete a DB proxy and its endpoints |+| `CreateDBProxyEndpoint` | Add a read/write or read-only endpoint to a DB proxy; see the proxy note below |+| `DescribeDBProxyEndpoints` | List proxy endpoints, each proxy's default endpoint first, filtered by `DBProxyName` and `DBProxyEndpointName` |+| `ModifyDBProxyEndpoint` | Rename a proxy endpoint or replace its security groups |+| `DeleteDBProxyEndpoint` | Delete a proxy endpoint || `RegisterDBProxyTargets` | Register a cluster or instance as a proxy target || `DeregisterDBProxyTargets` | Remove a cluster or instance from a proxy target group || `DescribeDBProxyTargetGroups` | List a proxy's target groups |@@ -346,6 +350,15 @@ services:is rejected with `InvalidParameterValue` unless the proxy's VPC and every subnet in`VpcSubnetIds` already carry an associated IPv6 CIDR block, matching AWS's own networkprerequisites for RDS Proxy.+ Proxy endpoints report the proxy's own host, so a client connects through one as through the+ proxy, and an IAM token signed for that host verifies there. The host is read from the proxy+ for each response, so when a restore gives the proxy a new host every endpoint reports it. `TargetRole` is recorded: Floci+ proxies have one target, so a `READ_ONLY` endpoint reaches the same target as the proxy rather+ than an Aurora reader. Each proxy's default endpoint (`default`, `IsDefault` true, `READ_WRITE`)+ is built from the proxy, has no ARN, and cannot be modified or deleted+ (`InvalidDBProxyEndpointStateFault`). Endpoint names are unique per account and Region, a proxy+ holds at most 20 endpoints (`DBProxyEndpointQuotaExceededFault`), and an endpoint with no+ `VpcSecurityGroupIds` gets its VPC's default security group.## Aurora Serverless v2 scalingdiff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.javaindex 84aa59e3ce..2a993c5600 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsQueryHandler.java@@ -22,6 +22,7 @@ import io.github.hectorvent.floci.services.rds.model.DbInstanceStatus;import io.github.hectorvent.floci.services.rds.model.DbParameterGroup;import io.github.hectorvent.floci.services.rds.model.DbProxy;import io.github.hectorvent.floci.services.rds.model.DbProxyAuth;+import io.github.hectorvent.floci.services.rds.model.DbProxyEndpoint;import io.github.hectorvent.floci.services.rds.model.DbProxyTarget;import io.github.hectorvent.floci.services.rds.model.DbProxyTargetGroup;import io.github.hectorvent.floci.services.rds.model.DbRoleAssociation;@@ -169,6 +170,10 @@ public class RdsQueryHandler {case "CreateDBProxy" -> handleCreateDbProxy(params, region);case "ModifyDBProxy" -> handleModifyDbProxy(params, region);case "DeleteDBProxy" -> handleDeleteDbProxy(params, region);+ case "CreateDBProxyEndpoint" -> handleCreateDbProxyEndpoint(params, region);+ case "DescribeDBProxyEndpoints" -> handleDescribeDbProxyEndpoints(params, region);+ case "ModifyDBProxyEndpoint" -> handleModifyDbProxyEndpoint(params, region);+ case "DeleteDBProxyEndpoint" -> handleDeleteDbProxyEndpoint(params, region);case "RegisterDBProxyTargets" -> handleRegisterDbProxyTargets(params, region);case "DeregisterDBProxyTargets" -> handleDeregisterDbProxyTargets(params, region);case "DescribeDBProxyTargetGroups" -> handleDescribeDbProxyTargetGroups(params, region);@@ -2205,6 +2210,84 @@ public class RdsQueryHandler {return Response.ok(AwsQueryResponse.envelope("DeleteDBProxy", AwsNamespaces.RDS, result)).build();}+ private Response handleCreateDbProxyEndpoint(MultivaluedMap<String, String> params, String region) {+ DbProxyEndpoint endpoint = service.createDbProxyEndpoint(region,+ params.getFirst("DBProxyName"),+ params.getFirst("DBProxyEndpointName"),+ memberList(params, "VpcSubnetIds"),+ memberList(params, "VpcSecurityGroupIds"),+ params.getFirst("TargetRole"),+ params.getFirst("EndpointNetworkType"),+ parseTags(params));+ return Response.ok(AwsQueryResponse.envelope("CreateDBProxyEndpoint", AwsNamespaces.RDS,+ dbProxyEndpointXml(endpoint))).build();+ }++ private Response handleDescribeDbProxyEndpoints(MultivaluedMap<String, String> params, String region) {+ RdsService.ProxyEndpointPage page = service.describeDbProxyEndpoints(region,+ params.getFirst("DBProxyName"),+ params.getFirst("DBProxyEndpointName"),+ optionalInt(params.getFirst("MaxRecords")),+ params.getFirst("Marker"));+ XmlBuilder xml = new XmlBuilder().start("DBProxyEndpoints");+ for (DbProxyEndpoint endpoint : page.endpoints()) {+ xml.start("member").raw(dbProxyEndpointInnerXml(endpoint)).end("member");+ }+ xml.end("DBProxyEndpoints");+ if (page.marker() != null) {+ xml.elem("Marker", page.marker());+ }+ return Response.ok(AwsQueryResponse.envelope("DescribeDBProxyEndpoints", AwsNamespaces.RDS,+ xml.build())).build();+ }++ private Response handleModifyDbProxyEndpoint(MultivaluedMap<String, String> params, String region) {+ // Security groups left out of the request are kept; a list given replaces them.+ DbProxyEndpoint endpoint = service.modifyDbProxyEndpoint(region,+ params.getFirst("DBProxyEndpointName"),+ params.getFirst("NewDBProxyEndpointName"),+ hasMemberKeys(params, "VpcSecurityGroupIds") ? memberList(params, "VpcSecurityGroupIds") : null);+ return Response.ok(AwsQueryResponse.envelope("ModifyDBProxyEndpoint", AwsNamespaces.RDS,+ dbProxyEndpointXml(endpoint))).build();+ }++ private Response handleDeleteDbProxyEndpoint(MultivaluedMap<String, String> params, String region) {+ DbProxyEndpoint endpoint = service.deleteDbProxyEndpoint(region, params.getFirst("DBProxyEndpointName"));+ return Response.ok(AwsQueryResponse.envelope("DeleteDBProxyEndpoint", AwsNamespaces.RDS,+ dbProxyEndpointXml(endpoint))).build();+ }++ private static String dbProxyEndpointXml(DbProxyEndpoint e) {+ return new XmlBuilder().start("DBProxyEndpoint").raw(dbProxyEndpointInnerXml(e)).end("DBProxyEndpoint").build();+ }++ /** The DBProxyEndpoint members; a proxy's default endpoint has no ARN. */+ private static String dbProxyEndpointInnerXml(DbProxyEndpoint e) {+ XmlBuilder xml = new XmlBuilder().elem("DBProxyEndpointName", e.getDbProxyEndpointName());+ if (e.getDbProxyEndpointArn() != null) {+ xml.elem("DBProxyEndpointArn", e.getDbProxyEndpointArn());+ }+ xml.elem("DBProxyName", e.getDbProxyName())+ .elem("Status", e.getStatus());+ if (e.getVpcId() != null) {+ xml.elem("VpcId", e.getVpcId());+ }+ xml.start("VpcSecurityGroupIds");+ e.getVpcSecurityGroupIds().forEach(id -> xml.elem("member", id));+ xml.end("VpcSecurityGroupIds");+ xml.start("VpcSubnetIds");+ e.getVpcSubnetIds().forEach(id -> xml.elem("member", id));+ xml.end("VpcSubnetIds");+ xml.elem("Endpoint", e.getEndpoint());+ if (e.getCreatedDate() != null) {+ xml.elem("CreatedDate", e.getCreatedDate().toString());+ }+ xml.elem("TargetRole", e.getTargetRole())+ .elem("IsDefault", String.valueOf(e.isDefault()))+ .elem("EndpointNetworkType", e.getEndpointNetworkType() != null ? e.getEndpointNetworkType() : "IPV4");+ return xml.build();+ }+private Response handleRegisterDbProxyTargets(MultivaluedMap<String, String> params, String region) {String name = params.getFirst("DBProxyName");String tgName = params.getFirst("TargetGroupName");diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.javaindex f7d1ca39d6..f2a725eef4 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java@@ -48,6 +48,7 @@ import io.github.hectorvent.floci.services.rds.model.DbInstanceStatus;import io.github.hectorvent.floci.services.rds.model.DbParameterGroup;import io.github.hectorvent.floci.services.rds.model.DbProxy;import io.github.hectorvent.floci.services.rds.model.DbProxyAuth;+import io.github.hectorvent.floci.services.rds.model.DbProxyEndpoint;import io.github.hectorvent.floci.services.rds.model.DbProxyTarget;import io.github.hectorvent.floci.services.rds.model.DbProxyTargetGroup;import io.github.hectorvent.floci.services.rds.model.DbRoleAssociation;@@ -182,6 +183,7 @@ public class RdsService implements Resettable, ResourceProvider {private StorageBackend<String, RdsEvent> events = new InMemoryStorage<>();private final StorageBackend<String, EventSubscription> eventSubscriptions;private final StorageBackend<String, DbClusterEndpoint> clusterEndpoints;+ private final StorageBackend<String, DbProxyEndpoint> proxyEndpoints;private final RdsContainerManager containerManager;private final RdsProxyManager proxyManager;// CreateDBCluster/CreateDBInstance register the new resource only after the@@ -257,6 +259,8 @@ public class RdsService implements Resettable, ResourceProvider {new TypeReference<Map<String, EventSubscription>>() {});this.clusterEndpoints = storageFactory.create("rds", "rds-cluster-endpoints.json",new TypeReference<Map<String, DbClusterEndpoint>>() {});+ this.proxyEndpoints = storageFactory.create("rds", "rds-proxy-endpoints.json",+ new TypeReference<Map<String, DbProxyEndpoint>>() {});this.clusters = storageFactory.create("rds", "rds-clusters.json",new TypeReference<Map<String, DbCluster>>() {});this.parameterGroups = storageFactory.create("rds", "rds-parameter-groups.json",@@ -419,6 +423,7 @@ public class RdsService implements Resettable, ResourceProvider {this.snapshotData = new io.github.hectorvent.floci.core.storage.InMemoryStorage<>();this.eventSubscriptions = new InMemoryStorage<>();this.clusterEndpoints = new InMemoryStorage<>();+ this.proxyEndpoints = new InMemoryStorage<>();}public void restorePersistedRuntime() {@@ -2525,6 +2530,16 @@ public class RdsService implements Resettable, ResourceProvider {eventSubscriptions.put(eventSubscriptionKey(effectiveRegion, resourceId), subscription);});}+ case "db-proxy-endpoint" -> {+ DbProxyEndpoint endpoint = proxyEndpoints.scan(k -> k.startsWith(effectiveRegion + "::")).stream()+ .filter(candidate -> resourceName.equals(candidate.getDbProxyEndpointArn()))+ .findFirst()+ .orElseThrow(() -> proxyEndpointNotFound(resourceId));+ yield new TagHandle(endpoint.getTags(), updated -> {+ endpoint.setTags(updated);+ proxyEndpoints.put(proxyEndpointKey(effectiveRegion, endpoint.getDbProxyEndpointName()), endpoint);+ });+ }case "db-proxy" -> {DbProxy proxy = proxies.scan(k -> true).stream().filter(candidate -> effectiveRegion.equals(regionFromArn(candidate.getDbProxyArn())))@@ -6310,6 +6325,7 @@ public class RdsService implements Resettable, ResourceProvider {.or(() -> legacyTargetGroup.filter(candidate -> targetGroupMatchesProxy(candidate, proxy))).orElse(null);+ List<DbProxyEndpoint> endpoints = proxyEndpointsOf(effectiveRegion, name);boolean realMode = !config.services().rds().mock();if (realMode) {try {@@ -6320,6 +6336,10 @@ public class RdsService implements Resettable, ResourceProvider {}}try {+ // A proxy's endpoints go with it.+ for (DbProxyEndpoint endpoint : endpoints) {+ proxyEndpoints.delete(proxyEndpointKey(effectiveRegion, endpoint.getDbProxyEndpointName()));+ }deleteTargetGroupKey(accountId, proxyKey);if (legacyTargetGroup.isPresent()) {deleteTargetGroupKey(accountId, name);@@ -6329,6 +6349,10 @@ public class RdsService implements Resettable, ResourceProvider {}deleteProxyKey(accountId, proxyKey);} catch (RuntimeException deleteFailure) {+ for (DbProxyEndpoint endpoint : endpoints) {+ attemptRollback(deleteFailure, () -> proxyEndpoints.put(+ proxyEndpointKey(effectiveRegion, endpoint.getDbProxyEndpointName()), endpoint));+ }attemptRollback(deleteFailure,() -> putProxyForAccount(accountId, proxyKey, proxy));canonicalTargetGroup.ifPresent(targetGroup -> attemptRollback(deleteFailure,@@ -6344,6 +6368,216 @@ public class RdsService implements Resettable, ResourceProvider {LOG.infov("DB proxy {0} deleted", name);}+ // ── DB Proxy endpoints ────────────────────────────────────────────────────++ /** AWS's limit on the endpoints a caller adds to one proxy, besides its default endpoint. */+ private static final int MAX_ENDPOINTS_PER_PROXY = 20;+ private static final String DEFAULT_PROXY_ENDPOINT_NAME = "default";+ private static final Set<String> PROXY_ENDPOINT_TARGET_ROLES = Set.of("READ_WRITE", "READ_ONLY");+ private static final Set<String> PROXY_ENDPOINT_NETWORK_TYPES = Set.of("IPV4", "IPV6", "DUAL");++ public record ProxyEndpointPage(List<DbProxyEndpoint> endpoints, String marker) {}++ /**+ * Adds an endpoint to a proxy. It reports the proxy's own host, so a client reaches the proxy's+ * listener through it, and an IAM token signed for that host verifies there.+ */+ public synchronized DbProxyEndpoint createDbProxyEndpoint(String region, String dbProxyName, String endpointName,+ List<String> vpcSubnetIds,+ List<String> vpcSecurityGroupIds, String targetRole,+ String endpointNetworkType, Map<String, String> tags) {+ String effectiveRegion = effectiveRegion(region);+ requireParameter(dbProxyName, "DBProxyName");+ String name = requireProxyEndpointName(endpointName, "DBProxyEndpointName");+ if (vpcSubnetIds == null || vpcSubnetIds.isEmpty()) {+ throw new AwsException("MissingParameter", "The request must contain the parameter VpcSubnetIds.", 400);+ }+ DbProxy proxy = getDbProxy(dbProxyName, effectiveRegion);+ String role = isBlank(targetRole) ? "READ_WRITE" : targetRole;+ if (!PROXY_ENDPOINT_TARGET_ROLES.contains(role)) {+ throw new AwsException("InvalidParameterValue", "TargetRole must be READ_WRITE or READ_ONLY.", 400);+ }+ if ("READ_ONLY".equals(role) && "SQLSERVER".equalsIgnoreCase(proxy.getEngineFamily())) {+ throw new AwsException("InvalidParameterCombination",+ "A DB proxy for RDS for SQL Server supports only the READ_WRITE target role.", 400);+ }+ String networkType = isBlank(endpointNetworkType) ? "IPV4" : endpointNetworkType;+ if (!PROXY_ENDPOINT_NETWORK_TYPES.contains(networkType)) {+ throw new AwsException("InvalidParameterValue", "EndpointNetworkType must be IPV4, IPV6, or DUAL.", 400);+ }+ if (!"available".equals(proxy.getStatus())) {+ throw new AwsException("InvalidDBProxyStateFault",+ "DB proxy " + proxy.getDbProxyName() + " is not available.", 400);+ }+ String key = proxyEndpointKey(effectiveRegion, name);+ if (DEFAULT_PROXY_ENDPOINT_NAME.equals(name) || proxyEndpoints.get(key).isPresent()) {+ throw new AwsException("DBProxyEndpointAlreadyExistsFault",+ "DB proxy endpoint " + name + " already exists.", 400);+ }+ if (proxyEndpointsOf(effectiveRegion, proxy.getDbProxyName()).size() >= MAX_ENDPOINTS_PER_PROXY) {+ throw new AwsException("DBProxyEndpointQuotaExceededFault",+ "DB proxy " + proxy.getDbProxyName() + " already has " + MAX_ENDPOINTS_PER_PROXY+ + " endpoints.", 400);+ }+ String vpcId = resolveDbProxyVpc(vpcSubnetIds, effectiveRegion);+ if (!"IPV4".equals(networkType)) {+ validateVpcHasIpv6CidrBlock(vpcId, effectiveRegion);+ validateSubnetsHaveIpv6CidrBlock(vpcSubnetIds, effectiveRegion);+ }++ DbProxyEndpoint endpoint = new DbProxyEndpoint();+ endpoint.setDbProxyEndpointName(name);+ endpoint.setDbProxyEndpointArn(regionResolver.buildArn("rds", effectiveRegion,+ "db-proxy-endpoint:prx-endpoint-" + randomResourceSuffix()));+ endpoint.setDbProxyName(proxy.getDbProxyName());+ endpoint.setStatus("available");+ endpoint.setVpcId(vpcId);+ endpoint.setVpcSubnetIds(vpcSubnetIds);+ endpoint.setVpcSecurityGroupIds(vpcSecurityGroupIds == null || vpcSecurityGroupIds.isEmpty()+ ? defaultSecurityGroupOf(vpcId, effectiveRegion) : vpcSecurityGroupIds);+ endpoint.setCreatedDate(Instant.now());+ endpoint.setTargetRole(role);+ endpoint.setEndpointNetworkType(networkType);+ endpoint.setTags(tags);+ proxyEndpoints.put(key, endpoint);+ return withProxyHost(endpoint, proxy);+ }++ /**+ * Each proxy in scope's default endpoint, then the endpoints added to it by name, narrowed by+ * the request's proxy and endpoint names.+ */+ public synchronized ProxyEndpointPage describeDbProxyEndpoints(String region, String dbProxyName,+ String endpointName, Integer maxRecords,+ String marker) {+ String effectiveRegion = effectiveRegion(region);+ requireValidMaxRecords(maxRecords);+ List<DbProxy> scope = !isBlank(dbProxyName)+ ? List.of(getDbProxy(dbProxyName, effectiveRegion))+ : listDbProxies(null, effectiveRegion).stream()+ .sorted(Comparator.comparing(DbProxy::getDbProxyName))+ .toList();+ List<DbProxyEndpoint> all = new ArrayList<>();+ for (DbProxy proxy : scope) {+ all.add(defaultProxyEndpoint(proxy));+ proxyEndpointsOf(effectiveRegion, proxy.getDbProxyName()).stream()+ .sorted(Comparator.comparing(DbProxyEndpoint::getDbProxyEndpointName))+ .map(endpoint -> withProxyHost(endpoint, proxy))+ .forEach(all::add);+ }+ List<DbProxyEndpoint> matching = all.stream()+ .filter(e -> isBlank(endpointName) || endpointName.equals(e.getDbProxyEndpointName()))+ .toList();+ if (!isBlank(endpointName) && matching.isEmpty()) {+ throw proxyEndpointNotFound(endpointName);+ }+ OffsetPage<DbProxyEndpoint> page = offsetPage(matching, maxRecords, marker);+ return new ProxyEndpointPage(page.items(), page.marker());+ }++ /** Renames an endpoint or replaces its security groups; a proxy's default endpoint cannot change. */+ public synchronized DbProxyEndpoint modifyDbProxyEndpoint(String region, String endpointName, String newName,+ List<String> vpcSecurityGroupIds) {+ String effectiveRegion = effectiveRegion(region);+ DbProxyEndpoint endpoint = requireProxyEndpoint(effectiveRegion, endpointName);+ DbProxy proxy = getDbProxy(endpoint.getDbProxyName(), effectiveRegion);+ if (!"available".equals(proxy.getStatus())) {+ throw new AwsException("InvalidDBProxyStateFault",+ "DB proxy " + proxy.getDbProxyName() + " is not available.", 400);+ }+ String name = isBlank(newName) ? endpoint.getDbProxyEndpointName()+ : requireProxyEndpointName(newName, "NewDBProxyEndpointName");+ boolean renamed = !name.equals(endpoint.getDbProxyEndpointName());+ if (renamed && (DEFAULT_PROXY_ENDPOINT_NAME.equals(name)+ || proxyEndpoints.get(proxyEndpointKey(effectiveRegion, name)).isPresent())) {+ throw new AwsException("DBProxyEndpointAlreadyExistsFault",+ "DB proxy endpoint " + name + " already exists.", 400);+ }+ String oldKey = proxyEndpointKey(effectiveRegion, endpoint.getDbProxyEndpointName());+ endpoint.setDbProxyEndpointName(name);+ if (vpcSecurityGroupIds != null) {+ endpoint.setVpcSecurityGroupIds(vpcSecurityGroupIds);+ }+ proxyEndpoints.put(proxyEndpointKey(effectiveRegion, name), endpoint);+ if (renamed) {+ proxyEndpoints.delete(oldKey);+ }+ return withProxyHost(endpoint, proxy);+ }++ /** Deletes an endpoint; the response reports it as {@code deleting}. */+ public synchronized DbProxyEndpoint deleteDbProxyEndpoint(String region, String endpointName) {+ String effectiveRegion = effectiveRegion(region);+ DbProxyEndpoint endpoint = requireProxyEndpoint(effectiveRegion, endpointName);+ proxyEndpoints.delete(proxyEndpointKey(effectiveRegion, endpoint.getDbProxyEndpointName()));+ endpoint.setStatus("deleting");+ return withProxyHost(endpoint, getDbProxy(endpoint.getDbProxyName(), effectiveRegion));+ }++ /** A stored endpoint by name; the default endpoint is in a state no change can be made in. */+ private DbProxyEndpoint requireProxyEndpoint(String region, String endpointName) {+ String name = requireProxyEndpointName(endpointName, "DBProxyEndpointName");+ if (DEFAULT_PROXY_ENDPOINT_NAME.equals(name)) {+ throw new AwsException("InvalidDBProxyEndpointStateFault",+ "The default endpoint of a DB proxy cannot be modified or deleted.", 400);+ }+ return proxyEndpoints.get(proxyEndpointKey(region, name)).orElseThrow(() -> proxyEndpointNotFound(name));+ }++ private static String requireProxyEndpointName(String name, String parameter) {+ requireParameter(name, parameter);+ if (name.length() > 63 || !DB_PROXY_NAME_PATTERN.matcher(name).matches()) {+ throw new AwsException("InvalidParameterValue", parameter + " must be 1-63 characters, begin with a "+ + "letter, and contain only letters, digits, and single hyphens.", 400);+ }+ return name;+ }++ /** Reports the proxy's current host, which a restore can change after the endpoint was created. */+ private static DbProxyEndpoint withProxyHost(DbProxyEndpoint endpoint, DbProxy proxy) {+ endpoint.setEndpoint(proxy.getEndpoint());+ return endpoint;+ }++ private static AwsException proxyEndpointNotFound(String name) {+ return new AwsException("DBProxyEndpointNotFoundFault", "DB proxy endpoint " + name + " not found.", 404);+ }++ /** The endpoint RDS gives every proxy: read/write, in the proxy's VPC, at the proxy's host. */+ private static DbProxyEndpoint defaultProxyEndpoint(DbProxy proxy) {+ DbProxyEndpoint endpoint = new DbProxyEndpoint();+ endpoint.setDbProxyEndpointName(DEFAULT_PROXY_ENDPOINT_NAME);+ endpoint.setDbProxyName(proxy.getDbProxyName());+ endpoint.setStatus(proxy.getStatus());+ endpoint.setVpcId(proxy.getVpcId());+ endpoint.setVpcSubnetIds(proxy.getVpcSubnetIds());+ endpoint.setVpcSecurityGroupIds(proxy.getVpcSecurityGroupIds());+ endpoint.setEndpoint(proxy.getEndpoint());+ endpoint.setCreatedDate(proxy.getCreatedAt());+ endpoint.setTargetRole("READ_WRITE");+ endpoint.setDefault(true);+ endpoint.setEndpointNetworkType(proxy.getEndpointNetworkType());+ return endpoint;+ }++ private List<String> defaultSecurityGroupOf(String vpcId, String region) {+ return ec2Service.getSecurityGroupsForVpc(region, vpcId, Map.of()).stream()+ .filter(group -> "default".equals(group.getGroupName()))+ .map(group -> group.getGroupId())+ .toList();+ }++ private List<DbProxyEndpoint> proxyEndpointsOf(String region, String dbProxyName) {+ String prefix = effectiveRegion(region) + "::";+ return proxyEndpoints.scan(key -> key.startsWith(prefix)).stream()+ .filter(endpoint -> dbProxyName.equals(endpoint.getDbProxyName()))+ .toList();+ }++ private String proxyEndpointKey(String region, String endpointName) {+ return effectiveRegion(region) + "::" + endpointName;+ }+// ── DB Subnet Groups ──────────────────────────────────────────────────────public DbSubnetGroup createDbSubnetGroup(String name, String description, List<String> subnetIds) {diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/model/DbProxyEndpoint.java b/src/main/java/io/github/hectorvent/floci/services/rds/model/DbProxyEndpoint.javanew file mode 100644index 0000000000..7effa6fe03--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/rds/model/DbProxyEndpoint.java@@ -0,0 +1,85 @@+package io.github.hectorvent.floci.services.rds.model;++import com.fasterxml.jackson.annotation.JsonIgnore;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++/**+ * A DB proxy endpoint as DescribeDBProxyEndpoints reports it. Endpoints a caller creates are+ * stored; a proxy's default endpoint is built from the proxy when described and carries no ARN.+ * Every endpoint reports the proxy's own host, so a connection through it reaches the proxy's+ * listener and the proxy's one target, whatever its target role. The host is not stored: a restored+ * proxy can come back on a new one, so each response reads it from the proxy.+ */+@RegisterForReflection+public class DbProxyEndpoint {++ private String dbProxyEndpointName;+ private String dbProxyEndpointArn;+ private String dbProxyName;+ private String status;+ private String vpcId;+ private List<String> vpcSubnetIds = new ArrayList<>();+ private List<String> vpcSecurityGroupIds = new ArrayList<>();+ /** The owning proxy's host, filled in for each response. */+ @JsonIgnore+ private String endpoint;+ private Instant createdDate;+ /** READ_WRITE or READ_ONLY. */+ private String targetRole;+ private boolean isDefault;+ private String endpointNetworkType;+ private Map<String, String> tags = new LinkedHashMap<>();++ public DbProxyEndpoint() {}++ public String getDbProxyEndpointName() { return dbProxyEndpointName; }+ public void setDbProxyEndpointName(String dbProxyEndpointName) { this.dbProxyEndpointName = dbProxyEndpointName; }++ public String getDbProxyEndpointArn() { return dbProxyEndpointArn; }+ public void setDbProxyEndpointArn(String dbProxyEndpointArn) { this.dbProxyEndpointArn = dbProxyEndpointArn; }++ public String getDbProxyName() { return dbProxyName; }+ public void setDbProxyName(String dbProxyName) { this.dbProxyName = dbProxyName; }++ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }++ public String getVpcId() { return vpcId; }+ public void setVpcId(String vpcId) { this.vpcId = vpcId; }++ public List<String> getVpcSubnetIds() { return vpcSubnetIds; }+ public void setVpcSubnetIds(List<String> vpcSubnetIds) {+ this.vpcSubnetIds = vpcSubnetIds != null ? new ArrayList<>(vpcSubnetIds) : new ArrayList<>();+ }++ public List<String> getVpcSecurityGroupIds() { return vpcSecurityGroupIds; }+ public void setVpcSecurityGroupIds(List<String> vpcSecurityGroupIds) {+ this.vpcSecurityGroupIds = vpcSecurityGroupIds != null ? new ArrayList<>(vpcSecurityGroupIds) : new ArrayList<>();+ }++ public String getEndpoint() { return endpoint; }+ public void setEndpoint(String endpoint) { this.endpoint = endpoint; }++ public Instant getCreatedDate() { return createdDate; }+ public void setCreatedDate(Instant createdDate) { this.createdDate = createdDate; }++ public String getTargetRole() { return targetRole; }+ public void setTargetRole(String targetRole) { this.targetRole = targetRole; }++ public boolean isDefault() { return isDefault; }+ public void setDefault(boolean isDefault) { this.isDefault = isDefault; }++ public String getEndpointNetworkType() { return endpointNetworkType; }+ public void setEndpointNetworkType(String endpointNetworkType) { this.endpointNetworkType = endpointNetworkType; }++ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) {+ this.tags = tags != null ? new LinkedHashMap<>(tags) : new LinkedHashMap<>();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsProxyEndpointIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsProxyEndpointIntegrationTest.javanew file mode 100644index 0000000000..b3df3017cd--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsProxyEndpointIntegrationTest.java@@ -0,0 +1,217 @@+package io.github.hectorvent.floci.services.rds;++import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.specification.RequestSpecification;+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 io.restassured.http.ContentType.URLENC;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * DB proxy endpoints over the Query protocol: create, describe after the proxy's default endpoint,+ * tag, rename, delete, and removal with their proxy. Runs in its own Region so the endpoint names+ * it uses are its own.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class RdsProxyEndpointIntegrationTest {++ private static final String REGION = "eu-west-3";+ private static final String PROXY = "pep-proxy";+ private static final String MEMBERS =+ "DescribeDBProxyEndpointsResponse.DescribeDBProxyEndpointsResult.DBProxyEndpoints.member";+ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20261019/" + REGION + "/rds/aws4_request, "+ + "SignedHeaders=content-type;host, Signature=test";++ private static String endpointArn;++ private static RequestSpecification query(String action) {+ return given().header("Authorization", AUTH)+ .contentType(URLENC)+ .formParam("Action", action)+ .formParam("Version", "2014-10-31");+ }++ private static RequestSpecification withSubnets(RequestSpecification request) {+ return request.formParam("VpcSubnetIds.member.1", Ec2Service.defaultSubnetId(REGION, "a"))+ .formParam("VpcSubnetIds.member.2", Ec2Service.defaultSubnetId(REGION, "b"));+ }++ private static RequestSpecification describe() {+ return query("DescribeDBProxyEndpoints").formParam("DBProxyName", PROXY);+ }++ @Test+ @Order(1)+ void anEndpointIsAddedToAProxy() {+ withSubnets(query("CreateDBProxy"))+ .formParam("DBProxyName", PROXY)+ .formParam("EngineFamily", "POSTGRESQL")+ .formParam("RoleArn", "arn:aws:iam::000000000000:role/proxy")+ .formParam("VpcSecurityGroupIds.member.1", "sg-proxy")+ .formParam("Auth.member.1.AuthScheme", "SECRETS")+ .formParam("Auth.member.1.SecretArn",+ "arn:aws:secretsmanager:" + REGION + ":000000000000:secret:db-AbCdEf")+ .when().post("/").then().statusCode(200);++ endpointArn = withSubnets(query("CreateDBProxyEndpoint"))+ .formParam("DBProxyName", PROXY)+ .formParam("DBProxyEndpointName", "reader")+ .formParam("TargetRole", "READ_ONLY")+ .formParam("VpcSecurityGroupIds.member.1", "sg-endpoint")+ .formParam("Tags.Tag.1.Key", "team")+ .formParam("Tags.Tag.1.Value", "data")+ .when().post("/").then()+ .statusCode(200)+ .body(containsString("<CreateDBProxyEndpointResult><DBProxyEndpoint>"))+ .body("CreateDBProxyEndpointResponse.CreateDBProxyEndpointResult.DBProxyEndpoint.DBProxyEndpointName",+ equalTo("reader"))+ .body(containsString("<DBProxyName>" + PROXY + "</DBProxyName>"))+ .body(containsString("<Status>available</Status>"))+ .body(containsString("<TargetRole>READ_ONLY</TargetRole>"))+ .body(containsString("<IsDefault>false</IsDefault>"))+ .body(containsString("<EndpointNetworkType>IPV4</EndpointNetworkType>"))+ .body(containsString("<VpcSecurityGroupIds><member>sg-endpoint</member></VpcSecurityGroupIds>"))+ .body(containsString("<CreatedDate>"))+ .extract().path("CreateDBProxyEndpointResponse.CreateDBProxyEndpointResult.DBProxyEndpoint"+ + ".DBProxyEndpointArn");+ assertTrue(+ endpointArn.startsWith("arn:aws:rds:" + REGION + ":000000000000:db-proxy-endpoint:prx-endpoint-"),+ endpointArn);+ }++ @Test+ @Order(2)+ void theProxysDefaultEndpointIsListedFirst() {+ String proxyHost = query("DescribeDBProxies").formParam("DBProxyName", PROXY)+ .when().post("/").then().statusCode(200)+ .extract().path("DescribeDBProxiesResponse.DescribeDBProxiesResult.DBProxies.member.Endpoint");++ describe().when().post("/").then()+ .statusCode(200)+ .body(MEMBERS + ".size()", equalTo(2))+ .body(MEMBERS + "[0].DBProxyEndpointName", equalTo("default"))+ .body(MEMBERS + "[0].IsDefault", equalTo("true"))+ .body(MEMBERS + "[0].TargetRole", equalTo("READ_WRITE"))+ // Only the added endpoint has an ARN.+ .body(MEMBERS + ".DBProxyEndpointArn.size()", equalTo(1))+ .body(MEMBERS + "[1].DBProxyEndpointArn", equalTo(endpointArn))+ .body(MEMBERS + "[0].Endpoint", equalTo(proxyHost))+ .body(MEMBERS + "[1].DBProxyEndpointName", equalTo("reader"))+ .body(MEMBERS + "[1].Endpoint", equalTo(proxyHost))+ .body(not(containsString("<Marker>")));++ query("DescribeDBProxyEndpoints").formParam("DBProxyEndpointName", "absent")+ .when().post("/").then().statusCode(404)+ .body(containsString("<Code>DBProxyEndpointNotFoundFault</Code>"));+ query("DescribeDBProxyEndpoints").formParam("DBProxyName", "absent-proxy")+ .when().post("/").then().statusCode(404)+ .body(containsString("<Code>DBProxyNotFoundFault</Code>"));+ }++ @Test+ @Order(3)+ void anEndpointIsTaggedByItsArn() {+ query("ListTagsForResource").formParam("ResourceName", endpointArn)+ .when().post("/").then().statusCode(200)+ .body(containsString("<Key>team</Key><Value>data</Value>"));+ }++ @Test+ @Order(4)+ void requestsOutsideTheModelAreRefused() {+ withSubnets(query("CreateDBProxyEndpoint"))+ .formParam("DBProxyName", PROXY).formParam("DBProxyEndpointName", "reader")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>DBProxyEndpointAlreadyExistsFault</Code>"));+ withSubnets(query("CreateDBProxyEndpoint"))+ .formParam("DBProxyName", PROXY).formParam("DBProxyEndpointName", "bad--name")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"));+ withSubnets(query("CreateDBProxyEndpoint"))+ .formParam("DBProxyName", PROXY).formParam("DBProxyEndpointName", "writer")+ .formParam("TargetRole", "WRITER")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"));+ query("CreateDBProxyEndpoint")+ .formParam("DBProxyName", PROXY).formParam("DBProxyEndpointName", "lonely")+ .formParam("VpcSubnetIds.member.1", Ec2Service.defaultSubnetId(REGION, "a"))+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidSubnet</Code>"));+ withSubnets(query("CreateDBProxyEndpoint")).formParam("DBProxyEndpointName", "orphan")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>MissingParameter</Code>"))+ .body(containsString("The request must contain the parameter DBProxyName."));+ withSubnets(query("CreateDBProxyEndpoint")).formParam("DBProxyName", PROXY)+ .when().post("/").then().statusCode(400)+ .body(containsString("The request must contain the parameter DBProxyEndpointName."));+ query("CreateDBProxyEndpoint")+ .formParam("DBProxyName", PROXY).formParam("DBProxyEndpointName", "nowhere")+ .when().post("/").then().statusCode(400)+ .body(containsString("The request must contain the parameter VpcSubnetIds."));+ query("DeleteDBProxyEndpoint")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>MissingParameter</Code>"));+ query("ModifyDBProxyEndpoint").formParam("DBProxyEndpointName", "default")+ .formParam("NewDBProxyEndpointName", "renamed")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidDBProxyEndpointStateFault</Code>"));+ query("DeleteDBProxyEndpoint").formParam("DBProxyEndpointName", "default")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidDBProxyEndpointStateFault</Code>"));+ describe().formParam("MaxRecords", "19")+ .when().post("/").then().statusCode(400)+ .body(containsString("<Code>InvalidParameterValue</Code>"));+ }++ @Test+ @Order(5)+ void anEndpointIsRenamedAndDeleted() {+ query("ModifyDBProxyEndpoint")+ .formParam("DBProxyEndpointName", "reader")+ .formParam("NewDBProxyEndpointName", "analytics")+ .formParam("VpcSecurityGroupIds.member.1", "sg-other")+ .when().post("/").then()+ .statusCode(200)+ .body(containsString("<ModifyDBProxyEndpointResult><DBProxyEndpoint>"))+ .body(containsString("<DBProxyEndpointName>analytics</DBProxyEndpointName>"))+ .body(containsString("<DBProxyEndpointArn>" + endpointArn + "</DBProxyEndpointArn>"))+ .body(containsString("<VpcSecurityGroupIds><member>sg-other</member></VpcSecurityGroupIds>"));++ query("DeleteDBProxyEndpoint").formParam("DBProxyEndpointName", "analytics")+ .when().post("/").then()+ .statusCode(200)+ .body(containsString("<DeleteDBProxyEndpointResult><DBProxyEndpoint>"))+ .body(containsString("<Status>deleting</Status>"));+ query("DeleteDBProxyEndpoint").formParam("DBProxyEndpointName", "analytics")+ .when().post("/").then().statusCode(404)+ .body(containsString("<Code>DBProxyEndpointNotFoundFault</Code>"));+ describe().when().post("/").then().statusCode(200)+ .body(MEMBERS + ".DBProxyEndpointName", equalTo("default"));+ }++ @Test+ @Order(6)+ void deletingTheProxyDeletesItsEndpoints() {+ withSubnets(query("CreateDBProxyEndpoint"))+ .formParam("DBProxyName", PROXY).formParam("DBProxyEndpointName", "leftover")+ .when().post("/").then().statusCode(200);++ query("DeleteDBProxy").formParam("DBProxyName", PROXY).when().post("/").then().statusCode(200);++ query("DeleteDBProxyEndpoint").formParam("DBProxyEndpointName", "leftover")+ .when().post("/").then().statusCode(404)+ .body(containsString("<Code>DBProxyEndpointNotFoundFault</Code>"));+ query("DescribeDBProxyEndpoints").when().post("/").then().statusCode(200)+ .body(not(containsString("<member>")));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.javaindex 053a8a9205..0049a5de8d 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java@@ -12,6 +12,7 @@ import io.github.hectorvent.floci.core.storage.InMemoryStorage;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.SecurityGroup;import io.github.hectorvent.floci.services.ec2.model.Subnet;import io.github.hectorvent.floci.services.ec2.model.Vpc;import io.github.hectorvent.floci.services.ec2.model.VpcIpv6CidrBlockAssociation;@@ -35,6 +36,7 @@ import io.github.hectorvent.floci.services.rds.model.DbInstanceStatus;import io.github.hectorvent.floci.services.rds.model.DbParameterGroup;import io.github.hectorvent.floci.services.rds.model.DbProxy;import io.github.hectorvent.floci.services.rds.model.DbProxyAuth;+import io.github.hectorvent.floci.services.rds.model.DbProxyEndpoint;import io.github.hectorvent.floci.services.rds.model.DbProxyTarget;import io.github.hectorvent.floci.services.rds.model.DbProxyTargetGroup;import io.github.hectorvent.floci.services.rds.model.DbSnapshot;@@ -56,6 +58,7 @@ import io.github.hectorvent.floci.services.secretsmanager.model.Secret;import io.github.hectorvent.floci.testutil.LogCapture;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.function.Executable;import org.junit.jupiter.params.ParameterizedTest;import org.junit.jupiter.params.provider.CsvSource;import org.junit.jupiter.params.provider.ValueSource;@@ -67,6 +70,7 @@ import java.time.Duration;import java.time.Instant;import java.util.Collection;import java.util.HashMap;+import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Optional;@@ -10343,4 +10347,291 @@ class RdsServiceTest {rdsService.deleteDbInstance("writer");assertEquals("reader", rdsService.getDbCluster("aurora").resolveWriterIdentifier());}++ // ── DB proxy endpoints ────────────────────────────────────────────────────++ private DbProxy proxyForEndpoints(String name, String engineFamily) {+ return rdsService.createDbProxy(name, engineFamily, true, false, PROXY_ROLE_ARN,+ PROXY_SUBNET_IDS, List.of("sg-proxy"), PROXY_AUTH, Map.of());+ }++ private DbProxyEndpoint addProxyEndpoint(String proxyName, String endpointName, String targetRole) {+ return rdsService.createDbProxyEndpoint("us-east-1", proxyName, endpointName, PROXY_SUBNET_IDS,+ List.of("sg-endpoint"), targetRole, null, Map.of());+ }++ private static List<String> endpointNames(RdsService.ProxyEndpointPage page) {+ return page.endpoints().stream().map(DbProxyEndpoint::getDbProxyEndpointName).toList();+ }++ @Test+ void proxyEndpointIsCreatedDescribedRenamedAndDeleted() {+ DbProxy proxy = proxyForEndpoints("app-proxy", "POSTGRESQL");++ DbProxyEndpoint reader = rdsService.createDbProxyEndpoint("us-east-1", "app-proxy", "reader",+ PROXY_SUBNET_IDS, List.of("sg-endpoint"), "READ_ONLY", null, Map.of("team", "data"));+ assertEquals("READ_ONLY", reader.getTargetRole());+ assertEquals("available", reader.getStatus());+ assertEquals("IPV4", reader.getEndpointNetworkType());+ assertEquals(proxy.getEndpoint(), reader.getEndpoint());+ assertEquals(proxy.getVpcId(), reader.getVpcId());+ assertFalse(reader.isDefault());+ assertTrue(reader.getDbProxyEndpointArn()+ .startsWith("arn:aws:rds:us-east-1:123456789012:db-proxy-endpoint:prx-endpoint-"));++ RdsService.ProxyEndpointPage page = rdsService.describeDbProxyEndpoints("us-east-1", "app-proxy", null,+ null, null);+ assertEquals(List.of("default", "reader"), endpointNames(page));+ DbProxyEndpoint byDefault = page.endpoints().get(0);+ assertTrue(byDefault.isDefault());+ assertEquals("READ_WRITE", byDefault.getTargetRole());+ assertNull(byDefault.getDbProxyEndpointArn());+ assertEquals(proxy.getEndpoint(), byDefault.getEndpoint());+ assertEquals(List.of("sg-proxy"), byDefault.getVpcSecurityGroupIds());+ assertNull(page.marker());++ DbProxyEndpoint renamed = rdsService.modifyDbProxyEndpoint("us-east-1", "reader", "analytics",+ List.of("sg-other"));+ assertEquals("analytics", renamed.getDbProxyEndpointName());+ assertEquals(List.of("sg-other"), renamed.getVpcSecurityGroupIds());+ assertEquals(reader.getDbProxyEndpointArn(), renamed.getDbProxyEndpointArn());+ AwsException oldName = assertThrows(AwsException.class,+ () -> rdsService.describeDbProxyEndpoints("us-east-1", null, "reader", null, null));+ assertEquals("DBProxyEndpointNotFoundFault", oldName.getErrorCode());++ // Leaving the security groups out keeps them.+ assertEquals(List.of("sg-other"), rdsService.modifyDbProxyEndpoint("us-east-1", "analytics", null, null)+ .getVpcSecurityGroupIds());++ assertEquals("deleting", rdsService.deleteDbProxyEndpoint("us-east-1", "analytics").getStatus());+ assertEquals(List.of("default"), endpointNames(+ rdsService.describeDbProxyEndpoints("us-east-1", "app-proxy", null, null, null)));+ AwsException gone = assertThrows(AwsException.class,+ () -> rdsService.deleteDbProxyEndpoint("us-east-1", "analytics"));+ assertEquals("DBProxyEndpointNotFoundFault", gone.getErrorCode());+ }++ /**+ * A restore can bring a proxy back on a new host. Every endpoint follows it, not only the+ * default one built from the proxy.+ */+ @Test+ void proxyEndpointsReportTheProxysHostAfterARestoreMovesIt() {+ InMemoryStorage<String, DbProxy> proxies = new InMemoryStorage<>();+ RdsService service = proxyStoreService(regionResolver, config, proxies, new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>());+ service.createDbProxy("app-proxy", "POSTGRESQL", true, false, PROXY_ROLE_ARN, PROXY_SUBNET_IDS,+ List.of(), PROXY_AUTH, Map.of());+ service.createDbProxyEndpoint("us-east-1", "app-proxy", "reader", PROXY_SUBNET_IDS, List.of(),+ "READ_ONLY", null, Map.of());++ // Each step moves the proxy to a new host first, so no answer can carry an earlier one.+ moveProxyHost(proxies, "us-east-1::app-proxy", "proxy-restored-1.internal");+ RdsService.ProxyEndpointPage page = service.describeDbProxyEndpoints("us-east-1", "app-proxy", null,+ null, null);+ assertEquals(List.of("proxy-restored-1.internal", "proxy-restored-1.internal"),+ page.endpoints().stream().map(DbProxyEndpoint::getEndpoint).toList());+ moveProxyHost(proxies, "us-east-1::app-proxy", "proxy-restored-2.internal");+ assertEquals("proxy-restored-2.internal", service.modifyDbProxyEndpoint("us-east-1", "reader", null, null)+ .getEndpoint());+ moveProxyHost(proxies, "us-east-1::app-proxy", "proxy-restored-3.internal");+ assertEquals("proxy-restored-3.internal", service.deleteDbProxyEndpoint("us-east-1", "reader").getEndpoint());+ }++ private static void moveProxyHost(InMemoryStorage<String, DbProxy> proxies, String key, String host) {+ DbProxy restored = proxies.get(key).orElseThrow();+ restored.setEndpointHost(host);+ proxies.put(key, restored);+ }++ /** A missing required member is MissingParameter, checked before any lookup, and changes nothing. */+ @Test+ void proxyEndpointRequiredMembersAreMissingParameter() {+ proxyForEndpoints("app-proxy", "POSTGRESQL");+ addProxyEndpoint("app-proxy", "kept", null);++ List<Map.Entry<String, Executable>> missing = List.of(+ Map.entry("DBProxyName", () -> rdsService.createDbProxyEndpoint("us-east-1", null, "ep",+ PROXY_SUBNET_IDS, List.of(), null, null, Map.of())),+ Map.entry("DBProxyEndpointName", () -> rdsService.createDbProxyEndpoint("us-east-1", "app-proxy",+ "", PROXY_SUBNET_IDS, List.of(), null, null, Map.of())),+ Map.entry("VpcSubnetIds", () -> rdsService.createDbProxyEndpoint("us-east-1", "app-proxy", "ep",+ List.of(), List.of(), null, null, Map.of())),+ // Reported as missing before the unknown proxy is looked up.+ Map.entry("VpcSubnetIds", () -> rdsService.createDbProxyEndpoint("us-east-1", "absent", "ep",+ null, List.of(), null, null, Map.of())),+ Map.entry("DBProxyEndpointName", () -> rdsService.modifyDbProxyEndpoint("us-east-1", null,+ "renamed", List.of("sg-x"))),+ Map.entry("DBProxyEndpointName", () -> rdsService.deleteDbProxyEndpoint("us-east-1", " ")));+ for (Map.Entry<String, Executable> c : missing) {+ AwsException e = assertThrows(AwsException.class, c.getValue(), c.getKey());+ assertEquals("MissingParameter", e.getErrorCode(), c.getKey());+ assertEquals("The request must contain the parameter " + c.getKey() + ".", e.getMessage());+ assertEquals(400, e.getHttpStatus());+ }+ assertEquals(List.of("default", "kept"), endpointNames(+ rdsService.describeDbProxyEndpoints("us-east-1", "app-proxy", null, null, null)));+ }++ @Test+ void proxyEndpointRequestsAreCheckedAgainstTheModel() {+ proxyForEndpoints("app-proxy", "POSTGRESQL");+ proxyForEndpoints("mssql-proxy", "SQLSERVER");+ addProxyEndpoint("app-proxy", "taken", null);++ Map<String, Executable> refused = new LinkedHashMap<>();+ refused.put("DBProxyNotFoundFault", () -> addProxyEndpoint("absent", "ep", null));+ refused.put("InvalidParameterValue", () -> addProxyEndpoint("app-proxy", "1st", null));+ refused.put("DBProxyEndpointAlreadyExistsFault", () -> addProxyEndpoint("app-proxy", "taken", null));+ refused.put("InvalidParameterCombination", () -> addProxyEndpoint("mssql-proxy", "ro", "READ_ONLY"));+ refused.put("InvalidSubnet", () -> rdsService.createDbProxyEndpoint("us-east-1", "app-proxy", "ep",+ List.of("subnet-missing"), List.of(), null, null, Map.of()));+ for (Map.Entry<String, Executable> c : refused.entrySet()) {+ assertEquals(c.getKey(), assertThrows(AwsException.class, c.getValue()).getErrorCode(), c.getKey());+ }+ for (Executable invalid : List.<Executable>of(+ () -> addProxyEndpoint("app-proxy", "a--b", null),+ () -> addProxyEndpoint("app-proxy", "ends-", null),+ () -> addProxyEndpoint("app-proxy", "e".repeat(64), null),+ () -> addProxyEndpoint("app-proxy", "ep", "WRITER"),+ // The default VPC carries no IPv6 block, so an IPv6 endpoint cannot be placed in it.+ () -> rdsService.createDbProxyEndpoint("us-east-1", "app-proxy", "ep", PROXY_SUBNET_IDS,+ List.of(), null, "IPV6", Map.of()))) {+ assertEquals("InvalidParameterValue", assertThrows(AwsException.class, invalid).getErrorCode());+ }+ // An unknown network type is refused for what it is, before any VPC check.+ AwsException networkType = assertThrows(AwsException.class, () -> rdsService.createDbProxyEndpoint(+ "us-east-1", "app-proxy", "ep", PROXY_SUBNET_IDS, List.of(), null, "IPV5", Map.of()));+ assertEquals("InvalidParameterValue", networkType.getErrorCode());+ assertTrue(networkType.getMessage().contains("EndpointNetworkType must be IPV4, IPV6, or DUAL"),+ networkType.getMessage());+ // The name is the default endpoint's, which every proxy already has.+ assertEquals("DBProxyEndpointAlreadyExistsFault", assertThrows(AwsException.class,+ () -> addProxyEndpoint("app-proxy", "default", null)).getErrorCode());+ // Names are unique across the account's proxies, not per proxy.+ assertEquals("DBProxyEndpointAlreadyExistsFault", assertThrows(AwsException.class,+ () -> addProxyEndpoint("mssql-proxy", "taken", null)).getErrorCode());+ assertEquals("READ_WRITE", addProxyEndpoint("mssql-proxy", "rw", null).getTargetRole());+ }++ @Test+ void aProxyHoldsAtMostTwentyEndpoints() {+ proxyForEndpoints("app-proxy", "POSTGRESQL");+ for (int i = 1; i < 20; i++) {+ addProxyEndpoint("app-proxy", "ep" + i, null);+ }+ addProxyEndpoint("app-proxy", "ep20", null);+ AwsException full = assertThrows(AwsException.class, () -> addProxyEndpoint("app-proxy", "ep21", null));+ assertEquals("DBProxyEndpointQuotaExceededFault", full.getErrorCode());+ }++ @Test+ void theDefaultProxyEndpointCannotBeChangedAndARenameCannotTakeAName() {+ proxyForEndpoints("app-proxy", "POSTGRESQL");+ addProxyEndpoint("app-proxy", "first", null);+ addProxyEndpoint("app-proxy", "second", null);++ assertEquals("InvalidDBProxyEndpointStateFault", assertThrows(AwsException.class,+ () -> rdsService.modifyDbProxyEndpoint("us-east-1", "default", "renamed", null)).getErrorCode());+ assertEquals("InvalidDBProxyEndpointStateFault", assertThrows(AwsException.class,+ () -> rdsService.deleteDbProxyEndpoint("us-east-1", "default")).getErrorCode());+ assertEquals("DBProxyEndpointAlreadyExistsFault", assertThrows(AwsException.class,+ () -> rdsService.modifyDbProxyEndpoint("us-east-1", "first", "second", null)).getErrorCode());+ assertEquals("DBProxyEndpointAlreadyExistsFault", assertThrows(AwsException.class,+ () -> rdsService.modifyDbProxyEndpoint("us-east-1", "first", "default", null)).getErrorCode());+ assertEquals("DBProxyEndpointNotFoundFault", assertThrows(AwsException.class,+ () -> rdsService.modifyDbProxyEndpoint("us-east-1", "absent", null, null)).getErrorCode());+ assertEquals(List.of("default", "first", "second"), endpointNames(+ rdsService.describeDbProxyEndpoints("us-east-1", "app-proxy", null, null, null)));+ }++ @Test+ void anEndpointOnAProxyThatIsNotAvailableIsRefused() {+ InMemoryStorage<String, DbProxy> proxies = new InMemoryStorage<>();+ rdsService = proxyStoreService(regionResolver, config, proxies, new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>());+ proxyForEndpoints("app-proxy", "POSTGRESQL");+ addProxyEndpoint("app-proxy", "before", null);+ String key = proxies.keys().iterator().next();+ DbProxy stored = proxies.get(key).orElseThrow();+ stored.setStatus("modifying");+ proxies.put(key, stored);++ assertEquals("InvalidDBProxyStateFault", assertThrows(AwsException.class,+ () -> addProxyEndpoint("app-proxy", "ep", null)).getErrorCode());+ assertEquals("InvalidDBProxyStateFault", assertThrows(AwsException.class,+ () -> rdsService.modifyDbProxyEndpoint("us-east-1", "before", "after", null)).getErrorCode());+ }++ @Test+ void deletingAProxyDeletesItsEndpoints() {+ proxyForEndpoints("proxy-a", "POSTGRESQL");+ proxyForEndpoints("proxy-b", "POSTGRESQL");+ addProxyEndpoint("proxy-a", "shared-name", null);+ addProxyEndpoint("proxy-b", "b-endpoint", null);++ rdsService.deleteDbProxy("proxy-a", "us-east-1");++ assertEquals(List.of("default", "b-endpoint"), endpointNames(+ rdsService.describeDbProxyEndpoints("us-east-1", null, null, null, null)));+ assertEquals("DBProxyEndpointNotFoundFault", assertThrows(AwsException.class,+ () -> rdsService.deleteDbProxyEndpoint("us-east-1", "shared-name")).getErrorCode());+ // The deleted proxy's endpoint name is free again.+ assertEquals("proxy-b", addProxyEndpoint("proxy-b", "shared-name", null).getDbProxyName());+ }++ @Test+ void proxyEndpointsPageAndFilterByName() {+ proxyForEndpoints("proxy-a", "POSTGRESQL");+ proxyForEndpoints("proxy-b", "POSTGRESQL");+ for (int i = 10; i < 30; i++) {+ addProxyEndpoint("proxy-a", "a" + i, null);+ }+ for (int i = 10; i < 15; i++) {+ addProxyEndpoint("proxy-b", "b" + i, null);+ }++ RdsService.ProxyEndpointPage first = rdsService.describeDbProxyEndpoints("us-east-1", null, null, 20, null);+ assertEquals(20, first.endpoints().size());+ assertEquals("default", first.endpoints().get(0).getDbProxyEndpointName());+ assertEquals("proxy-a", first.endpoints().get(0).getDbProxyName());+ assertNotNull(first.marker());+ RdsService.ProxyEndpointPage second = rdsService.describeDbProxyEndpoints("us-east-1", null, null, 20,+ first.marker());+ assertEquals(List.of("a29", "default", "b10", "b11", "b12", "b13", "b14"), endpointNames(second));+ assertNull(second.marker());++ assertEquals(List.of("b12"), endpointNames(+ rdsService.describeDbProxyEndpoints("us-east-1", null, "b12", null, null)));+ assertEquals("DBProxyEndpointNotFoundFault", assertThrows(AwsException.class,+ () -> rdsService.describeDbProxyEndpoints("us-east-1", "proxy-a", "b12", null, null))+ .getErrorCode());+ assertEquals("DBProxyNotFoundFault", assertThrows(AwsException.class,+ () -> rdsService.describeDbProxyEndpoints("us-east-1", "absent", null, null, null)).getErrorCode());+ assertEquals("InvalidParameterValue", assertThrows(AwsException.class,+ () -> rdsService.describeDbProxyEndpoints("us-east-1", null, null, 19, null)).getErrorCode());+ }++ @Test+ void proxyEndpointTagsRoundTripAndItDefaultsToTheVpcsDefaultSecurityGroup() {+ DbProxy proxy = proxyForEndpoints("app-proxy", "POSTGRESQL");+ SecurityGroup defaultGroup = new SecurityGroup();+ defaultGroup.setGroupId("sg-vpc-default");+ defaultGroup.setGroupName("default");+ SecurityGroup otherGroup = new SecurityGroup();+ otherGroup.setGroupId("sg-vpc-other");+ otherGroup.setGroupName("other");+ when(ec2Service.getSecurityGroupsForVpc("us-east-1", proxy.getVpcId(), Map.of()))+ .thenReturn(List.of(otherGroup, defaultGroup));++ DbProxyEndpoint endpoint = rdsService.createDbProxyEndpoint("us-east-1", "app-proxy", "ep",+ PROXY_SUBNET_IDS, List.of(), null, null, Map.of("env", "dev"));+ assertEquals(List.of("sg-vpc-default"), endpoint.getVpcSecurityGroupIds());++ String arn = endpoint.getDbProxyEndpointArn();+ assertEquals(Map.of("env", "dev"), rdsService.listTagsForResource(arn));+ rdsService.addTagsToResource(arn, Map.of("team", "data"));+ rdsService.removeTagsFromResource(arn, List.of("env"));+ assertEquals(Map.of("team", "data"), rdsService.listTagsForResource(arn));+ }}