Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudformation): refuse a template that holds a null value (#6071)
Alessandro Lattao5fa67625c11a
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationCognitoResourceServerTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationCognitoResourceServerTest.javaindex 14b18eafbb..51a5263639 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationCognitoResourceServerTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationCognitoResourceServerTest.java@@ -274,18 +274,21 @@ class CloudFormationCognitoResourceServerTest {@ParameterizedTest@ValueSource(booleans = {false, true})- @DisplayName("Explicit and resolved null Scopes fail without clearing the existing server")+ @DisplayName("Explicit and resolved null Scopes are refused without touching the existing server")void nullScopesUpdatesPreserveTheExistingConfiguration(boolean conditional) throws Exception {String identifier = stackName + "-api";List<Parameter> original = parameters(identifier, p1, "Original API", "read", "Read access", true, false, false);createStack(original);String invalidTemplate = nullScopesTemplate(conditional);+ String path = conditional ? "/Resources/Server/Type/Scopes/Fn::If/1" : "/Resources/Server/Type/Scopes";- cfn.updateStack(r -> r.stackName(stackName).templateBody(invalidTemplate)- .parameters(parameters(identifier, p1, "Changed API", "write", "Write access", true, false, false)));- awaitStatus("UPDATE_ROLLBACK_COMPLETE");+ // As on AWS, a template holding a null is refused when the update is requested.+ assertThatThrownBy(() -> cfn.updateStack(r -> r.stackName(stackName).templateBody(invalidTemplate)+ .parameters(parameters(identifier, p1, "Changed API", "write", "Write access", true, false, false))))+ .isInstanceOfSatisfying(CloudFormationException.class, e -> assertThat(e.awsErrorDetails().errorMessage())+ .isEqualTo("[" + path + "] 'null' values are not allowed in templates"));+ awaitStatus("CREATE_COMPLETE");- assertThat(failedEvents()).contains("Scopes must be a list");assertIdentity(identifier);assertServer(p1, identifier, "Original API", "read", "Read access");updateStack(parameters(identifier, p1, "Recovered API", "write", "Write access", true, false, false),diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationNullValuesTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationNullValuesTest.javanew file mode 100644index 0000000000..fa85641fa9--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationNullValuesTest.java@@ -0,0 +1,70 @@+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 static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++@DisplayName("CloudFormation templates holding a null value")+class CloudFormationNullValuesTest {++ private static CloudFormationClient cfn;+ private String stackName;++ @BeforeAll+ static void clients() {+ cfn = TestFixtures.cloudFormationClient();+ }++ @BeforeEach+ void setup() {+ stackName = TestFixtures.uniqueName("compat-cfn-null");+ }++ /** The stack is never created, and DeleteStack of a stack that does not exist succeeds; this covers a regression. */+ @AfterEach+ void cleanup() {+ cfn.deleteStack(r -> r.stackName(stackName));+ }++ @AfterAll+ static void closeClients() {+ cfn.close();+ }++ @Test+ @DisplayName("ValidateTemplate and CreateStack name the first null, and nothing is created")+ void aNullValueIsRefused() {+ String template = """+ Resources:+ Queue:+ Type: AWS::SQS::Queue+ Properties:+ QueueName:+ DelaySeconds: ~+ """;+ String message = "[/Resources/Queue/Type/QueueName] 'null' values are not allowed in templates";++ assertThatThrownBy(() -> cfn.validateTemplate(r -> r.templateBody(template)))+ .isInstanceOfSatisfying(CloudFormationException.class, e -> {+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("ValidationError");+ assertThat(e.awsErrorDetails().errorMessage()).isEqualTo(message);+ });+ assertThatThrownBy(() -> cfn.createStack(r -> r.stackName(stackName).templateBody(template)))+ .isInstanceOfSatisfying(CloudFormationException.class, e -> {+ assertThat(e.awsErrorDetails().errorCode()).isEqualTo("ValidationError");+ assertThat(e.awsErrorDetails().errorMessage()).isEqualTo(message);+ });++ assertThatThrownBy(() -> cfn.describeStacks(r -> r.stackName(stackName)))+ .isInstanceOf(CloudFormationException.class)+ .hasMessageContaining("does not exist");+ }+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationS3VectorsTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationS3VectorsTest.javaindex 6eba8e4ad2..23a8f0aaf3 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationS3VectorsTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationS3VectorsTest.java@@ -212,7 +212,6 @@ class CloudFormationS3VectorsTest {Arguments.of("float32", "manhattan", List.of(), "distanceMetric"),Arguments.of("float32", "cosine", List.of(""), "NonFilterableMetadataKeys"),Arguments.of("float32", "cosine", List.of(" "), "NonFilterableMetadataKeys"),- Arguments.of("float32", "cosine", Collections.singletonList(null), "NonFilterableMetadataKeys"),Arguments.of("float32", "cosine", List.of("a".repeat(64)), "NonFilterableMetadataKeys"),Arguments.of("float32", "cosine", Collections.nCopies(11, "key"), "NonFilterableMetadataKeys"));}@@ -418,7 +417,7 @@ class CloudFormationS3VectorsTest {}@ParameterizedTest- @ValueSource(strings = {"absent", "null", "{}", "{\"SseType\":null}", "{\"SseType\":\"AES256\"}"})+ @ValueSource(strings = {"absent", "{}", "{\"SseType\":\"AES256\"}"})void indexesInheritBucketEncryptionUnlessExplicitlyOverridden(String configuration) throws Exception {String name = TestFixtures.uniqueName("cfn-vectors-inherit");ObjectNode template = (ObjectNode) MAPPER.readTree(TEMPLATE);diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.mdindex 584783270e..f0394ceddf 100644--- a/docs/services/cloudformation.md+++ b/docs/services/cloudformation.md@@ -24,7 +24,7 @@| `ListStackResources` | List resource summaries || `GetTemplate` | Retrieve the template body || `GetTemplateSummary` | Summarize a template's Parameters, Resources and Transform sections, by StackName, TemplateBody or TemplateURL |-| `ValidateTemplate` | Accepted; returns success without validating (stub) |+| `ValidateTemplate` | Refuses a template holding a `null` value (see [Null values](#null-values)); otherwise returns success without validating further || `ListStacks` | List stacks by status || `ListExports` | - || `SetStackPolicy` | Accepted; no-op (stub — stack policies are not enforced) |@@ -631,6 +631,29 @@ intrinsic's reference page:or Fn::GetAZs.` In a nested stack's template the same rules fail the child's resource with thesame message when the child is created, and the parent rolls back.+## Null values++As on AWS, a template holding a `null` anywhere (JSON `null`, YAML `~` or a key with no value) is+refused when `ValidateTemplate`, `CreateStack`, `UpdateStack` or `CreateChangeSet` is requested,+before anything is created, with `ValidationError` `[<path>] 'null' values are not allowed in+templates`. The path names the first `null` in document order, as AWS's does: below a resource's+`Properties` it says `Type` where `Properties` would be (`[/Resources/Queue/Type/QueueName]`), a+`null` `Properties` is `[/Resources/Queue/Properties]`, list entries are numbered from 0, and an+intrinsic's arguments are part of the path (`[/Resources/Queue/Type/QueueName/Fn::Join/1/1]`).+A template that is null as a whole (`null`, `~`) is refused with `Template format error: At least+one Resources member must be defined.` `CreateStackSet` and `UpdateStackSet` refuse a template+holding a `null` before the stack set keeps it, with the same message followed by the service+exception's details, as on AWS.++## Template URLs++A `TemplateURL` names an object in Floci's S3, virtual-hosted or path-style. As on AWS, one whose+bucket or object does not exist is refused by `ValidateTemplate`, `CreateStack` and+`GetTemplateSummary` alike, with `ValidationError` `S3 error: The specified bucket does not exist`+or `S3 object does not exist. Bucket: <bucket>, Key: <key>. Error: NoSuchKey`. AWS also refuses a+URL that is not an S3 one (`TemplateURL must be a supported URL.`); Floci reads any host as S3, so+the URL can name Floci by whatever host reaches it.+## Template ParametersParameters passed to `CreateStack` / `UpdateStack` (and echoed back by `DescribeStacks`) are resolveddiff --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 5257268059..34daa043d0 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@@ -581,6 +581,11 @@ public class CloudFormationQueryHandler {// ── ValidateTemplate ──────────────────────────────────────────────────────private Response validateTemplate(MultivaluedMap<String, String> params) {+ try {+ cfnService.validateTemplate(params.getFirst("TemplateBody"), params.getFirst("TemplateURL"));+ } catch (AwsException e) {+ return xmlError(e.getErrorCode(), e.getMessage(), e.getHttpStatus());+ }String xml = new XmlBuilder().start("ValidateTemplateResponse", CF_NS).start("ValidateTemplateResult")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 3afc5c2635..c322aa71ad 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@@ -401,6 +401,7 @@ public class CloudFormationService implements ResourceProvider {Map<String, String> tags, String region, String accountId,boolean attachToReviewInProgressStack, boolean fromPreviousTemplate) {String resolvedTemplate = resolveTemplate(templateBody, templateUrl);+ requireNoNullValues(resolvedTemplate);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.@@ -3974,6 +3975,18 @@ public class CloudFormationService implements ResourceProvider {try {S3Object obj = s3Service.getObject(ref.bucket(), ref.key());return new String(obj.getData());+ } catch (AwsException e) {+ // Measured (eu-west-1, 2026-10-20), alike for ValidateTemplate, CreateStack and GetTemplateSummary.+ if ("NoSuchBucket".equals(e.getErrorCode())) {+ throw new AwsException("ValidationError", "S3 error: The specified bucket does not exist\nFor more"+ + " information check http://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html", 400);+ }+ if ("NoSuchKey".equals(e.getErrorCode())) {+ throw new AwsException("ValidationError", "S3 object does not exist. Bucket: " + ref.bucket()+ + ", Key: " + ref.key() + ". Error: NoSuchKey", 400);+ }+ LOG.errorv("Failed to fetch CloudFormation template from {0}: {1}", url, e.getMessage());+ throw new RuntimeException("Failed to fetch CloudFormation template from " + url + ": " + e.getMessage(), e);} catch (Exception e) {LOG.errorv("Failed to fetch CloudFormation template from {0}: {1}", url, e.getMessage());throw new RuntimeException("Failed to fetch CloudFormation template from " + url + ": " + e.getMessage(), e);@@ -4480,6 +4493,68 @@ public class CloudFormationService implements ResourceProvider {return value;}+ /** ValidateTemplate's check of a template: the null values AWS refuses there. */+ public void validateTemplate(String templateBody, String templateUrl) {+ String resolvedBody = resolveTemplateBody(templateBody, templateUrl);+ if (resolvedBody != null) {+ requireNoNullValues(resolvedBody);+ }+ }++ /**+ * Refuses a template that holds a null value anywhere, as AWS does when ValidateTemplate,+ * CreateStack, UpdateStack or CreateChangeSet is requested, before anything is created+ * (measured, eu-west-1, 2026-10-20): ValidationError "[path] 'null' values are not allowed in+ * templates", naming the first null in document order. Below a resource's Properties the path+ * says Type where Properties would be, as AWS's does; a null Properties is named as it is.+ */+ void requireNoNullValues(String templateBody) {+ JsonNode parsed;+ try {+ parsed = parseTemplate(templateBody);+ } catch (Exception e) {+ // As validateResourceDependencies: a template that does not parse fails where it is+ // processed, with the parser's error.+ LOG.debugv("Skipping null value validation; template did not parse: {0}", e.getMessage());+ return;+ }+ if (parsed == null || parsed.isNull()) {+ // Measured: a template that is null as a whole ("null", "~") lacks its resources first.+ throw new AwsException("ValidationError",+ "Template format error: At least one Resources member must be defined.", 400);+ }+ String path = firstNullPath(parsed, "", false);+ if (path != null) {+ throw new AwsException("ValidationError",+ "[" + path + "] 'null' values are not allowed in templates", 400);+ }+ }++ private static String firstNullPath(JsonNode node, String path, boolean isResource) {+ if (node.isNull()) {+ return path;+ }+ if (node.isObject()) {+ boolean childIsResource = "/Resources".equals(path);+ for (Map.Entry<String, JsonNode> member : node.properties()) {+ String name = isResource && "Properties".equals(member.getKey()) && !member.getValue().isNull()+ ? "Type" : member.getKey();+ String found = firstNullPath(member.getValue(), path + "/" + name, childIsResource);+ if (found != null) {+ return found;+ }+ }+ } else if (node.isArray()) {+ for (int i = 0; i < node.size(); i++) {+ String found = firstNullPath(node.get(i), path + "/" + i, false);+ if (found != null) {+ return found;+ }+ }+ }+ return null;+ }+/*** The places AWS refuses {@code Fn::GetStackOutput} when the stack operation is requested,* before anything runs (measured, eu-west-1, 2026-10-04 and 2026-10-17): anywhere in thediff --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 7bb8a230e9..d295d9850b 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@@ -133,6 +133,7 @@ public class StackSetService implements PassedRoleLookup {if ("SELF_MANAGED".equals(resolvedPermissionModel) && (autoDeploymentEnabled || retainStacksOnAccountRemoval)) {throw new AwsException("ValidationError", "AutoDeployment is valid only for SERVICE_MANAGED StackSets.", 400);}+ requireNoNullValues(templateBody);// 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);@@ -210,8 +211,9 @@ public class StackSetService implements PassedRoleLookup {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(),+ String keptTemplate = templateBody != null && !templateBody.isBlank() ? templateBody : ss.getTemplateBody();+ requireNoNullValues(keptTemplate);+ cfnService.requireParameterValues(keptTemplate,parameters != null && !parameters.isEmpty() ? parameters : ss.getParameters());String operationId = reserveOperation(name, "UPDATE", requestedOperationId).getOperationId();if (templateBody != null && !templateBody.isBlank()) {@@ -721,6 +723,20 @@ public class StackSetService implements PassedRoleLookup {return anyFailed ? "FAILED" : "SUCCEEDED";}+ /**+ * Refuses a template holding a null value before the stack set stores it, as CreateStackSet and+ * UpdateStackSet do (measured, eu-west-1, 2026-10-20). StackSets passes CloudFormation's message+ * on with the details of the service exception it came in.+ */+ private void requireNoNullValues(String templateBody) {+ try {+ cfnService.requireNoNullValues(templateBody);+ } catch (AwsException e) {+ throw new AwsException(e.getErrorCode(), CloudFormationTemplateEngine.sdkErrorMessage(+ e.getMessage(), "AmazonCloudFormation", e.getHttpStatus(), e.getErrorCode()), e.getHttpStatus());+ }+ }+private StackSet getStackSetOrThrow(String name) {return stackSets.get(name).orElseThrow(() -> new AwsException("StackSetNotFoundException",diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationNullValuesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationNullValuesIntegrationTest.javanew file mode 100644index 0000000000..26fa02994e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationNullValuesIntegrationTest.java@@ -0,0 +1,186 @@+package io.github.hectorvent.floci.services.cloudformation;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.Arguments;+import org.junit.jupiter.params.provider.MethodSource;+import org.junit.jupiter.params.provider.ValueSource;++import java.util.List;+import java.util.stream.Stream;++import static io.restassured.RestAssured.given;+import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.allOf;+import static org.hamcrest.Matchers.endsWith;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.startsWith;+import static org.junit.jupiter.api.Assertions.assertEquals;++/**+ * A template holding a null value is refused when the operation is requested, before anything is+ * created. Measured on CloudFormation (eu-west-1, 2026-10-20): ValidateTemplate, CreateStack,+ * UpdateStack and CreateChangeSet answer 400 ValidationError "[path] 'null' values are not allowed+ * in templates", the path naming the first null in document order, with Type where a resource's+ * Properties would be.+ */+@QuarkusTest+class CloudFormationNullValuesIntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20261020/us-east-1/cloudformation/aws4_request";++ @ParameterizedTest(name = "{0}")+ @MethodSource("nullValues")+ void aNullValueIsRefusedWhereAwsNamesIt(String where, String template, String path) {+ String message = "[" + path + "] 'null' values are not allowed in templates";+ String name = "cfn-null-" + System.nanoTime();++ assertRefused(request("ValidateTemplate", null, template), message);+ assertRefused(request("CreateStack", name, template), message);+ given().contentType("application/x-www-form-urlencoded").header("Authorization", AUTH)+ .formParam("Action", "DescribeStacks").formParam("StackName", name)+ .when().post("/").then().statusCode(400);+ }++ static Stream<Arguments> nullValues() {+ return Stream.of(+ Arguments.of("a property", queue("{\"QueueName\": null}"), "/Resources/Q/Type/QueueName"),+ Arguments.of("a nested member", queue("{\"RedrivePolicy\": {\"deadLetterTargetArn\": null, \"maxReceiveCount\": 3}}"),+ "/Resources/Q/Type/RedrivePolicy/deadLetterTargetArn"),+ Arguments.of("a list item's member", queue("{\"Tags\": [{\"Key\": \"k\", \"Value\": null}]}"),+ "/Resources/Q/Type/Tags/0/Value"),+ Arguments.of("a list entry", "{\"Resources\": {\"T\": {\"Type\": \"AWS::SNS::Topic\", \"Properties\": {\"Subscription\": [null]}}}}",+ "/Resources/T/Type/Subscription/0"),+ Arguments.of("Properties", "{\"Resources\": {\"Q\": {\"Type\": \"AWS::SQS::Queue\", \"Properties\": null}}}",+ "/Resources/Q/Properties"),+ Arguments.of("Type", "{\"Resources\": {\"Q\": {\"Type\": null}}}", "/Resources/Q/Type"),+ Arguments.of("Resources", "{\"Resources\": null}", "/Resources"),+ Arguments.of("an intrinsic's argument", queue("{\"QueueName\": {\"Fn::Join\": [\"-\", [\"a\", null]]}}"),+ "/Resources/Q/Type/QueueName/Fn::Join/1/1"),+ Arguments.of("an output's value", "{\"Resources\": {\"H\": {\"Type\": \"AWS::CloudFormation::WaitConditionHandle\"}},"+ + " \"Outputs\": {\"O\": {\"Value\": null}}}", "/Outputs/O/Value"),+ Arguments.of("a parameter's default", "{\"Parameters\": {\"P\": {\"Type\": \"String\", \"Default\": null}},"+ + " \"Resources\": {\"H\": {\"Type\": \"AWS::CloudFormation::WaitConditionHandle\"}}}", "/Parameters/P/Default"),+ Arguments.of("a resource's metadata", "{\"Resources\": {\"H\": {\"Type\": \"AWS::CloudFormation::WaitConditionHandle\","+ + " \"Metadata\": {\"m\": null}}}}", "/Resources/H/Metadata/m"),+ Arguments.of("two nulls", queue("{\"QueueName\": null, \"DelaySeconds\": null}"), "/Resources/Q/Type/QueueName"),+ Arguments.of("YAML, empty and ~", "Resources:\n Q:\n Type: AWS::SQS::Queue\n Properties:\n"+ + " QueueName:\n DelaySeconds: ~\n", "/Resources/Q/Type/QueueName"));+ }++ @Test+ void anUpdateAndAChangeSetAreRefusedToo() {+ String name = "cfn-null-update-" + System.nanoTime();+ given().contentType("application/x-www-form-urlencoded").header("Authorization", AUTH)+ .formParam("Action", "CreateStack").formParam("StackName", name)+ .formParam("TemplateBody", "{\"Resources\": {\"H\": {\"Type\": \"AWS::CloudFormation::WaitConditionHandle\"}}}")+ .when().post("/").then().statusCode(200);+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(name).status());+ String message = "[/Resources/Q/Type/QueueName] 'null' values are not allowed in templates";+ String template = queue("{\"QueueName\": null}");++ assertRefused(request("UpdateStack", name, template), message);+ assertRefused(given().contentType("application/x-www-form-urlencoded").header("Authorization", AUTH)+ .formParam("Action", "CreateChangeSet").formParam("StackName", name)+ .formParam("ChangeSetName", "with-null").formParam("TemplateBody", template)+ .when().post("/"), message);++ given().contentType("application/x-www-form-urlencoded").header("Authorization", AUTH)+ .formParam("Action", "DeleteStack").formParam("StackName", name)+ .when().post("/").then().statusCode(200);+ CfnStackWaits.awaitStackDeleted(name);+ }++ /** Measured: a template that is null as a whole, or holds only a comment, is refused for lacking its resources. */+ @ParameterizedTest+ @ValueSource(strings = {"null", "~", "---\n~\n", "---\n", "# only a comment"})+ void aTemplateThatIsNullAsAWholeLacksItsResources(String template) {+ String message = "Template format error: At least one Resources member must be defined.";++ assertRefused(request("ValidateTemplate", null, template), message);+ assertRefused(request("CreateStack", "cfn-null-whole-" + System.nanoTime(), template), message);+ }++ /**+ * Measured: CreateStackSet and UpdateStackSet refuse the template before the stack set keeps it,+ * passing CloudFormation's message on with the service exception's details.+ */+ @Test+ void aStackSetRefusesATemplateWithANullValueBeforeKeepingIt() {+ String name = "cfn-null-set-" + System.nanoTime();+ String good = "{\"Resources\": {\"H\": {\"Type\": \"AWS::CloudFormation::WaitConditionHandle\"}}}";+ String prefix = "[/Resources/Q/Type/QueueName] 'null' values are not allowed in templates (Service:"+ + " AmazonCloudFormation; Status Code: 400; Error Code: ValidationError; Request ID: ";++ Response create = stackSet("CreateStackSet", name + "-refused", queue("{\"QueueName\": null}"));+ create.then().statusCode(400);+ assertThat(create.xmlPath().getString("ErrorResponse.Error.Message"),+ allOf(startsWith(prefix), endsWith("; Proxy: null)")));+ stackSet("CreateStackSet", name, good).then().statusCode(200);+ Response update = stackSet("UpdateStackSet", name, queue("{\"QueueName\": null}"));+ update.then().statusCode(400);+ assertThat(update.xmlPath().getString("ErrorResponse.Error.Message"), startsWith(prefix));++ given().contentType("application/x-www-form-urlencoded").header("Authorization", AUTH)+ .formParam("Action", "DescribeStackSet").formParam("StackSetName", name)+ .when().post("/").then().statusCode(200)+ .body("DescribeStackSetResponse.DescribeStackSetResult.StackSet.TemplateBody", equalTo(good));+ given().contentType("application/x-www-form-urlencoded").header("Authorization", AUTH)+ .formParam("Action", "DeleteStackSet").formParam("StackSetName", name)+ .when().post("/").then().statusCode(200);+ }++ /** Measured: a template URL whose object or bucket does not exist, alike for the three calls that read one. */+ @Test+ void aTemplateUrlOfNothingIsRefused() {+ String bucket = "cfn-null-tpl-" + System.nanoTime();+ given().header("Authorization", AUTH.replace("cloudformation", "s3")).when().put("/" + bucket)+ .then().statusCode(200);+ String missingKey = "S3 object does not exist. Bucket: " + bucket + ", Key: missing.json. Error: NoSuchKey";+ String missingBucket = "S3 error: The specified bucket does not exist\nFor more information check"+ + " http://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html";++ for (String action : List.of("ValidateTemplate", "CreateStack", "GetTemplateSummary")) {+ assertRefused(templateUrl(action, "http://localhost:4566/" + bucket + "/missing.json"), missingKey);+ assertRefused(templateUrl(action, "http://localhost:4566/" + bucket + "-gone/t.json"), missingBucket);+ }+ }++ private static Response templateUrl(String action, String url) {+ RequestSpecification request = given().contentType("application/x-www-form-urlencoded")+ .header("Authorization", AUTH).formParam("Action", action).formParam("TemplateURL", url);+ if ("CreateStack".equals(action)) {+ request.formParam("StackName", "cfn-null-url-" + System.nanoTime());+ }+ return request.when().post("/");+ }++ private static Response stackSet(String action, String name, String template) {+ return given().contentType("application/x-www-form-urlencoded").header("Authorization", AUTH)+ .formParam("Action", action).formParam("StackSetName", name).formParam("TemplateBody", template)+ .when().post("/");+ }++ private static String queue(String properties) {+ return "{\"Resources\": {\"Q\": {\"Type\": \"AWS::SQS::Queue\", \"Properties\": " + properties + "}}}";+ }++ private static Response request(String action, String stackName, String template) {+ RequestSpecification request = given().contentType("application/x-www-form-urlencoded").header("Authorization", AUTH)+ .formParam("Action", action).formParam("TemplateBody", template);+ if (stackName != null) {+ request.formParam("StackName", stackName);+ }+ return request.when().post("/");+ }++ private static void assertRefused(Response response, String message) {+ response.then().statusCode(400);+ assertEquals("ValidationError", response.xmlPath().getString("ErrorResponse.Error.Code"));+ assertEquals(message, response.xmlPath().getString("ErrorResponse.Error.Message"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CognitoResourceServerCfnIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CognitoResourceServerCfnIntegrationTest.javaindex d719840692..96eeb570fe 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CognitoResourceServerCfnIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CognitoResourceServerCfnIntegrationTest.java@@ -181,11 +181,8 @@ class CognitoResourceServerCfnIntegrationTest {@ValueSource(booleans = {false, true})void nullScopesFailCreationWithoutCreatingABackingServer(boolean conditional) throws Exception {String pool = createPool();- cloudFormation("CreateStack", nullScopesTemplate(pool, "Invalid API", conditional));- createdStack = true;- assertEquals("ROLLBACK_COMPLETE", CfnStackWaits.awaitTerminal(stack).status());- assertScopeValidationFailure();+ assertNullScopesRefused("CreateStack", nullScopesTemplate(pool, "Invalid API", conditional), conditional);assertServerGone(pool, IDENTIFIER);}@@ -195,9 +192,9 @@ class CognitoResourceServerCfnIntegrationTest {String pool = createPool();createStack(template(pool, IDENTIFIER, "Original API", "read"));- updateStack(nullScopesTemplate(pool, "Changed API", conditional), "UPDATE_ROLLBACK_COMPLETE");+ assertNullScopesRefused("UpdateStack", nullScopesTemplate(pool, "Changed API", conditional), conditional);- assertScopeValidationFailure();+ assertEquals("CREATE_COMPLETE", CfnStackWaits.awaitTerminal(stack).status());assertEquals(IDENTIFIER, output("ServerRef"));assertServer(pool, IDENTIFIER, "Original API", "read");updateStack(template(pool, IDENTIFIER, "Recovered API", "write"), "UPDATE_COMPLETE");@@ -823,11 +820,14 @@ class CognitoResourceServerCfnIntegrationTest {return template;}- private void assertScopeValidationFailure() {- String events = given().contentType("application/x-www-form-urlencoded")- .header("Authorization", CFN_AUTH).formParam("Action", "DescribeStackEvents")- .formParam("StackName", stack).post("/").then().statusCode(200).extract().asString();- assertTrue(events.contains("Scopes must be a list"));+ /** As on AWS, a template holding a null is refused when the operation is requested. */+ private void assertNullScopesRefused(String action, ObjectNode template, boolean conditional) {+ String path = conditional ? "/Resources/Server/Type/Scopes/Fn::If/1" : "/Resources/Server/Type/Scopes";+ given().contentType("application/x-www-form-urlencoded")+ .header("Authorization", CFN_AUTH).formParam("Action", action)+ .formParam("StackName", stack).formParam("TemplateBody", template.toString())+ .post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Message", equalTo("[" + path + "] 'null' values are not allowed in templates"));}private static void addFailingDependentResource(ObjectNode template) {