Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudformation): evaluate conditions with intrinsics, require parameter values (#5737)
Jackson Pricead8fba7f4580
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationConditionsTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationConditionsTest.javanew file mode 100644index 0000000000..83d680a2b2--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationConditionsTest.java@@ -0,0 +1,130 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.cloudformation.CloudFormationClient;+import software.amazon.awssdk.services.cloudformation.model.CloudFormationException;+import software.amazon.awssdk.services.cloudformation.model.Stack;+import software.amazon.awssdk.services.s3.S3Client;+import software.amazon.awssdk.services.s3.model.NoSuchBucketException;+import software.amazon.awssdk.services.sqs.SqsClient;++import java.util.List;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++@DisplayName("CloudFormation conditions with intrinsic operands")+class CloudFormationConditionsTest {++ private static CloudFormationClient cfn;+ private static S3Client s3;+ private static SqsClient sqs;+ private String stackName;++ @BeforeAll+ static void clients() {+ cfn = TestFixtures.cloudFormationClient();+ s3 = TestFixtures.s3Client();+ sqs = TestFixtures.sqsClient();+ }++ @BeforeEach+ void setup() {+ stackName = TestFixtures.uniqueName("compat-cfn-cond");+ }++ @AfterEach+ void cleanup() throws InterruptedException {+ // Also when the stack was refused: DeleteStack of a name with no stack does nothing.+ cfn.deleteStack(r -> r.stackName(stackName));+ TestFixtures.await(() -> {+ try {+ List<Stack> stacks = cfn.describeStacks(r -> r.stackName(stackName)).stacks();+ return stacks.isEmpty() || "DELETE_COMPLETE".equals(stacks.get(0).stackStatusAsString());+ } catch (CloudFormationException e) {+ return e.getMessage().contains("does not exist");+ }+ }, stackName, "deleted", TestFixtures.isRealAws() ? 600_000_000_000L : 60_000_000_000L,+ TestFixtures.isRealAws() ? 5_000 : 100);+ }++ @AfterAll+ static void closeClients() {+ cfn.close();+ s3.close();+ sqs.close();+ }++ @Test+ @DisplayName("Fn::FindInMap inside Fn::Equals compares the mapped value")+ void mappedConditionSelectsTheBucketName() throws InterruptedException {+ String region = TestFixtures.region().id();+ String prefix = stackName + "-";+ createStack("""+ {+ "Mappings": {"Locations": {"%1$s": {"Code": "false"}}},+ "Conditions": {"UseCode": {"Fn::Not": [{"Fn::Equals": [+ {"Fn::FindInMap": ["Locations", {"Ref": "AWS::Region"}, "Code"]}, "false"]}]}},+ "Resources": {"Bucket": {"Type": "AWS::S3::Bucket", "Properties": {"BucketName":+ {"Fn::Join": ["", ["%2$s", {"Fn::If": ["UseCode",+ {"Fn::FindInMap": ["Locations", {"Ref": "AWS::Region"}, "Code"]},+ {"Ref": "AWS::Region"}]}]]}}}}+ }+ """.formatted(region, prefix));++ s3.headBucket(r -> r.bucket(prefix + region));+ assertThatThrownBy(() -> s3.headBucket(r -> r.bucket(prefix + "false")))+ .isInstanceOf(NoSuchBucketException.class);+ }++ @Test+ @DisplayName("Ref AWS::StackName inside Fn::Equals is the stack's own name")+ void stackNameConditionCreatesTheResource() throws InterruptedException {+ createStack("""+ {+ "Conditions": {"IsThisStack": {"Fn::Equals": [{"Ref": "AWS::StackName"}, "%1$s"]}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Condition": "IsThisStack",+ "Properties": {"QueueName": "%1$s"}}}+ }+ """.formatted(stackName));++ assertThat(sqs.getQueueUrl(r -> r.queueName(stackName)).queueUrl()).endsWith("/" + stackName);+ }++ @Test+ @DisplayName("Fn::ImportValue inside a condition is a template error")+ void importValueInAConditionIsRefused() {+ assertThatThrownBy(() -> cfn.createStack(r -> r.stackName(stackName).templateBody("""+ {+ "Conditions": {"IsOn": {"Fn::Equals": [{"Fn::ImportValue": "%s-export"}, "on"]}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Condition": "IsOn"}}+ }+ """.formatted(stackName))))+ .isInstanceOfSatisfying(CloudFormationException.class, e -> {+ assertThat(e.statusCode()).isEqualTo(400);+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("ValidationError");+ assertThat(e.awsErrorDetails().errorMessage()).contains("Fn::ImportValue");+ });+ assertThatThrownBy(() -> cfn.describeStacks(r -> r.stackName(stackName)))+ .isInstanceOf(CloudFormationException.class)+ .hasMessageContaining("does not exist");+ }++ private void createStack(String template) throws InterruptedException {+ cfn.createStack(r -> r.stackName(stackName).templateBody(template));+ TestFixtures.await(() -> {+ Stack stack = cfn.describeStacks(r -> r.stackName(stackName)).stacks().get(0);+ String status = stack.stackStatusAsString();+ if (status.endsWith("_FAILED") || status.contains("ROLLBACK")) {+ throw new AssertionError(stackName + " reached " + status + ": " + stack.stackStatusReason());+ }+ return "CREATE_COMPLETE".equals(status);+ }, stackName, "CREATE_COMPLETE", TestFixtures.isRealAws() ? 600_000_000_000L : 60_000_000_000L,+ TestFixtures.isRealAws() ? 5_000 : 100);+ }+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationParameterValuesTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationParameterValuesTest.javanew file mode 100644index 0000000000..c824453701--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationParameterValuesTest.java@@ -0,0 +1,118 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.cloudformation.CloudFormationClient;+import software.amazon.awssdk.services.cloudformation.model.CloudFormationException;+import software.amazon.awssdk.services.cloudformation.model.Parameter;+import software.amazon.awssdk.services.cloudformation.model.Stack;+import software.amazon.awssdk.services.ssm.SsmClient;++import java.util.List;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++@DisplayName("CloudFormation parameters without a value")+class CloudFormationParameterValuesTest {++ private static final String TEMPLATE = """+ {+ "Parameters": {"Env": {"Type": "String"}},+ "Resources": {+ "Param": {+ "Type": "AWS::SSM::Parameter",+ "Properties": {"Name": {"Fn::Sub": "/${AWS::StackName}"}, "Type": "String",+ "Value": {"Ref": "Env"}, "Description": "%s"}+ }+ }+ }+ """;++ private static CloudFormationClient cfn;+ private static SsmClient ssm;+ private String stackName;++ @BeforeAll+ static void clients() {+ cfn = TestFixtures.cloudFormationClient();+ ssm = TestFixtures.ssmClient();+ }++ @BeforeEach+ void setup() {+ stackName = TestFixtures.uniqueName("compat-cfn-param-values");+ }++ @AfterEach+ void cleanup() throws InterruptedException {+ // Also when the stack was refused: DeleteStack of a name with no stack does nothing.+ cfn.deleteStack(r -> r.stackName(stackName));+ TestFixtures.await(() -> {+ try {+ List<Stack> stacks = cfn.describeStacks(r -> r.stackName(stackName)).stacks();+ return stacks.isEmpty() || "DELETE_COMPLETE".equals(stacks.get(0).stackStatusAsString());+ } catch (CloudFormationException e) {+ return e.getMessage().contains("does not exist");+ }+ }, stackName, "deleted", TestFixtures.isRealAws() ? 600_000_000_000L : 60_000_000_000L,+ TestFixtures.isRealAws() ? 5_000 : 100);+ }++ @AfterAll+ static void closeClients() {+ cfn.close();+ ssm.close();+ }++ @Test+ @DisplayName("CreateStack refuses a parameter with no value and no Default, and creates nothing")+ void createStackRefusesAParameterWithoutAValue() {+ assertThatThrownBy(() -> cfn.createStack(r -> r.stackName(stackName).templateBody(TEMPLATE.formatted("one"))))+ .isInstanceOfSatisfying(CloudFormationException.class, e -> {+ assertThat(e.statusCode()).isEqualTo(400);+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("ValidationError");+ assertThat(e.awsErrorDetails().errorMessage()).isEqualTo("Parameters: [Env] must have values");+ });+ assertThatThrownBy(() -> cfn.describeStacks(r -> r.stackName(stackName)))+ .isInstanceOf(CloudFormationException.class)+ .hasMessageContaining("does not exist");+ }++ @Test+ @DisplayName("UpdateStack needs the value again, or UsePreviousValue to keep the deployed one")+ void updateStackNeedsAValueOrUsePreviousValue() throws InterruptedException {+ cfn.createStack(r -> r.stackName(stackName).templateBody(TEMPLATE.formatted("one"))+ .parameters(Parameter.builder().parameterKey("Env").parameterValue("first").build()));+ awaitStatus("CREATE_COMPLETE");++ assertThatThrownBy(() -> cfn.updateStack(r -> r.stackName(stackName).templateBody(TEMPLATE.formatted("two"))))+ .isInstanceOfSatisfying(CloudFormationException.class, e -> {+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("ValidationError");+ assertThat(e.awsErrorDetails().errorMessage()).isEqualTo("Parameters: [Env] must have values");+ });+ assertThat(cfn.describeStacks(r -> r.stackName(stackName)).stacks().get(0).stackStatusAsString())+ .isEqualTo("CREATE_COMPLETE");++ cfn.updateStack(r -> r.stackName(stackName).templateBody(TEMPLATE.formatted("two"))+ .parameters(Parameter.builder().parameterKey("Env").usePreviousValue(true).build()));+ awaitStatus("UPDATE_COMPLETE");+ assertThat(ssm.getParameter(r -> r.name("/" + stackName)).parameter().value()).isEqualTo("first");+ }++ private void awaitStatus(String expected) throws InterruptedException {+ TestFixtures.await(() -> {+ Stack stack = cfn.describeStacks(r -> r.stackName(stackName)).stacks().get(0);+ String status = stack.stackStatusAsString();+ if (status.endsWith("_FAILED") || status.contains("ROLLBACK")) {+ throw new AssertionError(stackName + " reached " + status + ": " + stack.stackStatusReason());+ }+ return expected.equals(status);+ }, stackName, expected, TestFixtures.isRealAws() ? 600_000_000_000L : 60_000_000_000L,+ TestFixtures.isRealAws() ? 5_000 : 100);+ }+}diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.mdindex 48e27efdde..e2fc9ddce0 100644--- a/docs/services/cloudformation.md+++ b/docs/services/cloudformation.md@@ -416,6 +416,19 @@ before provisioning:tags, bucket names) from Parameter Store.- `AWS::SSM::Parameter::Value<List<String>>` and `AWS::SSM::Parameter::Name` typed parameters are**not yet** resolved — they are passed through as their literal input.+- **A declared parameter needs a value.** One that the request gives no value and the template no+ `Default` fails `CreateStack`, `UpdateStack` and `CreateChangeSet` with `ValidationError`+ `Parameters: [Env] must have values`, naming each such parameter, before anything changes. An+ empty value counts as a value. An update does not carry values over: set `UsePreviousValue` to+ keep the deployed one. `UsePreviousValue` on a parameter that has no deployed value passes none.+ The values are checked before the template's dependency checks (a cycle, an unresolved+ dependency, a malformed condition), which read them, so a template with a cycle and a missing+ value gets this error. A request for a stack that does not exist, cannot be updated, or already+ exists gets that stack error instead of this one; a dependency error still comes before the+ stack error. The same check+ refuses `CreateStackSet` and `UpdateStackSet`, and fails a nested stack's resource whose+ `Parameters` leave a child parameter without a value. A parameter that an `AWS::Include` defines+ is not checked, nor is any parameter in a section that carries an `AWS::Include` of its own.The `AWS::SSM::Parameter` **resource** type exposes `Value`, `Type`, `Name`, and `Arn` attributes through`Ref` / `Fn::GetAtt` so downstream resources can consume a parameter the same stack creates.@@ -481,6 +494,17 @@ Template `Conditions` are evaluated before provisioning. A resource whose `Condi`Ref` / `Fn::GetAtt` are not required to resolve. This matches CloudFormation and is required for thecondition-heavy templates CDK and LZA emit.+The operands of `Fn::Equals` are resolved as resource property values are, so `Ref` to a parameter+or a pseudo parameter (`AWS::StackName` and `AWS::StackId` included) and `Fn::FindInMap`, the+functions CloudFormation supports there, work inside a condition. The dependency check a create runs+before the stack exists sees the `AWS::StackId` the stack is then given. An operand Floci cannot+resolve compares as an empty string. `AWS::NotificationARNs` is the empty list everywhere, as+Floci keeps no notification ARNs. `Fn::ImportValue` is not allowed in a condition, as in CloudFormation: `CreateStack`,+`UpdateStack` and `CreateChangeSet` refuse such a template, with the message `Template error: Cannot+use Fn::ImportValue in Conditions.` A SAM template's change set fails with that reason instead, and+so does the stack when CreateStack or UpdateStack executes it; an `AWS::Include` template fails when+it is executed.+## Custom Resources and the CDK Provider Framework`AWS::CloudFormation::CustomResource` and `Custom::*` resources are backed by their `ServiceToken`diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationQueryHandler.javaindex d42df99e6e..74e0aa96ff 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationQueryHandler.java@@ -716,13 +716,14 @@ public class CloudFormationQueryHandler {/*** @param previousParameters the stack's currently deployed parameters, consulted when a member- * sets {@code UsePreviousValue=true} instead of a {@code ParameterValue}+ * sets {@code UsePreviousValue=true} instead of a {@code ParameterValue}.+ * A member naming one that has no deployed value is left out: there is+ * no value to keep, so the template's Default applies, or none.*/private Map<String, String> extractParameters(MultivaluedMap<String, String> params, Map<String, String> previousParameters) {Map<String, String> result = new HashMap<>();- int i = 1;- while (true) {+ for (int i = 1; ; i++) {String key = params.getFirst("Parameters.member." + i + ".ParameterKey");if (key == null) {break;@@ -730,11 +731,13 @@ public class CloudFormationQueryHandler {String value;if (Boolean.parseBoolean(params.getFirst("Parameters.member." + i + ".UsePreviousValue"))) {value = previousParameters.get(key);+ if (value == null) {+ continue;+ }} else {value = params.getFirst("Parameters.member." + i + ".ParameterValue");}result.put(key, value != null ? value : "");- i++;}return result;}@@ -902,7 +905,9 @@ public class CloudFormationQueryHandler {private Response updateStackSet(MultivaluedMap<String, String> params) {try {String stackSetName = params.getFirst("StackSetName");- Map<String, String> previousParameters = stackSetService.describeStackSet(stackSetName).getParameters();+ StackSet current = stackSetService.describeStackSet(stackSetName);+ Map<String, String> previousParameters =+ cfnService.parametersWithDefaults(current.getTemplateBody(), current.getParameters());StackSetOperation op = stackSetService.updateStackSet(stackSetName,cfnService.resolveTemplateBody(params.getFirst("TemplateBody"), params.getFirst("TemplateURL")),diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.javaindex 265b21768f..c57b75e1c4 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java@@ -377,6 +377,34 @@ public class CloudFormationService implements ResourceProvider {Map<String, String> tags, String region, String accountId,boolean attachToReviewInProgressStack, boolean fromPreviousTemplate) {String resolvedTemplate = resolveTemplate(templateBody, templateUrl);+ boolean isCreateType = "CREATE".equalsIgnoreCase(changeSetType);+ // An update names its stack by name or stack ID; the map is keyed by name. One that names no+ // live stack is keyed as given, so it lands in the missing-stack branch below.+ Stack live = isCreateType ? null : resolveStack(stackName, region, accountId);++ // Ahead of the transform and the preflight below, which both read the parameter values. A+ // request the claim below refuses for its stack alone (an update of a stack that is missing+ // or cannot be updated, a create over a name in use) gets that refusal instead: there is no+ // deployed value for its UsePreviousValue to keep.+ Stack named = isCreateType ? stacks.get(stackKey(accountId, stackName, region)) : live;+ boolean refusedForItsStack = isCreateType+ ? named != null && !(attachToReviewInProgressStack && "REVIEW_IN_PROGRESS".equals(named.getStatus()))+ : named == null || "DELETE_COMPLETE".equals(named.getStatus()) || refusesUpdate(named.getStatus());+ if (!refusedForItsStack) {+ requireParameterValues(resolvedTemplate, parameters);+ }++ // The preflight evaluates AWS::StackName and AWS::StackId as the execution will: an update+ // or a create attaching to a placeholder against that stack, any other create against the+ // id it is given below, allocated now. A create over a name in use is checked as that new+ // stack, never as the stack holding the name; an update of a missing stack, refused below,+ // with the name it gave and an empty id.+ boolean attaches = isCreateType && named != null && !refusedForItsStack;+ String createdStackId = isCreateType && !attaches ? newStackId(stackName, region, accountId) : null;+ Stack identity = isCreateType ? (attaches ? named : null) : live;+ String preflightStackName = identity != null ? identity.getStackName() : stackName;+ String preflightStackId = identity != null ? identity.getStackId()+ : createdStackId != null ? createdStackId : "";// Real CloudFormation runs a declared macro (here, only AWS::Serverless-2016-10-31)// before it ever evaluates the template's own resources or conditions. On real AWS,@@ -392,7 +420,8 @@ public class CloudFormationService implements ResourceProvider {// template declaring the SAM transform, whether or not that transform succeeded, so// gating this call on samTransformFailureReason == null duplicates that check for no// effect.- validateResourceDependencies(resolvedTemplate, parameters, region, accountId);+ validateResourceDependencies(resolvedTemplate, parameters, preflightStackName, preflightStackId,+ region, accountId);// A CREATE change set against a name that already has a stack of any status - including// ROLLBACK_COMPLETE - is a real conflict: AWS requires an explicit DeleteStack before a@@ -422,10 +451,6 @@ public class CloudFormationService implements ResourceProvider {// was already released, losing an accepted change set or corrupting the map's links. Only// persistStack() stays outside: it is storage I/O, and compute()'s contract is that the// remapping function does short, non-blocking work.- boolean isCreateType = "CREATE".equalsIgnoreCase(changeSetType);- // An update names its stack by name or stack ID; the map is keyed by name. One that names no- // live stack is keyed as given, so it lands in the missing-stack branch below.- Stack live = isCreateType ? null : resolveStack(stackName, region, accountId);String canonicalStackName = live == null ? stackName : live.getStackName();ChangeSet[] created = new ChangeSet[1];Stack stack = stacks.compute(stackKey(accountId, canonicalStackName, region), (k, existing) -> {@@ -434,7 +459,10 @@ public class CloudFormationService implements ResourceProvider {if (!isCreateType) {throw noStackToUpdate(stackName, region, accountId);}- target = newStack(stackName, region, accountId);+ // The id the preflight saw; a placeholder that left the map since then has none.+ target = newStack(stackName,+ createdStackId != null ? createdStackId : newStackId(stackName, region, accountId),+ region, accountId);if (tags != null) target.getTags().putAll(tags);// A CREATE change set puts a brand-new stack into REVIEW_IN_PROGRESS. Record the// matching stack-level event (as AWS and LocalStack do) so DescribeStackEvents is@@ -635,9 +663,10 @@ public class CloudFormationService implements ResourceProvider {changedParams.add(k);}});- // A parameter that was deployed but is omitted from this update with no template- // Default is dropped entirely by resolveDefaultParameters (matching what- // ExecuteChangeSet does); flag its disappearance too, not just a value change.+ // A parameter that was deployed but that the new template no longer declares, and the+ // update does not pass, is absent from the new values, as it is when ExecuteChangeSet+ // runs; flag its disappearance too, not just a value change. One the template still+ // declares has a value or a Default: createChangeSet refuses the update otherwise.oldResolvedParams.keySet().forEach(k -> {if (!newResolvedParams.containsKey(k)) {changedParams.add(k);@@ -654,7 +683,7 @@ public class CloudFormationService implements ResourceProvider {? resolveConditions(oldTemplate, oldResolvedParams, stack, region, regionResolver.getAccountId()): Map.of();Map<String, Boolean> newConditions = resolveConditions(- newTemplate, newResolvedParams, null, region, regionResolver.getAccountId());+ newTemplate, newResolvedParams, stack, region, regionResolver.getAccountId());Set<String> changedConditions = new HashSet<>();newConditions.forEach((name, val) -> {if (!Objects.equals(val, oldConditions.get(name))) {@@ -2927,28 +2956,57 @@ public class CloudFormationService implements ResourceProvider {private Map<String, Boolean> resolveConditions(JsonNode template, Map<String, String> params,Stack stack, String region, String accountId) {+ return resolveConditions(template, params, stack.getStackName(), stack.getStackId(), region, accountId);+ }++ /**+ * Evaluates the template's {@code Conditions} through the template engine, so an operand of+ * {@code Fn::Equals} can be any intrinsic the engine resolves, {@code Fn::FindInMap} and the+ * pseudo parameters included. {@code AWS::StackName} and {@code AWS::StackId} resolve to the+ * name and id given, so every evaluation of one stack's template passes the stack's own; a+ * create's preflight passes the id createChangeSet allocates for the stack it then creates.+ */+ private Map<String, Boolean> resolveConditions(JsonNode template, Map<String, String> params,+ String stackName, String stackId, String region,+ String accountId) {Map<String, Boolean> conditions = new HashMap<>();JsonNode condNode = template.path("Conditions");if (!condNode.isObject()) {return conditions;}+ Map<String, JsonNode> mappings = new HashMap<>();+ template.path("Mappings").fields().forEachRemaining(e -> mappings.put(e.getKey(), e.getValue()));+ // Every declared parameter has a value or a Default once a template is deployed, but a stack+ // stored by an older Floci may lack one. It compares as "", as it did when that stack was+ // deployed, rather than as its own name, which is how the engine answers a Ref it cannot resolve.+ Map<String, String> conditionParams = new HashMap<>(params);+ template.path("Parameters").fieldNames().forEachRemaining(name -> conditionParams.putIfAbsent(name, ""));+ // A template being deployed with an import in a condition is refused up front+ // (requireStringConditionReferences); one here is a stored template's, which reads it as "".+ CloudFormationTemplateEngine engine = new CloudFormationTemplateEngine(+ accountId, region, stackName, stackId, conditionParams, Map.of(), Map.of(),+ conditions, mappings, objectMapper, name -> "");// Two-pass: collect all names first, then evaluate (handles forward references)condNode.fields().forEachRemaining(e -> conditions.put(e.getKey(), false));condNode.fields().forEachRemaining(e ->- conditions.put(e.getKey(), evaluateCondition(e.getValue(), params, conditions, region, accountId)));+ conditions.put(e.getKey(), evaluateCondition(e.getValue(), conditions, engine)));return conditions;}private static final String NON_STRING_CONDITION_REFERENCE ="Template error: every Condition object must have a single String value.";+ private static final String IMPORT_VALUE_IN_CONDITION =+ "Template error: Cannot use Fn::ImportValue in Conditions.";/*** Rejects a template whose conditions name another one with anything but a string, as* CloudFormation does before evaluating any of them: {@code Fn::And}, {@code Fn::Or} and* {@code Fn::Not} stop early, so evaluation alone would read such an operand as false or never* reach it. SAM's translator emits this shape when a conditional function's event invoke- * destination is itself conditional. Checked on the template being deployed only, so a stored- * template is never a reason an update cannot proceed.+ * destination is itself conditional. Also rejects {@code Fn::ImportValue} anywhere in a+ * condition, which CloudFormation does not allow there. Checked on the template being deployed+ * only, so a stored template read as the old side of a diff, a rollback or a delete ordering is+ * never a reason an update cannot proceed.*/private static void requireStringConditionReferencesIn(JsonNode template) {template.path("Conditions").forEach(CloudFormationService::requireStringConditionReferences);@@ -2965,9 +3023,63 @@ public class CloudFormationService implements ResourceProvider {if (expression.has("Condition") && !expression.get("Condition").isTextual()) {throw new AwsException("ValidationError", NON_STRING_CONDITION_REFERENCE, 400);}+ if (expression.has("Fn::ImportValue")) {+ throw new AwsException("ValidationError", IMPORT_VALUE_IN_CONDITION, 400);+ }expression.forEach(CloudFormationService::requireStringConditionReferences);}+ /**+ * Refuses a template that declares a parameter the request gives no value and the template no+ * {@code Default}, as CloudFormation refuses CreateStack, UpdateStack and CreateChangeSet,+ * naming every such parameter in the order the template declares them. An empty value is a+ * value. {@code UsePreviousValue} is one too: the request handler has already replaced it with+ * the deployed value, or left the parameter without one when nothing was deployed. A template+ * that does not parse is left for the paths that report that, and so is what an+ * {@code AWS::Include} supplies, which only execution merges: a parameter whose definition uses+ * one, or every parameter when the section itself is one.+ */+ void requireParameterValues(String templateBody, Map<String, String> params) {+ JsonNode template;+ try {+ template = parseTemplate(templateBody);+ } catch (Exception ignored) {+ // No Parameters section to check; executing the change set reports the parse error.+ return;+ }+ JsonNode declared = template.path("Parameters");+ if (AwsIncludeProcessor.AWS_INCLUDE.equals(declared.path("Fn::Transform").path("Name").asText(""))) {+ return;+ }+ Map<String, String> given = resolveDefaultParameters(template, params);+ List<String> missing = new ArrayList<>();+ declared.properties().forEach(parameter -> {+ String name = parameter.getKey();+ if (!"Fn::Transform".equals(name) && !awsIncludeProcessor.containsAwsInclude(parameter.getValue())+ && !given.containsKey(name)) {+ missing.add(name);+ }+ });+ if (!missing.isEmpty()) {+ throw new AwsException("ValidationError",+ "Parameters: [" + String.join(", ", missing) + "] must have values", 400);+ }+ }++ /**+ * The values a template deploys with: {@code params} over each parameter's {@code Default}, or+ * {@code params} alone when the template does not parse. UpdateStackSet resolves+ * {@code UsePreviousValue} against these, since a stack set keeps only the values it was given.+ */+ Map<String, String> parametersWithDefaults(String templateBody, Map<String, String> params) {+ try {+ return resolveDefaultParameters(parseTemplate(templateBody), params);+ } catch (Exception ignored) {+ // No Defaults to add from a template that does not parse; the given values stand.+ return params != null ? params : Map.of();+ }+ }+/*** Fails a create/update before any stack state is mutated when a resource that will be created* depends on a resource excluded by a false condition, or when resources depend on each other@@ -2981,7 +3093,8 @@ public class CloudFormationService implements ResourceProvider {* graph the execution path resolves correctly.*/private void validateResourceDependencies(String templateBody, Map<String, String> params,- String region, String accountId) {+ String stackName, String stackId, String region,+ String accountId) {JsonNode template;try {template = parseTemplate(templateBody);@@ -3000,15 +3113,16 @@ public class CloudFormationService implements ResourceProvider {requireStringConditionReferencesIn(template);Map<String, String> resolvedParams = resolveDefaultParameters(template, params);+ // Against the stack name and id the execution will use, which createChangeSet decides.Map<String, Boolean> conditions =- resolveConditions(template, resolvedParams, null, region, accountId);+ resolveConditions(template, resolvedParams, stackName, stackId, region, accountId);// Throws the ValidationError for either case; the order itself is computed again on execution.topologicalSort(resources, conditions);}- private boolean evaluateCondition(JsonNode expr, Map<String, String> params,- Map<String, Boolean> conditions, String region, String accountId) {+ private boolean evaluateCondition(JsonNode expr, Map<String, Boolean> conditions,+ CloudFormationTemplateEngine engine) {if (expr == null || expr.isNull()) {return false;}@@ -3022,20 +3136,18 @@ public class CloudFormationService implements ResourceProvider {if (expr.has("Fn::Equals")) {JsonNode args = expr.get("Fn::Equals");if (args.isArray() && args.size() == 2) {- String left = resolveConditionValue(args.get(0), params, region, accountId);- String right = resolveConditionValue(args.get(1), params, region, accountId);- return left.equals(right);+ return conditionOperand(args.get(0), engine).equals(conditionOperand(args.get(1), engine));}}if (expr.has("Fn::Not")) {JsonNode args = expr.get("Fn::Not");if (args.isArray() && !args.isEmpty()) {- return !evaluateCondition(args.get(0), params, conditions, region, accountId);+ return !evaluateCondition(args.get(0), conditions, engine);}}if (expr.has("Fn::And")) {for (JsonNode item : expr.get("Fn::And")) {- if (!evaluateCondition(item, params, conditions, region, accountId)) {+ if (!evaluateCondition(item, conditions, engine)) {return false;}}@@ -3043,7 +3155,7 @@ public class CloudFormationService implements ResourceProvider {}if (expr.has("Fn::Or")) {for (JsonNode item : expr.get("Fn::Or")) {- if (evaluateCondition(item, params, conditions, region, accountId)) {+ if (evaluateCondition(item, conditions, engine)) {return true;}}@@ -3053,21 +3165,22 @@ public class CloudFormationService implements ResourceProvider {return false;}- private String resolveConditionValue(JsonNode node, Map<String, String> params,- String region, String accountId) {- if (node.isTextual()) {- return node.textValue();- }- if (node.isObject() && node.has("Ref")) {- String name = node.get("Ref").asText();- return switch (name) {- case "AWS::AccountId" -> accountId;- case "AWS::Region" -> region;- case "AWS::NoValue" -> "";- default -> params.getOrDefault(name, "");- };+ /**+ * An {@code Fn::Equals} operand as the template engine resolves it. One the engine cannot+ * resolve, such as an {@code Fn::Sub} whose template is not a string, compares as an empty+ * string, as every function did before conditions went through the engine, so a template that+ * evaluated then, stored or new, still evaluates and gets its dependency checks.+ */+ private static String conditionOperand(JsonNode operand, CloudFormationTemplateEngine engine) {+ try {+ return engine.resolve(operand);+ } catch (AwsException e) {+ throw e;+ } catch (RuntimeException e) {+ LOG.debugv("Condition operand {0} did not resolve and compares as an empty string: {1}",+ operand, e.getMessage());+ return "";}- return node.asText();}private JsonNode parseTemplate(String templateBody) throws Exception {@@ -3263,6 +3376,34 @@ public class CloudFormationService implements ResourceProvider {String childTemplate = fetchTemplateFromS3(templateUrl);String childStackName = parentStack.getStackName() + "-" + logicalId;+ // Resolved as a property value: Parameters may be an Fn::If choosing between whole maps,+ // and a value that is AWS::NoValue passes nothing, so the child's Default applies. A list,+ // such as an Fn::GetAZs resolves to, is passed joined with commas, and a null as an empty+ // string, as before.+ Map<String, String> childParams = new LinkedHashMap<>();+ JsonNode parameters = props == null ? null : engine.resolveNodeOmittingNoValue(props.get("Parameters"));+ if (parameters != null && parameters.isObject()) {+ parameters.fields().forEachRemaining(e -> {+ JsonNode value = e.getValue();+ if (value.isArray()) {+ List<String> items = new ArrayList<>();+ value.forEach(item -> items.add(item.asText()));+ childParams.put(e.getKey(), String.join(",", items));+ } else {+ childParams.put(e.getKey(), value.isNull() ? "" : value.asText());+ }+ });+ }+ // CloudFormation creates or updates the child with these values, so the call fails as a+ // CreateStack or UpdateStack would, before the child is created or changed.+ try {+ requireParameterValues(childTemplate, childParams);+ } catch (AwsException e) {+ resource.setStatus("CREATE_FAILED");+ resource.setStatusReason(e.getMessage());+ return resource;+ }+Stack childStack = null;boolean childCreate = isCreate || previousResource == null|| previousResource.getPhysicalId() == null;@@ -3271,17 +3412,11 @@ public class CloudFormationService implements ResourceProvider {childCreate = childStack == null;}if (childCreate) {- childStack = newStack(childStackName, region, accountId);+ childStack = newStack(childStackName, newStackId(childStackName, region, accountId), region, accountId);childStack.setStatus("CREATE_IN_PROGRESS");stacks.put(stackKey(accountId, childStackName, region), childStack);}- Map<String, String> childParams = new LinkedHashMap<>();- if (props != null && props.has("Parameters") && props.get("Parameters").isObject()) {- props.get("Parameters").fields().forEachRemaining(e ->- childParams.put(e.getKey(), engine.resolve(e.getValue())));- }-executeTemplate(childStack, childTemplate, childParams, null, childCreate, region, accountId);resource.setPhysicalId(childStack.getStackId());@@ -3310,13 +3445,16 @@ public class CloudFormationService implements ResourceProvider {}- private Stack newStack(String stackName, String region, String accountId) {+ private static String newStackId(String stackName, String region, String accountId) {+ return AwsArnUtils.Arn.of("cloudformation", region, accountId, "stack/" + stackName + "/" + UUID.randomUUID()).toString();+ }++ private Stack newStack(String stackName, String stackId, String region, String accountId) {Stack stack = new Stack();stack.setStackName(stackName);stack.setRegion(region);stack.setAccountId(accountId);stack.setStatus("REVIEW_IN_PROGRESS");- String stackId = AwsArnUtils.Arn.of("cloudformation", region, accountId, "stack/" + stackName + "/" + UUID.randomUUID()).toString();stack.setStackId(stackId);stack.setCreationTime(now());return stack;diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationTemplateEngine.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationTemplateEngine.javaindex d5004d77e6..62a0dca07c 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationTemplateEngine.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationTemplateEngine.java@@ -342,6 +342,8 @@ public class CloudFormationTemplateEngine {case "AWS::StackId" -> stackId;case "AWS::Partition" -> AwsRegions.partitionFor(region);case "AWS::URLSuffix" -> AwsRegions.dnsSuffixFor(region);+ // Floci keeps no notification ARNs for a stack, so the list is empty.+ case "AWS::NotificationARNs" -> "";case "AWS::NoValue" -> "";default -> {if (physicalIds.containsKey(name)) {diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/StackSetService.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/StackSetService.javaindex 48d77d9ef6..48250830e9 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/StackSetService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/StackSetService.java@@ -128,6 +128,9 @@ public class StackSetService {if ("SELF_MANAGED".equals(resolvedPermissionModel) && (autoDeploymentEnabled || retainStacksOnAccountRemoval)) {throw new AwsException("ValidationError", "AutoDeployment is valid only for SERVICE_MANAGED StackSets.", 400);}+ // Every instance is deployed with these parameters, so a template parameter left without a+ // value would fail each one; refuse the stack set instead.+ cfnService.requireParameterValues(templateBody, parameters);StackSet ss = new StackSet();ss.setStackSetName(name);@@ -194,6 +197,11 @@ public class StackSetService {Boolean retainStacksOnAccountRemoval,Boolean managedExecutionActive) {StackSet ss = getStackSetOrThrow(name);+ // Checked against the template and parameters the update leaves the stack set with, before+ // either is changed or an operation is recorded.+ cfnService.requireParameterValues(+ templateBody != null && !templateBody.isBlank() ? templateBody : ss.getTemplateBody(),+ parameters != null && !parameters.isEmpty() ? parameters : ss.getParameters());String operationId = reserveOperation(name, "UPDATE", requestedOperationId).getOperationId();if (templateBody != null && !templateBody.isBlank()) {ss.setTemplateBody(templateBody);@@ -311,36 +319,42 @@ public class StackSetService {for (String ou : targetOus) validateOuOrRoot(ou);String operationId = reserveOperation(name, "CREATE", requestedOperationId).getOperationId();- List<TargetAccount> targets = !directAccounts.isEmpty()- ? directAccounts.stream().map(account -> new TargetAccount(account, Set.of())).toList()- : resolveOrganizationTargets(targetOus, regions, name);-List<StackInstance> deployed = new ArrayList<>();- for (TargetAccount target : targets) {- for (String region : regions) {- String instanceKey = instanceKey(name, target.accountId(), region);- StackInstance existing = instances.get(instanceKey).orElse(null);- if (existing != null && !"OUTDATED".equals(existing.getStatus())) {- if (!target.organizationalUnitIds().isEmpty()) {- Set<String> associations = deploymentTargetsFor(existing);- if (associations.addAll(target.organizationalUnitIds())) {- applyDeploymentTargets(existing, associations);- instances.put(instanceKey, existing);+ try {+ List<TargetAccount> targets = !directAccounts.isEmpty()+ ? directAccounts.stream().map(account -> new TargetAccount(account, Set.of())).toList()+ : resolveOrganizationTargets(targetOus, regions, name);+ for (TargetAccount target : targets) {+ for (String region : regions) {+ String instanceKey = instanceKey(name, target.accountId(), region);+ StackInstance existing = instances.get(instanceKey).orElse(null);+ if (existing != null && !"OUTDATED".equals(existing.getStatus())) {+ if (!target.organizationalUnitIds().isEmpty()) {+ Set<String> associations = deploymentTargetsFor(existing);+ if (associations.addAll(target.organizationalUnitIds())) {+ applyDeploymentTargets(existing, associations);+ instances.put(instanceKey, existing);+ }}+ continue;}- continue;+ StackInstance inst = deployInstance(ss, target.accountId(), region, INSTANCE_CHANGE_SET, "CREATE");+ Set<String> associations = existing == null+ ? new LinkedHashSet<>() : deploymentTargetsFor(existing);+ associations.addAll(target.organizationalUnitIds());+ applyDeploymentTargets(inst, associations);+ instances.put(instanceKey, inst);+ deployed.add(inst);}- StackInstance inst = deployInstance(ss, target.accountId(), region, INSTANCE_CHANGE_SET, "CREATE");- Set<String> associations = existing == null- ? new LinkedHashSet<>() : deploymentTargetsFor(existing);- associations.addAll(target.organizationalUnitIds());- applyDeploymentTargets(inst, associations);- instances.put(instanceKey, inst);- deployed.add(inst);}+ completeOperation(name, operationId, deriveOperationStatus(deployed));+ return describeStackSetOperation(name, operationId);+ } catch (RuntimeException e) {+ // An organizational unit that cannot be resolved, or an instance whose change set is+ // refused: the operation fails rather than stay RUNNING, which would refuse every later one.+ completeOperation(name, operationId, "FAILED");+ throw e;}- completeOperation(name, operationId, deriveOperationStatus(deployed));- return describeStackSetOperation(name, operationId);}public List<StackSetAutoDeploymentTarget> listStackSetAutoDeploymentTargets(String name) {diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationChangeSetDiffIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationChangeSetDiffIntegrationTest.javaindex 1e6b931118..490445ab6f 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationChangeSetDiffIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationChangeSetDiffIntegrationTest.java@@ -230,7 +230,7 @@ class CloudFormationChangeSetDiffIntegrationTest {}@Test- void omittedParameterWithNoDefault_isReportedAsAChange() {+ void omittedParameterWithNoDefault_isRefused() {String stackName = "cs-diff-omitted-param-no-default-stack";stacksToDelete.add(stackName);@@ -262,9 +262,9 @@ class CloudFormationChangeSetDiffIntegrationTest {.then().statusCode(200);- // Same template, but the update omits Suffix entirely and the template has no Default -- // resolveDefaultParameters drops the parameter, and ExecuteChangeSet would apply the- // resulting (missing) value. The preview must flag the resource as changed too.+ // Same template, but the update omits Suffix entirely and the template has no Default. An+ // update does not carry the deployed value over, so CloudFormation refuses the change set+ // rather than preview, or apply, the parameter without a value.given().contentType("application/x-www-form-urlencoded").formParam("Action", "CreateChangeSet")@@ -275,19 +275,9 @@ class CloudFormationChangeSetDiffIntegrationTest {.when().post("/").then()- .statusCode(200);-- given()- .contentType("application/x-www-form-urlencoded")- .formParam("Action", "DescribeChangeSet")- .formParam("StackName", stackName)- .formParam("ChangeSetName", "omitted-param-no-default-cs")- .when()- .post("/")- .then()- .statusCode(200)- .body(containsString("<LogicalResourceId>Q</LogicalResourceId>"))- .body(containsString("<Action>Modify</Action>"));+ .statusCode(400)+ .body(containsString("<Code>ValidationError</Code>"))+ .body(containsString("<Message>Parameters: [Suffix] must have values</Message>"));}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationParameterValuesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationParameterValuesIntegrationTest.javanew file mode 100644index 0000000000..28ac98a142--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationParameterValuesIntegrationTest.java@@ -0,0 +1,663 @@+package io.github.hectorvent.floci.services.cloudformation;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++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;++/**+ * A declared parameter that the request gives no value and the template no {@code Default}+ * fails CreateStack, UpdateStack and CreateChangeSet with {@code Parameters: [X] must have values},+ * before any stack state changes. {@code UsePreviousValue} supplies the deployed value on an update.+ */+@QuarkusTest+class CloudFormationParameterValuesIntegrationTest {++ private static final String BLANK_ENV_TEMPLATE = """+ {+ "Parameters": {"Env": {"Type": "String"}},+ "Conditions": {"IsBlank": {"Fn::Equals": [{"Ref": "Env"}, ""]}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Condition": "IsBlank"}}+ }+ """;++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void createStackRefusesAParameterWithNoValueAndNoDefault() {+ String stackName = "cfn-param-missing-" + Long.toString(System.nanoTime(), 36);++ request("CreateStack", stackName)+ .formParam("TemplateBody", BLANK_ENV_TEMPLATE)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Env] must have values"));++ describeStacks(stackName).then().statusCode(400);+ }++ /** Every such parameter is named, in the order the template declares them. */+ @Test+ void everyParameterWithoutAValueIsNamed() {+ String stackName = "cfn-param-several-" + Long.toString(System.nanoTime(), 36);++ request("CreateStack", stackName)+ .formParam("TemplateBody", """+ {+ "Parameters": {+ "Zeta": {"Type": "String"},+ "Alpha": {"Type": "String", "Default": "a"},+ "Beta": {"Type": "Number"},+ "Gamma": {"Type": "String"}+ },+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue"}}+ }+ """)+ .formParam("Parameters.member.1.ParameterKey", "Gamma")+ .formParam("Parameters.member.1.ParameterValue", "g")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Zeta, Beta] must have values"));++ describeStacks(stackName).then().statusCode(400);+ }++ /**+ * The values are checked before the template's dependency checks, which evaluate conditions+ * that read them, so a template with both a cycle and a missing value gets the parameter error.+ */+ @Test+ void aMissingValueIsReportedBeforeADependencyCycle() {+ String stackName = "cfn-param-cycle-" + Long.toString(System.nanoTime(), 36);++ request("CreateStack", stackName)+ .formParam("TemplateBody", """+ {+ "Parameters": {"Env": {"Type": "String"}},+ "Resources": {+ "A": {"Type": "AWS::SQS::Queue", "DependsOn": "B"},+ "B": {"Type": "AWS::SQS::Queue", "DependsOn": "A"}+ }+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Env] must have values"));++ describeStacks(stackName).then().statusCode(400);+ }++ /** An empty value is a value, and a Default stands in for an omitted one. */+ @Test+ void anEmptyValueAndADefaultAreValues() {+ String stackName = "cfn-param-empty-" + Long.toString(System.nanoTime(), 36);+ String queueName = "param-empty-" + Long.toString(System.nanoTime(), 36);++ request("CreateStack", stackName)+ .formParam("TemplateBody", """+ {+ "Parameters": {+ "Env": {"Type": "String"},+ "Timeout": {"Type": "Number", "Default": "45"}+ },+ "Conditions": {"IsBlank": {"Fn::Equals": [{"Ref": "Env"}, ""]}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Condition": "IsBlank",+ "Properties": {"QueueName": "%s", "VisibilityTimeout": {"Ref": "Timeout"}}}}+ }+ """.formatted(queueName))+ .formParam("Parameters.member.1.ParameterKey", "Env")+ .formParam("Parameters.member.1.ParameterValue", "")+ .when()+ .post("/")+ .then()+ .statusCode(200);+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ getQueueUrl(queueName).then().statusCode(200);+ } finally {+ deleteStack(stackName);+ }+ }++ /** A CREATE change set is refused too, and leaves no REVIEW_IN_PROGRESS stack behind. */+ @Test+ void createChangeSetRefusesAParameterWithNoValue() {+ String stackName = "cfn-param-changeset-" + Long.toString(System.nanoTime(), 36);++ request("CreateChangeSet", stackName)+ .formParam("ChangeSetName", "deploy")+ .formParam("ChangeSetType", "CREATE")+ .formParam("TemplateBody", BLANK_ENV_TEMPLATE)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Env] must have values"));++ describeStacks(stackName).then().statusCode(400);+ }++ /**+ * The check runs before the SAM transform, so a SAM template is refused with the same 400+ * rather than given a change set that fails later.+ */+ @Test+ void samTemplateWithoutAValueIsRefusedBeforeTheTransform() {+ String stackName = "cfn-param-sam-" + Long.toString(System.nanoTime(), 36);++ request("CreateChangeSet", stackName)+ .formParam("ChangeSetName", "deploy")+ .formParam("ChangeSetType", "CREATE")+ .formParam("TemplateBody", """+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Parameters": {"Env": {"Type": "String"}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue",+ "Properties": {"QueueName": {"Fn::Sub": "sam-${Env}"}}}}+ }+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Env] must have values"));++ describeStacks(stackName).then().statusCode(400);+ }++ /**+ * An update does not carry a parameter over: one it omits is refused whether the update sends+ * a template or reuses the previous one, and the stack keeps its status and value.+ * {@code UsePreviousValue} keeps the deployed value, on UpdateStack and on an UPDATE change set.+ */+ @Test+ void anUpdateNeedsAValueOrUsePreviousValue() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-param-update-" + suffix;+ String queueName = "param-update-" + suffix;+ String template = """+ {+ "Parameters": {"Env": {"Type": "String"}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue",+ "Properties": {"QueueName": {"Fn::Sub": "%s-${Env}"}, "VisibilityTimeout": %d}}}+ }+ """;+ request("CreateStack", stackName)+ .formParam("TemplateBody", template.formatted(queueName, 30))+ .formParam("Parameters.member.1.ParameterKey", "Env")+ .formParam("Parameters.member.1.ParameterValue", "dev")+ .when()+ .post("/")+ .then()+ .statusCode(200);+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());++ request("UpdateStack", stackName)+ .formParam("TemplateBody", template.formatted(queueName, 60))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Env] must have values"));+ request("UpdateStack", stackName)+ .formParam("UsePreviousTemplate", "true")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Env] must have values"));+ request("CreateChangeSet", stackName)+ .formParam("ChangeSetName", "omits-env")+ .formParam("ChangeSetType", "UPDATE")+ .formParam("TemplateBody", template.formatted(queueName, 60))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Env] must have values"));+ describeStacks(stackName).then()+ .statusCode(200)+ .body(containsString("<StackStatus>CREATE_COMPLETE</StackStatus>"))+ .body(containsString("<ParameterValue>dev</ParameterValue>"));++ request("CreateChangeSet", stackName)+ .formParam("ChangeSetName", "keeps-env")+ .formParam("ChangeSetType", "UPDATE")+ .formParam("TemplateBody", template.formatted(queueName, 45))+ .formParam("Parameters.member.1.ParameterKey", "Env")+ .formParam("Parameters.member.1.UsePreviousValue", "true")+ .when()+ .post("/")+ .then()+ .statusCode(200);++ request("UpdateStack", stackName)+ .formParam("TemplateBody", template.formatted(queueName, 60))+ .formParam("Parameters.member.1.ParameterKey", "Env")+ .formParam("Parameters.member.1.UsePreviousValue", "true")+ .when()+ .post("/")+ .then()+ .statusCode(200);+ assertEquals("UPDATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ assertEquals("60", visibilityTimeout(queueName + "-dev"));+ describeStacks(stackName).then()+ .statusCode(200)+ .body(containsString("<ParameterValue>dev</ParameterValue>"));+ } finally {+ deleteStack(stackName);+ }+ }++ /**+ * {@code UsePreviousValue} keeps a deployed value; on a parameter that has none, on a create or+ * for a parameter the update adds, it passes nothing, so the template's Default applies, or the+ * request is refused.+ */+ @Test+ void usePreviousValueWithNothingDeployedPassesNoValue() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-param-previous-" + suffix;+ String queueName = "param-previous-" + suffix;++ request("CreateStack", stackName)+ .formParam("TemplateBody", BLANK_ENV_TEMPLATE)+ .formParam("Parameters.member.1.ParameterKey", "Env")+ .formParam("Parameters.member.1.UsePreviousValue", "true")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Env] must have values"));++ request("CreateStack", stackName)+ .formParam("TemplateBody", """+ {"Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Properties": {"QueueName": "%s"}}}}+ """.formatted(queueName))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ String added = """+ {+ "Parameters": {"Added": {"Type": "String"%s}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue",+ "Properties": {"QueueName": "%s", "Tags": [{"Key": "added", "Value": {"Ref": "Added"}}]}}}+ }+ """;+ request("UpdateStack", stackName)+ .formParam("TemplateBody", added.formatted("", queueName))+ .formParam("Parameters.member.1.ParameterKey", "Added")+ .formParam("Parameters.member.1.UsePreviousValue", "true")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Added] must have values"));++ request("UpdateStack", stackName)+ .formParam("TemplateBody", added.formatted(", \"Default\": \"fallback\"", queueName))+ .formParam("Parameters.member.1.ParameterKey", "Added")+ .formParam("Parameters.member.1.UsePreviousValue", "true")+ .when()+ .post("/")+ .then()+ .statusCode(200);+ assertEquals("UPDATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ describeStacks(stackName).then()+ .statusCode(200)+ .body(containsString("<ParameterValue>fallback</ParameterValue>"));+ } finally {+ deleteStack(stackName);+ }+ }++ /**+ * A request its stack refuses outright gets that refusal, whatever its parameters: an update of+ * a stack that does not exist, whose UsePreviousValue has nothing to keep, and a create over a+ * name in use.+ */+ @Test+ void aRequestItsStackRefusesGetsThatRefusal() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String missing = "cfn-param-missing-stack-" + suffix;+ request("UpdateStack", missing)+ .formParam("TemplateBody", BLANK_ENV_TEMPLATE)+ .formParam("Parameters.member.1.ParameterKey", "Env")+ .formParam("Parameters.member.1.UsePreviousValue", "true")+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Stack with id " + missing + " does not exist"));++ String taken = "cfn-param-taken-" + suffix;+ request("CreateStack", taken)+ .formParam("TemplateBody", BLANK_ENV_TEMPLATE)+ .formParam("Parameters.member.1.ParameterKey", "Env")+ .formParam("Parameters.member.1.ParameterValue", "")+ .when()+ .post("/")+ .then()+ .statusCode(200);+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(taken).status());+ request("CreateStack", taken)+ .formParam("TemplateBody", BLANK_ENV_TEMPLATE)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("AlreadyExistsException"));+ } finally {+ deleteStack(taken);+ }+ }++ /**+ * A REVIEW_IN_PROGRESS placeholder refuses an update, so an update without a value gets that+ * refusal; a CREATE change set may attach to it, so one without a value gets the parameter error.+ */+ @Test+ void aPlaceholderStackRefusesTheUpdateButNotTheAttachingCreate() {+ String stackName = "cfn-param-placeholder-" + Long.toString(System.nanoTime(), 36);+ request("CreateChangeSet", stackName)+ .formParam("ChangeSetName", "first")+ .formParam("ChangeSetType", "CREATE")+ .formParam("TemplateBody", BLANK_ENV_TEMPLATE)+ .formParam("Parameters.member.1.ParameterKey", "Env")+ .formParam("Parameters.member.1.ParameterValue", "")+ .when()+ .post("/")+ .then()+ .statusCode(200);+ try {+ request("UpdateStack", stackName)+ .formParam("TemplateBody", BLANK_ENV_TEMPLATE)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message",+ containsString("is in REVIEW_IN_PROGRESS state and can not be updated."));++ request("CreateChangeSet", stackName)+ .formParam("ChangeSetName", "second")+ .formParam("ChangeSetType", "CREATE")+ .formParam("TemplateBody", BLANK_ENV_TEMPLATE)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Env] must have values"));+ } finally {+ deleteStack(stackName);+ }+ }++ /**+ * A nested stack is created with the values its resource passes, so a child parameter left+ * without one fails that resource, as the child's CreateStack would, and the parent rolls+ * back. The child stack is never created.+ */+ @Test+ void aNestedStackWithoutAValueFailsItsResource() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String bucket = "cfn-param-nested-" + suffix;+ String stackName = "cfn-param-nested-" + suffix;+ String templateUrl = putChildTemplate(bucket);+ try {+ request("CreateStack", stackName)+ .formParam("TemplateBody", parentTemplate(templateUrl, "{}"))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ CfnStackWaits.StackState state = CfnStackWaits.awaitStatus(stackName, "ROLLBACK_COMPLETE");+ assertEquals("Parameters: [Env] must have values", state.reason());+ request("DescribeStackEvents", stackName)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("<ResourceStatusReason>Parameters: [Env] must have values</ResourceStatusReason>"));+ describeStacks(stackName + "-Child").then().statusCode(400);+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ deleteChildTemplate(bucket);+ }+ }++ /**+ * A nested stack update that leaves a child parameter without a value fails the resource+ * before the child changes, and the parent rolls back with the child as it was.+ */+ @Test+ void aNestedStackUpdateWithoutAValueLeavesTheChild() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String bucket = "cfn-param-nested-update-" + suffix;+ String stackName = "cfn-param-nested-update-" + suffix;+ String templateUrl = putChildTemplate(bucket);+ try {+ request("CreateStack", stackName)+ .formParam("TemplateBody", parentTemplate(templateUrl, "{\"Env\": \"dev\"}"))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());++ request("UpdateStack", stackName)+ .formParam("TemplateBody", parentTemplate(templateUrl, "{\"Size\": \"2\"}"))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ CfnStackWaits.awaitStatus(stackName, "UPDATE_ROLLBACK_COMPLETE");+ request("DescribeStackEvents", stackName)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("<ResourceStatusReason>Parameters: [Env] must have values</ResourceStatusReason>"));+ describeStacks(stackName + "-Child").then()+ .statusCode(200)+ .body(containsString("<StackStatus>CREATE_COMPLETE</StackStatus>"))+ .body(containsString("<ParameterValue>dev</ParameterValue>"));+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ deleteChildTemplate(bucket);+ }+ }++ /**+ * The resource's Parameters resolve as a property value: an Fn::If choosing the whole map+ * passes the chosen one, and a value that is AWS::NoValue passes nothing, so the child's+ * Default applies.+ */+ @Test+ void aNestedStacksParametersResolveAsAPropertyValue() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String bucket = "cfn-param-nested-if-" + suffix;+ String stackName = "cfn-param-nested-if-" + suffix;+ String templateUrl = putChildTemplate(bucket);+ try {+ request("CreateStack", stackName)+ .formParam("TemplateBody", """+ {+ "Conditions": {"Always": {"Fn::Equals": ["a", "a"]}},+ "Resources": {+ "Child": {+ "Type": "AWS::CloudFormation::Stack",+ "Properties": {"TemplateURL": "%s", "Parameters": {"Fn::If": ["Always",+ {"Env": "dev", "Size": {"Ref": "AWS::NoValue"}}, {"Env": "prod"}]}}+ }+ }+ }+ """.formatted(templateUrl))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ describeStacks(stackName + "-Child").then()+ .statusCode(200)+ .body("**.find { it.ParameterKey == 'Env' }.ParameterValue", equalTo("dev"))+ .body("**.find { it.ParameterKey == 'Size' }.ParameterValue", equalTo("1"));+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ deleteChildTemplate(bucket);+ }+ }++ /**+ * A parameter definition an AWS::Include supplies is only known once execution merges it, so it+ * is not checked up front: a Default the snippet carries still applies. The section's other+ * parameters are checked as usual.+ */+ @Test+ void aParameterAnIncludeDefinesIsNotCheckedUpFront() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String bucket = "cfn-param-include-" + suffix;+ String stackName = "cfn-param-include-" + suffix;+ String queueName = "param-include-" + suffix;+ given().when().put("/" + bucket).then().statusCode(200);+ given().body("{\"Type\": \"String\", \"Default\": \"dev\"}")+ .when().put("/" + bucket + "/env.json").then().statusCode(200);+ try {+ request("CreateStack", stackName)+ .formParam("TemplateBody", """+ {+ "Parameters": {"Env": {"Fn::Transform": {"Name": "AWS::Include",+ "Parameters": {"Location": "s3://%s/env.json"}}}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue",+ "Properties": {"QueueName": {"Fn::Sub": "%s-${Env}"}}}}+ }+ """.formatted(bucket, queueName))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ getQueueUrl(queueName + "-dev").then().statusCode(200);++ request("CreateStack", stackName + "-other")+ .formParam("TemplateBody", """+ {+ "Parameters": {"Other": {"Type": "String"}, "Env": {"Fn::Transform": {"Name": "AWS::Include",+ "Parameters": {"Location": "s3://%s/env.json"}}}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue"}}+ }+ """.formatted(bucket))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("Parameters: [Other] must have values"));+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ given().when().delete("/" + bucket + "/env.json");+ given().when().delete("/" + bucket);+ }+ }++ /** Puts a child template declaring Env (no Default) and Size (Default 1) in a new bucket. */+ private static String putChildTemplate(String bucket) {+ given().when().put("/" + bucket).then().statusCode(200);+ given().contentType("application/json")+ .body("""+ {+ "Parameters": {"Env": {"Type": "String"}, "Size": {"Type": "Number", "Default": "1"}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue"}}+ }+ """)+ .when()+ .put("/" + bucket + "/child.json")+ .then()+ .statusCode(200);+ return "http://localhost/" + bucket + "/child.json";+ }++ private static void deleteChildTemplate(String bucket) {+ given().when().delete("/" + bucket + "/child.json");+ given().when().delete("/" + bucket);+ }++ private static String parentTemplate(String templateUrl, String parameters) {+ return """+ {+ "Resources": {+ "Child": {+ "Type": "AWS::CloudFormation::Stack",+ "Properties": {"TemplateURL": "%s", "Parameters": %s}+ }+ }+ }+ """.formatted(templateUrl, parameters);+ }++ private static RequestSpecification request(String action, String stackName) {+ return given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", action)+ .formParam("StackName", stackName);+ }++ private static Response describeStacks(String stackName) {+ return request("DescribeStacks", stackName).when().post("/");+ }++ private static void deleteStack(String stackName) {+ request("DeleteStack", stackName).when().post("/").then().statusCode(200);+ }++ private static Response getQueueUrl(String queueName) {+ return given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "GetQueueUrl")+ .formParam("QueueName", queueName)+ .when()+ .post("/");+ }++ private static String visibilityTimeout(String queueName) {+ String queueUrl = getQueueUrl(queueName).then().statusCode(200).extract().xmlPath()+ .getString("GetQueueUrlResponse.GetQueueUrlResult.QueueUrl");+ return given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "GetQueueAttributes")+ .formParam("QueueUrl", queueUrl)+ .formParam("AttributeName.1", "VisibilityTimeout")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().xmlPath()+ .getString("**.find { it.Name == 'VisibilityTimeout' }.Value");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceConditionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceConditionIntegrationTest.javaindex ba046b329b..bdb4a24e6a 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceConditionIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceConditionIntegrationTest.java@@ -4,11 +4,14 @@ import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.quarkus.test.junit.QuarkusTest;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.containsString;import static org.hamcrest.Matchers.equalTo;import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.fail;@QuarkusTest@@ -62,6 +65,90 @@ class CloudFormationResourceConditionIntegrationTest {.statusCode(400);}+ /**+ * Fn::FindInMap inside Fn::Equals resolves through the template's mappings. Read as an empty+ * string, a mapped "false" made UseCode true, and the bucket was named after the mapped value.+ */+ @ParameterizedTest+ @CsvSource({"false,us-east-1", "iad,iad"})+ void mappedConditionSelectsTheBucketName(String mappedValue, String expectedLocation) {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-mapped-condition-" + suffix;+ String prefix = "mapped-condition-" + suffix + "-";+ createStack(stackName, """+ {+ "Mappings": {"Locations": {"us-east-1": {"Code": "%s"}}},+ "Conditions": {+ "UseCode": {"Fn::Not": [{"Fn::Equals": [+ {"Fn::FindInMap": ["Locations", {"Ref": "AWS::Region"}, "Code"]}, "false"+ ]}]}+ },+ "Resources": {+ "Bucket": {+ "Type": "AWS::S3::Bucket",+ "Properties": {"BucketName": {"Fn::Join": ["", ["%s",+ {"Fn::If": ["UseCode",+ {"Fn::FindInMap": ["Locations", {"Ref": "AWS::Region"}, "Code"]},+ {"Ref": "AWS::Region"}]}+ ]]}}+ }+ }+ }+ """.formatted(mappedValue, prefix));+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ given().when().head("/" + prefix + expectedLocation).then().statusCode(200);+ given().when().head("/" + prefix + "false").then().statusCode(404);+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ }+ given().when().head("/" + prefix + expectedLocation).then().statusCode(404);+ }++ /**+ * The update's change-set preview and its execution evaluate the mapped condition as the+ * create does, so a mapping edit that flips it reaches the property chosen by its Fn::If.+ */+ @Test+ void mappedConditionIsEvaluatedAgainOnUpdate() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-mapped-update-" + suffix;+ String queueName = "mapped-update-" + suffix;+ String template = """+ {+ "Mappings": {"Locations": {"us-east-1": {"Code": "%s"}}},+ "Conditions": {+ "UseCode": {"Fn::Not": [{"Fn::Equals": [+ {"Fn::FindInMap": ["Locations", {"Ref": "AWS::Region"}, "Code"]}, "false"+ ]}]}+ },+ "Resources": {+ "Queue": {+ "Type": "AWS::SQS::Queue",+ "Properties": {"QueueName": "%s", "VisibilityTimeout": {"Fn::If": ["UseCode", 60, 30]}}+ }+ }+ }+ """;+ createStack(stackName, template.formatted("false", queueName));+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ assertEquals("30", visibilityTimeout(queueName));++ updateStack(stackName, template.formatted("iad", queueName));+ assertEquals("UPDATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ assertEquals("60", visibilityTimeout(queueName));++ updateStack(stackName, template.formatted("false", queueName));+ assertEquals("UPDATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ assertEquals("30", visibilityTimeout(queueName));+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ }+ }+@Testvoid createStack_skipsResourceWhenResourceLevelConditionIsFalse() {String suffix = Long.toString(System.nanoTime(), 36);@@ -581,6 +668,340 @@ class CloudFormationResourceConditionIntegrationTest {.post("/");}+ /**+ * A create's dependency preflight evaluates {@code AWS::StackId} as the id the stack is given,+ * so it agrees with the execution: a dependency on a resource the stack id excludes is refused+ * up front, and one on a resource it includes deploys.+ */+ @Test+ void aCreatesPreflightSeesTheStackIdItWillGet() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String template = """+ {+ "Conditions": {+ "NoId": {"Fn::Equals": [{"Ref": "AWS::StackId"}, ""]},+ "HasId": {"Fn::Not": [{"Condition": "NoId"}]}+ },+ "Resources": {+ "Dependency": {"Type": "AWS::SQS::Queue", "Condition": "%s",+ "Properties": {"QueueName": "%s-dependency"}},+ "Dependent": {"Type": "AWS::SQS::Queue", "DependsOn": "Dependency",+ "Properties": {"QueueName": "%s-dependent"}}+ }+ }+ """;+ String excluded = "cfn-stackid-excluded-" + suffix;+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", excluded)+ .formParam("TemplateBody", template.formatted("NoId", excluded, excluded))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", containsString("Unresolved resource dependencies"));++ String included = "cfn-stackid-included-" + suffix;+ createStack(included, template.formatted("HasId", included, included));+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(included).status());+ getQueueUrl(included + "-dependency").then().statusCode(200);+ getQueueUrl(included + "-dependent").then().statusCode(200);+ } finally {+ deleteStack(included);+ CfnStackWaits.awaitStackDeleted(included);+ }+ }++ /**+ * A create over a name in use is checked as the new stack it asks for, not as the stack that+ * holds the name, so a template that is valid for a new stack gets AlreadyExistsException.+ */+ @Test+ void aCreateOverATakenNameIsCheckedAsTheNewStack() {+ String stackName = "cfn-stackid-taken-" + Long.toString(System.nanoTime(), 36);+ createStack(stackName, """+ {"Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Properties": {"QueueName": "%s"}}}}+ """.formatted(stackName));+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ String takenId = given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DescribeStacks")+ .formParam("StackName", stackName)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().xmlPath().getString("**.find { it.name() == 'StackId' }");+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", """+ {+ "Conditions": {"NotTheTakenStack": {"Fn::Not": [{"Fn::Equals": [+ {"Ref": "AWS::StackId"}, "%s"]}]}},+ "Resources": {+ "Dependency": {"Type": "AWS::SQS::Queue", "Condition": "NotTheTakenStack"},+ "Dependent": {"Type": "AWS::SQS::Queue", "DependsOn": "Dependency"}+ }+ }+ """.formatted(takenId))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("AlreadyExistsException"));+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ }+ }++ /**+ * The change-set preview, the preflight and the execution all evaluate {@code AWS::StackName}+ * against the stack. Read as an empty string, the condition was false and the stack held no+ * resources; with only the preview reading it so, the update would skip the queue's edit.+ */+ @Test+ void stackNameConditionHoldsAcrossAnUpdateThatEditsItsResource() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-stackname-condition-" + suffix;+ String queueName = "stackname-condition-" + suffix;+ String template = """+ {+ "Conditions": {"IsThisStack": {"Fn::Equals": [{"Ref": "AWS::StackName"}, "%s"]}},+ "Resources": {+ "Queue": {+ "Type": "AWS::SQS::Queue", "Condition": "IsThisStack",+ "Properties": {"QueueName": "%s", "VisibilityTimeout": %d}+ }+ }+ }+ """;+ createStack(stackName, template.formatted(stackName, queueName, 30));+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ assertEquals("30", visibilityTimeout(queueName));++ updateStack(stackName, template.formatted(stackName, queueName, 60));+ assertEquals("UPDATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ assertEquals("60", visibilityTimeout(queueName));+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ }+ }++ /**+ * CloudFormation allows only Ref, Fn::FindInMap and the condition functions inside a+ * condition, so a template that uses Fn::ImportValue there is refused, even though the+ * exporting stack has the export.+ */+ @Test+ void importValueInAConditionIsRejectedAsUnsupported() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String exporter = "cfn-cond-exporter-" + suffix;+ String exportName = "cfn-cond-export-" + suffix;+ String importer = "cfn-cond-importer-" + suffix;+ createStack(exporter, """+ {"Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Properties": {"QueueName": "%s"}}},+ "Outputs": {"Flag": {"Value": "on", "Export": {"Name": "%s"}}}}+ """.formatted("cond-export-queue-" + suffix, exportName));+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(exporter).status());+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", importer)+ .formParam("TemplateBody", """+ {"Conditions": {"IsOn": {"Fn::Equals": [{"Fn::ImportValue": "%s"}, "on"]}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Condition": "IsOn"}}}+ """.formatted(exportName))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))+ .body("ErrorResponse.Error.Message",+ equalTo("Template error: Cannot use Fn::ImportValue in Conditions."));+ } finally {+ deleteStack(importer);+ deleteStack(exporter);+ CfnStackWaits.awaitStackDeleted(exporter);+ }+ }++ /** An import in an Fn::Or operand that evaluation never reaches is still a template error. */+ @Test+ void importValueInAConditionOperandEvaluationSkipsIsStillRejected() {+ String stackName = "cfn-cond-or-import-" + Long.toString(System.nanoTime(), 36);+ try {+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", """+ {"Conditions": {"IsOn": {"Fn::Or": [{"Fn::Equals": ["a", "a"]},+ {"Fn::Equals": [{"Fn::ImportValue": "never-resolved"}, "on"]}]}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Condition": "IsOn"}}}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))+ .body("ErrorResponse.Error.Message",+ equalTo("Template error: Cannot use Fn::ImportValue in Conditions."));+ } finally {+ deleteStack(stackName);+ }+ }++ /**+ * A SAM template's conditions are checked after the transform, so an import there fails the+ * change set with the template error, as a non-string condition reference does.+ */+ @Test+ void importValueInASamTemplateConditionFailsTheChangeSet() {+ String stackName = "cfn-cond-sam-import-" + Long.toString(System.nanoTime(), 36);+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateChangeSet")+ .formParam("StackName", stackName)+ .formParam("ChangeSetName", "deploy")+ .formParam("ChangeSetType", "CREATE")+ .formParam("TemplateBody", """+ {"Transform": "AWS::Serverless-2016-10-31",+ "Conditions": {"IsOn": {"Fn::Equals": [{"Fn::ImportValue": "never-resolved"}, "on"]}},+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Condition": "IsOn"}}}+ """)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ try {+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DescribeChangeSet")+ .formParam("StackName", stackName)+ .formParam("ChangeSetName", "deploy")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeChangeSetResponse.DescribeChangeSetResult.Status", equalTo("FAILED"))+ .body("DescribeChangeSetResponse.DescribeChangeSetResult.StatusReason",+ equalTo("Template error: Cannot use Fn::ImportValue in Conditions."));+ } finally {+ deleteStack(stackName);+ }+ }++ /**+ * {@code AWS::NotificationARNs} is the empty list, in a condition and in an output: Floci keeps+ * no notification ARNs, and the template engine would otherwise answer the Ref with its name.+ */+ @Test+ void notificationArnsAreAnEmptyList() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-notification-arns-" + suffix;+ String queueName = "notification-arns-" + suffix;+ createStack(stackName, """+ {+ "Conditions": {+ "HasNotifications": {"Fn::Not": [{"Fn::Equals": [+ {"Fn::Join": [",", {"Ref": "AWS::NotificationARNs"}]}, ""]}]}+ },+ "Resources": {+ "Notified": {"Type": "AWS::SQS::Queue", "Condition": "HasNotifications",+ "Properties": {"QueueName": "%s-notified"}},+ "Always": {"Type": "AWS::SQS::Queue", "Properties": {"QueueName": "%s-always"}}+ },+ "Outputs": {"Arns": {"Value": {"Fn::Join": [",", ["arns", {"Fn::Join": [",",+ {"Ref": "AWS::NotificationARNs"}]}]]}}}+ }+ """.formatted(queueName, queueName));+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ getQueueUrl(queueName + "-always").then().statusCode(200);+ getQueueUrl(queueName + "-notified").then().statusCode(400);+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DescribeStacks")+ .formParam("StackName", stackName)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("**.find { it.OutputKey == 'Arns' }.OutputValue", equalTo("arns,"));+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ }+ }++ /**+ * A condition operand the template engine cannot resolve, here an Fn::Sub whose template is not+ * a string, compares as an empty string, as it did before conditions went through the engine:+ * the stack deploys, and the dependency checks still run, rather than the request failing with+ * a 500 or the stack with the engine's exception.+ */+ @Test+ void aConditionOperandTheEngineCannotResolveComparesAsEmpty() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "cfn-cond-malformed-sub-" + suffix;+ String queueName = "cond-malformed-sub-" + suffix;+ String condition = """+ "Conditions": {"IsBlank": {"Fn::Equals": [{"Fn::Sub": [{"Ref": "AWS::Region"}, {}]}, ""]}}""";+ createStack(stackName, """+ {%s,+ "Resources": {"Queue": {"Type": "AWS::SQS::Queue", "Condition": "IsBlank",+ "Properties": {"QueueName": "%s"}}}}+ """.formatted(condition, queueName));+ try {+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stackName).status());+ getQueueUrl(queueName).then().statusCode(200);+ } finally {+ deleteStack(stackName);+ CfnStackWaits.awaitStackDeleted(stackName);+ }++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName + "-cycle")+ .formParam("TemplateBody", """+ {%s,+ "Resources": {+ "A": {"Type": "AWS::SQS::Queue", "DependsOn": "B"},+ "B": {"Type": "AWS::SQS::Queue", "DependsOn": "A"}}}+ """.formatted(condition))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Message", containsString("Circular dependency between resources"));+ }++ private static String visibilityTimeout(String queueName) {+ String queueUrl = getQueueUrl(queueName).then().statusCode(200).extract().xmlPath()+ .getString("GetQueueUrlResponse.GetQueueUrlResult.QueueUrl");+ return given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "GetQueueAttributes")+ .formParam("QueueUrl", queueUrl)+ .formParam("AttributeName.1", "VisibilityTimeout")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().xmlPath()+ .getString("**.find { it.Name == 'VisibilityTimeout' }.Value");+ }+@Testvoid createStack_failsWhenResourceReferencesConditionFalseResourceViaGetAtt() {// Verified against real AWS: an unguarded Fn::GetAtt to a condition-false resource isdiff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationServiceManagedStackSetsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationServiceManagedStackSetsIntegrationTest.javaindex ba517ec76b..39e01962a5 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationServiceManagedStackSetsIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationServiceManagedStackSetsIntegrationTest.java@@ -381,6 +381,46 @@ class CloudFormationServiceManagedStackSetsIntegrationTest {assertQueueAbsent(account, queue);}+ @Test+ void anOrganizationalUnitThatCannotBeResolvedFailsTheOperation() {+ // Resolving the targets is part of the operation: a target that fails ends it FAILED rather+ // than leave it RUNNING, which would refuse every later operation on the stack set.+ String management = "646464646464";+ organizations(management, "CreateOrganization", "{\"FeatureSet\":\"ALL\"}")+ .post("/").then().statusCode(200);+ String rootId = organizations(management, "ListRoots", "{}")+ .post("/").then().statusCode(200)+ .extract().jsonPath().getString("Roots[0].Id");+ cloudFormation(management, "ActivateOrganizationsAccess")+ .post("/").then().statusCode(200);++ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String stackSet = "missing-ou-" + suffix;+ cloudFormation(management, "CreateStackSet")+ .formParam("StackSetName", stackSet)+ .formParam("TemplateBody", queueTemplate("missing-ou-q-" + suffix))+ .formParam("PermissionModel", "SERVICE_MANAGED")+ .post("/").then().statusCode(200);++ cloudFormation(management, "CreateStackInstances")+ .formParam("StackSetName", stackSet)+ .formParam("DeploymentTargets.OrganizationalUnitIds.member.1", "ou-zzzz-zzzzzzzz")+ .formParam("Regions.member.1", REGION)+ .post("/").then().statusCode(400)+ .body(containsString("OrganizationalUnitNotFoundException"));+ cloudFormation(management, "ListStackSetOperations")+ .formParam("StackSetName", stackSet)+ .post("/").then().statusCode(200)+ .body(containsString("<Status>FAILED</Status>"))+ .body(not(containsString("<Status>RUNNING</Status>")));++ cloudFormation(management, "CreateStackInstances")+ .formParam("StackSetName", stackSet)+ .formParam("DeploymentTargets.OrganizationalUnitIds.member.1", rootId)+ .formParam("Regions.member.1", REGION)+ .post("/").then().statusCode(200);+ }+@Testvoid activateOrganizationsAccessRequiresAllFeatures() {String management = "939393939393";diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationStackSetsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationStackSetsIntegrationTest.javaindex 5d6682f70d..8463b391b2 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationStackSetsIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationStackSetsIntegrationTest.java@@ -751,6 +751,249 @@ class CloudFormationStackSetsIntegrationTest {assertQueueAbsent(ACCOUNT_C, dependent);}+ @Test+ void createStackSetWithoutAParameterValueIsRefused() {+ // Every instance is deployed with the stack set's parameters, so a declared one the stack+ // set has no value for is refused up front, as a stack's CreateStack refuses it.+ String setName = "noval-" + UUID.randomUUID().toString().substring(0, 8);+ String queue = "noval-q-" + UUID.randomUUID().toString().substring(0, 8);+ String template = """+ {"Parameters":{"Suffix":{"Type":"String"}},+ "Resources":{"Q":{"Type":"AWS::SQS::Queue","Properties":{"QueueName":{"Fn::Sub":"%s-${Suffix}"}}}}}+ """.formatted(queue);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStackSet")+ .formParam("StackSetName", setName)+ .formParam("TemplateBody", template)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(400)+ .body(containsString("<Code>ValidationError</Code>"))+ .body(containsString("<Message>Parameters: [Suffix] must have values</Message>"));++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DescribeStackSet")+ .formParam("StackSetName", setName)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(404)+ .body(containsString("StackSetNotFoundException"));++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStackSet")+ .formParam("StackSetName", setName)+ .formParam("TemplateBody", template)+ .formParam("Parameters.member.1.ParameterKey", "Suffix")+ .formParam("Parameters.member.1.ParameterValue", "b")+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStackInstances")+ .formParam("StackSetName", setName)+ .formParam("Accounts.member.1", ACCOUNT_B)+ .formParam("Regions.member.1", REGION)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200);+ assertQueueVisible(ACCOUNT_B, queue + "-b");+ }++ @Test+ void updateStackSetWithoutAParameterValueChangesNothing() {+ // Checked against the template and parameters the update would leave the stack set with,+ // before either changes or an operation is recorded.+ String setName = "noval-update-" + UUID.randomUUID().toString().substring(0, 8);+ String queue = "noval-update-q-" + UUID.randomUUID().toString().substring(0, 8);+ String template = """+ {"Parameters":{"Suffix":{"Type":"String"}},+ "Resources":{"Q":{"Type":"AWS::SQS::Queue","Properties":{"QueueName":{"Fn::Sub":"%s-${Suffix}"}}}}}+ """.formatted(queue);+ String withExtra = """+ {"Parameters":{"Suffix":{"Type":"String"},"Extra":{"Type":"String"}},+ "Resources":{"Q":{"Type":"AWS::SQS::Queue","Properties":{"QueueName":{"Fn::Sub":"%s-${Suffix}"},+ "Tags":[{"Key":"extra","Value":{"Ref":"Extra"}}]}}}}+ """.formatted(queue);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStackSet")+ .formParam("StackSetName", setName)+ .formParam("TemplateBody", template)+ .formParam("Parameters.member.1.ParameterKey", "Suffix")+ .formParam("Parameters.member.1.ParameterValue", "a")+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200);+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStackInstances")+ .formParam("StackSetName", setName)+ .formParam("Accounts.member.1", ACCOUNT_B)+ .formParam("Regions.member.1", REGION)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200);+ assertQueueVisible(ACCOUNT_B, queue + "-a");++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "UpdateStackSet")+ .formParam("StackSetName", setName)+ .formParam("TemplateBody", withExtra)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(400)+ .body(containsString("<Message>Parameters: [Extra] must have values</Message>"));++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DescribeStackSet")+ .formParam("StackSetName", setName)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200)+ .body(not(containsString("Extra")));+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "ListStackSetOperations")+ .formParam("StackSetName", setName)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200)+ .body(not(containsString("<Action>UPDATE</Action>")));++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "UpdateStackSet")+ .formParam("StackSetName", setName)+ .formParam("TemplateBody", withExtra)+ .formParam("Parameters.member.1.ParameterKey", "Suffix")+ .formParam("Parameters.member.1.UsePreviousValue", "true")+ .formParam("Parameters.member.2.ParameterKey", "Extra")+ .formParam("Parameters.member.2.ParameterValue", "x")+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200);+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "ListStackSetOperations")+ .formParam("StackSetName", setName)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200)+ .body(containsString("<Action>UPDATE</Action>"))+ .body(not(containsString("<Status>FAILED</Status>")));+ }++ @Test+ void updateStackSetUsePreviousValueKeepsAValueTheStackSetTookFromItsDefault() {+ // A stack set keeps only the values it was given, so UsePreviousValue also reads the+ // previous template's Default: the instances deployed with it, and an update that drops+ // that Default keeps them on it.+ String setName = "upv-default-" + UUID.randomUUID().toString().substring(0, 8);+ String queue = "upv-default-q-" + UUID.randomUUID().toString().substring(0, 8);+ String template = """+ {"Parameters":{"Suffix":{"Type":"String"%s}},+ "Resources":{"Q":{"Type":"AWS::SQS::Queue","Properties":{"QueueName":{"Fn::Sub":"%s-${Suffix}"}}}}}+ """;++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStackSet")+ .formParam("StackSetName", setName)+ .formParam("TemplateBody", template.formatted(",\"Default\":\"d1\"", queue))+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200);+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStackInstances")+ .formParam("StackSetName", setName)+ .formParam("Accounts.member.1", ACCOUNT_B)+ .formParam("Regions.member.1", REGION)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200);+ assertQueueVisible(ACCOUNT_B, queue + "-d1");++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "UpdateStackSet")+ .formParam("StackSetName", setName)+ .formParam("TemplateBody", template.formatted("", queue))+ .formParam("Parameters.member.1.ParameterKey", "Suffix")+ .formParam("Parameters.member.1.UsePreviousValue", "true")+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200);+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DescribeStackSet")+ .formParam("StackSetName", setName)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200)+ .body(containsString("<ParameterValue>d1</ParameterValue>"));+ assertQueueVisible(ACCOUNT_B, queue + "-d1");+ }++ @Test+ void createStackInstancesThatIsRefusedFailsItsOperation() {+ // An instance whose change set is refused fails the operation instead of leaving it+ // RUNNING, which would refuse every later operation on the stack set.+ String setName = "refused-op-" + UUID.randomUUID().toString().substring(0, 8);+ String conditional = "refused-c-" + UUID.randomUUID().toString().substring(0, 8);+ String dependent = "refused-d-" + UUID.randomUUID().toString().substring(0, 8);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStackSet")+ .formParam("StackSetName", setName)+ .formParam("TemplateBody", conditionalDependentTemplate(ACCOUNT_B, conditional, dependent))+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStackInstances")+ .formParam("StackSetName", setName)+ .formParam("Accounts.member.1", ACCOUNT_C)+ .formParam("Regions.member.1", REGION)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(400)+ .body(containsString("Unresolved resource dependencies"));+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "ListStackSetOperations")+ .formParam("StackSetName", setName)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200)+ .body(containsString("<Status>FAILED</Status>"))+ .body(not(containsString("<Status>RUNNING</Status>")));++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStackInstances")+ .formParam("StackSetName", setName)+ .formParam("Accounts.member.1", ACCOUNT_B)+ .formParam("Regions.member.1", REGION)+ .header("Authorization", auth(ADMIN, "cloudformation"))+ .when().post("/")+ .then().statusCode(200);+ assertQueueVisible(ACCOUNT_B, conditional);+ assertQueueVisible(ACCOUNT_B, dependent);+ }+@Testvoid createStackInstancesRejectsInvalidAccountBeforeDeployment() {String setName = "invalid-account-" + UUID.randomUUID().toString().substring(0, 8);