Light, fluffy, and always free - The AWS Local Emulator alternative
feat(cloudformation): support SAM's optional AutoPublishAlias version properties (#5823)
Jackson Pricef22c2a4db1d4
diff --git a/docs/services/cloudformation.md b/docs/services/cloudformation.mdindex fa7566be58..c74899bcc8 100644--- a/docs/services/cloudformation.md+++ b/docs/services/cloudformation.md@@ -436,19 +436,52 @@ numeric `Version` attribute. CloudFormation resolves the version before creatingalias. As in SAM, the version's logical id is `<Function>Version` followed by ten hex digits of aSHA-1 over the function's code, with its template parameter references resolved (pseudoparameters such as `${AWS::Region}` stay as written), its `Environment` and `MemorySize` as-written, and its `SnapStart` when it sets an `ApplyOn` other than `None`. An update that changes the-code, `Environment` or `MemorySize`, or a parameter the code uses, publishes a new version and-moves the alias to it. A parameter used only in `Environment` or `MemorySize` does not, and neither-does a property outside the hash, such as `Timeout`. A new id publishes only when the function's-code or configuration changed since its last version. floci does not give the function-`SnapStart`, so turning it on changes the id but publishes nothing: the alias stays where it is.--The version a new id replaces stays published: like SAM, floci gives the version-`DeletionPolicy: Retain` unless the function sets a `DeletionPolicy`, and the update reports it-`DELETE_SKIPPED`. With `Delete` floci reports the old version `DELETE_COMPLETE` but never deletes-it, where AWS does. Changes made to `$LATEST` outside the stack, including Lambda's reactive S3-sync, do not reach the alias until an update publishes a new version. Event sources and API-integrations still invoke the function rather than the alias, so they run `$LATEST`.+written, and its `SnapStart` when it sets an `ApplyOn` other than `None`. By default, then, an+update that changes the code, `Environment` or `MemorySize`, or a parameter the code uses, publishes+a new version and moves the alias to it. A parameter used only in `Environment` or `MemorySize` does+not, and neither does a property outside the hash, such as `Timeout`.++Two optional function properties change the id. Under `AutoPublishAliasAllProperties: true` the+hash covers every property floci gives the function, its code's parameter references resolved as+above, plus its `SnapStart`; those properties differ from the ones SAM generates, so these ids are+floci's own rather than SAM's. An `AutoPublishCodeSha256` that is a string, or a `Ref` to a+parameter holding one, replaces the hash with its first ten characters, under+`AutoPublishAliasAllProperties` too; an empty value leaves the hash in place. `Globals` can set+`AutoPublishAliasAllProperties` and `VersionDeletionPolicy`, but as in SAM not+`AutoPublishCodeSha256`, which fails the transform there. floci does not honour a resource's+`IgnoreGlobals`, so no function can opt out of a `VersionDeletionPolicy` in `Globals` with it: one+without `AutoPublishAlias` fails the transform with+`'VersionDeletionPolicy' requires 'AutoPublishAlias'.`, as it does in SAM when it does not ignore+that global.++A new id publishes a version, and moves the alias to it, only when the function's code or+configuration changed since its last version. Otherwise the new version resource takes the last+version and the alias stays where it is, as when an update changes only one of these:++- A change to `SnapStart`: floci does not give the function `SnapStart`.+- A new `AutoPublishCodeSha256` alone: on AWS this publishes, because SAM appends it to the+ function's `Description`, but floci's transform sets no `Description` on the function.+- Under `AutoPublishAliasAllProperties`, a change to `Tags` or `ReservedConcurrentExecutions`+ only: AWS fails that update with+ `A version for this Lambda function exists ( N ). Modify the function to create a new version.`,+ where floci completes it.++A function whose code is hot-reloaded publishes a version for every new id.++Like SAM, floci gives the version the function's `DeletionPolicy`, else its `VersionDeletionPolicy`+(`Delete` or `Retain`), else `Delete` for a function with a `CapacityProviderConfig` and `Retain`+for any other. So by default the version a new id replaces stays published, and the update reports+it `DELETE_SKIPPED`. With `Delete` floci reports the old version `DELETE_COMPLETE` but never deletes+it, where AWS does. A `VersionDeletionPolicy` written as an intrinsic function, such as a `Ref` to+a parameter, is copied onto the version unresolved, as SAM copies it. CloudFormation takes+intrinsic functions only in resource properties, outputs, metadata attributes and update policy+attributes, unless a transform such as `AWS::LanguageExtensions` resolves them first, and floci+implements no such transform: it reads any `DeletionPolicy` that is not a plain string as `Delete`+(see [Deletion Policies](#deletion-policies)).++Changes made to `$LATEST` outside the stack, including Lambda's reactive S3 sync, do not reach the+alias until an update publishes a new version. Event sources and API integrations still invoke the+function rather than the alias, so they run `$LATEST`.## RDS Credential Dynamic Referencesdiff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.javaindex 9167d3a6d6..68a8ceac2d 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessor.java@@ -44,6 +44,9 @@ class SamTransformProcessor {/** A {@code ${Name}} reference in an {@code Fn::Sub} string, as SAM matches one. */private static final Pattern SUB_REFERENCE = Pattern.compile("\\$\\{([A-Za-z0-9.]+|AWS::[A-Z][A-Za-z]*)}");+ /** What SAM accepts as a logical id. */+ private static final Pattern ALPHANUMERIC = Pattern.compile("[A-Za-z0-9]+");+private final ObjectMapper objectMapper;SamTransformProcessor(ObjectMapper objectMapper) {@@ -91,6 +94,12 @@ class SamTransformProcessor {// (including the early return below when Resources is absent or not an object).JsonNode globals = expanded.path("Globals");expanded.remove("Globals");+ // SAM refuses any Globals property it does not list for a section. AutoPublishCodeSha256 is+ // one of them: one value there would name every function's version.+ if (globals.path("Function").has("AutoPublishCodeSha256")) {+ throw new AwsException("ValidationError", "'Globals' section is invalid. 'AutoPublishCodeSha256' "+ + "is not a supported property of 'Function'.", 400);+ }JsonNode resources = expanded.path("Resources");if (!resources.isObject()) {@@ -987,11 +996,13 @@ class SamTransformProcessor {* dependencies, so the alias selects the immutable version published by this stack. The* version's logical id carries a hash of what a new version publishes (see* {@link #versionLogicalId}), so an update that changes the code names a new version resource,- * which publishes, and the alias follows it.+ * which publishes, and the alias follows it; a given {@code AutoPublishCodeSha256} fixes the id+ * instead.*/private String expandAutoPublishAlias(String functionLogicalId, JsonNode properties, JsonNode functionProperties,ObjectNode passthrough, JsonNode template,Map<String, String> parameterValues, ObjectNode resources) {+ validateVersionProperties(functionLogicalId, properties);JsonNode aliasName = properties.path("AutoPublishAlias");if (aliasName.isMissingNode() || aliasName.isNull()|| (aliasName.isTextual() && aliasName.asText().isBlank())) {@@ -1010,7 +1021,7 @@ class SamTransformProcessor {// The version a new hash replaces leaves the template on that update; like SAM, keep it// published unless the template says otherwise, so the update reports it DELETE_SKIPPED.if (!versionDef.has("DeletionPolicy")) {- versionDef.put("DeletionPolicy", "Retain");+ versionDef.set("DeletionPolicy", defaultVersionDeletionPolicy(properties));}resources.set(versionId, versionDef);@@ -1032,34 +1043,105 @@ class SamTransformProcessor {}/**- * The logical id SAM gives the version it publishes: {@code <Function>Version} and the first ten+ * SAM's {@code DeletionPolicy} for the version when the function declares none: the function's+ * {@code VersionDeletionPolicy}, else {@code Delete} for a function on a capacity provider and+ * {@code Retain} for any other.+ */+ private JsonNode defaultVersionDeletionPolicy(JsonNode properties) {+ JsonNode versionDeletionPolicy = properties.path("VersionDeletionPolicy");+ if (isPropertyPresent(versionDeletionPolicy)) {+ return versionDeletionPolicy.deepCopy();+ }+ return TextNode.valueOf(isPropertyPresent(properties.path("CapacityProviderConfig")) ? "Delete" : "Retain");+ }++ /**+ * The checks SAM makes on every function's version properties before it transforms them: the+ * type each must have, and that {@code VersionDeletionPolicy} comes with an+ * {@code AutoPublishAlias}. Like SAM, it takes any one-key object for an intrinsic function where+ * the property allows one.+ */+ private void validateVersionProperties(String functionLogicalId, JsonNode properties) {+ JsonNode codeSha256 = properties.path("AutoPublishCodeSha256");+ if (isPropertyPresent(codeSha256) && !codeSha256.isTextual() && !isOneKeyObject(codeSha256)) {+ throw invalidResource(functionLogicalId, "Type of property 'AutoPublishCodeSha256' is invalid.");+ }+ JsonNode allProperties = properties.path("AutoPublishAliasAllProperties");+ if (isPropertyPresent(allProperties) && !allProperties.isBoolean()) {+ throw invalidResource(functionLogicalId, "Type of property 'AutoPublishAliasAllProperties' is invalid.");+ }+ JsonNode versionDeletionPolicy = properties.path("VersionDeletionPolicy");+ if (!isPropertyPresent(versionDeletionPolicy)) {+ return;+ }+ boolean allowed = versionDeletionPolicy.isTextual()+ && List.of("Delete", "Retain").contains(versionDeletionPolicy.asText());+ if (!allowed && !isOneKeyObject(versionDeletionPolicy)) {+ throw invalidResource(functionLogicalId,+ "Property 'VersionDeletionPolicy' should be a one of the strings: 'Delete' or 'Retain'.");+ }+ if (!isPropertyPresent(properties.path("AutoPublishAlias"))) {+ throw invalidResource(functionLogicalId, "'VersionDeletionPolicy' requires 'AutoPublishAlias'.");+ }+ }++ private static boolean isOneKeyObject(JsonNode node) {+ return node.isObject() && node.size() == 1;+ }++ /**+ * The logical id of the version the alias points at: {@code <Function>Version} and the first ten* hex digits of the SHA-1 of the function's {@code Code}, with references to template parameters* resolved, merged with its {@code Environment}, its {@code MemorySize} and a {@code SnapStart}* that applies, as sorted compact JSON with characters outside printable ASCII as lowercase hex- * escapes, apart from JSON's short escapes such as a newline's. A change to the hashed input is a new logical id: the update publishes a new version and the alias moves- * to it. Unchanged, the id and the version it published stay, since the version provisioner never- * republishes under the same id.+ * escapes, apart from JSON's short escapes such as a newline's; that is the id SAM gives. Under+ * {@code AutoPublishAliasAllProperties} the hash covers all the properties this transform gives+ * the function, the code's parameter references still resolved, plus its {@code SnapStart},+ * which makes the id floci's own. A string+ * {@code AutoPublishCodeSha256} names the version itself, by its first ten characters. A change+ * to the hashed input is a new logical id, so a new version resource, which publishes when the+ * function's code or configuration changed since its last version. Unchanged, the id and the+ * version it published stay, since the version provisioner never republishes under the same id.*/private String versionLogicalId(String functionLogicalId, JsonNode samProperties, JsonNode functionProperties,JsonNode template, Map<String, String> parameterValues) {+ String codeSha256 = autoPublishCodeSha256(functionLogicalId, samProperties, template, parameterValues);+ if (codeSha256 != null && !codeSha256.isEmpty()) {+ String given = codeSha256.substring(0, Math.min(10, codeSha256.length()));+ if (!ALPHANUMERIC.matcher(given).matches()) {+ throw invalidResource(functionLogicalId + "Version" + given, "Logical ids must be alphanumeric.");+ }+ return functionLogicalId + "Version" + given;+ }+ // SAM resolves the code in place, so the all-properties hash sees it resolved as well.JsonNode code = resolveParameterRefs(functionProperties.path("Code"), template, parameterValues);ObjectNode hashed = objectMapper.createObjectNode();- if (code.isObject()) {- hashed.setAll((ObjectNode) code);- }- JsonNode environment = functionProperties.path("Environment");- if (environment.isObject()) {- hashed.setAll((ObjectNode) environment.deepCopy());- }- if (functionProperties.has("MemorySize")) {- hashed.set("MemorySize", functionProperties.get("MemorySize").deepCopy());- }- // SAM hashes a SnapStart that applies, so the id matches the one SAM gives. A missing- // ApplyOn means None; a null one does not.JsonNode snapStart = samProperties.path("SnapStart");- JsonNode applyOn = snapStart.path("ApplyOn");- if (snapStart.isObject() && !applyOn.isMissingNode() && !"None".equals(applyOn.asText(null))) {- hashed.set("SnapStart", snapStart.deepCopy());+ if (samProperties.path("AutoPublishAliasAllProperties").asBoolean(false)) {+ hashed.setAll((ObjectNode) functionProperties.deepCopy());+ if (code.isObject()) {+ hashed.set("Code", code);+ }+ if (isPropertyPresent(snapStart)) {+ hashed.set("SnapStart", snapStart.deepCopy());+ }+ } else {+ if (code.isObject()) {+ hashed.setAll((ObjectNode) code);+ }+ JsonNode environment = functionProperties.path("Environment");+ if (environment.isObject()) {+ hashed.setAll((ObjectNode) environment.deepCopy());+ }+ if (functionProperties.has("MemorySize")) {+ hashed.set("MemorySize", functionProperties.get("MemorySize").deepCopy());+ }+ // SAM hashes a SnapStart that applies, so the id matches the one SAM gives. A missing+ // ApplyOn means None; a null one does not.+ JsonNode applyOn = snapStart.path("ApplyOn");+ if (snapStart.isObject() && !applyOn.isMissingNode() && !"None".equals(applyOn.asText(null))) {+ hashed.set("SnapStart", snapStart.deepCopy());+ }}String hashInput;try {@@ -1076,6 +1158,23 @@ class SamTransformProcessor {return functionLogicalId + "Version" + Digests.sha1Hex(hashInput).substring(0, 10);}+ /**+ * The function's {@code AutoPublishCodeSha256} with template parameters resolved, or null when it+ * declares none. As in SAM, an intrinsic function that does not resolve to a string is refused.+ */+ private String autoPublishCodeSha256(String functionLogicalId, JsonNode samProperties, JsonNode template,+ Map<String, String> parameterValues) {+ JsonNode given = samProperties.path("AutoPublishCodeSha256");+ if (!isPropertyPresent(given)) {+ return null;+ }+ JsonNode resolved = resolveParameterRefs(given, template, parameterValues);+ if (!resolved.isTextual()) {+ throw invalidResource(functionLogicalId, "AutoPublishCodeSha256 must be a string");+ }+ return resolved.asText();+ }+/*** {@code node} with each reference to a template parameter replaced by the stack's value for it,* or else its {@code Default}, as SAM resolves the code before hashing it: a {@code Ref}, and adiff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformIntegrationTest.javaindex 91c44a1aea..86863d7f64 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformIntegrationTest.java@@ -265,6 +265,140 @@ class SamTransformIntegrationTest {.body("release", equalTo("second"));}+ @Test+ void samAutoPublishCodeSha256DecidesWhenANewVersionPublishes() {+ String stackName = "sam-code-sha-stack";+ String function = "sam-code-sha-func";+ stacksToDelete.add(stackName);+ String template = """+ Transform: AWS::Serverless-2016-10-31+ Resources:+ Function:+ Type: AWS::Serverless::Function+ Properties:+ FunctionName: sam-code-sha-func+ Handler: index.handler+ Runtime: nodejs20.x+ AutoPublishAlias: live+ AutoPublishCodeSha256: "%s"+ InlineCode: "exports.handler = async () => ({ release: '%s' });"+ """;+ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", template.formatted("aaaaaaaaaa", "first"))+ .formParam("Capabilities.member.1", "CAPABILITY_IAM")+ .when().post("/").then().statusCode(200);+ waitForStackStatus(stackName, "CREATE_COMPLETE");++ // As in SAM, the given hash names the version, so new code under the same value is not published.+ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "UpdateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", template.formatted("aaaaaaaaaa", "second"))+ .formParam("Capabilities.member.1", "CAPABILITY_IAM")+ .when().post("/").then().statusCode(200);+ waitForStackStatus(stackName, "UPDATE_COMPLETE");+ given().when().get("/2015-03-31/functions/" + function + "/aliases/live")+ .then().statusCode(200).body("FunctionVersion", equalTo("1"));++ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "UpdateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", template.formatted("bbbbbbbbbb", "second"))+ .formParam("Capabilities.member.1", "CAPABILITY_IAM")+ .when().post("/").then().statusCode(200);+ waitForStackStatus(stackName, "UPDATE_COMPLETE");+ given().when().get("/2015-03-31/functions/" + function + "/aliases/live")+ .then().statusCode(200).body("FunctionVersion", equalTo("2"));+ given().when().get("/2015-03-31/functions/" + function + "/versions")+ .then().statusCode(200).body("Versions.Version", equalTo(List.of("$LATEST", "1", "2")));+ }++ /** Under AutoPublishAliasAllProperties a property outside the default hash, here Timeout, publishes. */+ @Test+ void samAutoPublishAliasAllPropertiesPublishesATimeoutChange() {+ String stackName = "sam-all-properties-stack";+ String function = "sam-all-properties-func";+ stacksToDelete.add(stackName);+ String template = """+ Transform: AWS::Serverless-2016-10-31+ Resources:+ Function:+ Type: AWS::Serverless::Function+ Properties:+ FunctionName: sam-all-properties-func+ Handler: index.handler+ Runtime: nodejs20.x+ Timeout: %d+ AutoPublishAlias: live+ AutoPublishAliasAllProperties: true+ InlineCode: "exports.handler = async () => ({});"+ """;+ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", template.formatted(3)).formParam("Capabilities.member.1", "CAPABILITY_IAM")+ .when().post("/").then().statusCode(200);+ waitForStackStatus(stackName, "CREATE_COMPLETE");++ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "UpdateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", template.formatted(9)).formParam("Capabilities.member.1", "CAPABILITY_IAM")+ .when().post("/").then().statusCode(200);+ waitForStackStatus(stackName, "UPDATE_COMPLETE");++ given().when().get("/2015-03-31/functions/" + function + "/aliases/live")+ .then().statusCode(200).body("FunctionVersion", equalTo("2"));+ given().queryParam("Qualifier", "live")+ .when().get("/2015-03-31/functions/" + function + "/configuration")+ .then().statusCode(200).body("Version", equalTo("2")).body("Timeout", equalTo(9));+ }++ /** With VersionDeletionPolicy: Delete, the version a code change replaces is reported deleted. */+ @Test+ void samVersionDeletionPolicyDeleteAppliesToTheReplacedVersion() {+ String stackName = "sam-version-delete-stack";+ String function = "sam-version-delete-func";+ stacksToDelete.add(stackName);+ String template = """+ Transform: AWS::Serverless-2016-10-31+ Resources:+ Function:+ Type: AWS::Serverless::Function+ Properties:+ FunctionName: sam-version-delete-func+ Handler: index.handler+ Runtime: nodejs20.x+ AutoPublishAlias: live+ VersionDeletionPolicy: Delete+ InlineCode: "exports.handler = async () => ({ release: '%s' });"+ """;+ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", template.formatted("first")).formParam("Capabilities.member.1", "CAPABILITY_IAM")+ .when().post("/").then().statusCode(200);+ waitForStackStatus(stackName, "CREATE_COMPLETE");++ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "UpdateStack").formParam("StackName", stackName)+ .formParam("TemplateBody", template.formatted("second")).formParam("Capabilities.member.1", "CAPABILITY_IAM")+ .when().post("/").then().statusCode(200);+ waitForStackStatus(stackName, "UPDATE_COMPLETE");++ given().when().get("/2015-03-31/functions/" + function + "/aliases/live")+ .then().statusCode(200).body("FunctionVersion", equalTo("2"));+ String events = given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DescribeStackEvents").formParam("StackName", stackName)+ .when().post("/").then().statusCode(200).extract().asString();+ // FunctionVersion6a52d0f87f is the id SAM gives the first InlineCode.+ List<String> oldVersionStatuses = XmlParser.extractGroups(events, "member").stream()+ .filter(event -> "FunctionVersion6a52d0f87f".equals(event.get("LogicalResourceId")))+ .map(event -> event.get("ResourceStatus"))+ .toList();+ assertThat(oldVersionStatuses, hasItem("DELETE_COMPLETE"));+ assertThat(oldVersionStatuses, not(hasItem("DELETE_SKIPPED")));+ // floci reports the version deleted but keeps every version it publishes; AWS deletes it.+ given().when().get("/2015-03-31/functions/" + function + "/versions")+ .then().statusCode(200).body("Versions.Version", equalTo(List.of("$LATEST", "1", "2")));+ }+/*** A code change names a new version resource: the change set adds it, modifies the alias and* removes the old version, which, retained as SAM retains it, stays published.diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.javaindex f57a1912a3..55d388c22f 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/SamTransformProcessorTest.java@@ -181,7 +181,8 @@ class SamTransformProcessorTest {/*** SAM also hashes a function's SnapStart when its ApplyOn is anything but "None", so turning- * SnapStart on names a new version; absent, empty or "None" leaves the id unchanged.+ * SnapStart on names a new version; absent, empty or "None" leaves the id unchanged. With+ * AutoPublishAliasAllProperties it is hashed like every other property.*/@Testvoid expandSamTemplate_autoPublishAliasVersionIdIncludesAppliedSnapStart() throws Exception {@@ -210,6 +211,20 @@ class SamTransformProcessorTest {for (String off : List.of("", ", \"SnapStart\": {\"ApplyOn\": \"None\"}", ", \"SnapStart\": {}")) {assertEquals("MyFuncVersion102360dfc3", publishedVersionId(template.formatted(off)), off);}+ String allProperties = ", \"AutoPublishAliasAllProperties\": true";+ // The SHA-1 of the properties the transform gives the function, as sorted compact JSON:+ // {"Code":{"ZipFile":"..."},"Handler":"index.handler","Role":{"Fn::GetAtt":["MyFuncRole","Arn"]},+ // "Runtime":"java21"}+ assertEquals("MyFuncVersionef5795a086", publishedVersionId(template.formatted(allProperties)));+ assertEquals("MyFuncVersion60f02511cd",+ publishedVersionId(template.formatted(allProperties + ", \"Timeout\": 9")),+ "every property is hashed, Timeout included");+ assertEquals("MyFuncVersion6c94e3ab8d",+ publishedVersionId(template.formatted(allProperties + ", \"SnapStart\": {\"ApplyOn\": \"None\"}")),+ "SnapStart is hashed whatever its ApplyOn");+ assertEquals("MyFuncVersion102360dfc3",+ publishedVersionId(template.formatted(", \"AutoPublishAliasAllProperties\": false")),+ "false hashes as if the property were absent");}/**@@ -267,12 +282,198 @@ class SamTransformProcessorTest {publishedVersionId(template, Map.of("Release", "2", "Memory", "256")));}+ /**+ * A given {@code AutoPublishCodeSha256} names the version: SAM takes its first ten characters+ * and hashes nothing else, so the code alone no longer names the version.+ */+ @Test+ void expandSamTemplate_autoPublishCodeSha256TakesTheHashesPlace() throws Exception {+ String template = """+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Resources": {+ "MyFunc": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Handler": "index.handler", "Runtime": "nodejs20.x", "AutoPublishAlias": "live",+ "InlineCode": "%s", "AutoPublishCodeSha256": "%s"+ }+ }+ }+ }+ """;+ String code = "exports.handler = async () => ({});";+ String sha = "6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b";++ assertEquals("MyFuncVersion6b86b273ff", publishedVersionId(template.formatted(code, sha)));+ assertEquals("MyFuncVersion6b86b273ff",+ publishedVersionId(template.formatted("exports.handler = async () => ({ changed: true });", sha)),+ "a code change under the same AutoPublishCodeSha256 keeps the version");+ assertEquals("MyFuncVersionabc", publishedVersionId(template.formatted(code, "abc")));+ assertEquals("MyFuncVersion102360dfc3", publishedVersionId(template.formatted(code, "")),+ "an empty AutoPublishCodeSha256 gives no hash, so the code is hashed");+ }++ /**+ * SAM refuses an AutoPublishCodeSha256 that is not a string: on any function when it is neither a+ * string nor a one-key object, and with AutoPublishAlias when it does not resolve to a string.+ */+ @Test+ void expandSamTemplate_autoPublishCodeSha256MustBeAString() throws Exception {+ String template = """+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Resources": {+ "Bucket": {"Type": "AWS::S3::Bucket"},+ "MyFunc": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Handler": "index.handler", "Runtime": "nodejs20.x",%s+ "InlineCode": "exports.handler = async () => ({});", "AutoPublishCodeSha256": %s+ }+ }+ }+ }+ """;+ String alias = " \"AutoPublishAlias\": \"live\",";++ AwsException number = assertThrows(AwsException.class,+ () -> processor.expandSamTemplate(objectMapper.readTree(template.formatted("", "12"))));+ assertEquals("ValidationError", number.getErrorCode());+ assertEquals("Resource with id [MyFunc] is invalid. Type of property 'AutoPublishCodeSha256' is invalid.",+ number.getMessage(), "checked whether or not the function publishes a version");+ assertEquals("Resource with id [MyFunc] is invalid. Type of property 'AutoPublishCodeSha256' is invalid.",+ assertThrows(AwsException.class, () -> publishedVersionId(template.formatted(alias,+ "{\"Fn::Sub\": \"a\", \"Fn::Join\": [\"\", []]}"))).getMessage());+ for (String unresolved : List.of("{\"Fn::GetAtt\": [\"Bucket\", \"Arn\"]}", "{\"Sha\": \"abc\"}")) {+ assertEquals("Resource with id [MyFunc] is invalid. AutoPublishCodeSha256 must be a string",+ assertThrows(AwsException.class, () -> publishedVersionId(template.formatted(alias, unresolved)))+ .getMessage(), unresolved);+ }+ assertEquals("Resource with id [MyFuncVersion1.2.3-rc] is invalid. Logical ids must be alphanumeric.",+ assertThrows(AwsException.class, () -> publishedVersionId(template.formatted(alias, "\"1.2.3-rc\"")))+ .getMessage());+ assertEquals("MyFuncVersionabcdefghij", publishedVersionId(template.formatted(alias, "\"abcdefghij-x\"")),+ "only the first ten characters name the version");+ }++ /** SAM's types for the other version properties, and VersionDeletionPolicy needs AutoPublishAlias. */+ @Test+ void expandSamTemplate_versionPropertiesHaveSamsTypes() throws Exception {+ String template = """+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Parameters": {"Policy": {"Type": "String", "Default": "Retain"}},+ "Resources": {+ "MyFunc": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Handler": "index.handler", "Runtime": "nodejs20.x",+ "InlineCode": "exports.handler = async () => ({});"%s+ }+ }+ }+ }+ """;+ String alias = ", \"AutoPublishAlias\": \"live\"";++ for (String allProperties : List.of("\"true\"", "1", "{\"Ref\": \"HashAll\"}")) {+ assertEquals("Resource with id [MyFunc] is invalid. Type of property 'AutoPublishAliasAllProperties' "+ + "is invalid.",+ assertThrows(AwsException.class, () -> processor.expandSamTemplate(objectMapper.readTree(+ template.formatted(alias + ", \"AutoPublishAliasAllProperties\": " + allProperties))))+ .getMessage(), allProperties);+ }+ assertEquals("Resource with id [MyFunc] is invalid. Property 'VersionDeletionPolicy' should be a one of the "+ + "strings: 'Delete' or 'Retain'.",+ assertThrows(AwsException.class, () -> processor.expandSamTemplate(objectMapper.readTree(+ template.formatted(alias + ", \"VersionDeletionPolicy\": \"retain\"")))).getMessage());+ assertEquals("Resource with id [MyFunc] is invalid. 'VersionDeletionPolicy' requires 'AutoPublishAlias'.",+ assertThrows(AwsException.class, () -> processor.expandSamTemplate(objectMapper.readTree(+ template.formatted(", \"VersionDeletionPolicy\": \"Retain\"")))).getMessage());+ assertEquals("{\"Ref\":\"Policy\"}", processor.expandSamTemplate(objectMapper.readTree(+ template.formatted(alias + ", \"VersionDeletionPolicy\": {\"Ref\": \"Policy\"}")))+ .path("Resources").path("MyFuncVersion102360dfc3").path("DeletionPolicy").toString(),+ "an intrinsic function is copied unresolved, as SAM copies it");+ }++ /** As in SAM, a given AutoPublishCodeSha256 names the version under AutoPublishAliasAllProperties too. */+ @Test+ void expandSamTemplate_autoPublishCodeSha256OutranksAutoPublishAliasAllProperties() throws Exception {+ String template = """+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Resources": {+ "MyFunc": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Handler": "index.handler", "Runtime": "nodejs20.x", "AutoPublishAlias": "live",+ "AutoPublishAliasAllProperties": true, "AutoPublishCodeSha256": "abc123",+ "InlineCode": "exports.handler = async () => ({});", "Timeout": %d+ }+ }+ }+ }+ """;++ assertEquals("MyFuncVersionabc123", publishedVersionId(template.formatted(3)));+ assertEquals("MyFuncVersionabc123", publishedVersionId(template.formatted(9)));+ }++ /** Globals.Function carries AutoPublishAliasAllProperties and VersionDeletionPolicy, as SAM's do. */+ @Test+ void expandSamTemplate_versionPropertiesComeFromGlobals() throws Exception {+ JsonNode resources = processor.expandSamTemplate(objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {"Function": {"AutoPublishAlias": "live", "AutoPublishAliasAllProperties": true,+ "VersionDeletionPolicy": "Delete"}},+ "Resources": {+ "MyFunc": {+ "Type": "AWS::Serverless::Function",+ "Properties": {"Handler": "index.handler", "Runtime": "nodejs20.x",+ "InlineCode": "exports.handler = async () => ({});"}+ }+ }+ }+ """)).path("Resources");++ // Without AutoPublishAliasAllProperties the id is MyFuncVersion102360dfc3.+ assertEquals("[\"MyFuncVersionb6788accf2\",\"Version\"]", resources.path("MyFuncAliasLive")+ .path("Properties").path("FunctionVersion").path("Fn::GetAtt").toString());+ assertEquals("Delete", resources.path("MyFuncVersionb6788accf2").path("DeletionPolicy").asText());+ }++ /** SAM's Globals do not take AutoPublishCodeSha256, which would name every function's version. */+ @Test+ void expandSamTemplate_globalsRefuseAutoPublishCodeSha256() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {"Function": {"AutoPublishAlias": "live", "AutoPublishCodeSha256": "release1234"}},+ "Resources": {+ "MyFunc": {+ "Type": "AWS::Serverless::Function",+ "Properties": {"Handler": "index.handler", "Runtime": "nodejs20.x",+ "InlineCode": "exports.handler = async () => ({});"}+ }+ }+ }+ """);++ AwsException refused = assertThrows(AwsException.class, () -> processor.expandSamTemplate(template));+ assertEquals("ValidationError", refused.getErrorCode());+ assertEquals("'Globals' section is invalid. 'AutoPublishCodeSha256' is not a supported property of "+ + "'Function'.", refused.getMessage());+ }+/*** SAM retains each version it publishes unless the function sets a {@code DeletionPolicy}, which- * the version and alias both take.+ * the version and alias both take, or a {@code VersionDeletionPolicy}; a function on a capacity+ * provider defaults to {@code Delete}.*/@Test- void expandSamTemplate_autoPublishAliasVersionIsRetainedUnlessTheFunctionSaysOtherwise() throws Exception {+ void expandSamTemplate_autoPublishAliasVersionDeletionPolicyFollowsSam() throws Exception {String template = """{"Transform": "AWS::Serverless-2016-10-31",@@ -293,7 +494,16 @@ class SamTransformProcessorTest {assertEquals("Retain", retained.path("MyFuncVersion102360dfc3").path("DeletionPolicy").asText());assertTrue(retained.path("MyFuncAliasLive").path("DeletionPolicy").isMissingNode(),"the alias takes only what the function declares");- assertEquals("Delete", versionDeletionPolicy(template.formatted(" \"DeletionPolicy\": \"Delete\",", "")));+ assertEquals("Delete", versionDeletionPolicy(template.formatted(+ " \"DeletionPolicy\": \"Delete\",", ", \"VersionDeletionPolicy\": \"Retain\"")));+ assertEquals("Delete", versionDeletionPolicy(template.formatted(+ "", ", \"VersionDeletionPolicy\": \"Delete\"")));+ assertEquals("Retain", versionDeletionPolicy(template.formatted(+ "", ", \"VersionDeletionPolicy\": \"Retain\"")));+ assertEquals("Delete", versionDeletionPolicy(template.formatted(+ "", ", \"CapacityProviderConfig\": {\"Arn\": \"capacity-provider-arn\"}")));+ assertEquals("Retain", versionDeletionPolicy(template.formatted("", ", \"VersionDeletionPolicy\": \"Retain\", "+ + "\"CapacityProviderConfig\": {\"Arn\": \"capacity-provider-arn\"}")));}private String versionDeletionPolicy(String template) throws Exception {@@ -332,9 +542,10 @@ class SamTransformProcessorTest {}/**- * A parameter reaches the hash the way SAM resolves it: as a {@code Ref}, and as a- * {@code ${Name}} in an {@code Fn::Sub}. Otherwise a parameter-only update changes the function- * but publishes no version, and the alias keeps the old code.+ * A parameter reaches the hash the way SAM resolves it: as a {@code Ref}, as a {@code ${Name}}+ * in an {@code Fn::Sub}, under {@code AutoPublishAliasAllProperties} too, and in+ * {@code AutoPublishCodeSha256}. Otherwise a parameter-only update changes the function but+ * publishes no version, and the alias keeps the old code.*/@Testvoid expandSamTemplate_autoPublishAliasVersionIdFollowsParametersInEveryForm() throws Exception {@@ -363,6 +574,15 @@ class SamTransformProcessorTest {publishedVersionId(template.formatted(sub, ""), Map.of("Release", "2")));assertNotEquals(publishedVersionId(template.formatted(ref, ""), Map.of("Release", "1")),publishedVersionId(template.formatted(ref, ""), Map.of("Release", "2")));+ String allProperties = ", \"AutoPublishAliasAllProperties\": true";+ assertNotEquals(publishedVersionId(template.formatted(ref, allProperties), Map.of("Release", "1")),+ publishedVersionId(template.formatted(ref, allProperties), Map.of("Release", "2")));+ String codeSha = ", \"AutoPublishCodeSha256\": {\"Ref\": \"Release\"}";+ assertEquals("MyFuncVersion2",+ publishedVersionId(template.formatted("\"app.zip\"", codeSha), Map.of("Release", "2")));+ assertEquals(publishedVersionId(template.formatted("\"app.zip\"", ""), Map.of()),+ publishedVersionId(template.formatted("\"app.zip\"", codeSha), Map.of("Release", "")),+ "a Ref resolving to an empty value leaves the hash in place");}private String publishedVersionId(String template) throws Exception {