Light, fluffy, and always free - The AWS Local Emulator alternative
feat(redshift-serverless): manage namespace admin credentials (#6491)
Vũ Thế Huy0a13e4259e43
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.javaindex 0df0d3df14..6a2aad9a5d 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.java@@ -1,5 +1,7 @@package com.floci.test;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;import org.jboss.logging.Logger;import org.junit.jupiter.api.DisplayName;import org.junit.jupiter.api.Test;@@ -29,8 +31,11 @@ import software.amazon.awssdk.services.redshiftserverless.model.UsageLimitUsageTimport software.amazon.awssdk.services.redshiftserverless.model.ValidationException;import software.amazon.awssdk.services.redshiftserverless.model.Workgroup;import software.amazon.awssdk.services.redshiftserverless.model.WorkgroupStatus;+import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;+import software.amazon.awssdk.services.secretsmanager.model.SecretsManagerException;import java.time.Instant;+import java.util.UUID;import static org.assertj.core.api.Assertions.assertThat;import static org.assertj.core.api.Assertions.assertThatThrownBy;@@ -42,6 +47,58 @@ class RedshiftServerlessTest {private static final Logger LOG = Logger.getLogger(RedshiftServerlessTest.class);+ @Test+ void managedNamespaceSecretAuthenticatesDataApiAndIsRemovedWhenManagementIsDisabled() throws Exception {+ assumeFalse(TestFixtures.isRealAws(), "Creates local resources and verifies immediate secret cleanup");++ try (RedshiftServerlessClient client = TestFixtures.redshiftServerlessClient();+ SecretsManagerClient secrets = TestFixtures.secretsManagerClient();+ RedshiftDataClient data = TestFixtures.redshiftDataClient()) {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String namespaceName = "floci-managed-ns-" + suffix;+ String workgroupName = "floci-managed-wg-" + suffix;+ try {+ Namespace created = client.createNamespace(request -> request.namespaceName(namespaceName)+ .adminUsername("admin").dbName("analytics").manageAdminPassword(true)).namespace();+ String secretArn = created.adminPasswordSecretArn();+ assertThat(secretArn).isNotBlank();+ assertThat(client.getNamespace(request -> request.namespaceName(namespaceName))+ .namespace().adminPasswordSecretArn()).isEqualTo(secretArn);+ JsonNode credentials = new ObjectMapper().readTree(secrets.getSecretValue(request -> request+ .secretId(secretArn)).secretString());+ assertThat(credentials.path("username").asText()).isEqualTo("admin");+ assertThat(credentials.path("password").asText()).isNotBlank();+ assertThat(credentials.path("dbname").asText()).isEqualTo("analytics");+ assertThat(credentials.path("engine").asText()).isEqualTo("redshift");+ assertThat(secrets.describeSecret(request -> request.secretId(secretArn)).owningService())+ .isEqualTo("redshift");++ client.createWorkgroup(request -> request.workgroupName(workgroupName).namespaceName(namespaceName));+ ExecuteStatementResponse executed = data.executeStatement(request -> request+ .workgroupName(workgroupName).secretArn(secretArn).database("analytics")+ .sql("SELECT 1").waitTimeSeconds(30));+ DescribeStatementResponse described = data.describeStatement(request -> request.id(executed.id()));+ assertThat(described.status()).as(described.error()).isEqualTo(StatusString.FINISHED);+ assertThat(data.getStatementResult(request -> request.id(executed.id()))+ .records().get(0).get(0).longValue()).isEqualTo(1L);++ Namespace updated = client.updateNamespace(request -> request.namespaceName(namespaceName)+ .manageAdminPassword(false).adminUserPassword("Replacement123!")).namespace();+ assertThat(updated.adminPasswordSecretArn()).isNull();+ assertThat(updated.adminPasswordSecretKmsKeyId()).isNull();+ assertThat(client.getNamespace(request -> request.namespaceName(namespaceName))+ .namespace().adminPasswordSecretArn()).isNull();+ assertThatThrownBy(() -> secrets.getSecretValue(request -> request.secretId(secretArn)))+ .isInstanceOfSatisfying(SecretsManagerException.class,+ error -> assertThat(error.awsErrorDetails().errorCode())+ .isEqualTo("ResourceNotFoundException"));+ } finally {+ deleteWorkgroupBestEffort(client, workgroupName);+ deleteBestEffort(client, namespaceName);+ }+ }+ }+@Testvoid namespaceLifecycleUsesAwsSdk() {assumeFalse(TestFixtures.isRealAws(), "Creates a namespace and asserts emulator-local defaults");diff --git a/docs/services/redshift-serverless.md b/docs/services/redshift-serverless.mdindex 687c228c79..fffe3188a3 100644--- a/docs/services/redshift-serverless.md+++ b/docs/services/redshift-serverless.md@@ -74,10 +74,10 @@ Namespace and workgroup state is account and Region scoped and persisted through## Compatibility Notes- **A workgroup runs a real PostgreSQL container.** `CreateWorkgroup` starts the container (this needs Docker and uses `floci.services.redshift.image-version`) and an authenticating proxy on the `endpoint`, whose port comes from the same pool as provisioned Redshift clusters (`floci.services.redshift.proxy-base-port` to `proxy-max-port`). Connect with any PostgreSQL client or JDBC driver using the namespace admin user and password, to the namespace `dbName`. The Redshift Data API accepts `WorkgroupName` ([details](redshift-data.md)). Only the operations in the Supported Actions table are served. The rest of the Redshift Serverless API is not emulated and answers `UnknownOperationException`: snapshot restore access policies, recovery points, table restore and restore status, the Identity Center token, and lakehouse configuration.-- **Admin credentials come from the namespace.** The backend role is the namespace `adminUsername` (default `admin`) and the password is the `adminUserPassword` the namespace was created with. A namespace created without a password gets a generated one that is kept internally and never returned, so such a workgroup is reachable through `GetCredentials` and the Data API only. `manageAdminPassword` still creates no secret. Changing `adminUserPassword` with `UpdateNamespace` takes effect for new connections and is refused with `ValidationException` if the backend rejects it (AWS password rules: 8 to 64 characters with upper case, lower case and a digit, and none of `' " / @`). Changing `adminUsername` on a running workgroup does not rename the backend role; the new name is accepted at the proxy, which opens the backend as the original role.+- **Admin credentials come from the namespace.** The backend role is the namespace `adminUsername` (default `admin`) and the password is the `adminUserPassword` the namespace was created with. A namespace created without a password gets a generated one that is kept internally and never returned, so such a workgroup is reachable through `GetCredentials` and the Data API only unless managed credentials are enabled. Changing `adminUserPassword` with `UpdateNamespace` takes effect for new connections and is refused with `ValidationException` if the backend rejects it (AWS password rules: 8 to 64 characters with upper case, lower case and a digit, and none of `' " / @`). Changing `adminUsername` on a running workgroup does not rename the backend role; the new name is accepted at the proxy, which opens the backend as the original role.- **`GetCredentials` returns a master-equivalent password.** `dbUser` is derived from the signing identity (`IAM:<user>` or `IAMR:<role>`, falling back to `IAMR:floci` when the caller cannot be resolved), `dbPassword` is random, and `expiration` and `nextRefreshTime` are epoch seconds (the same instant). `durationSeconds` defaults to 900 and must be 900 to 3600. `dbName`, when given, must be the namespace `dbName`. `customDomainName` can be used in place of `workgroupName` to resolve the associated workgroup. A returned credential stays valid until it expires or the workgroup is deleted.- **The runtime survives a restart when its container does.** On startup Floci re-attaches to the container and restarts the proxy on the same port, so the endpoint is stable. If the container is gone the workgroup comes back with an empty database; if neither can be started, the workgroup stays `AVAILABLE`, the Data API reports that its runtime is not available, and the failure is logged. Containers have no Docker volume, as for provisioned clusters.-- **`adminUserPassword` is accepted and never returned**, matching AWS. No secret is created for `manageAdminPassword`.+- **Managed admin credentials use Secrets Manager.** `CreateNamespace` and `UpdateNamespace` accept `manageAdminPassword=true` to generate a password and create a service-owned secret. The namespace returns `adminPasswordSecretArn` and, when supplied, `adminPasswordSecretKmsKeyId`; the latter requires `manageAdminPassword=true`. The secret contains `engine`, `username`, `password`, `dbname`, and `namespaceName`. `GetNamespace` and `ListNamespaces` return the same references, and the Data API accepts the secret ARN with `WorkgroupName`. Passwords are never returned in namespace responses. Enabling management updates a running backend's password. While credentials are managed, an explicit `adminUserPassword` is rejected; switching to `manageAdminPassword=false` requires a replacement password, updates the backend, and removes the secret. Deleting the namespace also removes its managed secret. Credential changes compensate backend, secret, and namespace writes on failure. The secret reference survives persistence and snapshot restore of the existing namespace. Changing managed-credential settings through `RestoreFromSnapshot` or CloudFormation is not implemented. As for other service-owned secrets in Floci, automatic rotation and `RotateSecret` password replacement are not executed; no successful rotation is reported.- **Defaults follow AWS.** `dbName` defaults to `dev`, `kmsKeyId` to `AWS_OWNED_KMS_KEY`, `logExports` to an empty list, and `status` to `AVAILABLE` immediately: there is no `MODIFYING` or `CREATING` phase to poll through.- **`creationDate` is an ISO-8601 string**, for example `2026-09-11T18:12:55.433Z`, not theepoch-seconds number that awsJson1.1 uses by default. `Namespace.creationDate` carriesdiff --git a/pom.xml b/pom.xmlindex c4c4ae8029..b3dbb1732e 100644--- a/pom.xml+++ b/pom.xml@@ -435,6 +435,18 @@<version>${aws.sdk.version}</version><scope>test</scope></dependency>+ <dependency>+ <groupId>software.amazon.awssdk</groupId>+ <artifactId>redshiftserverless</artifactId>+ <version>${aws.sdk.version}</version>+ <scope>test</scope>+ </dependency>+ <dependency>+ <groupId>software.amazon.awssdk</groupId>+ <artifactId>secretsmanager</artifactId>+ <version>${aws.sdk.version}</version>+ <scope>test</scope>+ </dependency><dependency><groupId>software.amazon.awssdk</groupId><artifactId>url-connection-client</artifactId>diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.java b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.javaindex 22e11cb538..505a9d6304 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolver.java@@ -13,6 +13,7 @@ import io.github.hectorvent.floci.services.redshift.spectrum.SpectrumSession;import io.github.hectorvent.floci.services.redshiftserverless.RedshiftServerlessRuntime;import io.github.hectorvent.floci.services.redshiftserverless.RedshiftServerlessService;import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;+import io.github.hectorvent.floci.services.secretsmanager.model.Secret;import io.github.hectorvent.floci.services.secretsmanager.model.SecretVersion;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -80,9 +81,25 @@ class RedshiftDataResourceResolver {return new DatabaseTarget(workgroup.arn(), workgroup.host(), workgroup.port(), database,workgroup.masterUsername(), workgroup.masterPassword(), spectrum);}- DatabaseSecretCredentials creds = secretCredentials(request.get("SecretArn").asText(), region);+ String secretArn = request.get("SecretArn").asText();+ DatabaseSecretCredentials creds = secretCredentials(secretArn, region);+ String user = creds.username();+ if (isManagedAdminSecret(secretArn, workgroup.adminPasswordSecretArn(), region)) {+ user = workgroup.masterUsername();+ }return new DatabaseTarget(workgroup.arn(), workgroup.host(), workgroup.port(), database,- creds.username(), creds.password(), spectrum);+ user, creds.password(), spectrum);+ }++ private boolean isManagedAdminSecret(String secretArn, String managedSecretArn, String region) {+ if (managedSecretArn == null) {+ return false;+ }+ if (managedSecretArn.equals(secretArn)) {+ return true;+ }+ Secret resolvedSecret = secretsManagerService.describeSecret(secretArn, region);+ return resolvedSecret != null && managedSecretArn.equals(resolvedSecret.getArn());}private DatabaseSecretCredentials secretCredentials(String secretArn, String region) {diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminSecrets.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminSecrets.javanew file mode 100644index 0000000000..4a0190dd5f--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminSecrets.java@@ -0,0 +1,60 @@+package io.github.hectorvent.floci.services.redshiftserverless;++import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.redshiftserverless.model.Namespace;+import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;+import io.github.hectorvent.floci.services.secretsmanager.model.Secret;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.util.List;++@ApplicationScoped+public class RedshiftServerlessAdminSecrets {+ private final SecretsManagerService secrets;+ private final ObjectMapper mapper;++ @Inject+ public RedshiftServerlessAdminSecrets(SecretsManagerService secrets, ObjectMapper mapper) {+ this.secrets = secrets;+ this.mapper = mapper;+ }++ void create(Namespace namespace, String kmsKeyId, String region) {+ Secret secret = secrets.createSecret("redshift-serverless/" + namespace.getNamespaceId(), value(namespace), null,+ "Managed admin credentials for Redshift Serverless namespace " + namespace.getNamespaceName(),+ kmsKeyId, List.of(), "redshift", region);+ namespace.setAdminPasswordSecretArn(secret.getArn());+ namespace.setAdminPasswordSecretKmsKeyId(kmsKeyId);+ }++ void update(Namespace namespace, String region) {+ secrets.updateSecret(namespace.getAdminPasswordSecretArn(), null,+ namespace.getAdminPasswordSecretKmsKeyId() == null ? "" : namespace.getAdminPasswordSecretKmsKeyId(), region);+ secrets.putSecretValue(namespace.getAdminPasswordSecretArn(), value(namespace), null, null, region,+ List.of("AWSCURRENT"));+ }++ void delete(Namespace namespace, String region) {+ if (namespace.getAdminPasswordSecretArn() == null) {+ return;+ }+ try {+ secrets.deleteSecret(namespace.getAdminPasswordSecretArn(), null, true, region);+ } catch (AwsException exception) {+ if (!"ResourceNotFoundException".equals(exception.getErrorCode())) {+ throw exception;+ }+ // A namespace can still be deleted when its managed secret was already removed.+ }+ }++ private String value(Namespace namespace) {+ return mapper.createObjectNode().put("engine", "redshift")+ .put("username", namespace.getAdminUsername())+ .put("password", namespace.getAdminUserPassword())+ .put("dbname", namespace.getDbName())+ .put("namespaceName", namespace.getNamespaceName()).toString();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandler.javaindex 6349883c3e..1df4f96d20 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandler.java@@ -124,6 +124,8 @@ public class RedshiftServerlessJsonHandler {ServerlessSupport.stringList(request, "iamRoles"),ServerlessSupport.stringList(request, "logExports"),parseTagList(request.path("tags"), "tags"),+ ServerlessSupport.bool(request, "manageAdminPassword"),+ ServerlessSupport.text(request, "adminPasswordSecretKmsKeyId"),region);return namespaceResponse(namespace);}@@ -153,6 +155,8 @@ public class RedshiftServerlessJsonHandler {ServerlessSupport.text(request, "defaultIamRoleArn"),ServerlessSupport.stringList(request, "iamRoles"),ServerlessSupport.stringList(request, "logExports"),+ ServerlessSupport.bool(request, "manageAdminPassword"),+ ServerlessSupport.text(request, "adminPasswordSecretKmsKeyId"),region);return namespaceResponse(namespace);}@@ -400,6 +404,12 @@ public class RedshiftServerlessJsonHandler {node.put("dbName", namespace.getDbName());node.put("kmsKeyId", namespace.getKmsKeyId());node.put("status", namespace.getStatus());+ if (namespace.getAdminPasswordSecretArn() != null) {+ node.put("adminPasswordSecretArn", namespace.getAdminPasswordSecretArn());+ }+ if (namespace.getAdminPasswordSecretKmsKeyId() != null) {+ node.put("adminPasswordSecretKmsKeyId", namespace.getAdminPasswordSecretKmsKeyId());+ }if (namespace.getAdminUsername() != null) {node.put("adminUsername", namespace.getAdminUsername());}diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.javaindex d28e3f6a37..e79724137f 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.java@@ -32,6 +32,7 @@ import java.util.ArrayList;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;+import java.util.Objects;import java.util.Optional;import java.util.Set;import java.util.UUID;@@ -108,11 +109,18 @@ public class RedshiftServerlessService implements Resettable {private final RedshiftServerlessEndpoints endpoints;private final RedshiftServerlessRuntime runtime;private final EmulatorConfig config;+ private final RedshiftServerlessAdminSecrets adminSecrets;- @Injectpublic RedshiftServerlessService(StorageFactory storageFactory, RegionResolver regionResolver,RedshiftServerlessEndpoints endpoints, RedshiftServerlessRuntime runtime,EmulatorConfig config) {+ this(storageFactory, regionResolver, endpoints, runtime, config, null);+ }++ @Inject+ public RedshiftServerlessService(StorageFactory storageFactory, RegionResolver regionResolver,+ RedshiftServerlessEndpoints endpoints, RedshiftServerlessRuntime runtime,+ EmulatorConfig config, RedshiftServerlessAdminSecrets adminSecrets) {this.namespaces = storageFactory.create("redshiftserverless", "redshiftserverless-namespaces.json",new TypeReference<Map<String, Namespace>>() {});this.workgroups = storageFactory.create("redshiftserverless", "redshiftserverless-workgroups.json",@@ -123,6 +131,7 @@ public class RedshiftServerlessService implements Resettable {this.endpoints = endpoints;this.runtime = runtime;this.config = config;+ this.adminSecrets = adminSecrets;}/**@@ -213,6 +222,17 @@ public class RedshiftServerlessService implements Resettable {String adminUserPassword, String dbName, String kmsKeyId,String defaultIamRoleArn, List<String> iamRoles,List<String> logExports, Map<String, String> tags, String region) {+ return createNamespace(namespaceName, adminUsername, adminUserPassword, dbName, kmsKeyId,+ defaultIamRoleArn, iamRoles, logExports, tags, null, null, region);+ }++ public synchronized Namespace createNamespace(String namespaceName, String adminUsername,+ String adminUserPassword, String dbName, String kmsKeyId,+ String defaultIamRoleArn, List<String> iamRoles,+ List<String> logExports, Map<String, String> tags,+ Boolean manageAdminPassword, String adminPasswordSecretKmsKeyId,+ String region) {+ validateManagedPassword(manageAdminPassword, adminUserPassword, adminPasswordSecretKmsKeyId);validateNamespaceName(namespaceName);String key = storageKey(region, namespaceName);if (namespaces.get(key).isPresent()) {@@ -234,7 +254,20 @@ public class RedshiftServerlessService implements Resettable {namespace.setStatus("AVAILABLE");namespace.setCreationDate(Instant.now());namespace.setTags(tags == null ? new LinkedHashMap<>() : new LinkedHashMap<>(tags));- namespaces.put(key, namespace);+ if (Boolean.TRUE.equals(manageAdminPassword)) {+ namespace.setAdminUsername(adminUserOf(namespace));+ namespace.setAdminUserPassword(runtime.generatePassword());+ requireAdminSecrets().create(namespace, adminPasswordSecretKmsKeyId, region);+ }+ try {+ namespaces.put(key, namespace);+ } catch (RuntimeException failure) {+ if (namespace.getAdminPasswordSecretArn() != null) {+ compensate(() -> namespaces.delete(key), failure, "remove namespace after failed create");+ compensate(() -> requireAdminSecrets().delete(namespace, region), failure, "delete orphaned admin secret");+ }+ throw failure;+ }return namespace;}@@ -267,7 +300,16 @@ public class RedshiftServerlessService implements Resettable {String defaultIamRoleArn, List<String> iamRoles,List<String> logExports, String region) {return applyNamespaceUpdate(namespaceName, adminUsername, adminUserPassword, kmsKeyId,- defaultIamRoleArn, iamRoles, logExports, region, false);+ defaultIamRoleArn, iamRoles, logExports, null, null, region, false);+ }++ public synchronized Namespace updateNamespace(String namespaceName, String adminUsername,+ String adminUserPassword, String kmsKeyId,+ String defaultIamRoleArn, List<String> iamRoles,+ List<String> logExports, Boolean manageAdminPassword,+ String adminPasswordSecretKmsKeyId, String region) {+ return applyNamespaceUpdate(namespaceName, adminUsername, adminUserPassword, kmsKeyId,+ defaultIamRoleArn, iamRoles, logExports, manageAdminPassword, adminPasswordSecretKmsKeyId, region, false);}/**@@ -280,7 +322,7 @@ public class RedshiftServerlessService implements Resettable {String defaultIamRoleArn, List<String> iamRoles,List<String> logExports, String region) {return applyNamespaceUpdate(namespaceName, adminUsername, adminUserPassword, kmsKeyId,- defaultIamRoleArn, iamRoles, logExports, region, true);+ defaultIamRoleArn, iamRoles, logExports, null, null, region, true);}/**@@ -291,7 +333,9 @@ public class RedshiftServerlessService implements Resettable {private Namespace applyNamespaceUpdate(String namespaceName, String adminUsername,String adminUserPassword, String kmsKeyId,String defaultIamRoleArn, List<String> iamRoles,- List<String> logExports, String region, boolean resetOmitted) {+ List<String> logExports, Boolean manageAdminPassword,+ String adminPasswordSecretKmsKeyId, String region, boolean resetOmitted) {+ validateManagedPassword(manageAdminPassword, adminUserPassword, adminPasswordSecretKmsKeyId);String key = storageKey(region, namespaceName);Namespace current = getNamespace(namespaceName, region);Namespace updated = new Namespace(current);@@ -312,36 +356,85 @@ public class RedshiftServerlessService implements Resettable {if (logExports != null) {updated.setLogExports(validateLogExports(logExports));}- boolean rotated = adminUserPassword != null && !adminUserPassword.isBlank();- if (rotated) {- applyNewAdminPassword(current, adminUserPassword, region);+ boolean wasManaged = current.getAdminPasswordSecretArn() != null;+ boolean managed = manageAdminPassword == null ? wasManaged : manageAdminPassword;+ if (managed && adminUserPassword != null) {+ throw ServerlessSupport.validation("adminUserPassword cannot be supplied while admin credentials are managed.");+ }+ if (!managed && wasManaged && blankToNull(adminUserPassword) == null) {+ throw ServerlessSupport.validation("adminUserPassword is required when disabling managed admin credentials.");+ }+ if (managed) {+ updated.setAdminUsername(adminUserOf(updated));+ if (!wasManaged) {+ updated.setAdminUserPassword(runtime.generatePassword());+ }+ if (adminPasswordSecretKmsKeyId != null) {+ updated.setAdminPasswordSecretKmsKeyId(adminPasswordSecretKmsKeyId);+ }+ } else if (blankToNull(adminUserPassword) != null) {updated.setAdminUserPassword(adminUserPassword);}+ if (!managed) {+ updated.setAdminPasswordSecretArn(null);+ updated.setAdminPasswordSecretKmsKeyId(null);+ }+ boolean rotated = !Objects.equals(current.getAdminUserPassword(), updated.getAdminUserPassword());+ boolean secretUpdated = managed && wasManaged+ && (!Objects.equals(current.getAdminUsername(), updated.getAdminUsername())+ || !Objects.equals(current.getAdminPasswordSecretKmsKeyId(), updated.getAdminPasswordSecretKmsKeyId()));+ boolean backendChanged = false;+ boolean storeAttempted = false;try {- namespaces.put(key, updated);- } catch (RuntimeException e) {+ if (managed && !wasManaged) {+ requireAdminSecrets().create(updated, adminPasswordSecretKmsKeyId, region);+ } else if (secretUpdated) {+ requireAdminSecrets().update(updated, region);+ }if (rotated) {- try {- restoreAdminPassword(current, region);- } catch (RuntimeException restoreFailure) {- LOG.errorv(restoreFailure, "Could not restore the admin password of namespace {0}; "- + "the backend may reject the stored password", namespaceName);- e.addSuppressed(restoreFailure);- }+ applyNewAdminPassword(current, updated.getAdminUserPassword(), region);+ backendChanged = true;}- throw e;+ storeAttempted = true;+ namespaces.put(key, updated);+ if (wasManaged && !managed) {+ requireAdminSecrets().delete(current, region);+ }+ } catch (RuntimeException failure) {+ if (storeAttempted) {+ compensate(() -> namespaces.put(key, current), failure, "restore namespace credentials");+ }+ if (backendChanged) {+ compensate(() -> restoreAdminPassword(current, region), failure, "restore backend admin password");+ }+ if (managed && !wasManaged && updated.getAdminPasswordSecretArn() != null) {+ compensate(() -> requireAdminSecrets().delete(updated, region), failure, "delete orphaned admin secret");+ } else if (secretUpdated) {+ compensate(() -> requireAdminSecrets().update(current, region), failure, "restore managed admin secret");+ }+ throw failure;}return updated;}public synchronized Namespace deleteNamespace(String namespaceName, String region) {- Namespace deleted = new Namespace(getNamespace(namespaceName, region));+ Namespace current = getNamespace(namespaceName, region);+ Namespace deleted = new Namespace(current);// A workgroup cannot outlive its namespace; the model lists ConflictException for this call// but not its trigger, so this guard is the single place to relax if AWS turns out to differ.if (workgroupOf(namespaceName, region).isPresent()) {throw ServerlessSupport.conflict("The namespace " + namespaceName + " still has a workgroup. Delete the workgroup first.");}- namespaces.delete(storageKey(region, namespaceName));+ String key = storageKey(region, namespaceName);+ try {+ namespaces.delete(key);+ if (deleted.getAdminPasswordSecretArn() != null) {+ requireAdminSecrets().delete(deleted, region);+ }+ } catch (RuntimeException failure) {+ compensate(() -> namespaces.put(key, current), failure, "restore namespace after failed deletion");+ throw failure;+ }deleted.setStatus("DELETING");return deleted;}@@ -829,15 +922,25 @@ public class RedshiftServerlessService implements Resettable {}return new WorkgroupTarget(workgroup.getWorkgroupArn(), workgroup.getWorkgroupName(),workgroup.getRuntimeHost(), workgroup.getRuntimePort(), namespace.getDbName(),- workgroup.getMasterUsername(), namespace.getAdminUserPassword(), adminUserOf(namespace), namespace.getIamRoles());+ workgroup.getMasterUsername(), namespace.getAdminUserPassword(), adminUserOf(namespace),+ namespace.getIamRoles(), namespace.getAdminPasswordSecretArn());}/** Connection details of a workgroup's backend; {@code adminUsername} is the name clients log in with. */public record WorkgroupTarget(String arn, String workgroupName, String host, int port, String database,- String masterUsername, String masterPassword, String adminUsername, List<String> iamRoleArns) {+ String masterUsername, String masterPassword, String adminUsername,+ List<String> iamRoleArns, String adminPasswordSecretArn) {+ public WorkgroupTarget(String arn, String workgroupName, String host, int port, String database,+ String masterUsername, String masterPassword, String adminUsername,+ List<String> iamRoleArns) {+ this(arn, workgroupName, host, port, database, masterUsername, masterPassword, adminUsername,+ iamRoleArns, null);+ }+public WorkgroupTarget(String arn, String workgroupName, String host, int port, String database,String masterUsername, String masterPassword, String adminUsername) {- this(arn, workgroupName, host, port, database, masterUsername, masterPassword, adminUsername, List.of());+ this(arn, workgroupName, host, port, database, masterUsername, masterPassword, adminUsername,+ List.of(), null);}public WorkgroupTarget {@@ -919,6 +1022,36 @@ public class RedshiftServerlessService implements Resettable {return value == null || value.isBlank() ? null : value;}+ private RedshiftServerlessAdminSecrets requireAdminSecrets() {+ if (adminSecrets == null) {+ throw new AwsException("InternalServerException", "Secrets Manager is unavailable.", 500);+ }+ return adminSecrets;+ }++ private static void validateManagedPassword(Boolean manage, String password, String secretKey) {+ if (Boolean.TRUE.equals(manage) && password != null) {+ throw ServerlessSupport.validation("adminUserPassword cannot be supplied when manageAdminPassword is true.");+ }+ if (secretKey != null) {+ if (!Boolean.TRUE.equals(manage)) {+ throw ServerlessSupport.validation("adminPasswordSecretKmsKeyId requires manageAdminPassword to be true.");+ }+ ServerlessSupport.requireText(secretKey, "adminPasswordSecretKmsKeyId");+ }+ }++ private static void compensate(Runnable action, RuntimeException failure, String operation) {+ try {+ action.run();+ } catch (RuntimeException rollbackFailure) {+ LOG.errorv(rollbackFailure, "Could not {0}", operation);+ if (rollbackFailure != failure) {+ failure.addSuppressed(rollbackFailure);+ }+ }+ }+private Optional<Workgroup> workgroupOf(String namespaceName, String region) {return workgroups.scan(key -> key.startsWith(region + "::")).stream().filter(workgroup -> namespaceName.equals(workgroup.getNamespaceName()))diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/model/Namespace.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/model/Namespace.javaindex e857594bef..14377a3ba5 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/model/Namespace.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/model/Namespace.java@@ -21,6 +21,8 @@ public class Namespace {* credentials. AWS never returns it, so no response builder may read it.*/private String adminUserPassword;+ private String adminPasswordSecretArn;+ private String adminPasswordSecretKmsKeyId;private String dbName;private String kmsKeyId;private String defaultIamRoleArn;@@ -45,6 +47,8 @@ public class Namespace {this.namespaceArn = other.namespaceArn;this.adminUsername = other.adminUsername;this.adminUserPassword = other.adminUserPassword;+ this.adminPasswordSecretArn = other.adminPasswordSecretArn;+ this.adminPasswordSecretKmsKeyId = other.adminPasswordSecretKmsKeyId;this.dbName = other.dbName;this.kmsKeyId = other.kmsKeyId;this.defaultIamRoleArn = other.defaultIamRoleArn;@@ -99,6 +103,22 @@ public class Namespace {return dbName;}+ public String getAdminPasswordSecretArn() {+ return adminPasswordSecretArn;+ }++ public void setAdminPasswordSecretArn(String adminPasswordSecretArn) {+ this.adminPasswordSecretArn = adminPasswordSecretArn;+ }++ public String getAdminPasswordSecretKmsKeyId() {+ return adminPasswordSecretKmsKeyId;+ }++ public void setAdminPasswordSecretKmsKeyId(String adminPasswordSecretKmsKeyId) {+ this.adminPasswordSecretKmsKeyId = adminPasswordSecretKmsKeyId;+ }+public void setDbName(String dbName) {this.dbName = dbName;}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataAdminSecretIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataAdminSecretIntegrationTest.javanew file mode 100644index 0000000000..d6eb15aaa9--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataAdminSecretIntegrationTest.java@@ -0,0 +1,219 @@+package io.github.hectorvent.floci.services.redshiftdata;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.services.redshift.model.Endpoint;+import io.github.hectorvent.floci.services.redshiftserverless.RedshiftServerlessRuntime;+import io.github.hectorvent.floci.services.redshiftserverless.RedshiftServerlessService;+import io.github.hectorvent.floci.testing.PartitionCleanup;+import io.quarkus.test.InjectMock;+import io.quarkus.test.common.http.TestHTTPResource;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.h2.Driver;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;+import org.mockito.ArgumentCaptor;+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;+import software.amazon.awssdk.regions.Region;+import software.amazon.awssdk.services.redshiftdata.RedshiftDataClient;+import software.amazon.awssdk.services.redshiftdata.model.DescribeStatementResponse;+import software.amazon.awssdk.services.redshiftdata.model.ExecuteStatementResponse;+import software.amazon.awssdk.services.redshiftdata.model.StatusString;+import software.amazon.awssdk.services.redshiftserverless.RedshiftServerlessClient;+import software.amazon.awssdk.services.redshiftserverless.model.Namespace;+import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;++import java.net.URI;+import java.sql.DriverManager;+import java.util.UUID;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyBoolean;+import static org.mockito.Mockito.atLeastOnce;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++@QuarkusTest+class RedshiftDataAdminSecretIntegrationTest {++ private static final String GENERATED_PASSWORD = "ManagedDataSecret123!";++ @TestHTTPResource("/")+ URI endpoint;++ @InjectMock+ RedshiftServerlessRuntime runtime;++ @InjectMock+ RedshiftDataConnectionFactory factory;++ @Inject+ RedshiftServerlessService serverlessService;++ @Inject+ RedshiftDataService dataService;++ @Inject+ ObjectMapper mapper;++ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();++ private RedshiftServerlessClient redshift;+ private SecretsManagerClient secrets;+ private RedshiftDataClient data;++ @BeforeEach+ void setup() throws Exception {+ Driver.load();+ String url = "jdbc:h2:mem:" + UUID.randomUUID();+ when(factory.open(any())).thenAnswer(invocation -> DriverManager.getConnection(url));+ when(runtime.generatePassword()).thenReturn(GENERATED_PASSWORD);+ when(runtime.start(any(String.class), any(String.class), any(String.class), any(String.class),+ any(String.class), any(String.class), any(Endpoint.class), anyBoolean(), any()))+ .thenReturn(new RedshiftServerlessRuntime.Backend("127.0.0.1", 55432));+ StaticCredentialsProvider credentials = StaticCredentialsProvider.create(+ AwsBasicCredentials.create("test", "test"));+ redshift = RedshiftServerlessClient.builder().endpointOverride(endpoint).region(Region.US_EAST_1)+ .credentialsProvider(credentials).build();+ secrets = SecretsManagerClient.builder().endpointOverride(endpoint).region(Region.US_EAST_1)+ .credentialsProvider(credentials).build();+ data = RedshiftDataClient.builder().endpointOverride(endpoint).region(Region.US_EAST_1)+ .credentialsProvider(credentials).build();+ cleanup.register(redshift::close);+ cleanup.register(secrets::close);+ cleanup.register(data::close);+ cleanup.register(dataService::clear);+ }++ @Test+ void sdkExecutesSqlUsingTheNamespaceManagedSecretAndPersistedCredentials() throws Exception {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String namespaceName = "data-secret-" + suffix;+ String workgroup = "data-secret-wg-" + suffix;+ Namespace namespace = redshift.createNamespace(request -> request.namespaceName(namespaceName)+ .adminUsername("warehouse_admin").dbName("analytics").manageAdminPassword(true)).namespace();+ cleanup.register(() -> redshift.deleteNamespace(request -> request.namespaceName(namespaceName)));+ redshift.createWorkgroup(request -> request.workgroupName(workgroup).namespaceName(namespaceName));+ cleanup.register(() -> redshift.deleteWorkgroup(request -> request.workgroupName(workgroup)));+ assertNotNull(namespace.adminPasswordSecretArn());+ JsonNode value = mapper.readTree(secrets.getSecretValue(request -> request+ .secretId(namespace.adminPasswordSecretArn())).secretString());+ assertEquals(serverlessService.getNamespace(namespaceName, "us-east-1").getAdminUserPassword(),+ value.path("password").asText());++ ExecuteStatementResponse executed = data.executeStatement(request -> request.workgroupName(workgroup)+ .secretArn(namespace.adminPasswordSecretArn()).database("analytics")+ .waitTimeSeconds(30).sql("SELECT 42 AS answer"));+ DescribeStatementResponse described = data.describeStatement(request -> request.id(executed.id()));+ assertEquals(StatusString.FINISHED, described.status(), described.error());+ assertEquals(42L, data.getStatementResult(request -> request.id(executed.id()))+ .records().getFirst().getFirst().longValue());+ ArgumentCaptor<RedshiftDataResourceResolver.DatabaseTarget> target =+ ArgumentCaptor.forClass(RedshiftDataResourceResolver.DatabaseTarget.class);+ verify(factory).open(target.capture());+ assertEquals("warehouse_admin", target.getValue().user());+ assertEquals(value.path("username").asText(), target.getValue().user());+ assertEquals(GENERATED_PASSWORD, target.getValue().password());+ assertEquals(value.path("password").asText(), target.getValue().password());+ assertEquals("analytics", target.getValue().database());+ }++ @Test+ void sdkExecutesSqlUsingManagedSecretAfterAdminUsernameRename() throws Exception {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String namespaceName = "data-rename-" + suffix;+ String workgroup = "data-rename-wg-" + suffix;+ Namespace namespace = redshift.createNamespace(request -> request.namespaceName(namespaceName)+ .adminUsername("initial_admin").dbName("analytics").manageAdminPassword(true)).namespace();+ cleanup.register(() -> redshift.deleteNamespace(request -> request.namespaceName(namespaceName)));+ redshift.createWorkgroup(request -> request.workgroupName(workgroup).namespaceName(namespaceName));+ cleanup.register(() -> redshift.deleteWorkgroup(request -> request.workgroupName(workgroup)));++ redshift.updateNamespace(request -> request.namespaceName(namespaceName).adminUsername("renamed_admin"));++ JsonNode value = mapper.readTree(secrets.getSecretValue(request -> request+ .secretId(namespace.adminPasswordSecretArn())).secretString());+ assertEquals("renamed_admin", value.path("username").asText());+ String partialSecretArn = namespace.adminPasswordSecretArn().substring(0,+ namespace.adminPasswordSecretArn().length() - 7);++ ExecuteStatementResponse executed = data.executeStatement(request -> request.workgroupName(workgroup)+ .secretArn(partialSecretArn).database("analytics")+ .waitTimeSeconds(30).sql("SELECT 101 AS answer"));+ DescribeStatementResponse described = data.describeStatement(request -> request.id(executed.id()));+ assertEquals(StatusString.FINISHED, described.status(), described.error());++ ArgumentCaptor<RedshiftDataResourceResolver.DatabaseTarget> target =+ ArgumentCaptor.forClass(RedshiftDataResourceResolver.DatabaseTarget.class);+ verify(factory, atLeastOnce()).open(target.capture());+ assertEquals("initial_admin", target.getValue().user());+ }++ @Test+ void sdkExecutesSqlUsingManagedSecretWhenManagementEnabledAfterUsernameRename() throws Exception {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String namespaceName = "data-late-manage-" + suffix;+ String workgroup = "data-late-manage-wg-" + suffix;+ redshift.createNamespace(request -> request.namespaceName(namespaceName)+ .adminUsername("initial_admin").adminUserPassword("ExplicitSecret123!").dbName("analytics"));+ cleanup.register(() -> redshift.deleteNamespace(request -> request.namespaceName(namespaceName)));+ redshift.createWorkgroup(request -> request.workgroupName(workgroup).namespaceName(namespaceName));+ cleanup.register(() -> redshift.deleteWorkgroup(request -> request.workgroupName(workgroup)));++ redshift.updateNamespace(request -> request.namespaceName(namespaceName).adminUsername("earlier_renamed_admin"));+ Namespace managed = redshift.updateNamespace(request -> request.namespaceName(namespaceName)+ .manageAdminPassword(true)).namespace();+ assertNotNull(managed.adminPasswordSecretArn());++ JsonNode value = mapper.readTree(secrets.getSecretValue(request -> request+ .secretId(managed.adminPasswordSecretArn())).secretString());+ assertEquals("earlier_renamed_admin", value.path("username").asText());++ ExecuteStatementResponse executed = data.executeStatement(request -> request.workgroupName(workgroup)+ .secretArn(managed.adminPasswordSecretArn()).database("analytics")+ .waitTimeSeconds(30).sql("SELECT 202 AS answer"));+ DescribeStatementResponse described = data.describeStatement(request -> request.id(executed.id()));+ assertEquals(StatusString.FINISHED, described.status(), described.error());++ ArgumentCaptor<RedshiftDataResourceResolver.DatabaseTarget> target =+ ArgumentCaptor.forClass(RedshiftDataResourceResolver.DatabaseTarget.class);+ verify(factory, atLeastOnce()).open(target.capture());+ assertEquals("initial_admin", target.getValue().user());+ }++ @Test+ void callerOwnedSecretConnectsAsItsOwnDatabaseUserEvenWhenMatchingAdminUsername() throws Exception {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String namespaceName = "data-caller-secret-" + suffix;+ String workgroup = "data-caller-secret-wg-" + suffix;+ Namespace namespace = redshift.createNamespace(request -> request.namespaceName(namespaceName)+ .adminUsername("initial_admin").dbName("analytics").manageAdminPassword(true)).namespace();+ cleanup.register(() -> redshift.deleteNamespace(request -> request.namespaceName(namespaceName)));+ redshift.createWorkgroup(request -> request.workgroupName(workgroup).namespaceName(namespaceName));+ cleanup.register(() -> redshift.deleteWorkgroup(request -> request.workgroupName(workgroup)));++ String callerSecretArn = secrets.createSecret(request -> request.name("caller-secret-" + suffix)+ .secretString("{\"username\":\"report_reader\",\"password\":\"ReaderSecret123!\"}")).arn();+ cleanup.register(() -> secrets.deleteSecret(request -> request.secretId(callerSecretArn).forceDeleteWithoutRecovery(true)));++ redshift.updateNamespace(request -> request.namespaceName(namespaceName).adminUsername("report_reader"));++ ExecuteStatementResponse executed = data.executeStatement(request -> request.workgroupName(workgroup)+ .secretArn(callerSecretArn).database("analytics")+ .waitTimeSeconds(30).sql("SELECT 303 AS answer"));+ DescribeStatementResponse described = data.describeStatement(request -> request.id(executed.id()));+ assertEquals(StatusString.FINISHED, described.status(), described.error());++ ArgumentCaptor<RedshiftDataResourceResolver.DatabaseTarget> target =+ ArgumentCaptor.forClass(RedshiftDataResourceResolver.DatabaseTarget.class);+ verify(factory, atLeastOnce()).open(target.capture());+ assertEquals("report_reader", target.getValue().user());+ assertEquals("ReaderSecret123!", target.getValue().password());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolverTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolverTest.javaindex 0095332862..8500391601 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolverTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftdata/RedshiftDataResourceResolverTest.java@@ -9,6 +9,7 @@ import io.github.hectorvent.floci.services.redshift.RedshiftService;import io.github.hectorvent.floci.services.redshift.model.Cluster;import io.github.hectorvent.floci.services.redshiftserverless.RedshiftServerlessService;import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;+import io.github.hectorvent.floci.services.secretsmanager.model.Secret;import io.github.hectorvent.floci.services.secretsmanager.model.SecretVersion;import org.junit.jupiter.api.Test;@@ -143,6 +144,87 @@ class RedshiftDataResourceResolverTest {assertEquals(55433, target.port());}+ @Test+ void aWorkgroupWithARenamedAdminSecretConnectsWithTheBackendRole() {+ String secretArn = "arn:aws:secretsmanager:us-east-1:" + ACCOUNT + ":secret:redshift-serverless/ns-1";+ RedshiftServerlessService.WorkgroupTarget renamedTarget = new RedshiftServerlessService.WorkgroupTarget(+ "arn:aws:redshift-serverless:us-east-1:" + ACCOUNT + ":workgroup/wg-id", "wg-1",+ "127.0.0.1", 55433, "analytics", "root", "Secret123", "renamed_admin",+ List.of("arn:aws:iam::" + ACCOUNT + ":role/Spectrum"), secretArn);+ when(serverless.getWorkgroupTarget("wg-1", REGION)).thenReturn(renamedTarget);+ SecretsManagerService secrets = mock(SecretsManagerService.class);+ SecretVersion version = new SecretVersion();+ version.setSecretString("{\"username\":\"renamed_admin\",\"password\":\"Secret123\"}");+ when(secrets.getSecretValue(eq(secretArn), any(), any(), eq(REGION))).thenReturn(version);+ ObjectNode req = mapper.createObjectNode();+ req.put("WorkgroupName", "wg-1");+ req.put("Database", "analytics");+ req.put("SecretArn", secretArn);++ RedshiftDataResourceResolver.DatabaseTarget target =+ resolver(mock(RedshiftService.class), secrets).resolve(req, REGION);++ assertEquals("root", target.user());+ assertEquals("Secret123", target.password());+ assertEquals(55433, target.port());+ }++ @Test+ void aWorkgroupResolvesAPartialManagedSecretArnToTheBackendRole() {+ String fullSecretArn = "arn:aws:secretsmanager:us-east-1:" + ACCOUNT+ + ":secret:redshift-serverless/ns-1-AbCdEf";+ String partialSecretArn = "arn:aws:secretsmanager:us-east-1:" + ACCOUNT+ + ":secret:redshift-serverless/ns-1";+ RedshiftServerlessService.WorkgroupTarget renamedTarget = new RedshiftServerlessService.WorkgroupTarget(+ "arn:aws:redshift-serverless:us-east-1:" + ACCOUNT + ":workgroup/wg-id", "wg-1",+ "127.0.0.1", 55433, "analytics", "root", "Secret123", "renamed_admin",+ List.of("arn:aws:iam::" + ACCOUNT + ":role/Spectrum"), fullSecretArn);+ when(serverless.getWorkgroupTarget("wg-1", REGION)).thenReturn(renamedTarget);+ SecretsManagerService secrets = mock(SecretsManagerService.class);+ SecretVersion version = new SecretVersion();+ version.setSecretString("{\"username\":\"renamed_admin\",\"password\":\"Secret123\"}");+ when(secrets.getSecretValue(eq(partialSecretArn), any(), any(), eq(REGION))).thenReturn(version);+ Secret metadata = new Secret();+ metadata.setArn(fullSecretArn);+ when(secrets.describeSecret(partialSecretArn, REGION)).thenReturn(metadata);+ ObjectNode req = mapper.createObjectNode();+ req.put("WorkgroupName", "wg-1");+ req.put("Database", "analytics");+ req.put("SecretArn", partialSecretArn);++ RedshiftDataResourceResolver.DatabaseTarget target =+ resolver(mock(RedshiftService.class), secrets).resolve(req, REGION);++ assertEquals("root", target.user());+ assertEquals("Secret123", target.password());+ }++ @Test+ void aCallerOwnedSecretDoesNotRewriteUsernameEvenWhenMatchingAdminUsername() {+ String managedSecretArn = "arn:aws:secretsmanager:us-east-1:" + ACCOUNT + ":secret:redshift-serverless/ns-1";+ String callerSecretArn = "arn:aws:secretsmanager:us-east-1:" + ACCOUNT + ":secret:caller-secret";+ RedshiftServerlessService.WorkgroupTarget renamedTarget = new RedshiftServerlessService.WorkgroupTarget(+ "arn:aws:redshift-serverless:us-east-1:" + ACCOUNT + ":workgroup/wg-id", "wg-1",+ "127.0.0.1", 55433, "analytics", "root", "Secret123", "report_reader",+ List.of("arn:aws:iam::" + ACCOUNT + ":role/Spectrum"), managedSecretArn);+ when(serverless.getWorkgroupTarget("wg-1", REGION)).thenReturn(renamedTarget);+ SecretsManagerService secrets = mock(SecretsManagerService.class);+ SecretVersion version = new SecretVersion();+ version.setSecretString("{\"username\":\"report_reader\",\"password\":\"ReaderPass123\"}");+ when(secrets.getSecretValue(eq(callerSecretArn), any(), any(), eq(REGION))).thenReturn(version);+ ObjectNode req = mapper.createObjectNode();+ req.put("WorkgroupName", "wg-1");+ req.put("Database", "analytics");+ req.put("SecretArn", callerSecretArn);++ RedshiftDataResourceResolver.DatabaseTarget target =+ resolver(mock(RedshiftService.class), secrets).resolve(req, REGION);++ assertEquals("report_reader", target.user());+ assertEquals("ReaderPass123", target.password());+ assertEquals(55433, target.port());+ }+@Testvoid aWorkgroupRejectsAClusterIdentifierAndAWrongDatabase() {when(serverless.getWorkgroupTarget("wg-1", REGION)).thenReturn(workgroupTarget());diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminSecretsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminSecretsIntegrationTest.javanew file mode 100644index 0000000000..836fe218c9--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminSecretsIntegrationTest.java@@ -0,0 +1,242 @@+package io.github.hectorvent.floci.services.redshiftserverless;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.services.kms.KmsService;+import io.github.hectorvent.floci.services.kms.model.KmsKey;+import io.github.hectorvent.floci.services.redshift.model.Endpoint;+import io.github.hectorvent.floci.testing.PartitionCleanup;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.InjectMock;+import io.quarkus.test.common.http.TestHTTPResource;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;+import software.amazon.awssdk.regions.Region;+import software.amazon.awssdk.services.redshiftserverless.RedshiftServerlessClient;+import software.amazon.awssdk.services.redshiftserverless.model.CreateNamespaceRequest;+import software.amazon.awssdk.services.redshiftserverless.model.Namespace;+import software.amazon.awssdk.services.redshiftserverless.model.ValidationException;+import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;+import software.amazon.awssdk.services.secretsmanager.model.DescribeSecretResponse;+import software.amazon.awssdk.services.secretsmanager.model.ResourceNotFoundException;++import java.net.URI;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyBoolean;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++@QuarkusTest+class RedshiftServerlessAdminSecretsIntegrationTest {++ private static final String GENERATED_PASSWORD = "ManagedSecret123!";+ private static final String ORIGINAL_PASSWORD = "OriginalSecret123!";+ private static final String REPLACEMENT_PASSWORD = "ReplacementSecret123!";+ private static final String SECRET_KEY = "alias/admin-secret-key";++ @TestHTTPResource("/")+ URI endpoint;++ @InjectMock+ RedshiftServerlessRuntime runtime;++ @Inject+ ObjectMapper mapper;++ @Inject+ KmsService kms;++ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();++ private RedshiftServerlessClient redshift;+ private SecretsManagerClient secrets;++ @BeforeEach+ void setup() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ StaticCredentialsProvider credentials = StaticCredentialsProvider.create(+ AwsBasicCredentials.create("test", "test"));+ redshift = RedshiftServerlessClient.builder().endpointOverride(endpoint).region(Region.US_EAST_1)+ .credentialsProvider(credentials).build();+ secrets = SecretsManagerClient.builder().endpointOverride(endpoint).region(Region.US_EAST_1)+ .credentialsProvider(credentials).build();+ cleanup.register(redshift::close);+ cleanup.register(secrets::close);+ when(runtime.generatePassword()).thenReturn(GENERATED_PASSWORD);+ when(runtime.start(any(String.class), any(String.class), any(String.class), any(String.class),+ any(String.class), any(String.class), any(Endpoint.class), anyBoolean(), any()))+ .thenReturn(new RedshiftServerlessRuntime.Backend("127.0.0.1", 55432));+ }++ @Test+ void sdkCreateExposesAnOwnedSecretAndKeepsThePasswordOutOfNamespaceResponses() throws Exception {+ Namespace created = createNamespace(CreateNamespaceRequest.builder().namespaceName(name())+ .adminUsername("warehouse_admin").dbName("analytics").manageAdminPassword(true).build());+ String arn = created.adminPasswordSecretArn();+ assertNotNull(arn);+ JsonNode value = secretValue(arn);+ assertEquals("warehouse_admin", value.path("username").asText());+ assertEquals(GENERATED_PASSWORD, value.path("password").asText());+ assertEquals("analytics", value.path("dbname").asText());+ assertEquals("redshift", value.path("engine").asText());+ DescribeSecretResponse described = secrets.describeSecret(request -> request.secretId(arn));+ assertEquals("redshift", described.owningService());+ assertEquals(arn, redshift.getNamespace(request -> request.namespaceName(created.namespaceName()))+ .namespace().adminPasswordSecretArn());+ Namespace listed = redshift.listNamespaces(request -> request.maxResults(100)).namespaces().stream()+ .filter(namespace -> created.namespaceName().equals(namespace.namespaceName()))+ .findFirst().orElseThrow();+ assertEquals(arn, listed.adminPasswordSecretArn());+ assertPasswordAbsentFromWireResponse(created.namespaceName());+ }++ @Test+ void sdkCreateAndUpdateExposeTheSecretEncryptionKey() {+ String secretKey = createSecretKey();+ Namespace created = createNamespace(CreateNamespaceRequest.builder().namespaceName(name())+ .adminUsername("admin").manageAdminPassword(true).adminPasswordSecretKmsKeyId(secretKey).build());+ String arn = created.adminPasswordSecretArn();+ assertEquals(secretKey, created.adminPasswordSecretKmsKeyId());+ assertEquals(secretKey, secrets.describeSecret(request -> request.secretId(arn)).kmsKeyId());+ assertEquals(secretKey, redshift.getNamespace(request -> request.namespaceName(created.namespaceName()))+ .namespace().adminPasswordSecretKmsKeyId());+ Namespace updated = redshift.updateNamespace(request -> request.namespaceName(created.namespaceName())+ .logExportsWithStrings("userlog")).namespace();+ assertEquals(arn, updated.adminPasswordSecretArn());+ assertEquals(secretKey, updated.adminPasswordSecretKmsKeyId());+ Namespace listed = redshift.listNamespaces(request -> request.maxResults(100)).namespaces().stream()+ .filter(namespace -> created.namespaceName().equals(namespace.namespaceName()))+ .findFirst().orElseThrow();+ assertEquals(secretKey, listed.adminPasswordSecretKmsKeyId());+ }++ @Test+ void sdkRejectsManagedPasswordAndExplicitPasswordTogetherOnCreateAndUpdate() {+ assertThrows(ValidationException.class, () -> createNamespace(CreateNamespaceRequest.builder()+ .namespaceName(name()).adminUsername("admin").manageAdminPassword(true)+ .adminUserPassword(ORIGINAL_PASSWORD).build()));+ Namespace created = createNamespace(CreateNamespaceRequest.builder().namespaceName(name())+ .adminUsername("admin").adminUserPassword(ORIGINAL_PASSWORD).build());+ assertThrows(ValidationException.class, () -> redshift.updateNamespace(request -> request+ .namespaceName(created.namespaceName()).manageAdminPassword(true)+ .adminUserPassword(REPLACEMENT_PASSWORD)));+ assertNull(redshift.getNamespace(request -> request.namespaceName(created.namespaceName()))+ .namespace().adminPasswordSecretArn());+ }++ @Test+ void sdkRequiresManagementWhenSpecifyingASecretKey() {+ assertThrows(ValidationException.class, () -> createNamespace(CreateNamespaceRequest.builder()+ .namespaceName(name()).adminUsername("admin").adminPasswordSecretKmsKeyId(SECRET_KEY).build()));+ assertThrows(ValidationException.class, () -> createNamespace(CreateNamespaceRequest.builder()+ .namespaceName(name()).adminUsername("admin").manageAdminPassword(false)+ .adminPasswordSecretKmsKeyId(SECRET_KEY).build()));+ Namespace created = createNamespace(CreateNamespaceRequest.builder().namespaceName(name())+ .adminUsername("admin").adminUserPassword(ORIGINAL_PASSWORD).build());+ assertThrows(ValidationException.class, () -> redshift.updateNamespace(request -> request+ .namespaceName(created.namespaceName()).adminPasswordSecretKmsKeyId(SECRET_KEY)));+ assertThrows(ValidationException.class, () -> redshift.updateNamespace(request -> request+ .namespaceName(created.namespaceName()).manageAdminPassword(false)+ .adminUserPassword(REPLACEMENT_PASSWORD).adminPasswordSecretKmsKeyId(SECRET_KEY)));+ }++ @Test+ void sdkEnablingAndDisablingManagementChangesTheLivePasswordAndRemovesTheSecret() throws Exception {+ String secretKey = createSecretKey();+ Namespace created = createNamespace(CreateNamespaceRequest.builder().namespaceName(name())+ .adminUsername("admin").adminUserPassword(ORIGINAL_PASSWORD).dbName("analytics").build());+ String workgroup = name();+ redshift.createWorkgroup(request -> request.workgroupName(workgroup).namespaceName(created.namespaceName()));+ cleanup.register(() -> redshift.deleteWorkgroup(request -> request.workgroupName(workgroup)));+ Namespace managed = redshift.updateNamespace(request -> request.namespaceName(created.namespaceName())+ .manageAdminPassword(true).adminPasswordSecretKmsKeyId(secretKey)).namespace();+ String arn = managed.adminPasswordSecretArn();+ assertNotNull(arn);+ assertEquals(secretKey, managed.adminPasswordSecretKmsKeyId());+ assertEquals(GENERATED_PASSWORD, secretValue(arn).path("password").asText());+ verify(runtime).changeMasterPassword(any(String.class), eq("us-east-1"), eq(workgroup), eq("admin"),+ eq("analytics"), eq(ORIGINAL_PASSWORD), eq(GENERATED_PASSWORD));++ assertThrows(ValidationException.class, () -> redshift.updateNamespace(request -> request+ .namespaceName(created.namespaceName()).manageAdminPassword(false)));+ assertEquals(arn, redshift.getNamespace(request -> request.namespaceName(created.namespaceName()))+ .namespace().adminPasswordSecretArn());+ assertEquals(GENERATED_PASSWORD, secretValue(arn).path("password").asText());++ Namespace unmanaged = redshift.updateNamespace(request -> request.namespaceName(created.namespaceName())+ .manageAdminPassword(false).adminUserPassword(REPLACEMENT_PASSWORD)).namespace();+ assertNull(unmanaged.adminPasswordSecretArn());+ assertNull(unmanaged.adminPasswordSecretKmsKeyId());+ assertNull(redshift.getNamespace(request -> request.namespaceName(created.namespaceName()))+ .namespace().adminPasswordSecretArn());+ verify(runtime).changeMasterPassword(any(String.class), eq("us-east-1"), eq(workgroup), eq("admin"),+ eq("analytics"), eq(GENERATED_PASSWORD), eq(REPLACEMENT_PASSWORD));+ assertThrows(ResourceNotFoundException.class, () -> secrets.getSecretValue(request -> request.secretId(arn)));+ }++ @Test+ void sdkDeletingTheNamespaceDeletesItsManagedSecret() {+ Namespace created = createNamespace(CreateNamespaceRequest.builder().namespaceName(name())+ .adminUsername("admin").manageAdminPassword(true).build());+ String arn = created.adminPasswordSecretArn();+ assertNotNull(arn);+ redshift.deleteNamespace(request -> request.namespaceName(created.namespaceName()));+ assertThrows(ResourceNotFoundException.class, () -> secrets.describeSecret(request -> request.secretId(arn)));+ assertThrows(ResourceNotFoundException.class, () -> secrets.getSecretValue(request -> request.secretId(arn)));+ }++ private Namespace createNamespace(CreateNamespaceRequest request) {+ Namespace namespace = redshift.createNamespace(request).namespace();+ cleanup.register(() -> {+ try {+ redshift.deleteNamespace(delete -> delete.namespaceName(namespace.namespaceName()));+ } catch (software.amazon.awssdk.services.redshiftserverless.model.ResourceNotFoundException expected) {+ // This SDK exception clashes with Secrets Manager's; the lifecycle test already deleted the namespace.+ }+ });+ return namespace;+ }++ private JsonNode secretValue(String arn) throws Exception {+ return mapper.readTree(secrets.getSecretValue(request -> request.secretId(arn)).secretString());+ }++ private String createSecretKey() {+ KmsKey key = kms.createKey("Redshift Serverless admin secret integration test", "us-east-1");+ cleanup.register(() -> kms.scheduleKeyDeletion(key.getKeyId(), 7, "us-east-1"));+ return key.getArn();+ }++ private void assertPasswordAbsentFromWireResponse(String namespace) throws Exception {+ String response = given().header("Authorization",+ "AWS4-HMAC-SHA256 Credential=test/20261025/us-east-1/redshift-serverless/aws4_request")+ .header("X-Amz-Target", "RedshiftServerless.GetNamespace")+ .contentType("application/x-amz-json-1.1").body(Map.of("namespaceName", namespace))+ .post(endpoint).then().statusCode(200).extract().asString();+ JsonNode body = mapper.readTree(response).path("namespace");+ assertFalse(body.has("adminUserPassword"));+ assertFalse(response.contains(GENERATED_PASSWORD));+ assertTrue(body.hasNonNull("adminPasswordSecretArn"));+ }++ private static String name() {+ return "managed-" + UUID.randomUUID().toString().substring(0, 8);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminSecretsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminSecretsServiceTest.javanew file mode 100644index 0000000000..9e1c4ce931--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminSecretsServiceTest.java@@ -0,0 +1,258 @@+package io.github.hectorvent.floci.services.redshiftserverless;++import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+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.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.redshift.model.Endpoint;+import io.github.hectorvent.floci.services.redshiftserverless.model.Namespace;+import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;+import io.github.hectorvent.floci.services.secretsmanager.model.Secret;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.mockito.ArgumentCaptor;++import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertSame;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyBoolean;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.ArgumentMatchers.isNull;+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;+import static org.mockito.Mockito.clearInvocations;+import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.spy;+import static org.mockito.Mockito.times;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++class RedshiftServerlessAdminSecretsServiceTest {++ private static final String REGION = "us-east-1";+ private static final String ACCOUNT = "123456789012";+ private static final String NAME = "managed-ns";+ private static final String WORKGROUP = "managed-wg";+ private static final String STORAGE_KEY = REGION + "::" + NAME;+ private static final String SECRET_ARN = "arn:aws:secretsmanager:us-east-1:123456789012:secret:managed-admin-abcdef";+ private static final String SECRET_KEY = "arn:aws:kms:us-east-1:123456789012:key/admin-secret-key";+ private static final String ORIGINAL_PASSWORD = "Original123!";+ private static final String GENERATED_PASSWORD = "Generated123!";++ private RedshiftServerlessService service;+ private AccountAwareStorageBackend<Namespace> namespaces;+ private RedshiftServerlessRuntime runtime;+ private SecretsManagerService secrets;+ private ObjectMapper mapper;++ @BeforeEach+ @SuppressWarnings({"unchecked", "rawtypes"})+ void setup() {+ StorageFactory storageFactory = mock(StorageFactory.class);+ namespaces = spy(AccountAwareStorageBackend.inMemory(ACCOUNT));+ when(storageFactory.create(eq("redshiftserverless"), eq("redshiftserverless-namespaces.json"),+ any(TypeReference.class))).thenReturn((AccountAwareStorageBackend) namespaces);+ when(storageFactory.create(eq("redshiftserverless"), eq("redshiftserverless-workgroups.json"),+ any(TypeReference.class))).thenReturn(AccountAwareStorageBackend.inMemory(ACCOUNT));+ when(storageFactory.create(eq("redshiftserverless"), eq("redshiftserverless-snapshots.json"),+ any(TypeReference.class))).thenReturn(AccountAwareStorageBackend.inMemory(ACCOUNT));+ RegionResolver regions = mock(RegionResolver.class);+ when(regions.getAccountId()).thenReturn(ACCOUNT);+ when(regions.buildArn(eq("redshift-serverless"), eq(REGION), any(String.class)))+ .thenAnswer(invocation -> "arn:aws:redshift-serverless:" + REGION + ":" + ACCOUNT + ":"+ + invocation.getArgument(2, String.class));+ RedshiftServerlessEndpoints endpoints = mock(RedshiftServerlessEndpoints.class);+ when(endpoints.allocate()).thenReturn(new Endpoint("localhost", 7100));+ runtime = mock(RedshiftServerlessRuntime.class);+ when(runtime.generatePassword()).thenReturn(GENERATED_PASSWORD);+ when(runtime.start(any(String.class), any(String.class), any(String.class), any(String.class),+ any(String.class), any(String.class), any(Endpoint.class), anyBoolean(), any()))+ .thenReturn(new RedshiftServerlessRuntime.Backend("127.0.0.1", 55432));+ secrets = mock(SecretsManagerService.class);+ Secret secret = new Secret();+ secret.setArn(SECRET_ARN);+ secret.setKmsKeyId(SECRET_KEY);+ when(secrets.createSecret(any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(secret);+ when(secrets.createSecret(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(secret);+ mapper = new ObjectMapper().findAndRegisterModules();+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ service = new RedshiftServerlessService(storageFactory, regions, endpoints, runtime, config,+ new RedshiftServerlessAdminSecrets(secrets, mapper));+ }++ @Test+ void managedCreateStorageFailureDeletesTheNewSecret() {+ IllegalStateException failure = failStorageWrites();+ assertSame(failure, assertThrows(IllegalStateException.class, this::createManaged));+ verify(secrets).deleteSecret(SECRET_ARN, null, true, REGION);+ assertEquals("ResourceNotFoundException", assertThrows(AwsException.class,+ () -> service.getNamespace(NAME, REGION)).getErrorCode());+ }++ @Test+ void enablingManagementBackendFailureDeletesTheNewSecretAndPreservesNamespace() {+ Namespace previous = createUnmanaged();+ attachWorkgroup();+ AwsException failure = new AwsException("InternalServerException", "Backend unavailable", 500);+ doThrow(failure).when(runtime).changeMasterPassword(ACCOUNT, REGION, WORKGROUP, "admin", "analytics",+ ORIGINAL_PASSWORD, GENERATED_PASSWORD);+ assertSame(failure, assertThrows(AwsException.class, () -> update(null, null, true)));+ verify(secrets).deleteSecret(SECRET_ARN, null, true, REGION);+ assertSame(previous, service.getNamespace(NAME, REGION));+ assertNull(previous.getAdminPasswordSecretArn());+ assertEquals(ORIGINAL_PASSWORD, previous.getAdminUserPassword());+ }++ @Test+ void enablingManagementStorageFailureRestoresBackendAndDeletesTheNewSecret() {+ Namespace previous = createUnmanaged();+ attachWorkgroup();+ IllegalStateException failure = failStorageWrites();+ assertSame(failure, assertThrows(IllegalStateException.class, () -> update(null, null, true)));+ verify(runtime).changeMasterPassword(ACCOUNT, REGION, WORKGROUP, "admin", "analytics",+ ORIGINAL_PASSWORD, GENERATED_PASSWORD);+ verify(runtime).restoreMasterPassword(ACCOUNT, REGION, WORKGROUP, "admin", "analytics", ORIGINAL_PASSWORD);+ verify(secrets).deleteSecret(SECRET_ARN, null, true, REGION);+ assertSame(previous, service.getNamespace(NAME, REGION));+ assertNull(previous.getAdminPasswordSecretArn());+ }++ @Test+ void continuingManagementUsernameChangeUpdatesTheExistingSecret() throws Exception {+ createManaged();+ clearInvocations(secrets);+ Namespace updated = update("renamed_admin", null, null);+ ArgumentCaptor<String> values = ArgumentCaptor.forClass(String.class);+ verify(secrets).putSecretValue(eq(SECRET_ARN), values.capture(), isNull(), isNull(), eq(REGION), any());+ JsonNode value = mapper.readTree(values.getValue());+ assertEquals("renamed_admin", value.path("username").asText());+ assertEquals(GENERATED_PASSWORD, value.path("password").asText());+ assertEquals("analytics", value.path("dbname").asText());+ assertEquals("redshift", value.path("engine").asText());+ assertEquals(SECRET_ARN, updated.getAdminPasswordSecretArn());+ verify(secrets, never()).deleteSecret(any(), any(), anyBoolean(), any());+ }++ @Test+ void continuingManagementStorageFailureRestoresTheOriginalSecretValue() throws Exception {+ Namespace previous = createManaged();+ clearInvocations(secrets);+ IllegalStateException failure = failStorageWrites();+ assertSame(failure, assertThrows(IllegalStateException.class, () -> update("renamed_admin", null, null)));+ ArgumentCaptor<String> values = ArgumentCaptor.forClass(String.class);+ verify(secrets, times(2)).putSecretValue(eq(SECRET_ARN), values.capture(), isNull(), isNull(), eq(REGION), any());+ List<String> writes = values.getAllValues();+ assertEquals("renamed_admin", mapper.readTree(writes.getFirst()).path("username").asText());+ JsonNode restored = mapper.readTree(writes.getLast());+ assertEquals("admin", restored.path("username").asText());+ assertEquals(GENERATED_PASSWORD, restored.path("password").asText());+ assertSame(previous, service.getNamespace(NAME, REGION));+ assertEquals("admin", previous.getAdminUsername());+ verify(secrets, never()).deleteSecret(any(), any(), anyBoolean(), any());+ }++ @Test+ void disablingManagementStorageFailureKeepsTheSecretAndRestoresBackend() {+ Namespace previous = createManaged();+ attachWorkgroup();+ clearInvocations(secrets);+ IllegalStateException failure = failStorageWrites();+ assertSame(failure, assertThrows(IllegalStateException.class,+ () -> update(null, ORIGINAL_PASSWORD, false)));+ verify(secrets, never()).deleteSecret(any(), any(), anyBoolean(), any());+ verify(runtime).restoreMasterPassword(ACCOUNT, REGION, WORKGROUP, "admin", "analytics", GENERATED_PASSWORD);+ assertSame(previous, service.getNamespace(NAME, REGION));+ assertEquals(SECRET_ARN, previous.getAdminPasswordSecretArn());+ }++ @Test+ void deletingNamespaceWithWorkgroupDoesNotDeleteTheSecret() {+ createManaged();+ attachWorkgroup();+ clearInvocations(secrets);+ assertEquals("ConflictException", assertThrows(AwsException.class,+ () -> service.deleteNamespace(NAME, REGION)).getErrorCode());+ verify(secrets, never()).deleteSecret(any(), any(), anyBoolean(), any());+ assertEquals(SECRET_ARN, service.getNamespace(NAME, REGION).getAdminPasswordSecretArn());+ }++ @Test+ void secretDeletionFailureRestoresNamespace() {+ Namespace previous = createManaged();+ clearInvocations(namespaces);+ AwsException failure = new AwsException("AccessDeniedException", "Cannot delete secret", 400);+ doThrow(failure).when(secrets).deleteSecret(SECRET_ARN, null, true, REGION);+ assertSame(failure, assertThrows(AwsException.class, () -> service.deleteNamespace(NAME, REGION)));+ assertSame(previous, service.getNamespace(NAME, REGION));+ verify(namespaces).delete(STORAGE_KEY);+ verify(namespaces).put(STORAGE_KEY, previous);+ }++ @Test+ void namespaceDeletionFailureKeepsItsManagedSecret() {+ Namespace previous = createManaged();+ IllegalStateException failure = new IllegalStateException("Namespace deletion failed");+ doThrow(failure).when(namespaces).delete(STORAGE_KEY);++ assertSame(failure, assertThrows(IllegalStateException.class, () -> service.deleteNamespace(NAME, REGION)));++ verify(secrets, never()).deleteSecret(any(), any(), anyBoolean(), any());+ assertSame(previous, service.getNamespace(NAME, REGION));+ }++ @Test+ void missingSecretDoesNotPreventNamespaceDeletion() {+ createManaged();+ doThrow(new AwsException("ResourceNotFoundException", "Already deleted", 400))+ .when(secrets).deleteSecret(SECRET_ARN, null, true, REGION);+ assertEquals("DELETING", service.deleteNamespace(NAME, REGION).getStatus());+ assertThrows(AwsException.class, () -> service.getNamespace(NAME, REGION));+ }++ @Test+ void namespaceJsonRoundTripAndCopyRetainSecretMetadata() throws Exception {+ Namespace created = createManaged();+ Namespace restored = mapper.readValue(mapper.writeValueAsBytes(created), Namespace.class);+ assertEquals(SECRET_ARN, restored.getAdminPasswordSecretArn());+ assertEquals(SECRET_KEY, restored.getAdminPasswordSecretKmsKeyId());+ assertEquals(GENERATED_PASSWORD, restored.getAdminUserPassword());+ Namespace copy = new Namespace(restored);+ assertEquals(SECRET_ARN, copy.getAdminPasswordSecretArn());+ assertEquals(SECRET_KEY, copy.getAdminPasswordSecretKmsKeyId());+ }++ private Namespace createManaged() {+ return service.createNamespace(NAME, "admin", null, "analytics", null, null, List.of(), List.of(), Map.of(),+ true, SECRET_KEY, REGION);+ }++ private Namespace createUnmanaged() {+ return service.createNamespace(NAME, "admin", ORIGINAL_PASSWORD, "analytics", null, null, List.of(),+ List.of(), Map.of(), REGION);+ }++ private Namespace update(String username, String password, Boolean manage) {+ return service.updateNamespace(NAME, username, password, null, null, null, null, manage, null, REGION);+ }++ private void attachWorkgroup() {+ service.createWorkgroup(WORKGROUP, NAME,+ new WorkgroupSettings(null, null, null, null, null, null, null, null, null, null, null, null), null, REGION);+ }++ private IllegalStateException failStorageWrites() {+ IllegalStateException failure = new IllegalStateException("Namespace write failed");+ doThrow(failure).when(namespaces).put(eq(STORAGE_KEY), any(Namespace.class));+ return failure;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.javaindex 51def2c375..ef1e9c7a1a 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.java@@ -14,6 +14,8 @@ import io.github.hectorvent.floci.services.redshift.TempCredential;import io.github.hectorvent.floci.services.redshift.model.Endpoint;import io.github.hectorvent.floci.services.redshiftserverless.model.Namespace;import io.github.hectorvent.floci.services.redshiftserverless.model.Workgroup;+import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;+import io.github.hectorvent.floci.services.secretsmanager.model.Secret;import jakarta.ws.rs.core.Response;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;@@ -41,6 +43,13 @@ import static org.mockito.Mockito.when;* strict SDKs rejected the response.*/class RedshiftServerlessJsonHandlerTest {+ @Test+ void managedNamespaceReturnsItsSecretArn() throws Exception {+ JsonNode response = (JsonNode) handler.handle("CreateNamespace", mapper.readTree(+ "{\"namespaceName\":\"managed-admin\",\"manageAdminPassword\":true}"), REGION).getEntity();+ assertTrue(response.path("namespace").path("adminPasswordSecretArn").isTextual(), response.toString());+ }+private static final String REGION = "us-east-1";private static final String ACCOUNT_ID = "123456789012";@@ -85,8 +94,12 @@ class RedshiftServerlessJsonHandlerTest {any(TypeReference.class))).thenReturn((AccountAwareStorageBackend)AccountAwareStorageBackend.inMemory(ACCOUNT_ID));stubAdministrationStores(storageFactory);- RedshiftServerlessService service =- new RedshiftServerlessService(storageFactory, regionResolver, endpoints, runtime, config);+ SecretsManagerService secrets = mock(SecretsManagerService.class);+ Secret secret = new Secret();+ secret.setArn("arn:aws:secretsmanager:us-east-1:" + ACCOUNT_ID + ":secret:managed-admin-abcdef");+ when(secrets.createSecret(any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(secret);+ RedshiftServerlessService service = new RedshiftServerlessService(storageFactory, regionResolver,+ endpoints, runtime, config, new RedshiftServerlessAdminSecrets(secrets, mapper));AcmService acmService = mock(AcmService.class);RedshiftServerlessCustomDomainService customDomains =new RedshiftServerlessCustomDomainService(storageFactory, service, acmService);diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessRuntimeIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessRuntimeIntegrationTest.javaindex fd721f076c..29bfef67bf 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessRuntimeIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessRuntimeIntegrationTest.java@@ -225,6 +225,66 @@ class RedshiftServerlessRuntimeIntegrationTest {assertFalse(isListening(port), "the endpoint must be closed once the workgroup is deleted");}+ @Test+ void secretLoginSurvivesAdminUsernameRenameAndLateManagementEnablement() {+ String namespace = "rt-it-secret-ns";+ String workgroup = "rt-it-secret-wg";+ RestAssuredJsonUtils.awsAction("RedshiftServerless", "CreateNamespace", """+ {"namespaceName":"%s","adminUsername":"initial_admin","adminUserPassword":"%s","dbName":"dev"}+ """.formatted(namespace, ADMIN_PASSWORD)).then().statusCode(200);+ RestAssuredJsonUtils.awsAction("RedshiftServerless", "CreateWorkgroup", """+ {"workgroupName":"%s","namespaceName":"%s"}+ """.formatted(workgroup, namespace)).then().statusCode(200);++ try {+ // Case 1: Rename username while unmanaged, then enable management.+ RestAssuredJsonUtils.awsAction("RedshiftServerless", "UpdateNamespace", """+ {"namespaceName":"%s","adminUsername":"pre_managed_admin"}+ """.formatted(namespace)).then().statusCode(200);+ String secretArn = RestAssuredJsonUtils.awsAction("RedshiftServerless", "UpdateNamespace", """+ {"namespaceName":"%s","manageAdminPassword":true}+ """.formatted(namespace)).then().statusCode(200)+ .extract().path("namespace.adminPasswordSecretArn");+ assertNotNull(secretArn);++ String id1 = executeWithSecretAndWait("SELECT 1 AS answer", workgroup, secretArn);+ ExtractableResponse<Response> result1 = RestAssuredJsonUtils.awsAction("RedshiftData", "GetStatementResult",+ "{\"Id\":\"" + id1 + "\"}").then().statusCode(200).extract();+ assertEquals(1, ((Number) result1.path("Records[0][0].longValue")).intValue());++ // Case 2: Rename admin username on already-managed namespace.+ RestAssuredJsonUtils.awsAction("RedshiftServerless", "UpdateNamespace", """+ {"namespaceName":"%s","adminUsername":"post_managed_admin"}+ """.formatted(namespace)).then().statusCode(200);++ String id2 = executeWithSecretAndWait("SELECT 2 AS answer", workgroup, secretArn);+ ExtractableResponse<Response> result2 = RestAssuredJsonUtils.awsAction("RedshiftData", "GetStatementResult",+ "{\"Id\":\"" + id2 + "\"}").then().statusCode(200).extract();+ assertEquals(2, ((Number) result2.path("Records[0][0].longValue")).intValue());+ } finally {+ RestAssuredJsonUtils.awsAction("RedshiftServerless", "DeleteWorkgroup",+ "{\"workgroupName\":\"" + workgroup + "\"}").then().statusCode(200);+ RestAssuredJsonUtils.awsAction("RedshiftServerless", "DeleteNamespace",+ "{\"namespaceName\":\"" + namespace + "\"}").then().statusCode(200);+ }+ }++ private String executeWithSecretAndWait(String sql, String workgroup, String secretArn) {+ String id = RestAssuredJsonUtils.awsAction("RedshiftData", "ExecuteStatement", """+ {"Sql": "%s", "WorkgroupName": "%s", "Database": "dev", "SecretArn": "%s"}+ """.formatted(sql, workgroup, secretArn)).then().statusCode(200)+ .extract().path("Id");+ Awaitility.await().atMost(Duration.ofSeconds(30)).pollDelay(Duration.ZERO)+ .pollInterval(Duration.ofMillis(250)).until(() -> {+ String status = RestAssuredJsonUtils.awsAction("RedshiftData", "DescribeStatement",+ "{\"Id\":\"" + id + "\"}").then().statusCode(200).extract().path("Status");+ assertFalse("FAILED".equals(status) || "ABORTED".equals(status),+ () -> "statement " + id + " ended " + status);+ return "FINISHED".equals(status);+ });+ return id;+ }+private static boolean isListening(int port) {try (Socket socket = new Socket()) {socket.connect(new InetSocketAddress("127.0.0.1", port), 1000);