Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(cognito): provision AWS::Cognito::UserPoolDomain (#3005)

Mario Toffiaf3c251ef2085
diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.md
index 1962ac6a8d..3b87395658 100644
--- a/docs/services/cloudformation.md
+++ b/docs/services/cloudformation.md
@@ -79,7 +79,7 @@ cross-resource references.
| CodePipeline | `Pipeline`, `CustomActionType`, `Webhook` |
| CodeBuild | `Project` |
| Batch | `ComputeEnvironment`, `JobQueue`, `JobDefinition` |
-| Cognito | `UserPool`, `UserPoolClient` |
+| Cognito | `UserPool`, `UserPoolClient`, `UserPoolDomain` |
| ACM | `Certificate` |
| EventBridge | `Rule`, `EventBus`, `EventBusPolicy` |
| EventBridge Scheduler | `ScheduleGroup` |
diff --git a/docs/services/cognito.md b/docs/services/cognito.md
index 9b3603bcb2..4a68b913c3 100644
--- a/docs/services/cognito.md
+++ b/docs/services/cognito.md
@@ -98,6 +98,7 @@ always returns it.
|--------|-------------|
| CreateUserPoolDomain | Creates a Cognito prefix domain, or a custom domain when `CustomDomainConfig.CertificateArn` is given. |
| DescribeUserPoolDomain | Returns a domain's description, including `CloudFrontDistribution` for custom domains. |
+| UpdateUserPoolDomain | Replaces a custom domain's certificate or changes the managed login version in place. The domain keeps its `CloudFrontDistribution`. |
| DeleteUserPoolDomain | Deletes a domain from its user pool. |
### Log Delivery
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CognitoCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CognitoCfnProvisioner.java
new file mode 100644
index 0000000000..0ecf39f711
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CognitoCfnProvisioner.java
@@ -0,0 +1,141 @@
+package io.github.hectorvent.floci.services.cloudformation.provisioners;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;
+import io.github.hectorvent.floci.services.cognito.CognitoService;
+import io.github.hectorvent.floci.services.cognito.model.UserPoolDomain;
+import jakarta.enterprise.context.ApplicationScoped;
+import org.jboss.logging.Logger;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Provisions {@code AWS::Cognito::UserPoolDomain}. The physical id is the domain name, as in AWS,
+ * and {@code Fn::GetAtt CloudFrontDistribution} is the CloudFront name a custom domain's DNS alias
+ * points at. A prefix domain has no distribution of its own in Floci, so for one the attribute is
+ * empty rather than the literal {@code LogicalId.CloudFrontDistribution} an unset attribute yields.
+ *
+ * <p>{@code Routing} (regional failover) is accepted and ignored; nothing in the emulator fails
+ * over. {@code AWS::Cognito::UserPool} and {@code UserPoolClient} still live in the legacy switch.
+ */
+@ApplicationScoped
+public class CognitoCfnProvisioner implements CfnResourceProvisioner {
+
+ private static final Logger LOG = Logger.getLogger(CognitoCfnProvisioner.class);
+ private static final String NOT_FOUND = "ResourceNotFoundException";
+
+ private final CognitoService cognitoService;
+
+ public CognitoCfnProvisioner(CognitoService cognitoService) {
+ this.cognitoService = cognitoService;
+ }
+
+ @Override
+ public Set<String> resourceTypes() {
+ return Set.of("AWS::Cognito::UserPoolDomain");
+ }
+
+ @Override
+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {
+ String domain = ctx.resolveOptional(props, "Domain");
+ String userPoolId = ctx.resolveOptional(props, "UserPoolId");
+ if (domain == null || domain.isBlank() || userPoolId == null || userPoolId.isBlank()) {
+ throw new IllegalArgumentException("AWS::Cognito::UserPoolDomain requires Domain and UserPoolId");
+ }
+ Map<String, Object> customDomainConfig = resolveCustomDomainConfig(props, ctx);
+ Integer managedLoginVersion = resolveManagedLoginVersion(props, ctx);
+
+ // Domain and UserPoolId are createOnly in the schema: a change to either replaces the
+ // domain, and the prior one is removed once the new one exists. Domain names are unique
+ // across pools, so a change to UserPoolId alone fails on the create, as it does on AWS,
+ // where CloudFormation also creates the replacement before deleting the original. Anything
+ // else, a renewed certificate or another managed login version, is applied in place so the
+ // CloudFront distribution a DNS alias points at survives, as on AWS.
+ UserPoolDomain existing = ctx.isUpdate() ? findExisting(ctx.priorPhysicalId()) : null;
+ UserPoolDomain provisioned;
+ if (existing != null && ctx.reusesPriorEntity(domain) && userPoolId.equals(existing.getUserPoolId())) {
+ provisioned = cognitoService.updateUserPoolDomain(domain, userPoolId, customDomainConfig, managedLoginVersion);
+ } else {
+ provisioned = cognitoService.createUserPoolDomain(domain, userPoolId, customDomainConfig, managedLoginVersion);
+ if (existing != null) {
+ deleteDomain(existing.getDomain(), existing.getUserPoolId());
+ }
+ }
+ r.setPhysicalId(domain);
+ // Recorded so delete can name the owning pool: DeleteUserPoolDomain needs both.
+ r.getAttributes().put("UserPoolId", userPoolId);
+ r.getAttributes().put("CloudFrontDistribution",
+ provisioned.getCloudFrontDistribution() == null ? "" : provisioned.getCloudFrontDistribution());
+ }
+
+ /** Deletes the domain from the pool recorded at create time; without that record, looks the pool up. */
+ @Override
+ public void delete(StackResource resource, String region) {
+ String userPoolId = resource.getAttributes() == null ? null : resource.getAttributes().get("UserPoolId");
+ if (userPoolId == null || userPoolId.isBlank()) {
+ delete(resource.getResourceType(), resource.getPhysicalId(), region);
+ return;
+ }
+ deleteDomain(resource.getPhysicalId(), userPoolId);
+ }
+
+ /** Only the domain itself can say which pool owns it here; one that is already gone needs nothing. */
+ @Override
+ public void delete(String resourceType, String physicalId, String region) {
+ UserPoolDomain existing = findExisting(physicalId);
+ if (existing != null) {
+ deleteDomain(physicalId, existing.getUserPoolId());
+ }
+ }
+
+ private void deleteDomain(String domain, String userPoolId) {
+ CfnDeletes.safeDelete("user pool domain", domain,
+ () -> cognitoService.deleteUserPoolDomain(domain, userPoolId), NOT_FOUND);
+ }
+
+ private UserPoolDomain findExisting(String domain) {
+ try {
+ return cognitoService.describeUserPoolDomain(domain);
+ } catch (AwsException e) {
+ if (!NOT_FOUND.equals(e.getErrorCode())) {
+ throw e;
+ }
+ LOG.debugv("User pool domain {0} is gone", domain);
+ return null;
+ }
+ }
+
+ private static Map<String, Object> resolveCustomDomainConfig(JsonNode props, ProvisionContext ctx) {
+ if (props == null || !props.hasNonNull("CustomDomainConfig")) {
+ return null;
+ }
+ JsonNode resolved = ctx.engine().resolveNode(props.get("CustomDomainConfig"));
+ if (resolved == null || !resolved.isObject()) {
+ return null;
+ }
+ Map<String, Object> config = new LinkedHashMap<>();
+ resolved.fields().forEachRemaining(field -> {
+ // A JSON null is an absent value, not the text "null" that asText() would make of it.
+ if (!field.getValue().isNull()) {
+ config.put(field.getKey(), field.getValue().asText());
+ }
+ });
+ return config;
+ }
+
+ private static Integer resolveManagedLoginVersion(JsonNode props, ProvisionContext ctx) {
+ String value = ctx.resolveOptional(props, "ManagedLoginVersion");
+ if (value == null || value.isBlank()) {
+ return null;
+ }
+ try {
+ return Integer.valueOf(value.trim());
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(
+ "AWS::Cognito::UserPoolDomain ManagedLoginVersion must be an integer, got: " + value, e);
+ }
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java
index 86892d031e..d793c33bc7 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java
@@ -70,6 +70,7 @@ public class CognitoJsonHandler {
case "DeleteIdentityProvider" -> handleDeleteIdentityProvider(request);
case "CreateUserPoolDomain" -> handleCreateUserPoolDomain(request);
case "DescribeUserPoolDomain" -> handleDescribeUserPoolDomain(request);
+ case "UpdateUserPoolDomain" -> handleUpdateUserPoolDomain(request);
case "DeleteUserPoolDomain" -> handleDeleteUserPoolDomain(request);
case "SetLogDeliveryConfiguration" -> handleSetLogDeliveryConfiguration(request);
case "GetLogDeliveryConfiguration" -> handleGetLogDeliveryConfiguration(request);
@@ -443,16 +444,46 @@ public class CognitoJsonHandler {
}
private Response handleCreateUserPoolDomain(JsonNode request) {
- JsonNode customDomainConfigNode = request.path("CustomDomainConfig");
- Map<String, Object> customDomainConfig = customDomainConfigNode.isObject()
- ? objectMapper.convertValue(customDomainConfigNode, new TypeReference<Map<String, Object>>() {})
- : null;
UserPoolDomain domain = service.createUserPoolDomain(
request.path("Domain").asText(),
request.path("UserPoolId").asText(),
- customDomainConfig,
- request.has("ManagedLoginVersion") ? request.path("ManagedLoginVersion").asInt() : null
+ customDomainConfig(request),
+ managedLoginVersion(request)
+ );
+ return Response.ok(userPoolDomainResultToNode(domain)).build();
+ }
+
+ private Response handleUpdateUserPoolDomain(JsonNode request) {
+ UserPoolDomain domain = service.updateUserPoolDomain(
+ request.path("Domain").asText(),
+ request.path("UserPoolId").asText(),
+ customDomainConfig(request),
+ managedLoginVersion(request)
);
+ return Response.ok(userPoolDomainResultToNode(domain)).build();
+ }
+
+ private Map<String, Object> customDomainConfig(JsonNode request) {
+ JsonNode node = request.path("CustomDomainConfig");
+ return node.isObject()
+ ? objectMapper.convertValue(node, new TypeReference<Map<String, Object>>() {})
+ : null;
+ }
+
+ /** Absent or null yields null; a value of another JSON type is a SerializationException, as on AWS. */
+ private static Integer managedLoginVersion(JsonNode request) {
+ JsonNode node = request.get("ManagedLoginVersion");
+ if (node == null || node.isNull()) {
+ return null;
+ }
+ if (!node.isIntegralNumber()) {
+ throw new AwsException("SerializationException", "Expected integer or null", 400);
+ }
+ return node.intValue();
+ }
+
+ /** CreateUserPoolDomain and UpdateUserPoolDomain share this result shape. */
+ private ObjectNode userPoolDomainResultToNode(UserPoolDomain domain) {
ObjectNode response = objectMapper.createObjectNode();
if (domain.isCustomDomain()) {
response.put("CloudFrontDomain", domain.getCloudFrontDistribution());
@@ -460,7 +491,7 @@ public class CognitoJsonHandler {
if (domain.getManagedLoginVersion() != null) {
response.put("ManagedLoginVersion", domain.getManagedLoginVersion());
}
- return Response.ok(response).build();
+ return response;
}
private Response handleDescribeUserPoolDomain(JsonNode request) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java
index f19f17758b..cca2f4274b 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java
@@ -1123,6 +1123,43 @@ public class CognitoService implements ResourceProvider {
.orElseThrow(() -> new AwsException("ResourceNotFoundException", "Domain does not exist", 404));
}
+ /**
+ * Changes a domain in place: the certificate behind a custom domain ({@code CustomDomainConfig})
+ * or the managed login version. As on AWS the domain keeps its CloudFront distribution, so a
+ * DNS alias pointing at it stays valid. A setting the request omits is left unchanged.
+ */
+ public UserPoolDomain updateUserPoolDomain(String domain, String userPoolId,
+ Map<String, Object> customDomainConfig, Integer managedLoginVersion) {
+ describeUserPool(userPoolId);
+ UserPoolDomain userPoolDomain = describeUserPoolDomain(domain);
+ if (!userPoolDomain.getUserPoolId().equals(userPoolId)) {
+ throw new AwsException("ResourceNotFoundException", "Domain does not exist", 404);
+ }
+ if (customDomainConfig != null) {
+ if (!userPoolDomain.isCustomDomain()) {
+ throw new AwsException("InvalidParameterException",
+ "CustomDomainConfig cannot be set on an Amazon Cognito prefix domain", 400);
+ }
+ String certificateArn = (String) customDomainConfig.get("CertificateArn");
+ if (certificateArn == null || certificateArn.isBlank()) {
+ throw new AwsException("InvalidParameterException",
+ "CertificateArn is required in CustomDomainConfig", 400);
+ }
+ userPoolDomain.setCertificateArn(certificateArn);
+ Object securityPolicy = customDomainConfig.get("SecurityPolicy");
+ if (securityPolicy != null) {
+ userPoolDomain.setSecurityPolicy(securityPolicy.toString());
+ }
+ }
+ if (managedLoginVersion != null) {
+ userPoolDomain.setManagedLoginVersion(managedLoginVersion);
+ }
+ userPoolDomain.setLastModifiedDate(System.currentTimeMillis() / 1000L);
+ domainStore.put(domain, userPoolDomain);
+ LOG.infov("Updated User Pool Domain: {0} for pool {1}", domain, userPoolId);
+ return userPoolDomain;
+ }
+
public void deleteUserPoolDomain(String domain, String userPoolId) {
UserPoolDomain userPoolDomain = describeUserPoolDomain(domain);
if (!userPoolDomain.getUserPoolId().equals(userPoolId)) {
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java
index 06de9a0f64..5d49965050 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java
@@ -26,6 +26,7 @@ import io.github.hectorvent.floci.services.cloudformation.provisioners.ApiGatewa
import io.github.hectorvent.floci.services.cloudformation.provisioners.AutoScalingLifecycleHookCfnProvisioner;
import io.github.hectorvent.floci.services.cloudformation.provisioners.CdkMetadataCfnProvisioner;
import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudWatchCfnProvisioner;
+import io.github.hectorvent.floci.services.cloudformation.provisioners.CognitoCfnProvisioner;
import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2LaunchTemplateCfnProvisioner;
import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2NetworkAclCfnProvisioner;
import io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2SecurityGroupRuleCfnProvisioner;
@@ -206,6 +207,9 @@ final class CfnProvisionerFixture {
if (pipesService != null) {
discovered.add(new PipesCfnProvisioner(pipesService));
}
+ if (cognitoService != null) {
+ discovered.add(new CognitoCfnProvisioner(cognitoService));
+ }
if (firehoseService != null) {
discovered.add(new FirehoseCfnProvisioner(firehoseService));
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CognitoCfnIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CognitoCfnIntegrationTest.java
new file mode 100644
index 0000000000..d1ba53a28d
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CognitoCfnIntegrationTest.java
@@ -0,0 +1,278 @@
+package io.github.hectorvent.floci.services.cloudformation;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.github.hectorvent.floci.core.common.XmlParser;
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.specification.RequestSpecification;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static io.github.hectorvent.floci.services.cognito.CognitoRestAssuredUtils.cognitoAction;
+import static io.github.hectorvent.floci.services.cognito.CognitoRestAssuredUtils.cognitoJson;
+import static io.github.hectorvent.floci.testing.RestAssuredJsonUtils.awsAction;
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Provisions an {@code AWS::Cognito::UserPoolDomain} through a CloudFormation stack, laid out the
+ * way CDK emits a custom domain: a user pool, an {@code AWS::CertificateManager::Certificate}, the
+ * domain referencing the certificate, and a Route 53 alias record whose target is
+ * {@code Fn::GetAtt CloudFrontDistribution}. Asserts that the attribute is the CloudFront name
+ * {@code DescribeUserPoolDomain} reports rather than the literal {@code Domain.CloudFrontDistribution}
+ * the stub arm would leave in the record, that rotating to a new certificate resource updates the
+ * domain in place so the alias target survives, that a changed domain name replaces the domain, and
+ * that deleting the stack removes the domain before the pool that owns it. A prefix domain, which
+ * has no distribution of its own, resolves the attribute to an empty string rather than the literal.
+ */
+@QuarkusTest
+class CognitoCfnIntegrationTest {
+
+ private static final String CFN_AUTH =
+ "AWS4-HMAC-SHA256 Credential=test/20260903/us-east-1/cloudformation/aws4_request";
+ private static final String CUSTOM_STACK = "cognito-cfn-it";
+ private static final String PREFIX_STACK = "cognito-cfn-prefix-it";
+ private static final String DOMAIN = "auth.cognito-cfn-it.example.com";
+ private static final String REPLACEMENT_DOMAIN = "login.cognito-cfn-it.example.com";
+ private static final String PREFIX_DOMAIN = "cognito-cfn-it-prefix";
+
+ /**
+ * The certificate carries the logical id so a rotation can add a new certificate resource and
+ * drop the old one, which is how a certificate is replaced without a moment where the domain
+ * points at a certificate that is being deleted. A wildcard name keeps a domain rename from
+ * replacing the certificate as well.
+ */
+ private static String customDomainTemplate(String domain, String certificateLogicalId) {
+ return """
+ {
+ "Resources": {
+ "Pool": {
+ "Type": "AWS::Cognito::UserPool",
+ "Properties": {"UserPoolName": "cognito-cfn-it-pool"}
+ },
+ "%1$s": {
+ "Type": "AWS::CertificateManager::Certificate",
+ "Properties": {"DomainName": "*.cognito-cfn-it.example.com", "ValidationMethod": "DNS"}
+ },
+ "Domain": {
+ "Type": "AWS::Cognito::UserPoolDomain",
+ "Properties": {
+ "Domain": "%2$s",
+ "UserPoolId": {"Ref": "Pool"},
+ "CustomDomainConfig": {"CertificateArn": {"Fn::GetAtt": ["%1$s", "CertificateArn"]}},
+ "ManagedLoginVersion": 2
+ }
+ },
+ "Zone": {
+ "Type": "AWS::Route53::HostedZone",
+ "Properties": {"Name": "cognito-cfn-it.example.com"}
+ },
+ "AuthAlias": {
+ "Type": "AWS::Route53::RecordSet",
+ "Properties": {
+ "HostedZoneId": {"Ref": "Zone"},
+ "Name": "%2$s",
+ "Type": "A",
+ "AliasTarget": {
+ "DNSName": {"Fn::GetAtt": ["Domain", "CloudFrontDistribution"]},
+ "HostedZoneId": "Z2FDTNDATAQYW2"
+ }
+ }
+ }
+ },
+ "Outputs": {
+ "PoolId": {"Value": {"Ref": "Pool"}},
+ "DomainRef": {"Value": {"Ref": "Domain"}},
+ "CertArn": {"Value": {"Fn::GetAtt": ["%1$s", "CertificateArn"]}},
+ "AliasTarget": {"Value": {"Fn::GetAtt": ["Domain", "CloudFrontDistribution"]}}
+ }
+ }
+ """.formatted(certificateLogicalId, domain);
+ }
+
+ private static final String PREFIX_DOMAIN_TEMPLATE = """
+ {
+ "Resources": {
+ "Pool": {
+ "Type": "AWS::Cognito::UserPool",
+ "Properties": {"UserPoolName": "cognito-cfn-prefix-it-pool"}
+ },
+ "Domain": {
+ "Type": "AWS::Cognito::UserPoolDomain",
+ "Properties": {
+ "Domain": "%s",
+ "UserPoolId": {"Ref": "Pool"}
+ }
+ }
+ },
+ "Outputs": {
+ "PoolId": {"Value": {"Ref": "Pool"}},
+ "DomainRef": {"Value": {"Ref": "Domain"}},
+ "CloudFront": {"Value": {"Fn::GetAtt": ["Domain", "CloudFrontDistribution"]}}
+ }
+ }
+ """.formatted(PREFIX_DOMAIN);
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @Test
+ void customDomainStackExposesTheCloudFrontNameRotatesTheCertificateReplacesOnRenameAndDeletesBeforeThePool()
+ throws Exception {
+ cloudFormation(CUSTOM_STACK, "CreateStack", customDomainTemplate(DOMAIN, "Cert"));
+
+ String stacks = describeStacks(CUSTOM_STACK, "CREATE_COMPLETE");
+ String poolId = outputValue(stacks, "PoolId");
+ String aliasTarget = outputValue(stacks, "AliasTarget");
+ String certificateArn = outputValue(stacks, "CertArn");
+ assertEquals(DOMAIN, outputValue(stacks, "DomainRef"));
+ assertTrue(aliasTarget.endsWith(".cloudfront.net"),
+ "Fn::GetAtt CloudFrontDistribution must be a CloudFront name: " + aliasTarget);
+ assertTrue(certificateArn.startsWith("arn:aws:acm:us-east-1:"),
+ "the certificate must be provisioned rather than stubbed: " + certificateArn);
+ assertCertificateStatus(certificateArn, "ISSUED");
+
+ JsonNode description = describeDomain(DOMAIN);
+ assertEquals(poolId, description.path("UserPoolId").asText());
+ assertEquals(aliasTarget, description.path("CloudFrontDistribution").asText());
+ assertEquals(certificateArn, description.path("CustomDomainConfig").path("CertificateArn").asText());
+ assertEquals(2, description.path("ManagedLoginVersion").asInt());
+
+ // Rotation: a new certificate resource takes over and the old one leaves the template. The
+ // domain moves to the new certificate in place, and the old certificate is removed once
+ // nothing references it.
+ cloudFormation(CUSTOM_STACK, "UpdateStack", customDomainTemplate(DOMAIN, "RenewedCert"));
+
+ stacks = describeStacks(CUSTOM_STACK, "UPDATE_COMPLETE");
+ String renewedCertificateArn = outputValue(stacks, "CertArn");
+ assertNotEquals(certificateArn, renewedCertificateArn);
+ description = describeDomain(DOMAIN);
+ assertEquals(renewedCertificateArn, description.path("CustomDomainConfig").path("CertificateArn").asText());
+ assertEquals(aliasTarget, description.path("CloudFrontDistribution").asText(),
+ "a certificate change must keep the CloudFront distribution the alias record points at");
+ assertCertificateIsGone(certificateArn);
+
+ // Domain is createOnly: a new name is a replacement, created before the old domain goes.
+ cloudFormation(CUSTOM_STACK, "UpdateStack", customDomainTemplate(REPLACEMENT_DOMAIN, "RenewedCert"));
+
+ stacks = describeStacks(CUSTOM_STACK, "UPDATE_COMPLETE");
+ assertEquals(REPLACEMENT_DOMAIN, outputValue(stacks, "DomainRef"));
+ String replacementTarget = outputValue(stacks, "AliasTarget");
+ assertTrue(replacementTarget.endsWith(".cloudfront.net"), replacementTarget);
+ assertNotEquals(aliasTarget, replacementTarget, "the replacement is a new domain with its own distribution");
+ assertDomainIsGone(DOMAIN);
+ description = describeDomain(REPLACEMENT_DOMAIN);
+ assertEquals(poolId, description.path("UserPoolId").asText());
+ assertEquals(replacementTarget, description.path("CloudFrontDistribution").asText());
+ assertEquals(renewedCertificateArn, description.path("CustomDomainConfig").path("CertificateArn").asText());
+
+ cloudFormation(CUSTOM_STACK, "DeleteStack", null);
+ awaitStackDeleted(CUSTOM_STACK);
+
+ assertDomainIsGone(REPLACEMENT_DOMAIN);
+ assertCertificateIsGone(renewedCertificateArn);
+ cognitoAction("DescribeUserPool", "{\"UserPoolId\": \"" + poolId + "\"}")
+ .then()
+ .body("__type", equalTo("ResourceNotFoundException"));
+ }
+
+ @Test
+ void prefixDomainStackResolvesAnEmptyCloudFrontDistribution() throws Exception {
+ cloudFormation(PREFIX_STACK, "CreateStack", PREFIX_DOMAIN_TEMPLATE);
+
+ String stacks = describeStacks(PREFIX_STACK, "CREATE_COMPLETE");
+ assertEquals(PREFIX_DOMAIN, outputValue(stacks, "DomainRef"));
+ assertEquals("", outputValue(stacks, "CloudFront"),
+ "a prefix domain has no distribution of its own, and must not resolve to the literal attribute name");
+
+ JsonNode description = describeDomain(PREFIX_DOMAIN);
+ assertEquals(outputValue(stacks, "PoolId"), description.path("UserPoolId").asText());
+ assertFalse(description.has("CloudFrontDistribution"));
+ assertFalse(description.has("CustomDomainConfig"));
+
+ cloudFormation(PREFIX_STACK, "DeleteStack", null);
+ awaitStackDeleted(PREFIX_STACK);
+
+ assertDomainIsGone(PREFIX_DOMAIN);
+ }
+
+ private static void cloudFormation(String stack, String action, String templateBody) {
+ RequestSpecification request = given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", CFN_AUTH)
+ .formParam("Action", action)
+ .formParam("StackName", stack);
+ if (templateBody != null) {
+ request.formParam("TemplateBody", templateBody);
+ }
+ request.when().post("/").then().statusCode(200);
+ }
+
+ private static String describeStacks(String stack, String expectedStatus) {
+ return given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", CFN_AUTH)
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stack)
+ .when().post("/").then().statusCode(200)
+ .body(containsString("<StackStatus>" + expectedStatus + "</StackStatus>"))
+ .extract().asString();
+ }
+
+ /** DeleteStack runs asynchronously; a successful delete removes the stack entirely. */
+ private static void awaitStackDeleted(String stack) throws InterruptedException {
+ for (int i = 0; i < 100; i++) {
+ String body = given()
+ .contentType("application/x-www-form-urlencoded")
+ .header("Authorization", CFN_AUTH)
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stack)
+ .when().post("/").then().extract().asString();
+ if (body.contains("does not exist")) {
+ return;
+ }
+ if (body.contains("<StackStatus>DELETE_FAILED</StackStatus>")) {
+ fail("stack delete failed: " + body);
+ }
+ Thread.sleep(50);
+ }
+ fail("stack " + stack + " was not deleted within the timeout");
+ }
+
+ private static JsonNode describeDomain(String domain) throws Exception {
+ return cognitoJson("DescribeUserPoolDomain", "{\"Domain\": \"" + domain + "\"}").path("DomainDescription");
+ }
+
+ private static void assertDomainIsGone(String domain) {
+ cognitoAction("DescribeUserPoolDomain", "{\"Domain\": \"" + domain + "\"}")
+ .then()
+ .statusCode(404)
+ .body("__type", equalTo("ResourceNotFoundException"));
+ }
+
+ private static void assertCertificateStatus(String certificateArn, String status) {
+ awsAction("CertificateManager", "DescribeCertificate", "{\"CertificateArn\": \"" + certificateArn + "\"}")
+ .then()
+ .statusCode(200)
+ .body("Certificate.Status", equalTo(status));
+ }
+
+ private static void assertCertificateIsGone(String certificateArn) {
+ awsAction("CertificateManager", "DescribeCertificate", "{\"CertificateArn\": \"" + certificateArn + "\"}")
+ .then()
+ .statusCode(404)
+ .body("__type", equalTo("ResourceNotFoundException"));
+ }
+
+ private static String outputValue(String xml, String key) {
+ return XmlParser.extractPairs(xml, "Outputs", "OutputKey", "OutputValue").get(key);
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CognitoCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CognitoCfnProvisionerTest.java
new file mode 100644
index 0000000000..4719c8a073
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CognitoCfnProvisionerTest.java
@@ -0,0 +1,297 @@
+package io.github.hectorvent.floci.services.cloudformation.provisioners;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.services.cloudformation.CloudFormationTemplateEngine;
+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;
+import io.github.hectorvent.floci.services.cognito.CognitoService;
+import io.github.hectorvent.floci.services.cognito.model.UserPoolDomain;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * The Cognito CFN provisioner in isolation: one mocked service. Every case asserts the exact
+ * physical id and the exact {@code Fn::GetAtt} attribute keys, since an unmapped type still
+ * reports CREATE_COMPLETE through the dispatcher's stub arm.
+ */
+class CognitoCfnProvisionerTest {
+
+ private static final String TYPE = "AWS::Cognito::UserPoolDomain";
+ private static final String REGION = "us-east-1";
+ private static final String POOL_ID = "us-east-1_AbCdEfGhI";
+ private static final String DOMAIN = "auth.example.com";
+ private static final String CERTIFICATE_ARN =
+ "arn:aws:acm:us-east-1:000000000000:certificate/11111111-2222-3333-4444-555555555555";
+ private static final String RENEWED_CERTIFICATE_ARN =
+ "arn:aws:acm:us-east-1:000000000000:certificate/99999999-2222-3333-4444-555555555555";
+ private static final String CLOUDFRONT = "d1234567890abc.cloudfront.net";
+
+ private final CognitoService cognito = mock(CognitoService.class);
+ private final CognitoCfnProvisioner provisioner = new CognitoCfnProvisioner(cognito);
+ private final ObjectMapper mapper = new ObjectMapper();
+
+ private ProvisionContext ctx() {
+ return ctx(null);
+ }
+
+ private ProvisionContext ctx(String priorPhysicalId) {
+ CloudFormationTemplateEngine engine = mock(CloudFormationTemplateEngine.class);
+ when(engine.resolve(any())).thenAnswer(inv -> {
+ JsonNode node = inv.getArgument(0);
+ return node == null || node.isMissingNode() || node.isNull() ? null : node.asText();
+ });
+ when(engine.resolveNode(any())).thenAnswer(inv -> inv.getArgument(0));
+ return new ProvisionContext(engine, REGION, "000000000000", "my-stack", priorPhysicalId);
+ }
+
+ private static StackResource resource() {
+ StackResource r = new StackResource();
+ r.setLogicalId("Domain");
+ r.setResourceType(TYPE);
+ r.setAttributes(new HashMap<>());
+ return r;
+ }
+
+ private static StackResource resource(String physicalId, Map<String, String> attributes) {
+ StackResource r = resource();
+ r.setPhysicalId(physicalId);
+ r.setAttributes(new HashMap<>(attributes));
+ return r;
+ }
+
+ private static UserPoolDomain domain(String domain, String userPoolId, String cloudFront) {
+ UserPoolDomain d = new UserPoolDomain();
+ d.setDomain(domain);
+ d.setUserPoolId(userPoolId);
+ d.setCloudFrontDistribution(cloudFront);
+ return d;
+ }
+
+ private ObjectNode customDomainProps(String certificateArn) {
+ ObjectNode props = mapper.createObjectNode()
+ .put("Domain", DOMAIN)
+ .put("UserPoolId", POOL_ID)
+ .put("ManagedLoginVersion", 2);
+ props.putObject("CustomDomainConfig").put("CertificateArn", certificateArn);
+ return props;
+ }
+
+ @Test
+ void customDomainSetsDomainAsPhysicalIdAndCloudFrontAttribute() {
+ when(cognito.createUserPoolDomain(DOMAIN, POOL_ID, Map.of("CertificateArn", CERTIFICATE_ARN), 2))
+ .thenReturn(domain(DOMAIN, POOL_ID, CLOUDFRONT));
+ StackResource r = resource();
+
+ provisioner.provision(r, customDomainProps(CERTIFICATE_ARN), ctx());
+
+ assertEquals(DOMAIN, r.getPhysicalId());
+ assertEquals(Map.of("UserPoolId", POOL_ID, "CloudFrontDistribution", CLOUDFRONT), r.getAttributes());
+ }
+
+ @Test
+ void prefixDomainHasAnEmptyCloudFrontDistribution() {
+ when(cognito.createUserPoolDomain(eq("my-prefix"), eq(POOL_ID), isNull(), isNull()))
+ .thenReturn(domain("my-prefix", POOL_ID, null));
+ StackResource r = resource();
+
+ provisioner.provision(r, mapper.createObjectNode().put("Domain", "my-prefix").put("UserPoolId", POOL_ID), ctx());
+
+ assertEquals("my-prefix", r.getPhysicalId());
+ assertEquals(Map.of("UserPoolId", POOL_ID, "CloudFrontDistribution", ""), r.getAttributes());
+ }
+
+ @Test
+ void customDomainConfigPassesEveryFieldThrough() {
+ when(cognito.createUserPoolDomain(any(), any(), any(), any())).thenReturn(domain(DOMAIN, POOL_ID, CLOUDFRONT));
+ ObjectNode props = mapper.createObjectNode().put("Domain", DOMAIN).put("UserPoolId", POOL_ID);
+ props.putObject("CustomDomainConfig")
+ .put("CertificateArn", CERTIFICATE_ARN)
+ .put("SecurityPolicy", "TLS_V1_2_2021");
+
+ provisioner.provision(resource(), props, ctx());
+
+ verify(cognito).createUserPoolDomain(DOMAIN, POOL_ID,
+ Map.of("CertificateArn", CERTIFICATE_ARN, "SecurityPolicy", "TLS_V1_2_2021"), null);
+ }
+
+ @Test
+ void customDomainConfigSkipsNullValues() {
+ // A JSON null must not reach the service as the text "null", where it would pass for an ARN.
+ when(cognito.createUserPoolDomain(any(), any(), any(), any())).thenReturn(domain(DOMAIN, POOL_ID, CLOUDFRONT));
+ ObjectNode props = mapper.createObjectNode().put("Domain", DOMAIN).put("UserPoolId", POOL_ID);
+ props.putObject("CustomDomainConfig")
+ .putNull("CertificateArn")
+ .put("SecurityPolicy", "TLS_V1_2_2021");
+
+ provisioner.provision(resource(), props, ctx());
+
+ verify(cognito).createUserPoolDomain(DOMAIN, POOL_ID, Map.of("SecurityPolicy", "TLS_V1_2_2021"), null);
+ }
+
+ @Test
+ void requiresDomainAndUserPoolId() {
+ assertThrows(IllegalArgumentException.class, () -> provisioner.provision(
+ resource(), mapper.createObjectNode().put("UserPoolId", POOL_ID), ctx()));
+ assertThrows(IllegalArgumentException.class, () -> provisioner.provision(
+ resource(), mapper.createObjectNode().put("Domain", DOMAIN), ctx()));
+
+ verify(cognito, never()).createUserPoolDomain(any(), any(), any(), any());
+ }
+
+ @Test
+ void rejectsANonIntegerManagedLoginVersion() {
+ ObjectNode props = customDomainProps(CERTIFICATE_ARN).put("ManagedLoginVersion", "two");
+
+ assertThrows(IllegalArgumentException.class, () -> provisioner.provision(resource(), props, ctx()));
+
+ verify(cognito, never()).createUserPoolDomain(any(), any(), any(), any());
+ }
+
+ @Test
+ void updateWithUnchangedDomainAndPoolUpdatesInPlace() {
+ when(cognito.describeUserPoolDomain(DOMAIN)).thenReturn(domain(DOMAIN, POOL_ID, CLOUDFRONT));
+ when(cognito.updateUserPoolDomain(DOMAIN, POOL_ID, Map.of("CertificateArn", RENEWED_CERTIFICATE_ARN), 2))
+ .thenReturn(domain(DOMAIN, POOL_ID, CLOUDFRONT));
+ StackResource r = resource(DOMAIN, Map.of("UserPoolId", POOL_ID, "CloudFrontDistribution", CLOUDFRONT));
+
+ provisioner.provision(r, customDomainProps(RENEWED_CERTIFICATE_ARN), ctx(DOMAIN));
+
+ verify(cognito, never()).createUserPoolDomain(any(), any(), any(), any());
+ verify(cognito, never()).deleteUserPoolDomain(any(), any());
+ assertEquals(DOMAIN, r.getPhysicalId());
+ assertEquals(Map.of("UserPoolId", POOL_ID, "CloudFrontDistribution", CLOUDFRONT), r.getAttributes());
+ }
+
+ @Test
+ void updateWithChangedDomainReplacesTheDomain() {
+ when(cognito.describeUserPoolDomain("old.example.com"))
+ .thenReturn(domain("old.example.com", POOL_ID, "dold.cloudfront.net"));
+ when(cognito.createUserPoolDomain(DOMAIN, POOL_ID, Map.of("CertificateArn", CERTIFICATE_ARN), 2))
+ .thenReturn(domain(DOMAIN, POOL_ID, CLOUDFRONT));
+ StackResource r = resource("old.example.com",
+ Map.of("UserPoolId", POOL_ID, "CloudFrontDistribution", "dold.cloudfront.net"));
+
+ provisioner.provision(r, customDomainProps(CERTIFICATE_ARN), ctx("old.example.com"));
+
+ verify(cognito, never()).updateUserPoolDomain(any(), any(), any(), any());
+ verify(cognito).deleteUserPoolDomain("old.example.com", POOL_ID);
+ assertEquals(DOMAIN, r.getPhysicalId());
+ assertEquals(Map.of("UserPoolId", POOL_ID, "CloudFrontDistribution", CLOUDFRONT), r.getAttributes());
+ }
+
+ @Test
+ void updateWithChangedUserPoolFailsWhileTheDomainNameIsTaken() {
+ // CloudFormation creates the replacement before deleting the original, and domain names are
+ // unique across pools, so moving an unchanged domain to another pool fails on AWS too. The
+ // original is left untouched for the rollback.
+ String otherPool = "us-east-1_ZzZzZzZzZ";
+ when(cognito.describeUserPoolDomain(DOMAIN)).thenReturn(domain(DOMAIN, otherPool, CLOUDFRONT));
+ when(cognito.createUserPoolDomain(DOMAIN, POOL_ID, Map.of("CertificateArn", CERTIFICATE_ARN), 2))
+ .thenThrow(new AwsException("InvalidParameterException",
+ "Domain " + DOMAIN + " already associated with another user pool", 400));
+ StackResource r = resource(DOMAIN, Map.of("UserPoolId", otherPool, "CloudFrontDistribution", CLOUDFRONT));
+
+ AwsException failure = assertThrows(AwsException.class,
+ () -> provisioner.provision(r, customDomainProps(CERTIFICATE_ARN), ctx(DOMAIN)));
+
+ assertEquals("InvalidParameterException", failure.getErrorCode());
+ verify(cognito, never()).updateUserPoolDomain(any(), any(), any(), any());
+ verify(cognito, never()).deleteUserPoolDomain(any(), any());
+ }
+
+ @Test
+ void updateWhosePriorDomainIsGoneCreatesItAgain() {
+ when(cognito.describeUserPoolDomain(DOMAIN))
+ .thenThrow(new AwsException("ResourceNotFoundException", "Domain does not exist", 404));
+ when(cognito.createUserPoolDomain(DOMAIN, POOL_ID, Map.of("CertificateArn", CERTIFICATE_ARN), 2))
+ .thenReturn(domain(DOMAIN, POOL_ID, CLOUDFRONT));
+ StackResource r = resource(DOMAIN, Map.of("UserPoolId", POOL_ID, "CloudFrontDistribution", CLOUDFRONT));
+
+ provisioner.provision(r, customDomainProps(CERTIFICATE_ARN), ctx(DOMAIN));
+
+ verify(cognito, never()).updateUserPoolDomain(any(), any(), any(), any());
+ verify(cognito, never()).deleteUserPoolDomain(any(), any());
+ assertEquals(DOMAIN, r.getPhysicalId());
+ }
+
+ @Test
+ void replacementToleratesAPriorDomainThatIsAlreadyGone() {
+ when(cognito.describeUserPoolDomain("old.example.com"))
+ .thenReturn(domain("old.example.com", POOL_ID, "dold.cloudfront.net"));
+ when(cognito.createUserPoolDomain(any(), any(), any(), any())).thenReturn(domain(DOMAIN, POOL_ID, CLOUDFRONT));
+ doThrow(new AwsException("ResourceNotFoundException", "Domain does not exist", 404))
+ .when(cognito).deleteUserPoolDomain("old.example.com", POOL_ID);
+ StackResource r = resource("old.example.com", Map.of("UserPoolId", POOL_ID));
+
+ assertDoesNotThrow(() -> provisioner.provision(r, customDomainProps(CERTIFICATE_ARN), ctx("old.example.com")));
+ assertEquals(DOMAIN, r.getPhysicalId());
+ }
+
+ @Test
+ void deleteUsesTheRecordedUserPoolId() {
+ provisioner.delete(resource(DOMAIN, Map.of("UserPoolId", POOL_ID, "CloudFrontDistribution", CLOUDFRONT)), REGION);
+
+ verify(cognito).deleteUserPoolDomain(DOMAIN, POOL_ID);
+ verify(cognito, never()).describeUserPoolDomain(any());
+ }
+
+ @Test
+ void deleteToleratesAnAlreadyDeletedDomain() {
+ doThrow(new AwsException("ResourceNotFoundException", "Domain does not exist", 404))
+ .when(cognito).deleteUserPoolDomain(DOMAIN, POOL_ID);
+
+ assertDoesNotThrow(() -> provisioner.delete(resource(DOMAIN, Map.of("UserPoolId", POOL_ID)), REGION));
+ }
+
+ @Test
+ void deletePropagatesOtherFailures() {
+ doThrow(new AwsException("InvalidParameterException", "Domain is required", 400))
+ .when(cognito).deleteUserPoolDomain(DOMAIN, POOL_ID);
+
+ assertThrows(AwsException.class,
+ () -> provisioner.delete(resource(DOMAIN, Map.of("UserPoolId", POOL_ID)), REGION));
+ }
+
+ @Test
+ void deleteWithoutARecordedUserPoolIdLooksTheDomainUp() {
+ when(cognito.describeUserPoolDomain(DOMAIN)).thenReturn(domain(DOMAIN, POOL_ID, CLOUDFRONT));
+
+ provisioner.delete(resource(DOMAIN, Map.of()), REGION);
+
+ verify(cognito).deleteUserPoolDomain(DOMAIN, POOL_ID);
+ }
+
+ @Test
+ void deleteWithoutARecordedUserPoolIdOfAMissingDomainIsANoOp() {
+ when(cognito.describeUserPoolDomain(DOMAIN))
+ .thenThrow(new AwsException("ResourceNotFoundException", "Domain does not exist", 404));
+
+ assertDoesNotThrow(() -> provisioner.delete(resource(DOMAIN, Map.of()), REGION));
+ verify(cognito, never()).deleteUserPoolDomain(any(), any());
+ }
+
+ @Test
+ void deleteByIdAloneLooksTheDomainUp() {
+ when(cognito.describeUserPoolDomain(DOMAIN)).thenReturn(domain(DOMAIN, POOL_ID, CLOUDFRONT));
+
+ provisioner.delete(TYPE, DOMAIN, REGION);
+
+ verify(cognito).deleteUserPoolDomain(DOMAIN, POOL_ID);
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandlerTest.java
index 544712960c..91c918e132 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandlerTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandlerTest.java
@@ -492,4 +492,46 @@ class CognitoJsonHandlerTest {
.collect(Collectors.toSet());
}
+ private String createPoolWithPrefixDomain(String domain) {
+ ObjectNode poolReq = mapper.createObjectNode().put("PoolName", "domain-pool");
+ String poolId = ((JsonNode) handler.handle("CreateUserPool", poolReq, "us-east-1").getEntity())
+ .get("UserPool").get("Id").asText();
+ ObjectNode domainReq = mapper.createObjectNode()
+ .put("Domain", domain)
+ .put("UserPoolId", poolId)
+ .put("ManagedLoginVersion", 1);
+ handler.handle("CreateUserPoolDomain", domainReq, "us-east-1");
+ return poolId;
+ }
+
+ @Test
+ void updateUserPoolDomainTreatsANullManagedLoginVersionAsAbsent() {
+ String poolId = createPoolWithPrefixDomain("null-version");
+ ObjectNode updateReq = mapper.createObjectNode().put("Domain", "null-version").put("UserPoolId", poolId);
+ updateReq.putNull("ManagedLoginVersion");
+
+ JsonNode updated = (JsonNode) handler.handle("UpdateUserPoolDomain", updateReq, "us-east-1").getEntity();
+
+ assertEquals(1, updated.get("ManagedLoginVersion").asInt());
+ JsonNode described = (JsonNode) handler.handle("DescribeUserPoolDomain",
+ mapper.createObjectNode().put("Domain", "null-version"), "us-east-1").getEntity();
+ assertEquals(1, described.get("DomainDescription").get("ManagedLoginVersion").asInt());
+ }
+
+ @Test
+ void userPoolDomainRejectsAManagedLoginVersionThatIsNotAnInteger() {
+ String poolId = createPoolWithPrefixDomain("typed-version");
+ ObjectNode updateReq = mapper.createObjectNode()
+ .put("Domain", "typed-version")
+ .put("UserPoolId", poolId)
+ .put("ManagedLoginVersion", "two");
+
+ AwsException failure = assertThrows(AwsException.class,
+ () -> handler.handle("UpdateUserPoolDomain", updateReq, "us-east-1"));
+
+ assertEquals("SerializationException", failure.getErrorCode());
+ JsonNode described = (JsonNode) handler.handle("DescribeUserPoolDomain",
+ mapper.createObjectNode().put("Domain", "typed-version"), "us-east-1").getEntity();
+ assertEquals(1, described.get("DomainDescription").get("ManagedLoginVersion").asInt());
+ }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java
index a04bc3b69d..acfbc86e21 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java
@@ -12,6 +12,7 @@ import io.github.hectorvent.floci.services.cognito.model.CognitoUser;
import io.github.hectorvent.floci.services.cognito.model.IdentityProvider;
import io.github.hectorvent.floci.services.cognito.model.UserPool;
import io.github.hectorvent.floci.services.cognito.model.UserPoolClient;
+import io.github.hectorvent.floci.services.cognito.model.UserPoolDomain;
import io.github.hectorvent.floci.services.cognito.verification.CognitoMessageDispatcher;
import io.github.hectorvent.floci.services.cognito.verification.VerificationCode;
import io.github.hectorvent.floci.services.cognito.verification.VerificationCodeService;
@@ -3255,6 +3256,129 @@ class CognitoServiceTest {
assertFalse(user.getEmailMfaSettings().isEnabled());
assertFalse(user.getEmailMfaSettings().isPreferredMfa());
}
+ // ──────────────────────────── User Pool Domains ────────────────────────────
+
+ private static final String CERTIFICATE_ARN =
+ "arn:aws:acm:us-east-1:000000000000:certificate/11111111-2222-3333-4444-555555555555";
+ private static final String RENEWED_CERTIFICATE_ARN =
+ "arn:aws:acm:us-east-1:000000000000:certificate/99999999-2222-3333-4444-555555555555";
+
+ private UserPool createPoolWithCustomDomain(String domain) {
+ UserPool pool = service.createUserPool(Map.of("PoolName", "DomainPool"), "us-east-1");
+ service.createUserPoolDomain(domain, pool.getId(), Map.of("CertificateArn", CERTIFICATE_ARN), 1);
+ return pool;
+ }
+
+ @Test
+ void updateUserPoolDomainReplacesTheCertificateAndKeepsTheCloudFrontDistribution() {
+ UserPool pool = createPoolWithCustomDomain("auth.example.com");
+ String cloudFront = service.describeUserPoolDomain("auth.example.com").getCloudFrontDistribution();
+
+ UserPoolDomain updated = service.updateUserPoolDomain("auth.example.com", pool.getId(),
+ Map.of("CertificateArn", RENEWED_CERTIFICATE_ARN), 2);
+
+ assertEquals(RENEWED_CERTIFICATE_ARN, updated.getCertificateArn());
+ assertEquals(cloudFront, updated.getCloudFrontDistribution());
+ assertEquals(2, updated.getManagedLoginVersion());
+ UserPoolDomain stored = service.describeUserPoolDomain("auth.example.com");
+ assertEquals(RENEWED_CERTIFICATE_ARN, stored.getCertificateArn());
+ assertEquals(2, stored.getManagedLoginVersion());
+ }
+
+ @Test
+ void updateUserPoolDomainLeavesOmittedSettingsUnchanged() {
+ UserPool pool = createPoolWithCustomDomain("auth.example.com");
+
+ service.updateUserPoolDomain("auth.example.com", pool.getId(), null, null);
+
+ UserPoolDomain stored = service.describeUserPoolDomain("auth.example.com");
+ assertEquals(CERTIFICATE_ARN, stored.getCertificateArn());
+ assertEquals(1, stored.getManagedLoginVersion());
+ }
+
+ @Test
+ void updateUserPoolDomainSetsTheManagedLoginVersionOfAPrefixDomain() {
+ UserPool pool = service.createUserPool(Map.of("PoolName", "DomainPool"), "us-east-1");
+ service.createUserPoolDomain("my-prefix", pool.getId(), null, null);
+
+ UserPoolDomain updated = service.updateUserPoolDomain("my-prefix", pool.getId(), null, 2);
+
+ assertEquals(2, updated.getManagedLoginVersion());
+ assertFalse(updated.isCustomDomain());
+ assertNull(updated.getCloudFrontDistribution());
+ }
+
+ @Test
+ void updateUserPoolDomainRejectsACustomDomainConfigOnAPrefixDomain() {
+ UserPool pool = service.createUserPool(Map.of("PoolName", "DomainPool"), "us-east-1");
+ service.createUserPoolDomain("my-prefix", pool.getId(), null, null);
+
+ AwsException failure = assertThrows(AwsException.class, () -> service.updateUserPoolDomain(
+ "my-prefix", pool.getId(), Map.of("CertificateArn", CERTIFICATE_ARN), null));
+
+ assertEquals("InvalidParameterException", failure.getErrorCode());
+ assertFalse(service.describeUserPoolDomain("my-prefix").isCustomDomain());
+ }
+
+ @Test
+ void updateUserPoolDomainRequiresACertificateArnInTheCustomDomainConfig() {
+ UserPool pool = createPoolWithCustomDomain("auth.example.com");
+
+ AwsException failure = assertThrows(AwsException.class, () -> service.updateUserPoolDomain(
+ "auth.example.com", pool.getId(), Map.of(), 2));
+
+ assertEquals("InvalidParameterException", failure.getErrorCode());
+ assertEquals(CERTIFICATE_ARN, service.describeUserPoolDomain("auth.example.com").getCertificateArn());
+ }
+
+ @Test
+ void updateUserPoolDomainOfAnotherPoolsDomainIsNotFound() {
+ createPoolWithCustomDomain("auth.example.com");
+ UserPool otherPool = service.createUserPool(Map.of("PoolName", "OtherPool"), "us-east-1");
+
+ AwsException failure = assertThrows(AwsException.class, () -> service.updateUserPoolDomain(
+ "auth.example.com", otherPool.getId(), Map.of("CertificateArn", RENEWED_CERTIFICATE_ARN), null));
+
+ assertEquals("ResourceNotFoundException", failure.getErrorCode());
+ assertEquals(CERTIFICATE_ARN, service.describeUserPoolDomain("auth.example.com").getCertificateArn());
+ }
+
+ @Test
+ void updateUserPoolDomainOfAnUnknownDomainIsNotFound() {
+ UserPool pool = service.createUserPool(Map.of("PoolName", "DomainPool"), "us-east-1");
+
+ AwsException failure = assertThrows(AwsException.class, () -> service.updateUserPoolDomain(
+ "nobody.example.com", pool.getId(), Map.of("CertificateArn", CERTIFICATE_ARN), null));
+
+ assertEquals("ResourceNotFoundException", failure.getErrorCode());
+ }
+
+ @Test
+ void updateUserPoolDomainReplacesTheSecurityPolicyAndKeepsItWhenOmitted() {
+ UserPool pool = createPoolWithCustomDomain("auth.example.com");
+ assertEquals("TLS_V1_2_2021", service.describeUserPoolDomain("auth.example.com").getSecurityPolicy());
+
+ service.updateUserPoolDomain("auth.example.com", pool.getId(),
+ Map.of("CertificateArn", RENEWED_CERTIFICATE_ARN, "SecurityPolicy", "TLS_V1_2_2019"), null);
+ assertEquals("TLS_V1_2_2019", service.describeUserPoolDomain("auth.example.com").getSecurityPolicy());
+
+ service.updateUserPoolDomain("auth.example.com", pool.getId(), Map.of("CertificateArn", CERTIFICATE_ARN), null);
+
+ UserPoolDomain stored = service.describeUserPoolDomain("auth.example.com");
+ assertEquals("TLS_V1_2_2019", stored.getSecurityPolicy());
+ assertEquals(CERTIFICATE_ARN, stored.getCertificateArn());
+ }
+
+ @Test
+ void updateUserPoolDomainOfAnUnknownPoolIsNotFound() {
+ createPoolWithCustomDomain("auth.example.com");
+
+ AwsException failure = assertThrows(AwsException.class, () -> service.updateUserPoolDomain(
+ "auth.example.com", "us-east-1_missing", Map.of("CertificateArn", CERTIFICATE_ARN), null));
+
+ assertEquals("ResourceNotFoundException", failure.getErrorCode());
+ }
+
private static String jwtPayload(String token) {
String segment = token.split("\\.")[1];
int pad = (4 - segment.length() % 4) % 4;
diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoUserPoolDomainIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoUserPoolDomainIntegrationTest.java
index 696caa8188..f315b76355 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoUserPoolDomainIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoUserPoolDomainIntegrationTest.java
@@ -18,7 +18,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
/**
- * Covers CreateUserPoolDomain/DescribeUserPoolDomain/DeleteUserPoolDomain (lex00/floci#63)
+ * Covers CreateUserPoolDomain/DescribeUserPoolDomain/UpdateUserPoolDomain/DeleteUserPoolDomain (lex00/floci#63)
* for both an Amazon Cognito prefix domain and a custom domain fronted by an ACM certificate.
*/
@QuarkusTest
@@ -30,6 +30,8 @@ class CognitoUserPoolDomainIntegrationTest {
private static String customDomain;
private static final String CERTIFICATE_ARN =
"arn:aws:acm:us-east-1:000000000000:certificate/" + UUID.randomUUID();
+ private static final String RENEWED_CERTIFICATE_ARN =
+ "arn:aws:acm:us-east-1:000000000000:certificate/" + UUID.randomUUID();
@BeforeAll
static void configureRestAssured() {
@@ -142,6 +144,56 @@ class CognitoUserPoolDomainIntegrationTest {
@Test
@Order(8)
+ void updateCustomDomainReplacesTheCertificateAndKeepsTheCloudFrontDistribution() throws Exception {
+ String cloudFront = cognitoJson("DescribeUserPoolDomain", """
+ {
+ "Domain": "%s"
+ }
+ """.formatted(customDomain)).path("DomainDescription").path("CloudFrontDistribution").asText();
+
+ JsonNode response = cognitoJson("UpdateUserPoolDomain", """
+ {
+ "Domain": "%s",
+ "UserPoolId": "%s",
+ "CustomDomainConfig": {
+ "CertificateArn": "%s"
+ },
+ "ManagedLoginVersion": 2
+ }
+ """.formatted(customDomain, poolId, RENEWED_CERTIFICATE_ARN));
+
+ // As on AWS, the distribution survives a certificate change, so a DNS alias stays valid.
+ assertEquals(cloudFront, response.path("CloudFrontDomain").asText());
+ assertEquals(2, response.path("ManagedLoginVersion").asInt());
+
+ JsonNode description = cognitoJson("DescribeUserPoolDomain", """
+ {
+ "Domain": "%s"
+ }
+ """.formatted(customDomain)).path("DomainDescription");
+ assertEquals(RENEWED_CERTIFICATE_ARN, description.path("CustomDomainConfig").path("CertificateArn").asText());
+ assertEquals(cloudFront, description.path("CloudFrontDistribution").asText());
+ assertEquals(2, description.path("ManagedLoginVersion").asInt());
+ }
+
+ @Test
+ @Order(9)
+ void updateDomainOfAnotherPoolIsNotFound() {
+ cognitoAction("UpdateUserPoolDomain", """
+ {
+ "Domain": "%s",
+ "UserPoolId": "us-east-1_missing",
+ "CustomDomainConfig": {
+ "CertificateArn": "%s"
+ }
+ }
+ """.formatted(customDomain, CERTIFICATE_ARN))
+ .then()
+ .body("__type", equalTo("ResourceNotFoundException"));
+ }
+
+ @Test
+ @Order(10)
void createCustomDomainWithoutCertificateArnFails() {
cognitoAction("CreateUserPoolDomain", """
{
@@ -156,7 +208,7 @@ class CognitoUserPoolDomainIntegrationTest {
}
@Test
- @Order(9)
+ @Order(11)
void deleteCustomDomainThenDescribeIsNotFound() {
cognitoAction("DeleteUserPoolDomain", """
{
@@ -178,7 +230,7 @@ class CognitoUserPoolDomainIntegrationTest {
}
@Test
- @Order(10)
+ @Order(12)
void deleteUserPoolWithDomainIsRejected() throws Exception {
// The DeleteUserPool API reference's own example documents this refusal verbatim.
String blockingDomain = "floci-block-" + UUID.randomUUID().toString().substring(0, 8);
@@ -211,7 +263,7 @@ class CognitoUserPoolDomainIntegrationTest {
}
@Test
- @Order(11)
+ @Order(13)
void deleteUserPoolSucceedsOnceDomainIsGone() {
cognitoAction("DeleteUserPool", """
{
diff --git a/src/test/resources/cloudformation/supported-resource-types.tsv b/src/test/resources/cloudformation/supported-resource-types.tsv
index 33d43c1f35..3e5fe3b457 100644
--- a/src/test/resources/cloudformation/supported-resource-types.tsv
+++ b/src/test/resources/cloudformation/supported-resource-types.tsv
@@ -28,6 +28,7 @@ AWS::CodePipeline::Pipeline CodePipelineCfnProvisioner
AWS::CodePipeline::Webhook CodePipelineCfnProvisioner
AWS::Cognito::UserPool LEGACY_SWITCH
AWS::Cognito::UserPoolClient LEGACY_SWITCH
+AWS::Cognito::UserPoolDomain CognitoCfnProvisioner
AWS::Config::ConfigRule ConfigCfnProvisioner
AWS::DynamoDB::GlobalTable LEGACY_SWITCH
AWS::DynamoDB::Table LEGACY_SWITCH