Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudformation): keep Route 53 routing policies and provision health checks (#6191)
lex005beb8d47b99b
diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.mdindex aa1aaa0385..8fa42ca9ef 100644--- a/docs/services/cloudformation.md+++ b/docs/services/cloudformation.md@@ -193,7 +193,7 @@ cross-resource references.| Elastic Load Balancing v2 | `LoadBalancer`, `TargetGroup`, `Listener`, `ListenerRule` || Auto Scaling | `LaunchConfiguration`, `AutoScalingGroup`, `LifecycleHook`, `ScalingPolicy` || Application Auto Scaling | `ScalableTarget` (`ScheduledActions` are accepted and not run; Floci has no scheduled scaling), `ScalingPolicy` |-| Route 53 | `HostedZone`, `RecordSet` |+| Route 53 | `HostedZone`, `RecordSet`, `HealthCheck` || Cloud Map | `HttpNamespace`, `PrivateDnsNamespace`, `PublicDnsNamespace`, `Service` || API Gateway (v1) | `RestApi`, `Resource`, `Authorizer`, `Method`, `Deployment`, `Stage`, `Account`, `DomainName`, `BasePathMapping`, `GatewayResponse`, `ApiKey`, `UsagePlan`, `UsagePlanKey` || API Gateway v2 | `Api`, `Authorizer`, `Route`, `Integration`, `Stage`, `Deployment`, `DomainName`, `ApiMapping`, `VpcLink` |diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.javaindex 88d1e701c8..429502eec6 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.java@@ -101,6 +101,13 @@ public final class CfnRollback {* {@code rollbackUpdate}.*/public static final String DASHBOARD_UPDATE_SNAPSHOT_ATTR = "__FlociDashboardUpdateSnapshot";++ /**+ * Holds the configuration and tags a Route 53 health check carried before an in-place update+ * changed them, so a failed stack update can put them back. Written by+ * {@code Route53CfnProvisioner} before its update call and spent by its {@code rollbackUpdate}.+ */+ public static final String HEALTH_CHECK_UPDATE_SNAPSHOT_ATTR = "__FlociRoute53HealthCheckUpdateSnapshot";public static final String S3_BUCKET_UPDATE_SNAPSHOT_ATTR = "__FlociS3BucketUpdateSnapshot";/**diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Route53CfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Route53CfnProvisioner.javaindex b25d173ae5..6a58b7ae05 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Route53CfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Route53CfnProvisioner.java@@ -1,10 +1,15 @@package io.github.hectorvent.floci.services.cloudformation.provisioners;+import com.fasterxml.jackson.core.JsonProcessingException;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.model.StackResource;import io.github.hectorvent.floci.services.route53.Route53Service;import io.github.hectorvent.floci.services.route53.model.AliasTarget;+import io.github.hectorvent.floci.services.route53.model.HealthCheck;+import io.github.hectorvent.floci.services.route53.model.HealthCheckConfig;import io.github.hectorvent.floci.services.route53.model.HostedZone;import io.github.hectorvent.floci.services.route53.model.ResourceRecord;import io.github.hectorvent.floci.services.route53.model.ResourceRecordSet;@@ -15,13 +20,16 @@ import org.jboss.logging.Logger;import java.util.ArrayList;import java.util.HashMap;+import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Objects;import java.util.Set;+import java.util.UUID;/**- * Provisions {@code AWS::Route53::HostedZone} and {@code AWS::Route53::RecordSet}.+ * Provisions {@code AWS::Route53::HostedZone}, {@code AWS::Route53::RecordSet} and+ * {@code AWS::Route53::HealthCheck}.** <p>A record set is written into its hosted zone through {@code ChangeResourceRecordSets}. On stack* create, and on an update that changes the record's identity (zone, Name, Type or SetIdentifier), the@@ -38,6 +46,16 @@ import java.util.Set;public class Route53CfnProvisioner implements CfnResourceProvisioner {static final String HOSTED_ZONE = "AWS::Route53::HostedZone";static final String RECORD_SET = "AWS::Route53::RecordSet";+ static final String HEALTH_CHECK = "AWS::Route53::HealthCheck";++ /** The registry schema's create-only HealthCheckConfig members. */+ private static final List<String> HEALTH_CHECK_CREATE_ONLY = List.of("Type", "RequestInterval", "MeasureLatency");+ /** The registry schema's HealthCheckConfig.Type enum. */+ private static final List<String> HEALTH_CHECK_TYPES = List.of("CALCULATED", "CLOUDWATCH_METRIC", "HTTP",+ "HTTP_STR_MATCH", "HTTPS", "HTTPS_STR_MATCH", "TCP", "RECOVERY_CONTROL");+ // Describes the check as its public attributes do, so a replacement rollback puts it back.+ private static final String HEALTH_CHECK_CREATE_ONLY_ATTR = CfnRollback.USES_ATTR_PREFIX + "Route53HealthCheckCreateOnly";+ private static final ObjectMapper MAPPER = new ObjectMapper();// Create-time values a record's delete needs to build a matching DELETE change; kept off the// published attributes by the __Floci prefix, as the other provisioners do.@@ -56,7 +74,7 @@ public class Route53CfnProvisioner implements CfnResourceProvisioner {@Overridepublic Set<String> resourceTypes() {- return Set.of(HOSTED_ZONE, RECORD_SET);+ return Set.of(HOSTED_ZONE, RECORD_SET, HEALTH_CHECK);}@Override@@ -64,6 +82,7 @@ public class Route53CfnProvisioner implements CfnResourceProvisioner {switch (resource.getResourceType()) {case "AWS::Route53::HostedZone" -> provisionHostedZone(resource, props, ctx);case "AWS::Route53::RecordSet" -> provisionRecordSet(resource, props, ctx);+ case "AWS::Route53::HealthCheck" -> provisionHealthCheck(resource, props, ctx);default -> throw new IllegalStateException("Route53CfnProvisioner received an unsupported type: " + resource.getResourceType());}@@ -103,6 +122,18 @@ public class Route53CfnProvisioner implements CfnResourceProvisioner {rrs.setSetIdentifier(setIdentifier);rrs.setRecords(parseResourceRecords(props, ctx));rrs.setAliasTarget(parseAliasTarget(props, ctx));+ rrs.setRegion(ctx.resolveOrDefault(props, "Region", null));+ rrs.setFailover(ctx.resolveOrDefault(props, "Failover", null));+ rrs.setHealthCheckId(ctx.resolveOrDefault(props, "HealthCheckId", null));+ String weight = ctx.resolveOrDefault(props, "Weight", null);+ if (weight != null) {+ try {+ rrs.setWeight(Long.parseLong(weight.trim()));+ } catch (NumberFormatException e) {+ throw new AwsException("ValidationError",+ "AWS::Route53::RecordSet Weight must be an integer: " + weight, 400);+ }+ }// The record's identity is Name + Type + SetIdentifier within a zone. Re-applying the identity// this resource wrote last time is an UPSERT, which replaces whatever record holds that@@ -230,6 +261,208 @@ public class Route53CfnProvisioner implements CfnResourceProvisioner {return target;}+ /**+ * Creates the health check, or updates it in place on a stack update. {@code Type},+ * {@code RequestInterval} and {@code MeasureLatency} are create-only, so an update that changes+ * one creates a new check; the displaced check is deleted once the update commits, or kept+ * under {@code UpdateReplacePolicy: Retain}, through {@link ReplacementCleanup}. An in-place+ * update first snapshots the check's configuration and tags, so a failed stack update can put+ * them back. {@code Ref} and {@code Fn::GetAtt HealthCheckId} are the health check id.+ */+ private void provisionHealthCheck(StackResource resource, JsonNode props, ProvisionContext ctx) {+ // A snapshot describes the update in flight; one an earlier update left behind is stale.+ resource.getAttributes().remove(CfnRollback.HEALTH_CHECK_UPDATE_SNAPSHOT_ATTR);+ if (ctx.isUpdate()) {+ ReplacementCleanup.endRollbackRetry(resource);+ }+ Map<String, String> attributesBefore = Map.copyOf(resource.getAttributes());++ JsonNode resolved = ctx.engine().resolveNode(props);+ JsonNode configNode = resolved != null ? resolved.path("HealthCheckConfig") : null;+ if (configNode == null || !configNode.isObject()) {+ throw new AwsException("ValidationError",+ "AWS::Route53::HealthCheck requires HealthCheckConfig.", 400);+ }+ HealthCheckConfig config = parseHealthCheckConfig(configNode);+ String createOnly = createOnlyValues(configNode);+ Map<String, String> tags = new LinkedHashMap<>();+ parseTags(resolved.path("HealthCheckTags")).forEach(tag -> tags.put(tag.get("Key"), tag.get("Value")));++ String priorId = ctx.isUpdate() ? ctx.priorPhysicalId() : null;+ HealthCheck prior = priorId != null ? findHealthCheck(priorId) : null;+ String id;+ if (prior != null && createOnly.equals(priorCreateOnlyValues(resource, prior))) {+ id = priorId;+ snapshotBeforeUpdate(resource, prior);+ try {+ route53Service.updateHealthCheck(id, config);+ reconcileHealthCheckTags(id, tags);+ } catch (RuntimeException failure) {+ unwindHealthCheckUpdate(resource, id, failure);+ throw failure;+ }+ } else {+ String callerReference = ctx.stackName() + "/" + resource.getLogicalId() + "/" + UUID.randomUUID();+ id = route53Service.createHealthCheck(callerReference, config, configNode.toString()).getId();+ try {+ reconcileHealthCheckTags(id, tags);+ } catch (RuntimeException failure) {+ // The check this provision created is not yet the resource's, so nothing else removes it.+ try {+ route53Service.deleteHealthCheck(id);+ } catch (RuntimeException cleanupFailure) {+ failure.addSuppressed(cleanupFailure);+ }+ throw failure;+ }+ }++ resource.setPhysicalId(id);+ resource.getAttributes().put("HealthCheckId", id);+ resource.getAttributes().put(HEALTH_CHECK_CREATE_ONLY_ATTR, createOnly);+ ReplacementCleanup.record(resource, ctx, attributesBefore);+ }++ private HealthCheck findHealthCheck(String id) {+ try {+ return route53Service.getHealthCheck(id);+ } catch (AwsException e) {+ if (!"NoSuchHealthCheck".equals(e.getErrorCode())) {+ throw e;+ }+ return null;+ }+ }++ private void reconcileHealthCheckTags(String id, Map<String, String> desired) {+ List<String> stale = ProvisionContext.staleTagKeys(+ route53Service.listTagsForResource("healthcheck", id), desired);+ List<Map<String, String>> add = new ArrayList<>();+ desired.forEach((key, value) -> add.add(Map.of("Key", key, "Value", value)));+ if (!add.isEmpty() || !stale.isEmpty()) {+ route53Service.changeTagsForResource("healthcheck", id, add, stale);+ }+ }++ /** The template's create-only members, as text, so a change to any of them is a replacement. */+ private static String createOnlyValues(JsonNode configNode) {+ ObjectNode values = MAPPER.createObjectNode();+ for (String member : HEALTH_CHECK_CREATE_ONLY) {+ JsonNode value = configNode.get(member);+ if (value == null || value.isNull() || value.isMissingNode()) {+ values.putNull(member);+ } else {+ values.put(member, value.asText());+ }+ }+ return values.toString();+ }++ /**+ * The create-only members the check was provisioned with. A check provisioned before they were+ * recorded falls back to what the check itself holds, which has no {@code MeasureLatency}.+ */+ private static String priorCreateOnlyValues(StackResource resource, HealthCheck prior) {+ String recorded = resource.getAttributes().get(HEALTH_CHECK_CREATE_ONLY_ATTR);+ if (recorded != null) {+ return recorded;+ }+ ObjectNode values = MAPPER.createObjectNode();+ values.put("Type", prior.getConfig().getType());+ Integer interval = prior.getConfig().getRequestInterval();+ if (interval == null) {+ values.putNull("RequestInterval");+ } else {+ values.put("RequestInterval", String.valueOf(interval));+ }+ values.putNull("MeasureLatency");+ return values.toString();+ }++ /** Keeps the check's configuration and tags before an in-place update changes them. */+ private void snapshotBeforeUpdate(StackResource resource, HealthCheck prior) {+ HealthCheckConfig config = prior.getConfig();+ ObjectNode snapshot = MAPPER.createObjectNode();+ snapshot.put("id", prior.getId());+ ObjectNode saved = snapshot.putObject("config");+ saved.put("Type", config.getType());+ saved.put("IPAddress", config.getIpAddress());+ saved.put("Port", config.getPort());+ saved.put("ResourcePath", config.getResourcePath());+ saved.put("FullyQualifiedDomainName", config.getFullyQualifiedDomainName());+ saved.put("RequestInterval", config.getRequestInterval());+ saved.put("FailureThreshold", config.getFailureThreshold());+ ObjectNode savedTags = snapshot.putObject("tags");+ route53Service.listTagsForResource("healthcheck", prior.getId()).forEach(savedTags::put);+ resource.getAttributes().put(CfnRollback.HEALTH_CHECK_UPDATE_SNAPSHOT_ATTR, snapshot.toString());+ }++ /**+ * An in-place update that changed the check and then failed undoes itself, as+ * {@code CloudWatchDashboardCfnProvisioner} does: the engine puts back the resource the stack+ * held before the attempt, which never carried this snapshot, so the rollback walker would+ * otherwise skip the restore.+ */+ private void unwindHealthCheckUpdate(StackResource resource, String id, RuntimeException failure) {+ try {+ rollbackUpdate(resource);+ resource.getAttributes().put(CfnRollback.UPDATE_ROLLBACK_RESTORED_ATTR, "true");+ } catch (RuntimeException unwindFailure) {+ resource.getAttributes().put(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR,+ "Could not roll back the update of health check " + id + ": " + unwindFailure.getMessage());+ if (unwindFailure != failure) {+ failure.addSuppressed(unwindFailure);+ }+ }+ }++ private static HealthCheckConfig parseHealthCheckConfig(JsonNode node) {+ String type = node.path("Type").asText(null);+ if (type == null || type.isBlank()) {+ throw new AwsException("ValidationError",+ "AWS::Route53::HealthCheck HealthCheckConfig requires Type.", 400);+ }+ if (!HEALTH_CHECK_TYPES.contains(type)) {+ throw new AwsException("ValidationError",+ "AWS::Route53::HealthCheck HealthCheckConfig Type must be one of "+ + String.join(", ", HEALTH_CHECK_TYPES) + ": " + type, 400);+ }+ HealthCheckConfig config = new HealthCheckConfig();+ config.setType(type);+ config.setIpAddress(node.path("IPAddress").asText(null));+ config.setPort(integerMember(node, "Port"));+ config.setResourcePath(node.path("ResourcePath").asText(null));+ config.setFullyQualifiedDomainName(node.path("FullyQualifiedDomainName").asText(null));+ config.setRequestInterval(integerMember(node, "RequestInterval"));+ config.setFailureThreshold(integerMember(node, "FailureThreshold"));+ return config;+ }++ private static HealthCheckConfig configFromSnapshot(JsonNode node) {+ HealthCheckConfig config = new HealthCheckConfig();+ config.setType(node.path("Type").asText(null));+ config.setIpAddress(node.path("IPAddress").asText(null));+ config.setPort(node.hasNonNull("Port") ? node.get("Port").asInt() : null);+ config.setResourcePath(node.path("ResourcePath").asText(null));+ config.setFullyQualifiedDomainName(node.path("FullyQualifiedDomainName").asText(null));+ config.setRequestInterval(node.hasNonNull("RequestInterval") ? node.get("RequestInterval").asInt() : null);+ config.setFailureThreshold(node.hasNonNull("FailureThreshold") ? node.get("FailureThreshold").asInt() : null);+ return config;+ }++ private static Integer integerMember(JsonNode node, String name) {+ JsonNode value = node.get(name);+ if (value == null || value.isNull()) {+ return null;+ }+ try {+ return Integer.parseInt(value.asText().trim());+ } catch (NumberFormatException e) {+ throw new AwsException("ValidationError",+ "AWS::Route53::HealthCheck " + name + " must be an integer: " + value.asText(), 400);+ }+ }+private void provisionHostedZone(StackResource resource, JsonNode props, ProvisionContext ctx) {String name = ctx.resolveOptional(props, "Name");if (name == null || name.isBlank()) {@@ -326,6 +559,65 @@ public class Route53CfnProvisioner implements CfnResourceProvisioner {}}+ @Override+ public boolean hasReplacementUpdate(StackResource resource) {+ return HEALTH_CHECK.equals(resource.getResourceType()) && ReplacementCleanup.hasReplacement(resource);+ }++ @Override+ public String updateCleanupPhysicalId(StackResource resource) {+ return HEALTH_CHECK.equals(resource.getResourceType())+ ? ReplacementCleanup.cleanupPhysicalId(resource) : null;+ }++ @Override+ public UpdateCleanupResult completeUpdate(StackResource resource) {+ return HEALTH_CHECK.equals(resource.getResourceType())+ ? ReplacementCleanup.complete(resource, this::delete) : UpdateCleanupResult.notApplicable();+ }++ @Override+ public void clearUpdate(StackResource resource) {+ if (HEALTH_CHECK.equals(resource.getResourceType())) {+ resource.getAttributes().remove(CfnRollback.HEALTH_CHECK_UPDATE_SNAPSHOT_ATTR);+ ReplacementCleanup.clear(resource);+ }+ }++ /**+ * A health check replacement is undone through the cleanup record, and an in-place update from+ * the snapshot taken before it. With neither on the resource the provision failed before it+ * changed anything. Hosted zones and record sets keep the engine's default.+ */+ @Override+ public boolean rollbackUpdate(StackResource resource) {+ if (!HEALTH_CHECK.equals(resource.getResourceType())) {+ return false;+ }+ if (ReplacementCleanup.rollback(resource, this::delete)) {+ return true;+ }+ // Spent only once the restore succeeded, so a restore that throws can be retried.+ String raw = resource.getAttributes().get(CfnRollback.HEALTH_CHECK_UPDATE_SNAPSHOT_ATTR);+ if (raw == null) {+ return true;+ }+ JsonNode snapshot;+ try {+ snapshot = MAPPER.readTree(raw);+ } catch (JsonProcessingException e) {+ throw new IllegalStateException("Could not read the health check update snapshot for "+ + resource.getLogicalId(), e);+ }+ String id = snapshot.path("id").asText();+ route53Service.updateHealthCheck(id, configFromSnapshot(snapshot.path("config")));+ Map<String, String> tags = new LinkedHashMap<>();+ snapshot.path("tags").fields().forEachRemaining(tag -> tags.put(tag.getKey(), tag.getValue().asText()));+ reconcileHealthCheckTags(id, tags);+ resource.getAttributes().remove(CfnRollback.HEALTH_CHECK_UPDATE_SNAPSHOT_ATTR);+ return true;+ }+/*** A record set's delete needs the zone id and type recorded at create time to build a matching* DELETE change; the physical id alone only carries the name. The zone-backed types fall through@@ -344,6 +636,8 @@ public class Route53CfnProvisioner implements CfnResourceProvisioner {public void delete(String resourceType, String physicalId, String region) {switch (resourceType) {case "AWS::Route53::HostedZone" -> route53Service.deleteHostedZone(physicalId);+ case "AWS::Route53::HealthCheck" -> CfnDeletes.safeDelete("Route53 health check", physicalId,+ () -> route53Service.deleteHealthCheck(physicalId), "NoSuchHealthCheck");// The record's zone and type live on the StackResource, not the physical id, so the// id-only path has nothing to match a DELETE change against; delete(resource, region)// is the real removal.diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationRoute53RecordSetIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationRoute53RecordSetIntegrationTest.javaindex fe37337c92..32399f88d4 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationRoute53RecordSetIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationRoute53RecordSetIntegrationTest.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.cloudformation;import io.github.hectorvent.floci.testing.CfnStackWaits;import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;@@ -12,6 +13,7 @@ import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.containsString;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;/**@@ -262,6 +264,241 @@ class CloudFormationRoute53RecordSetIntegrationTest {.when().post("/").then().statusCode(200);}+ @Test+ void latencyRecordsKeepTheirRoutingPolicyAndHealthCheck() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "r53-routing-" + suffix;+ String zoneName = suffix + ".cfn-routing-it.example.test";+ String template = """+ {+ "Resources": {+ "Zone": {+ "Type": "AWS::Route53::HostedZone",+ "Properties": {"Name": "%1$s"}+ },+ "Check": {+ "Type": "AWS::Route53::HealthCheck",+ "Properties": {+ "HealthCheckConfig": {"Type": "HTTPS", "FullyQualifiedDomainName": "app.example.net",+ "ResourcePath": "/", "RequestInterval": 10, "FailureThreshold": 2},+ "HealthCheckTags": [{"Key": "cloud", "Value": "aws"}]+ }+ },+ "Latency": {+ "Type": "AWS::Route53::RecordSet",+ "Properties": {+ "HostedZoneId": {"Ref": "Zone"},+ "Name": "www.%1$s.",+ "Type": "CNAME",+ "TTL": "60",+ "SetIdentifier": "aws",+ "Region": "us-east-1",+ "HealthCheckId": {"Ref": "Check"},+ "ResourceRecords": ["app.example.net"]+ }+ },+ "Weighted": {+ "Type": "AWS::Route53::RecordSet",+ "Properties": {+ "HostedZoneId": {"Ref": "Zone"},+ "Name": "api.%1$s.",+ "Type": "A",+ "TTL": "60",+ "SetIdentifier": "blue",+ "Weight": 70,+ "ResourceRecords": ["10.0.0.7"]+ }+ },+ "Primary": {+ "Type": "AWS::Route53::RecordSet",+ "Properties": {+ "HostedZoneId": {"Ref": "Zone"},+ "Name": "db.%1$s.",+ "Type": "A",+ "TTL": "60",+ "SetIdentifier": "primary",+ "Failover": "PRIMARY",+ "HealthCheckId": {"Fn::GetAtt": ["Check", "HealthCheckId"]},+ "ResourceRecords": ["10.0.0.8"]+ }+ },+ "CheckRef": {+ "Type": "AWS::SSM::Parameter",+ "Properties": {"Name": "/r53-routing/%2$s/ref", "Type": "String", "Value": {"Ref": "Check"}}+ },+ "CheckAttr": {+ "Type": "AWS::SSM::Parameter",+ "Properties": {"Name": "/r53-routing/%2$s/attr", "Type": "String",+ "Value": {"Fn::GetAtt": ["Check", "HealthCheckId"]}}+ },+ "ZoneParam": {+ "Type": "AWS::SSM::Parameter",+ "Properties": {"Name": "/r53-routing/%2$s/zone", "Type": "String", "Value": {"Ref": "Zone"}}+ }+ }+ }+ """.formatted(zoneName, suffix);++ createStack(stackName, template);+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ String checkId = parameterValue("/r53-routing/" + suffix + "/ref");+ try {+ assertEquals(checkId, parameterValue("/r53-routing/" + suffix + "/attr"));+ assertFalse(checkId.startsWith("arn:aws:stub"), "health check was stubbed: " + checkId);++ String check = given()+ .header("Authorization", ROUTE53_AUTH)+ .when().get("/2013-04-01/healthcheck/" + checkId)+ .then().statusCode(200)+ .extract().asString();+ assertTrue(check.contains("<Type>HTTPS</Type>"), check);+ assertTrue(check.contains("<FullyQualifiedDomainName>app.example.net</FullyQualifiedDomainName>"), check);+ assertTrue(check.contains("<RequestInterval>10</RequestInterval>"), check);+ assertTrue(check.contains("<FailureThreshold>2</FailureThreshold>"), check);+ String tags = given()+ .header("Authorization", ROUTE53_AUTH)+ .when().get("/2013-04-01/tags/healthcheck/" + checkId)+ .then().statusCode(200)+ .extract().asString();+ assertTrue(tags.contains("<Key>cloud</Key>") && tags.contains("<Value>aws</Value>"), tags);++ String records = listResourceRecordSets(parameterValue("/r53-routing/" + suffix + "/zone"));+ assertTrue(records.contains("<SetIdentifier>aws</SetIdentifier><Region>us-east-1</Region>"), records);+ assertTrue(records.contains("<SetIdentifier>blue</SetIdentifier><Weight>70</Weight>"), records);+ assertTrue(records.contains("<SetIdentifier>primary</SetIdentifier><Failover>PRIMARY</Failover>"), records);+ assertEquals(2, records.split("<HealthCheckId>" + checkId + "</HealthCheckId>", -1).length - 1, records);+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ }+ given()+ .header("Authorization", ROUTE53_AUTH)+ .when().get("/2013-04-01/healthcheck/" + checkId)+ .then().statusCode(404);+ }++ @Test+ void requestIntervalChangeReplacesTheCheckAndDeletesTheOldOneOnceTheUpdateCommits() {+ String stackName = "r53-hc-replace-" + Long.toString(System.nanoTime(), 36);+ createStack(stackName, healthCheckTemplate(30, false, false));+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ String oldId = physicalId(stackName, "Check");+ try {+ updateStack(stackName, healthCheckTemplate(10, false, false));+ assertEquals("UPDATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());++ String newId = physicalId(stackName, "Check");+ assertNotEquals(oldId, newId);+ assertTrue(healthCheck(newId).contains("<RequestInterval>10</RequestInterval>"));+ healthCheckRequest(oldId).then().statusCode(404);+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ }+ }++ @Test+ void retainedCheckOutlivesItsReplacement() {+ String stackName = "r53-hc-retain-" + Long.toString(System.nanoTime(), 36);+ createStack(stackName, healthCheckTemplate(30, true, false));+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ String oldId = physicalId(stackName, "Check");+ try {+ updateStack(stackName, healthCheckTemplate(10, true, false));+ assertEquals("UPDATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());++ assertNotEquals(oldId, physicalId(stackName, "Check"));+ assertTrue(healthCheck(oldId).contains("<RequestInterval>30</RequestInterval>"));+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ given().header("Authorization", ROUTE53_AUTH)+ .when().delete("/2013-04-01/healthcheck/" + oldId);+ }+ }++ @Test+ void failedUpdateRollsBackToTheOldCheck() {+ String stackName = "r53-hc-rollback-" + Long.toString(System.nanoTime(), 36);+ createStack(stackName, healthCheckTemplate(30, false, false));+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ String oldId = physicalId(stackName, "Check");+ try {+ updateStack(stackName, healthCheckTemplate(10, false, true));+ assertEquals("UPDATE_ROLLBACK_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());++ assertEquals(oldId, physicalId(stackName, "Check"));+ assertTrue(healthCheck(oldId).contains("<RequestInterval>30</RequestInterval>"));+ String checks = given().header("Authorization", ROUTE53_AUTH)+ .when().get("/2013-04-01/healthcheck")+ .then().statusCode(200)+ .extract().asString();+ assertEquals(1, checks.split("<CallerReference>" + stackName + "/Check/", -1).length - 1, checks);+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ }+ }++ /**+ * One TCP health check; {@code failing} adds a record set in a zone that does not exist, created+ * after the check, so the update fails once the check has been replaced.+ */+ private static String healthCheckTemplate(int requestInterval, boolean retain, boolean failing) {+ String policy = retain ? ", \"UpdateReplacePolicy\": \"Retain\"" : "";+ String broken = !failing ? "" : """+ ,+ "Broken": {+ "Type": "AWS::Route53::RecordSet",+ "DependsOn": "Check",+ "Properties": {"HostedZoneId": "ZNOSUCHZONE00", "Name": "x.example.test.", "Type": "A",+ "TTL": "60", "ResourceRecords": ["10.0.0.1"]}+ }""";+ return """+ {+ "Resources": {+ "Check": {+ "Type": "AWS::Route53::HealthCheck"%s,+ "Properties": {+ "HealthCheckConfig": {"Type": "TCP", "IPAddress": "10.0.0.5", "Port": 22,+ "RequestInterval": %d}+ }+ }%s+ }+ }+ """.formatted(policy, requestInterval, broken);+ }++ private void updateStack(String stackName, String template) {+ given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "UpdateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", template)+ .when().post("/").then().statusCode(200);+ }++ private String physicalId(String stackName, String logicalId) {+ return given()+ .contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH)+ .formParam("Action", "DescribeStackResource")+ .formParam("StackName", stackName)+ .formParam("LogicalResourceId", logicalId)+ .when().post("/").then().statusCode(200)+ .extract().xmlPath().getString("**.find { it.name() == 'PhysicalResourceId' }");+ }++ private Response healthCheckRequest(String id) {+ return given().header("Authorization", ROUTE53_AUTH)+ .when().get("/2013-04-01/healthcheck/" + id);+ }++ private String healthCheck(String id) {+ return healthCheckRequest(id).then().statusCode(200).extract().asString();+ }+private String listResourceRecordSets(String zoneId) {return given().header("Authorization", ROUTE53_AUTH)diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Route53CfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Route53CfnProvisionerTest.javaindex 194a8b9d5b..08b2fa59e5 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Route53CfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/Route53CfnProvisionerTest.java@@ -6,6 +6,8 @@ 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.route53.Route53Service;+import io.github.hectorvent.floci.services.route53.model.HealthCheck;+import io.github.hectorvent.floci.services.route53.model.HealthCheckConfig;import io.github.hectorvent.floci.services.route53.model.HostedZone;import io.github.hectorvent.floci.services.route53.model.ResourceRecord;import io.github.hectorvent.floci.services.route53.model.ResourceRecordSet;@@ -14,11 +16,13 @@ import org.junit.jupiter.api.Test;import org.mockito.ArgumentCaptor;import java.util.ArrayList;+import java.util.HashSet;import java.util.List;import java.util.Map;import java.util.Set;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.assertSame;@@ -700,6 +704,335 @@ class Route53CfnProvisionerTest {verifyNoInteractions(service);}+ @Test+ void recordSetCarriesItsRoutingPolicy() {+ Route53Service service = mock(Route53Service.class);+ JsonNode props = new ObjectMapper().createObjectNode()+ .put("HostedZoneId", "Z1")+ .put("Name", "www.example.test.")+ .put("Type", "CNAME")+ .put("TTL", "60")+ .put("SetIdentifier", "aws")+ .put("Region", "us-east-1")+ .put("Failover", "PRIMARY")+ .put("Weight", "10")+ .put("HealthCheckId", "hc-1");+ StackResource resource = new StackResource();+ resource.setLogicalId("Record");+ resource.setResourceType("AWS::Route53::RecordSet");++ new Route53CfnProvisioner(service).provision(resource, props,+ new ProvisionContext(recordEngine(), "us-east-1", "000000000000", "dns-stack"));++ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<Map<String, Object>>> captor = ArgumentCaptor.forClass(List.class);+ verify(service).changeResourceRecordSets(eq("Z1"), captor.capture(), any());+ ResourceRecordSet rrs = (ResourceRecordSet) captor.getValue().get(0).get("rrs");+ assertEquals("us-east-1", rrs.getRegion());+ assertEquals("PRIMARY", rrs.getFailover());+ assertEquals(Long.valueOf(10), rrs.getWeight());+ assertEquals("hc-1", rrs.getHealthCheckId());+ }++ @Test+ void recordSetWithANonNumericWeightIsRejected() {+ assertRecordSetRejected("{\"HostedZoneId\":\"Z1\",\"Name\":\"a.example.com\",\"Type\":\"A\","+ + "\"SetIdentifier\":\"a\",\"Weight\":\"heavy\"}");+ }++ @Test+ void healthCheckIsCreatedWithItsConfigTagsAndExactAttributes() throws Exception {+ Route53Service service = mock(Route53Service.class);+ when(service.createHealthCheck(any(), any(), any()))+ .thenAnswer(inv -> new HealthCheck("hc-1", inv.getArgument(0), inv.getArgument(1), inv.getArgument(2)));+ JsonNode props = new ObjectMapper().readTree("""+ {"HealthCheckConfig": {"Type": "HTTPS", "FullyQualifiedDomainName": "app.example.net",+ "ResourcePath": "/", "Port": 443, "RequestInterval": 10, "FailureThreshold": 2},+ "HealthCheckTags": [{"Key": "team", "Value": "web"}]}""");+ StackResource resource = new StackResource();+ resource.setLogicalId("Check");+ resource.setResourceType("AWS::Route53::HealthCheck");++ new Route53CfnProvisioner(service).provision(resource, props, healthCheckContext(null));++ assertEquals("hc-1", resource.getPhysicalId());+ assertEquals(Set.of("HealthCheckId"), publicAttributes(resource));+ assertEquals("hc-1", resource.getAttributes().get("HealthCheckId"));+ ArgumentCaptor<HealthCheckConfig> config = ArgumentCaptor.forClass(HealthCheckConfig.class);+ verify(service).createHealthCheck(argThat(ref -> ref.startsWith("dns-stack/Check/")), config.capture(), any());+ assertEquals("HTTPS", config.getValue().getType());+ assertEquals("app.example.net", config.getValue().getFullyQualifiedDomainName());+ assertEquals("/", config.getValue().getResourcePath());+ assertEquals(Integer.valueOf(443), config.getValue().getPort());+ assertEquals(Integer.valueOf(10), config.getValue().getRequestInterval());+ assertEquals(Integer.valueOf(2), config.getValue().getFailureThreshold());+ verify(service).changeTagsForResource("healthcheck", "hc-1",+ List.of(Map.of("Key", "team", "Value", "web")), List.of());+ }++ @Test+ void healthCheckUpdateKeepsTheCheckAndDropsRemovedTags() throws Exception {+ Route53Service service = mock(Route53Service.class);+ HealthCheckConfig priorConfig = new HealthCheckConfig();+ priorConfig.setType("HTTP");+ HealthCheck prior = new HealthCheck("hc-1", "ref", priorConfig, "");+ when(service.getHealthCheck("hc-1")).thenReturn(prior);+ when(service.updateHealthCheck(eq("hc-1"), any())).thenReturn(prior);+ when(service.listTagsForResource("healthcheck", "hc-1")).thenReturn(Map.of("old", "x"));+ JsonNode props = new ObjectMapper().readTree("""+ {"HealthCheckConfig": {"Type": "HTTP", "IPAddress": "10.0.0.5", "Port": 8080}}""");+ StackResource resource = new StackResource();+ resource.setLogicalId("Check");+ resource.setResourceType("AWS::Route53::HealthCheck");+ resource.setPhysicalId("hc-1");++ new Route53CfnProvisioner(service).provision(resource, props, healthCheckContext("hc-1"));++ assertEquals("hc-1", resource.getPhysicalId());+ verify(service, never()).createHealthCheck(any(), any(), any());+ verify(service).updateHealthCheck(eq("hc-1"), argThat(cfg -> "10.0.0.5".equals(cfg.getIpAddress())+ && Integer.valueOf(8080).equals(cfg.getPort())));+ verify(service).changeTagsForResource("healthcheck", "hc-1", List.of(), List.of("old"));+ }++ @Test+ void healthCheckTypeChangeReplacesTheCheckAndDeletesTheOldOneOnlyOnceTheUpdateCommits() throws Exception {+ Route53Service service = replacingService();+ StackResource resource = existingCheck();++ new Route53CfnProvisioner(service).provision(resource, healthCheckProps("TCP", null), healthCheckContext("hc-1"));++ assertEquals("hc-2", resource.getPhysicalId());+ assertEquals("hc-2", resource.getAttributes().get("HealthCheckId"));+ verify(service, never()).updateHealthCheck(any(), any());+ verify(service, never()).deleteHealthCheck(any());++ Route53CfnProvisioner provisioner = new Route53CfnProvisioner(service);+ assertTrue(provisioner.hasReplacementUpdate(resource));+ assertEquals("hc-1", provisioner.updateCleanupPhysicalId(resource));+ assertTrue(provisioner.completeUpdate(resource).complete());+ verify(service).deleteHealthCheck("hc-1");+ }++ @Test+ void healthCheckRequestIntervalChangeReplacesTheCheck() throws Exception {+ Route53Service service = replacingService();+ StackResource resource = existingCheck();++ new Route53CfnProvisioner(service).provision(resource, healthCheckProps("HTTP", 10), healthCheckContext("hc-1"));++ assertEquals("hc-2", resource.getPhysicalId());+ verify(service, never()).updateHealthCheck(any(), any());+ }++ @Test+ void healthCheckMeasureLatencyChangeReplacesTheCheck() throws Exception {+ Route53Service service = replacingService();+ StackResource resource = existingCheck();+ new Route53CfnProvisioner(service).provision(resource, healthCheckProps("HTTP", null), healthCheckContext("hc-1"));+ assertEquals("hc-1", resource.getPhysicalId());++ JsonNode props = new ObjectMapper().readTree("""+ {"HealthCheckConfig": {"Type": "HTTP", "IPAddress": "10.0.0.5", "Port": 80, "MeasureLatency": true}}""");+ new Route53CfnProvisioner(service).provision(resource, props, healthCheckContext("hc-1"));++ assertEquals("hc-2", resource.getPhysicalId());+ }++ @Test+ void retainedHealthCheckIsKeptWhenAReplacementCommits() throws Exception {+ Route53Service service = replacingService();+ StackResource resource = existingCheck();+ resource.setUpdateReplacePolicy("Retain");+ Route53CfnProvisioner provisioner = new Route53CfnProvisioner(service);++ provisioner.provision(resource, healthCheckProps("TCP", null), healthCheckContext("hc-1"));++ assertNull(provisioner.updateCleanupPhysicalId(resource));+ provisioner.completeUpdate(resource);+ verify(service, never()).deleteHealthCheck("hc-1");+ }++ @Test+ void rollingBackAReplacementDeletesTheNewCheckAndPointsBackAtTheOldOne() throws Exception {+ Route53Service service = replacingService();+ StackResource resource = existingCheck();+ Route53CfnProvisioner provisioner = new Route53CfnProvisioner(service);+ provisioner.provision(resource, healthCheckProps("TCP", null), healthCheckContext("hc-1"));++ assertTrue(provisioner.rollbackUpdate(resource));++ assertEquals("hc-1", resource.getPhysicalId());+ assertEquals("hc-1", resource.getAttributes().get("HealthCheckId"));+ verify(service).deleteHealthCheck("hc-2");+ verify(service, never()).deleteHealthCheck("hc-1");+ }++ @Test+ void rollingBackAnInPlaceUpdatePutsBackTheConfigAndTags() throws Exception {+ Route53Service service = mock(Route53Service.class);+ HealthCheckConfig priorConfig = new HealthCheckConfig();+ priorConfig.setType("HTTP");+ priorConfig.setIpAddress("10.0.0.5");+ priorConfig.setPort(80);+ HealthCheck prior = new HealthCheck("hc-1", "ref", priorConfig, "");+ when(service.getHealthCheck("hc-1")).thenReturn(prior);+ when(service.updateHealthCheck(eq("hc-1"), any())).thenReturn(prior);+ when(service.listTagsForResource("healthcheck", "hc-1")).thenReturn(Map.of("team", "web"));+ StackResource resource = existingCheck();+ Route53CfnProvisioner provisioner = new Route53CfnProvisioner(service);+ JsonNode props = new ObjectMapper().readTree("""+ {"HealthCheckConfig": {"Type": "HTTP", "IPAddress": "10.0.0.9", "Port": 8080}}""");+ provisioner.provision(resource, props, healthCheckContext("hc-1"));+ when(service.listTagsForResource("healthcheck", "hc-1")).thenReturn(Map.of());++ assertTrue(provisioner.rollbackUpdate(resource));++ verify(service).updateHealthCheck(eq("hc-1"), argThat(cfg -> "10.0.0.5".equals(cfg.getIpAddress())+ && Integer.valueOf(80).equals(cfg.getPort())));+ verify(service).changeTagsForResource("healthcheck", "hc-1",+ List.of(Map.of("Key", "team", "Value", "web")), List.of());+ assertFalse(resource.getAttributes().containsKey(CfnRollback.HEALTH_CHECK_UPDATE_SNAPSHOT_ATTR));+ }++ @Test+ void anInPlaceUpdateThatFailsPartWayPutsTheCheckBack() throws Exception {+ Route53Service service = mock(Route53Service.class);+ HealthCheckConfig priorConfig = new HealthCheckConfig();+ priorConfig.setType("HTTP");+ priorConfig.setIpAddress("10.0.0.5");+ HealthCheck prior = new HealthCheck("hc-1", "ref", priorConfig, "");+ when(service.getHealthCheck("hc-1")).thenReturn(prior);+ when(service.updateHealthCheck(eq("hc-1"), any())).thenReturn(prior);+ when(service.listTagsForResource("healthcheck", "hc-1")).thenReturn(Map.of());+ org.mockito.Mockito.doThrow(new AwsException("Throttling", "slow down", 400)).doNothing()+ .when(service).changeTagsForResource(eq("healthcheck"), eq("hc-1"), any(), any());+ StackResource resource = existingCheck();+ JsonNode props = new ObjectMapper().readTree("""+ {"HealthCheckConfig": {"Type": "HTTP", "IPAddress": "10.0.0.9"},+ "HealthCheckTags": [{"Key": "team", "Value": "web"}]}""");++ assertThrows(AwsException.class, () -> new Route53CfnProvisioner(service)+ .provision(resource, props, healthCheckContext("hc-1")));++ verify(service).updateHealthCheck(eq("hc-1"), argThat(cfg -> "10.0.0.5".equals(cfg.getIpAddress())));+ assertEquals("true", resource.getAttributes().get(CfnRollback.UPDATE_ROLLBACK_RESTORED_ATTR));+ }++ @Test+ void aNewHealthCheckWhoseTaggingFailsIsDeleted() throws Exception {+ Route53Service service = mock(Route53Service.class);+ when(service.createHealthCheck(any(), any(), any()))+ .thenAnswer(inv -> new HealthCheck("hc-1", inv.getArgument(0), inv.getArgument(1), inv.getArgument(2)));+ org.mockito.Mockito.doThrow(new AwsException("Throttling", "slow down", 400))+ .when(service).changeTagsForResource(any(), any(), any(), any());+ JsonNode props = new ObjectMapper().readTree("""+ {"HealthCheckConfig": {"Type": "TCP", "IPAddress": "10.0.0.5", "Port": 22},+ "HealthCheckTags": [{"Key": "team", "Value": "web"}]}""");+ StackResource resource = new StackResource();+ resource.setLogicalId("Check");+ resource.setResourceType("AWS::Route53::HealthCheck");++ assertThrows(AwsException.class, () -> new Route53CfnProvisioner(service)+ .provision(resource, props, healthCheckContext(null)));++ verify(service).deleteHealthCheck("hc-1");+ assertNull(resource.getPhysicalId());+ }++ @Test+ void healthCheckWithAnUnknownTypeIsRejected() throws Exception {+ Route53Service service = mock(Route53Service.class);+ JsonNode props = new ObjectMapper().readTree("{\"HealthCheckConfig\": {\"Type\": \"PING\"}}");+ StackResource resource = new StackResource();+ resource.setLogicalId("Check");+ resource.setResourceType("AWS::Route53::HealthCheck");++ AwsException error = assertThrows(AwsException.class, () -> new Route53CfnProvisioner(service)+ .provision(resource, props, healthCheckContext(null)));+ assertEquals("ValidationError", error.getErrorCode());+ verifyNoInteractions(service);+ }++ @Test+ void otherRoute53TypesKeepTheDefaultRollback() {+ StackResource zone = new StackResource();+ zone.setLogicalId("Zone");+ zone.setResourceType("AWS::Route53::HostedZone");++ assertFalse(new Route53CfnProvisioner(mock(Route53Service.class)).rollbackUpdate(zone));+ }++ /** A service holding check hc-1 (HTTP on 10.0.0.5:80) that creates hc-2. */+ private static Route53Service replacingService() {+ Route53Service service = mock(Route53Service.class);+ HealthCheckConfig priorConfig = new HealthCheckConfig();+ priorConfig.setType("HTTP");+ priorConfig.setIpAddress("10.0.0.5");+ priorConfig.setPort(80);+ when(service.getHealthCheck("hc-1")).thenReturn(new HealthCheck("hc-1", "ref", priorConfig, ""));+ when(service.createHealthCheck(any(), any(), any()))+ .thenAnswer(inv -> new HealthCheck("hc-2", inv.getArgument(0), inv.getArgument(1), inv.getArgument(2)));+ return service;+ }++ private static StackResource existingCheck() {+ StackResource resource = new StackResource();+ resource.setLogicalId("Check");+ resource.setResourceType("AWS::Route53::HealthCheck");+ resource.setPhysicalId("hc-1");+ resource.getAttributes().put("HealthCheckId", "hc-1");+ return resource;+ }++ private static JsonNode healthCheckProps(String type, Integer requestInterval) throws Exception {+ String interval = requestInterval == null ? "" : ", \"RequestInterval\": " + requestInterval;+ return new ObjectMapper().readTree("{\"HealthCheckConfig\": {\"Type\": \"" + type+ + "\", \"IPAddress\": \"10.0.0.5\", \"Port\": 80" + interval + "}}");+ }++ private static Set<String> publicAttributes(StackResource resource) {+ Set<String> keys = new HashSet<>(resource.getAttributes().keySet());+ keys.removeIf(key -> key.startsWith("__Floci"));+ return keys;+ }++ @Test+ void healthCheckWithoutAConfigTypeIsRejected() throws Exception {+ Route53Service service = mock(Route53Service.class);+ JsonNode props = new ObjectMapper().readTree("{\"HealthCheckConfig\": {\"Port\": 80}}");+ StackResource resource = new StackResource();+ resource.setLogicalId("Check");+ resource.setResourceType("AWS::Route53::HealthCheck");++ assertThrows(AwsException.class, () -> new Route53CfnProvisioner(service)+ .provision(resource, props, healthCheckContext(null)));+ verifyNoInteractions(service);+ }++ @Test+ void deletingAHealthCheckAlreadyGoneIsTolerated() {+ Route53Service service = mock(Route53Service.class);+ org.mockito.Mockito.doThrow(new AwsException("NoSuchHealthCheck", "gone", 404))+ .when(service).deleteHealthCheck("hc-1");+ StackResource resource = new StackResource();+ resource.setLogicalId("Check");+ resource.setResourceType("AWS::Route53::HealthCheck");+ resource.setPhysicalId("hc-1");++ new Route53CfnProvisioner(service).delete(resource, "us-east-1");++ verify(service).deleteHealthCheck("hc-1");+ }++ private static ProvisionContext healthCheckContext(String priorPhysicalId) {+ CloudFormationTemplateEngine engine = recordEngine();+ when(engine.resolveNode(any())).thenAnswer(invocation -> invocation.getArgument(0));+ return priorPhysicalId == null+ ? new ProvisionContext(engine, "us-east-1", "000000000000", "dns-stack")+ : new ProvisionContext(engine, "us-east-1", "000000000000", "dns-stack", priorPhysicalId);+ }+private static CloudFormationTemplateEngine recordEngine() {CloudFormationTemplateEngine engine = mock(CloudFormationTemplateEngine.class);when(engine.resolve(any())).thenAnswer(invocation -> {diff --git a/src/test/resources/cloudformation/supported-resource-types.tsv b/src/test/resources/cloudformation/supported-resource-types.tsvindex 3ca602e1df..2a4d12769e 100644--- a/src/test/resources/cloudformation/supported-resource-types.tsv+++ b/src/test/resources/cloudformation/supported-resource-types.tsv@@ -160,6 +160,7 @@ AWS::Redshift::ClusterSecurityGroup RedshiftClusterCfnProvisionerAWS::Redshift::ClusterSubnetGroup RedshiftClusterCfnProvisionerAWS::RedshiftServerless::Namespace RedshiftServerlessCfnProvisionerAWS::RedshiftServerless::Workgroup RedshiftServerlessCfnProvisioner+AWS::Route53::HealthCheck Route53CfnProvisionerAWS::Route53::HostedZone Route53CfnProvisionerAWS::Route53::RecordSet Route53CfnProvisionerAWS::S3::Bucket S3CfnProvisionerdiff --git a/tools/docs/cfn_resource_types.yaml b/tools/docs/cfn_resource_types.yamlindex ab2c2c731b..79436858e9 100644--- a/tools/docs/cfn_resource_types.yaml+++ b/tools/docs/cfn_resource_types.yaml@@ -106,7 +106,7 @@ type_order:AWS::ElasticLoadBalancingV2: [LoadBalancer, TargetGroup, Listener, ListenerRule]AWS::ApplicationAutoScaling: [ScalableTarget, ScalingPolicy]AWS::AutoScaling: [LaunchConfiguration, AutoScalingGroup, LifecycleHook]- AWS::Route53: [HostedZone, RecordSet]+ AWS::Route53: [HostedZone, RecordSet, HealthCheck]AWS::ApiGateway: [RestApi, Resource, Authorizer, Method, Deployment, Stage, Account, DomainName, BasePathMapping, GatewayResponse]AWS::ApiGatewayV2: [Api, Authorizer, Route, Integration, Stage, Deployment, DomainName, ApiMapping]AWS::AppSync: [GraphQLApi, GraphQLSchema, DataSource, FunctionConfiguration, Resolver, ApiKey]