Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudformation): preserve SAM implicit API auth (#3501)
Franklin G. Mendoza8963c665eb03
diff --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 4849aeb305..ddfd0fc57c 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@@ -148,7 +148,7 @@ class SamTransformProcessor {return template.path("Globals");}- private record ApiRoute(String functionLogicalId, String path, String httpMethod) {}+ private record ApiRoute(String functionLogicalId, String path, String httpMethod, String authorizerName) {}private List<ApiRoute> collectApiRoutes(List<String> samLogicalIds, JsonNode resources) {List<ApiRoute> routes = new ArrayList<>();@@ -178,7 +178,8 @@ class SamTransformProcessor {}JsonNode methodNode = p.path("Method");String method = methodNode.isTextual() ? methodNode.asText() : "ANY";- routes.add(new ApiRoute(logicalId, pathNode.asText(), method));+ String authorizerName = p.path("Auth").path("Authorizer").asText(null);+ routes.add(new ApiRoute(logicalId, pathNode.asText(), method, authorizerName));}}return routes;@@ -546,6 +547,143 @@ class SamTransformProcessor {resources.set(permissionLogicalId, perm);}+ private Map<String, String> expandImplicitRestApiAuthorizers(String apiId, JsonNode auth,+ ObjectNode resources) {+ Map<String, String> logicalIds = new java.util.LinkedHashMap<>();+ JsonNode authorizers = auth.path("Authorizers");+ if (authorizers.isTextual()) {+ if (!"AWS_IAM".equals(authorizers.asText())) {+ throw new AwsException("ValidationError",+ "SAM Api Auth.Authorizers must be AWS_IAM or an authorizer map.", 400);+ }+ return logicalIds;+ }+ if (!authorizers.isObject()) {+ return logicalIds;+ }+ Iterator<Map.Entry<String, JsonNode>> it = authorizers.fields();+ while (it.hasNext()) {+ Map.Entry<String, JsonNode> entry = it.next();+ String name = entry.getKey();+ JsonNode config = entry.getValue();+ String payloadType = config.path("FunctionPayloadType").asText("TOKEN");+ if (!"REQUEST".equals(payloadType)) {+ throw new AwsException("ValidationError",+ "SAM implicit REST API authorizer " + name + " uses unsupported FunctionPayloadType "+ + payloadType + "; Floci currently supports REQUEST authorizers only.", 400);+ }+ JsonNode functionArn = config.get("FunctionArn");+ if (functionArn == null || functionArn.isNull() || functionArn.isMissingNode()) {+ throw new AwsException("ValidationError",+ "SAM REQUEST authorizer " + name + " must define FunctionArn.", 400);+ }+ JsonNode identity = config.path("Identity");+ if (!identity.isObject()) {+ throw new AwsException("ValidationError",+ "SAM REQUEST authorizer " + name + " must define Identity.", 400);+ }+ if (config.has("FunctionInvokeRole") && !config.path("FunctionInvokeRole").isNull()) {+ throw new AwsException("ValidationError",+ "SAM REQUEST authorizer " + name + " uses FunctionInvokeRole, which Floci does not "+ + "model yet; refusing to drop authorizer credentials silently.", 400);+ }++ String logicalId = uniqueId(apiId + sanitize(name) + "Authorizer", resources);+ ObjectNode def = objectMapper.createObjectNode();+ def.put("Type", "AWS::ApiGateway::Authorizer");+ ObjectNode props = objectMapper.createObjectNode();+ props.set("RestApiId", ref(apiId));+ props.put("Name", name);+ props.put("Type", "REQUEST");+ props.set("AuthorizerUri", authorizerInvokeUri(functionArn));++ String identitySource = requestAuthorizerIdentitySource(identity);+ if (identitySource != null) {+ props.put("IdentitySource", identitySource);+ }+ JsonNode reauthorizeEvery = identity.path("ReauthorizeEvery");+ if (!reauthorizeEvery.isMissingNode() && !reauthorizeEvery.isNull()) {+ if (!reauthorizeEvery.isIntegralNumber()+ || reauthorizeEvery.asInt() < 0 || reauthorizeEvery.asInt() > 3600) {+ throw new AwsException("ValidationError",+ "SAM REQUEST authorizer " + name+ + " Identity.ReauthorizeEvery must be an integer from 0 to 3600.", 400);+ }+ props.set("AuthorizerResultTtlInSeconds", reauthorizeEvery.deepCopy());+ }+ def.set("Properties", props);+ resources.set(logicalId, def);+ logicalIds.put(name, logicalId);++ if (!config.path("DisableFunctionDefaultPermissions").asBoolean(false)) {+ ObjectNode permission = objectMapper.createObjectNode();+ permission.put("Type", "AWS::Lambda::Permission");+ ObjectNode permissionProps = objectMapper.createObjectNode();+ permissionProps.set("FunctionName", functionArn.deepCopy());+ permissionProps.put("Action", "lambda:InvokeFunction");+ permissionProps.put("Principal", "apigateway.amazonaws.com");+ permission.set("Properties", permissionProps);+ resources.set(uniqueId(logicalId + "Permission", resources), permission);+ }+ }+ return logicalIds;+ }++ private String requestAuthorizerIdentitySource(JsonNode identity) {+ if (!identity.isObject()) {+ return null;+ }+ List<String> sources = new ArrayList<>();+ appendIdentitySources(identity.path("Headers"), "method.request.header.", sources);+ appendIdentitySources(identity.path("QueryStrings"), "method.request.querystring.", sources);+ appendIdentitySources(identity.path("StageVariables"), "stageVariables.", sources);+ appendIdentitySources(identity.path("Context"), "context.", sources);+ return sources.isEmpty() ? null : String.join(",", sources);+ }++ private void appendIdentitySources(JsonNode values, String prefix, List<String> target) {+ if (!values.isArray()) {+ return;+ }+ for (JsonNode value : values) {+ if (value.isTextual() && !value.asText().isBlank()) {+ target.add(prefix + value.asText());+ }+ }+ }++ private ObjectNode authorizerInvokeUri(JsonNode functionArn) {+ ObjectNode sub = objectMapper.createObjectNode();+ ArrayNode args = objectMapper.createArrayNode();+ args.add("arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${AuthorizerArn}/invocations");+ ObjectNode vars = objectMapper.createObjectNode();+ vars.set("AuthorizerArn", functionArn.deepCopy());+ args.add(vars);+ sub.set("Fn::Sub", args);+ return sub;+ }++ private void applyImplicitRestApiAuthorization(ObjectNode methodProperties, String requestedAuthorizer,+ String defaultAuthorizer,+ Map<String, String> authorizerLogicalIds) {+ String effective = requestedAuthorizer != null ? requestedAuthorizer : defaultAuthorizer;+ if (effective == null || "NONE".equals(effective)) {+ methodProperties.put("AuthorizationType", "NONE");+ return;+ }+ if ("AWS_IAM".equals(effective)) {+ methodProperties.put("AuthorizationType", "AWS_IAM");+ return;+ }+ String logicalId = authorizerLogicalIds.get(effective);+ if (logicalId == null) {+ throw new AwsException("ValidationError",+ "SAM Api authorizer '" + effective + "' is not defined in Auth.Authorizers.", 400);+ }+ methodProperties.put("AuthorizationType", "CUSTOM");+ methodProperties.set("AuthorizerId", ref(logicalId));+ }+private void generateImplicitApi(List<ApiRoute> routes, JsonNode globals, ObjectNode resources) {// Collision-safe: reuse "ServerlessRestApi" when free, otherwise a suffixed id, so an existing// resource with that logical id is never silently overwritten.@@ -563,6 +701,20 @@ class SamTransformProcessor {api.set("Properties", apiProps);resources.set(apiId, api);+ JsonNode auth = globals.path("Api").path("Auth");+ Map<String, String> authorizerLogicalIds = expandImplicitRestApiAuthorizers(apiId, auth, resources);+ String defaultAuthorizer = auth.path("DefaultAuthorizer").asText(null);+ if (defaultAuthorizer == null && auth.path("Authorizers").isTextual()+ && "AWS_IAM".equals(auth.path("Authorizers").asText())) {+ defaultAuthorizer = "AWS_IAM";+ }+ if (defaultAuthorizer != null && !"AWS_IAM".equals(defaultAuthorizer)+ && !"NONE".equals(defaultAuthorizer)+ && !authorizerLogicalIds.containsKey(defaultAuthorizer)) {+ throw new AwsException("ValidationError",+ "SAM Api authorizer '" + defaultAuthorizer + "' is not defined in Auth.Authorizers.", 400);+ }+Map<String, String> pathToResource = new java.util.LinkedHashMap<>();List<String> methodIds = new ArrayList<>();java.util.Set<String> permissionFns = new java.util.LinkedHashSet<>();@@ -575,14 +727,15 @@ class SamTransformProcessor {}String resourceId = ensureResourcePath(apiId, r.path(), pathToResource, resources);- String methodLogicalId = uniqueId(apiId + "Method" + sanitize(r.path()) + capitalize(method.toLowerCase()), resources);+ String methodLogicalId = uniqueId(+ apiId + "Method" + sanitize(r.path()) + capitalize(method.toLowerCase()), resources);ObjectNode m = objectMapper.createObjectNode();m.put("Type", "AWS::ApiGateway::Method");ObjectNode mp = objectMapper.createObjectNode();mp.set("RestApiId", ref(apiId));mp.set("ResourceId", resourceId == null ? getAtt(apiId, "RootResourceId") : ref(resourceId));mp.put("HttpMethod", method);- mp.put("AuthorizationType", "NONE");+ applyImplicitRestApiAuthorization(mp, r.authorizerName(), defaultAuthorizer, authorizerLogicalIds);ObjectNode integ = objectMapper.createObjectNode();integ.put("Type", "AWS_PROXY");integ.put("IntegrationHttpMethod", "POST");@@ -1068,6 +1221,12 @@ class SamTransformProcessor {}private void expandServerlessApi(String logicalId, JsonNode properties, ObjectNode resources) {+ JsonNode auth = properties.path("Auth");+ if (auth.isObject() && !auth.isEmpty()) {+ throw new AwsException("ValidationError",+ "SAM AWS::Serverless::Api Auth is not supported for explicit REST APIs yet; "+ + "Floci refuses to drop the authorization configuration silently.", 400);+ }resources.remove(logicalId);ObjectNode apiDef = objectMapper.createObjectNode();diff --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 c9f15f3acf..fe6ac1b9bc 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@@ -470,6 +470,105 @@ class SamTransformIntegrationTest {assertThat(resourcesXml, not(containsString("AWS::Serverless::Api")));}+ @Test+ void samImplicitApi_globalRequestAuthorizerCreatesAndWiresApiGatewayAuthorizer() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String stackName = "sam-api-auth-" + suffix;+ String apiName = "sam-api-auth-" + suffix;+ stacksToDelete.add(stackName);++ String template = """+ AWSTemplateFormatVersion: '2010-09-09'+ Transform: AWS::Serverless-2016-10-31+ Globals:+ Api:+ Name: %s+ Auth:+ DefaultAuthorizer: MyAuth+ Authorizers:+ MyAuth:+ FunctionPayloadType: REQUEST+ FunctionArn: !GetAtt AuthFn.Arn+ Identity:+ Headers: [Authorization]+ ReauthorizeEvery: 0+ Resources:+ ApiFn:+ Type: AWS::Serverless::Function+ Properties:+ Handler: index.handler+ Runtime: nodejs22.x+ InlineCode: "exports.handler = async () => ({statusCode:200, body:'ok'});"+ Events:+ Get:+ Type: Api+ Properties:+ Path: /secret+ Method: get+ AuthFn:+ Type: AWS::Serverless::Function+ Properties:+ Handler: index.handler+ Runtime: nodejs22.x+ InlineCode: >-+ exports.handler = async () => ({principalId:'p',+ policyDocument:{Version:'2012-10-17', Statement:[]}});+ """.formatted(apiName);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateStack")+ .formParam("StackName", stackName)+ .formParam("TemplateBody", template)+ .formParam("Capabilities.member.1", "CAPABILITY_IAM")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("<StackId>"));++ waitForStackStatus(stackName, "CREATE_COMPLETE");++ String apiId = given()+ .when()+ .get("/restapis")+ .then()+ .statusCode(200)+ .body("item.find { it.name == '" + apiName + "' }.name", equalTo(apiName))+ .extract()+ .path("item.find { it.name == '" + apiName + "' }.id");++ String authorizerId = given()+ .when()+ .get("/restapis/" + apiId + "/authorizers")+ .then()+ .statusCode(200)+ .body("item.size()", equalTo(1))+ .body("item[0].name", equalTo("MyAuth"))+ .body("item[0].type", equalTo("REQUEST"))+ .body("item[0].identitySource", equalTo("method.request.header.Authorization"))+ .body("item[0].authorizerResultTtlInSeconds", equalTo(0))+ .extract()+ .path("item[0].id");++ String resourceId = given()+ .when()+ .get("/restapis/" + apiId + "/resources")+ .then()+ .statusCode(200)+ .body("item.path", hasItem("/secret"))+ .extract()+ .path("item.find { it.path == '/secret' }.id");++ given()+ .when()+ .get("/restapis/" + apiId + "/resources/" + resourceId + "/methods/GET")+ .then()+ .statusCode(200)+ .body("authorizationType", equalTo("CUSTOM"))+ .body("authorizerId", equalTo(authorizerId));+ }+@Testvoid samApi_definitionBodyCreatesApiGatewayMethods() {String suffix = Long.toString(System.nanoTime(), 36);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 30ba7c965d..c0492bbd0f 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@@ -854,6 +854,282 @@ class SamTransformProcessorTest {assertTrue(hasPermission, "expected a Lambda permission for apigateway.amazonaws.com");}+ @Test+ void expandSamTemplate_implicitApiGlobalRequestAuthorizerWiresMethods() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {+ "Api": {+ "Auth": {+ "DefaultAuthorizer": "MyAuth",+ "Authorizers": {+ "MyAuth": {+ "FunctionPayloadType": "REQUEST",+ "FunctionArn": {"Fn::GetAtt": ["AuthFn", "Arn"]},+ "Identity": {+ "Headers": ["Authorization", "X-Tenant"],+ "QueryStrings": ["token"],+ "ReauthorizeEvery": 60+ }+ }+ }+ }+ }+ },+ "Resources": {+ "ApiFn": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Handler": "index.handler",+ "Runtime": "nodejs20.x",+ "InlineCode": "code",+ "Events": {+ "Get": {"Type": "Api", "Properties": {"Path": "/secret", "Method": "GET"}}+ }+ }+ },+ "AuthFn": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Handler": "index.handler",+ "Runtime": "nodejs20.x",+ "InlineCode": "code"+ }+ }+ }+ }+ """);++ JsonNode resources = processor.expandSamTemplate(template).path("Resources");++ JsonNode authorizer = resources.fields().next().getValue();+ for (Iterator<Map.Entry<String, JsonNode>> it = resources.fields(); it.hasNext();) {+ JsonNode candidate = it.next().getValue();+ if ("AWS::ApiGateway::Authorizer".equals(candidate.path("Type").asText())) {+ authorizer = candidate;+ break;+ }+ }+ assertEquals("REQUEST", authorizer.path("Properties").path("Type").asText());+ assertEquals("MyAuth", authorizer.path("Properties").path("Name").asText());+ assertEquals("method.request.header.Authorization,method.request.header.X-Tenant,"+ + "method.request.querystring.token",+ authorizer.path("Properties").path("IdentitySource").asText());+ assertEquals(60, authorizer.path("Properties").path("AuthorizerResultTtlInSeconds").asInt());++ boolean customMethod = false;+ boolean authPermission = false;+ for (Iterator<Map.Entry<String, JsonNode>> it = resources.fields(); it.hasNext();) {+ JsonNode candidate = it.next().getValue();+ if ("AWS::ApiGateway::Method".equals(candidate.path("Type").asText())+ && "CUSTOM".equals(candidate.path("Properties").path("AuthorizationType").asText())+ && candidate.path("Properties").path("AuthorizerId").path("Ref").isTextual()) {+ customMethod = true;+ }+ if ("AWS::Lambda::Permission".equals(candidate.path("Type").asText())+ && "AuthFn".equals(candidate.path("Properties").path("FunctionName")+ .path("Fn::GetAtt").path(0).asText())) {+ authPermission = true;+ }+ }+ assertTrue(customMethod, "expected the implicit method to reference the generated authorizer");+ assertTrue(authPermission, "expected SAM to grant API Gateway permission to invoke the authorizer");+ }++ @Test+ void expandSamTemplate_implicitApiEventCanOptOutOfGlobalAuthorizer() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {"Api": {"Auth": {+ "DefaultAuthorizer": "AWS_IAM"+ }}},+ "Resources": {+ "Fn": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Handler": "index.handler", "Runtime": "nodejs20.x", "InlineCode": "code",+ "Events": {+ "Private": {"Type": "Api", "Properties": {"Path": "/private", "Method": "GET"}},+ "Public": {"Type": "Api", "Properties": {"Path": "/public", "Method": "GET",+ "Auth": {"Authorizer": "NONE"}}}+ }+ }+ }+ }+ }+ """);++ JsonNode resources = processor.expandSamTemplate(template).path("Resources");+ int iam = 0;+ int none = 0;+ for (Iterator<Map.Entry<String, JsonNode>> it = resources.fields(); it.hasNext();) {+ JsonNode candidate = it.next().getValue();+ if (!"AWS::ApiGateway::Method".equals(candidate.path("Type").asText())) {+ continue;+ }+ String authorizationType = candidate.path("Properties").path("AuthorizationType").asText();+ if ("AWS_IAM".equals(authorizationType)) iam++;+ if ("NONE".equals(authorizationType)) none++;+ }+ assertEquals(1, iam);+ assertEquals(1, none);+ }++ @Test+ void expandSamTemplate_implicitApiSupportsAwsIamAuthorizersShorthand() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {"Api": {"Auth": {"Authorizers": "AWS_IAM"}}},+ "Resources": {+ "Fn": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Handler": "index.handler", "Runtime": "nodejs20.x", "InlineCode": "code",+ "Events": {"Get": {"Type": "Api", "Properties": {"Path": "/x", "Method": "GET"}}}+ }+ }+ }+ }+ """);++ JsonNode resources = processor.expandSamTemplate(template).path("Resources");+ boolean found = false;+ for (Iterator<Map.Entry<String, JsonNode>> it = resources.fields(); it.hasNext();) {+ JsonNode candidate = it.next().getValue();+ if ("AWS::ApiGateway::Method".equals(candidate.path("Type").asText())) {+ assertEquals("AWS_IAM", candidate.path("Properties").path("AuthorizationType").asText());+ found = true;+ }+ }+ assertTrue(found);+ }++ @Test+ void expandSamTemplate_requestAuthorizerRequiresIdentity() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {"Api": {"Auth": {+ "DefaultAuthorizer": "MyAuth",+ "Authorizers": {"MyAuth": {+ "FunctionPayloadType": "REQUEST",+ "FunctionArn": "arn:aws:lambda:us-east-1:000000000000:function:auth"+ }}+ }}},+ "Resources": {+ "Fn": {"Type": "AWS::Serverless::Function", "Properties": {+ "Handler": "index.handler", "Runtime": "nodejs20.x", "InlineCode": "code",+ "Events": {"Get": {"Type": "Api", "Properties": {"Path": "/x", "Method": "GET"}}}+ }}+ }+ }+ """);++ AwsException error = assertThrows(AwsException.class, () -> processor.expandSamTemplate(template));+ assertTrue(error.getMessage().contains("Identity"));+ }++ @Test+ void expandSamTemplate_requestAuthorizerRejectsUnsupportedInvokeRole() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {"Api": {"Auth": {+ "DefaultAuthorizer": "MyAuth",+ "Authorizers": {"MyAuth": {+ "FunctionPayloadType": "REQUEST",+ "FunctionArn": "arn:aws:lambda:us-east-1:000000000000:function:auth",+ "FunctionInvokeRole": "arn:aws:iam::000000000000:role/auth-invoke",+ "Identity": {"Headers": ["Authorization"]}+ }}+ }}},+ "Resources": {+ "Fn": {"Type": "AWS::Serverless::Function", "Properties": {+ "Handler": "index.handler", "Runtime": "nodejs20.x", "InlineCode": "code",+ "Events": {"Get": {"Type": "Api", "Properties": {"Path": "/x", "Method": "GET"}}}+ }}+ }+ }+ """);++ AwsException error = assertThrows(AwsException.class, () -> processor.expandSamTemplate(template));+ assertTrue(error.getMessage().contains("FunctionInvokeRole"));+ }++ @Test+ void expandSamTemplate_requestAuthorizerRejectsOutOfRangeTtl() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {"Api": {"Auth": {+ "DefaultAuthorizer": "MyAuth",+ "Authorizers": {"MyAuth": {+ "FunctionPayloadType": "REQUEST",+ "FunctionArn": "arn:aws:lambda:us-east-1:000000000000:function:auth",+ "Identity": {"Headers": ["Authorization"], "ReauthorizeEvery": 3601}+ }}+ }}},+ "Resources": {+ "Fn": {"Type": "AWS::Serverless::Function", "Properties": {+ "Handler": "index.handler", "Runtime": "nodejs20.x", "InlineCode": "code",+ "Events": {"Get": {"Type": "Api", "Properties": {"Path": "/x", "Method": "GET"}}}+ }}+ }+ }+ """);++ AwsException error = assertThrows(AwsException.class, () -> processor.expandSamTemplate(template));+ assertTrue(error.getMessage().contains("ReauthorizeEvery"));+ }++ @Test+ void expandSamTemplate_implicitApiRejectsUnknownDefaultAuthorizer() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Globals": {"Api": {"Auth": {"DefaultAuthorizer": "Missing"}}},+ "Resources": {+ "Fn": {+ "Type": "AWS::Serverless::Function",+ "Properties": {+ "Handler": "index.handler", "Runtime": "nodejs20.x", "InlineCode": "code",+ "Events": {"Get": {"Type": "Api", "Properties": {"Path": "/x", "Method": "GET"}}}+ }+ }+ }+ }+ """);++ AwsException error = assertThrows(AwsException.class, () -> processor.expandSamTemplate(template));+ assertEquals("ValidationError", error.getErrorCode());+ assertTrue(error.getMessage().contains("Missing"));+ }++ @Test+ void expandSamTemplate_explicitServerlessApiAuthFailsInsteadOfBeingDropped() throws Exception {+ JsonNode template = objectMapper.readTree("""+ {+ "Transform": "AWS::Serverless-2016-10-31",+ "Resources": {+ "Api": {+ "Type": "AWS::Serverless::Api",+ "Properties": {+ "StageName": "Prod",+ "Auth": {"DefaultAuthorizer": "AWS_IAM"}+ }+ }+ }+ }+ """);++ AwsException error = assertThrows(AwsException.class, () -> processor.expandSamTemplate(template));+ assertEquals("ValidationError", error.getErrorCode());+ assertTrue(error.getMessage().contains("Auth"));+ }+@Testvoid expandSamTemplate_dedupesDuplicateApiRoutes() throws Exception {// Two events resolving to the same (path, method) must collapse to a single API Gateway Method.