Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(cloudformation): provision AWS::ApiGatewayV2::Authorizer and wire Route.AuthorizerId (#1760)

Jay7f51c746cdc2
diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java
index b635322300..4949f70649 100644
--- a/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java
+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java
@@ -1212,7 +1212,7 @@ public class ApiGatewayExecuteController {
}
if ("JWT".equalsIgnoreCase(route.getAuthorizationType()) && route.getAuthorizerId() != null) {
- Response authError = enforceJwtAuthorizer(region, apiId, route, headers);
+ Response authError = enforceJwtAuthorizer(region, apiId, route, headers, uriInfo);
if (authError != null) return authError;
}
@@ -1441,7 +1441,8 @@ public class ApiGatewayExecuteController {
/** Extracts parameter names from a route template; the pattern itself is constant. */
private static final Pattern ROUTE_PARAM_NAMES = Pattern.compile("\\{([a-zA-Z_]+)\\+?\\}");
- private Response enforceJwtAuthorizer(String region, String apiId, Route route, HttpHeaders headers) {
+ private Response enforceJwtAuthorizer(String region, String apiId, Route route, HttpHeaders headers,
+ UriInfo uriInfo) {
Authorizer authorizer;
try {
authorizer = apiGatewayV2Service.getAuthorizer(region, apiId, route.getAuthorizerId());
@@ -1451,7 +1452,7 @@ public class ApiGatewayExecuteController {
.type(MediaType.APPLICATION_JSON).build();
}
- String token = extractToken(authorizer, headers);
+ String token = extractToken(authorizer, headers, uriInfo);
if (token == null) {
return Response.status(401)
.entity(jsonMessage("Unauthorized"))
@@ -1763,7 +1764,7 @@ public class ApiGatewayExecuteController {
}
}
- private String extractToken(Authorizer authorizer, HttpHeaders headers) {
+ private String extractToken(Authorizer authorizer, HttpHeaders headers, UriInfo uriInfo) {
List<String> sources = authorizer.getIdentitySource();
if (sources == null || sources.isEmpty()) {
// Default: Authorization header
@@ -1775,6 +1776,10 @@ public class ApiGatewayExecuteController {
String headerName = source.substring("$request.header.".length());
String value = headers.getHeaderString(headerName);
if (value != null) return stripBearer(value);
+ } else if (source.startsWith("$request.querystring.")) {
+ String paramName = source.substring("$request.querystring.".length());
+ String value = uriInfo.getQueryParameters().getFirst(paramName);
+ if (value != null) return stripBearer(value);
}
}
return null;
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java
index c7f9134242..81b6eeb54f 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java
@@ -314,6 +314,7 @@ public class CloudFormationResourceProvisioner {
case "AWS::ApiGateway::Deployment" -> provisionApiGatewayDeployment(resource, properties, engine, region);
case "AWS::ApiGateway::Stage" -> provisionApiGatewayStage(resource, properties, engine, region);
case "AWS::ApiGatewayV2::Api" -> provisionApiGatewayV2Api(resource, properties, engine, region, accountId, stackName);
+ case "AWS::ApiGatewayV2::Authorizer" -> provisionApiGatewayV2Authorizer(resource, properties, engine, region);
case "AWS::ApiGatewayV2::Route" -> provisionApiGatewayV2Route(resource, properties, engine, region);
case "AWS::ApiGatewayV2::Integration" -> provisionApiGatewayV2Integration(resource, properties, engine, region);
case "AWS::ApiGatewayV2::Stage" -> provisionApiGatewayV2Stage(resource, properties, engine, region);
@@ -436,6 +437,21 @@ public class CloudFormationResourceProvisioner {
resource.getAttributes().get("EventBusName"), region);
return;
}
+ // Authorizer deletion needs the api id (a stored attribute, not the physical id, which is
+ // the authorizer id) — same shape as the Nodegroup case above. Without this, the generic
+ // type/physicalId delete path has no case for this type at all and silently no-ops,
+ // leaving the authorizer behind in AWS after the stack reports deleted.
+ if ("AWS::ApiGatewayV2::Authorizer".equals(resourceType)) {
+ String apiId = resource.getAttributes().get("ApiId");
+ if (apiId != null && !apiId.isBlank()) {
+ try {
+ apiGatewayV2Service.deleteAuthorizer(region, apiId, resource.getPhysicalId());
+ } catch (Exception e) {
+ LOG.debugv("Error deleting authorizer {0}: {1}", resource.getPhysicalId(), e.getMessage());
+ }
+ }
+ return;
+ }
// AWS::IAM::Policy is an inline policy; detaching it needs the principals it was attached to,
// which the type/physicalId delete path can't provide (only the delete-stack path has them).
if ("AWS::IAM::Policy".equals(resourceType)) {
@@ -3578,12 +3594,78 @@ public class CloudFormationResourceProvisioner {
return out;
}
+ /**
+ * Resolves {@code IdentitySource} accepting either the documented array form or a single
+ * scalar string — {@code ApiGatewayV2Service.createAuthorizer}/{@code updateAuthorizer}
+ * already accept both ({@code identitySourceRaw instanceof String}), so the CFN provisioner
+ * should not be stricter than the service it calls.
+ */
+ private List<String> resolveIdentitySource(JsonNode props, String source, CloudFormationTemplateEngine engine) {
+ if (props == null || !props.has(source) || props.get(source).isNull()) {
+ return List.of();
+ }
+ JsonNode resolved = engine.resolveNode(props.get(source));
+ if (resolved == null) {
+ return List.of();
+ }
+ if (resolved.isTextual()) {
+ return List.of(resolved.asText());
+ }
+ if (!resolved.isArray()) {
+ return List.of();
+ }
+ List<String> values = new ArrayList<>();
+ resolved.forEach(v -> values.add(v.asText()));
+ return values;
+ }
+
+ private void provisionApiGatewayV2Authorizer(StackResource r, JsonNode props, CloudFormationTemplateEngine engine,
+ String region) {
+ String apiId = resolveOptional(props, "ApiId", engine);
+ Map<String, Object> req = new HashMap<>();
+ req.put("name", resolveOptional(props, "Name", engine));
+ req.put("authorizerType", resolveOptional(props, "AuthorizerType", engine));
+ req.put("identitySource", resolveIdentitySource(props, "IdentitySource", engine));
+ req.put("authorizerUri", resolveOptional(props, "AuthorizerUri", engine));
+ req.put("authorizerPayloadFormatVersion", resolveOptional(props, "AuthorizerPayloadFormatVersion", engine));
+
+ String ttl = resolveOptional(props, "AuthorizerResultTtlInSeconds", engine);
+ if (ttl != null) {
+ req.put("authorizerResultTtlInSeconds", Integer.parseInt(ttl));
+ }
+ String simpleResponses = resolveOptional(props, "EnableSimpleResponses", engine);
+ if (simpleResponses != null) {
+ req.put("enableSimpleResponses", simpleResponses);
+ }
+
+ JsonNode jwtConfigNode = props != null ? props.get("JwtConfiguration") : null;
+ if (jwtConfigNode != null && !jwtConfigNode.isNull()) {
+ Map<String, Object> jwtConfig = new HashMap<>();
+ jwtConfig.put("audience", resolveStringListOrEmpty(jwtConfigNode, "Audience", engine));
+ jwtConfig.put("issuer", resolveOptional(jwtConfigNode, "Issuer", engine));
+ req.put("jwtConfiguration", jwtConfig);
+ }
+
+ Authorizer authorizer;
+ if (r.getPhysicalId() == null) {
+ authorizer = apiGatewayV2Service.createAuthorizer(region, apiId, req);
+ } else {
+ authorizer = apiGatewayV2Service.updateAuthorizer(region, apiId, r.getPhysicalId(), req);
+ }
+ r.setPhysicalId(authorizer.getAuthorizerId());
+ r.getAttributes().put("AuthorizerId", authorizer.getAuthorizerId());
+ // ApiId is needed by delete(StackResource, region) to scope deleteAuthorizer — the
+ // type/physicalId-only delete overload has no apiId to call it with.
+ r.getAttributes().put("ApiId", apiId);
+ }
+
private void provisionApiGatewayV2Route(StackResource r, JsonNode props, CloudFormationTemplateEngine engine,
String region) {
String apiId = resolveOptional(props, "ApiId", engine);
Map<String, Object> req = new HashMap<>();
req.put("routeKey", resolveOptional(props, "RouteKey", engine));
req.put("authorizationType", resolveOrDefault(props, "AuthorizationType", engine, "NONE"));
+ req.put("authorizerId", resolveOptional(props, "AuthorizerId", engine));
req.put("target", resolveOptional(props, "Target", engine));
Route route;
diff --git a/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiJwtAuthorizerQuerystringTest.java b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiJwtAuthorizerQuerystringTest.java
new file mode 100644
index 0000000000..228b1e1beb
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiJwtAuthorizerQuerystringTest.java
@@ -0,0 +1,149 @@
+package io.github.hectorvent.floci.services.apigatewayv2;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.http.ContentType;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.notNullValue;
+
+/**
+ * Regression test: HTTP API (v2) JWT authorizers support {@code $request.querystring.*}
+ * identity sources, not just {@code $request.header.*} — a template/API call configuring
+ * a query-string token source must not 401 a request carrying a valid token there.
+ *
+ * <p>Tokens here are unsigned (header.payload.signature-shaped strings whose payload is
+ * plain base64url JSON) — {@code ApiGatewayExecuteController.parseJwtClaims} doesn't verify
+ * a signature, matching this emulator's local-dev scope, so no real signing key is needed
+ * to exercise the extraction and claims-matching logic under test.
+ */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class HttpApiJwtAuthorizerQuerystringTest {
+
+ private static String httpApiId;
+ private static String integrationId;
+ private static String routeId;
+ private static String authorizerId;
+
+ private static final String ISSUER = "https://issuer.example.com";
+ private static final String AUDIENCE = "my-client-id";
+
+ @Test
+ @Order(1)
+ void setup() {
+ httpApiId = given()
+ .contentType(ContentType.JSON)
+ .body("""
+ {"name":"http-v2-jwt-querystring-test","protocolType":"HTTP"}
+ """)
+ .when().post("/v2/apis")
+ .then()
+ .statusCode(201)
+ .body("apiId", notNullValue())
+ .extract().path("apiId");
+
+ given()
+ .contentType(ContentType.JSON)
+ .body("""
+ {"stageName":"test"}
+ """)
+ .when().post("/v2/apis/" + httpApiId + "/stages")
+ .then()
+ .statusCode(201);
+
+ integrationId = given()
+ .contentType(ContentType.JSON)
+ .body("""
+ {"integrationType":"HTTP_PROXY","integrationUri":"https://backend.example.com","payloadFormatVersion":"1.0"}
+ """)
+ .when().post("/v2/apis/" + httpApiId + "/integrations")
+ .then()
+ .statusCode(201)
+ .extract().path("integrationId");
+
+ routeId = given()
+ .contentType(ContentType.JSON)
+ .body("""
+ {"routeKey":"GET /hello","target":"integrations/%s"}
+ """.formatted(integrationId))
+ .when().post("/v2/apis/" + httpApiId + "/routes")
+ .then()
+ .statusCode(201)
+ .extract().path("routeId");
+
+ authorizerId = given()
+ .contentType(ContentType.JSON)
+ .body("""
+ {"name":"jwt-querystring-auth","authorizerType":"JWT",\
+ "identitySource":"$request.querystring.token",\
+ "jwtConfiguration":{"audience":["%s"],"issuer":"%s"}}
+ """.formatted(AUDIENCE, ISSUER))
+ .when().post("/v2/apis/" + httpApiId + "/authorizers")
+ .then().statusCode(201)
+ .extract().path("authorizerId");
+
+ given()
+ .contentType(ContentType.JSON)
+ .body("""
+ {"authorizationType":"JWT","authorizerId":"%s"}
+ """.formatted(authorizerId))
+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)
+ .then().statusCode(200);
+ }
+
+ @Test
+ @Order(10)
+ void requestWithValidTokenInQueryStringIsAuthorized() {
+ // The integration target isn't a real reachable backend, so a successful proxy
+ // round-trip isn't asserted here — only that the request got past the authorizer.
+ // Before the fix, an invalid/missing token (or a source type extractToken can't read)
+ // 401s before ever reaching the integration; getting a 502 (backend unreachable) rather
+ // than a 401 proves the querystring token was actually extracted and accepted.
+ String token = fakeJwt(ISSUER, AUDIENCE);
+
+ given()
+ .when().get("/execute-api/" + httpApiId + "/test/hello?token=" + token)
+ .then().statusCode(502);
+ }
+
+ @Test
+ @Order(20)
+ void requestWithNoTokenAnywhereIsUnauthorized() {
+ given()
+ .when().get("/execute-api/" + httpApiId + "/test/hello")
+ .then().statusCode(401);
+ }
+
+ @Test
+ @Order(30)
+ void requestWithValidTokenOnlyInHeaderIsUnauthorizedWhenSourceIsQuerystring() {
+ // The authorizer's IdentitySource is $request.querystring.token, not a header — a
+ // token presented via Authorization must not satisfy an identity source it wasn't
+ // configured for.
+ String token = fakeJwt(ISSUER, AUDIENCE);
+
+ given()
+ .header("Authorization", "Bearer " + token)
+ .when().get("/execute-api/" + httpApiId + "/test/hello")
+ .then().statusCode(401);
+ }
+
+ private static String fakeJwt(String issuer, String audience) {
+ String header = base64Url("{\"alg\":\"none\"}");
+ String payload = base64Url(
+ "{\"iss\":\"" + issuer + "\",\"aud\":\"" + audience + "\",\"exp\":9999999999}");
+ return header + "." + payload + ".signature";
+ }
+
+ private static String base64Url(String json) {
+ return Base64.getUrlEncoder().withoutPadding()
+ .encodeToString(json.getBytes(StandardCharsets.UTF_8));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java
index 19e7187372..a1f24c2c64 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java
@@ -6504,6 +6504,293 @@ class CloudFormationIntegrationTest {
.statusCode(200);
}
+ private io.restassured.response.ValidatableResponse getAuthorizers(String apiId) {
+ return given()
+ .header("X-Amz-Target", "AmazonApiGatewayV2.GetAuthorizers")
+ .contentType(APIGWV2_CONTENT_TYPE)
+ .body("{\"ApiId\": \"" + apiId + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ // ── Issue #1758: AWS::ApiGatewayV2::Authorizer dropped by CloudFormation ──
+
+ @Test
+ void createStack_apiGatewayV2AuthorizerIsProvisionedAndWiredToRoute() {
+ String template = """
+ {
+ "Resources": {
+ "HttpApi": {
+ "Type": "AWS::ApiGatewayV2::Api",
+ "Properties": { "Name": "cfn-apigwv2-authz-api", "ProtocolType": "HTTP" }
+ },
+ "Authorizer": {
+ "Type": "AWS::ApiGatewayV2::Authorizer",
+ "Properties": {
+ "ApiId": { "Ref": "HttpApi" },
+ "Name": "cfn-jwt-authorizer",
+ "AuthorizerType": "JWT",
+ "IdentitySource": ["$request.header.Authorization"],
+ "JwtConfiguration": {
+ "Audience": ["my-client-id"],
+ "Issuer": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_xxxxx"
+ }
+ }
+ },
+ "Integration": {
+ "Type": "AWS::ApiGatewayV2::Integration",
+ "Properties": {
+ "ApiId": { "Ref": "HttpApi" },
+ "IntegrationType": "HTTP_PROXY",
+ "IntegrationUri": "https://example.com",
+ "PayloadFormatVersion": "1.0"
+ }
+ },
+ "Route": {
+ "Type": "AWS::ApiGatewayV2::Route",
+ "Properties": {
+ "ApiId": { "Ref": "HttpApi" },
+ "RouteKey": "GET /hello",
+ "AuthorizationType": "JWT",
+ "AuthorizerId": { "Ref": "Authorizer" },
+ "Target": { "Fn::Join": ["/", ["integrations", { "Ref": "Integration" }]] }
+ }
+ }
+ },
+ "Outputs": {
+ "ApiId": { "Value": { "Ref": "HttpApi" } },
+ "AuthorizerId": { "Value": { "Ref": "Authorizer" } },
+ "RouteId": { "Value": { "Ref": "Route" } }
+ }
+ }
+ """;
+
+ String stackName = "cfn-apigwv2-authorizer-stack";
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String createXml = apigwv2DescribeStacks(stackName);
+ String apiId = apigwOutputValue(createXml, "ApiId");
+ String authorizerId = apigwOutputValue(createXml, "AuthorizerId");
+ String routeId = apigwOutputValue(createXml, "RouteId");
+
+ // The authorizer is a real resource, not dropped by the default-case stub.
+ getAuthorizers(apiId).body("Items.size()", equalTo(1))
+ .body("Items[0].AuthorizerId", equalTo(authorizerId))
+ .body("Items[0].Name", equalTo("cfn-jwt-authorizer"))
+ .body("Items[0].AuthorizerType", equalTo("JWT"))
+ .body("Items[0].IdentitySource", hasItem("$request.header.Authorization"))
+ .body("Items[0].JwtConfiguration.Issuer",
+ equalTo("https://cognito-idp.us-east-1.amazonaws.com/us-east-1_xxxxx"));
+
+ // The route's Ref to the authorizer resolved to a real id and was persisted.
+ getRoutes(apiId).body("Items.size()", equalTo(1))
+ .body("Items[0].RouteId", equalTo(routeId))
+ .body("Items[0].AuthorizerId", equalTo(authorizerId));
+ }
+
+ @Test
+ void createStack_apiGatewayV2AuthorizerAcceptsScalarIdentitySource() {
+ // IdentitySource is documented as Array of String, but ApiGatewayV2Service.createAuthorizer
+ // already accepts a bare scalar string too — the CFN provisioner must not be stricter than
+ // the service it calls, or a template written with the scalar form silently loses its
+ // identity source instead of erroring or working.
+ String template = """
+ {
+ "Resources": {
+ "HttpApi": {
+ "Type": "AWS::ApiGatewayV2::Api",
+ "Properties": { "Name": "cfn-apigwv2-authz-scalar-api", "ProtocolType": "HTTP" }
+ },
+ "Authorizer": {
+ "Type": "AWS::ApiGatewayV2::Authorizer",
+ "Properties": {
+ "ApiId": { "Ref": "HttpApi" },
+ "Name": "cfn-jwt-authorizer-scalar",
+ "AuthorizerType": "JWT",
+ "IdentitySource": "$request.header.Authorization",
+ "JwtConfiguration": {
+ "Audience": ["my-client-id"],
+ "Issuer": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_xxxxx"
+ }
+ }
+ }
+ },
+ "Outputs": {
+ "ApiId": { "Value": { "Ref": "HttpApi" } }
+ }
+ }
+ """;
+
+ String stackName = "cfn-apigwv2-authorizer-scalar-stack";
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String apiId = apigwOutputValue(apigwv2DescribeStacks(stackName), "ApiId");
+
+ getAuthorizers(apiId).body("Items.size()", equalTo(1))
+ .body("Items[0].IdentitySource", hasItem("$request.header.Authorization"));
+ }
+
+ @Test
+ void createStack_apiGatewayV2RouteResolvesAuthorizerIdViaGetAtt() {
+ // Ref already resolved AuthorizerId via the physical id (covered above); Fn::GetAtt reads
+ // a separate attributes map that provisionApiGatewayV2Authorizer must also populate, or
+ // the route ends up wired to the literal placeholder string "Authorizer.AuthorizerId"
+ // instead of the real id.
+ String template = """
+ {
+ "Resources": {
+ "HttpApi": {
+ "Type": "AWS::ApiGatewayV2::Api",
+ "Properties": { "Name": "cfn-apigwv2-authz-getatt-api", "ProtocolType": "HTTP" }
+ },
+ "Authorizer": {
+ "Type": "AWS::ApiGatewayV2::Authorizer",
+ "Properties": {
+ "ApiId": { "Ref": "HttpApi" },
+ "Name": "cfn-jwt-authorizer-getatt",
+ "AuthorizerType": "JWT",
+ "IdentitySource": ["$request.header.Authorization"],
+ "JwtConfiguration": {
+ "Audience": ["my-client-id"],
+ "Issuer": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_xxxxx"
+ }
+ }
+ },
+ "Integration": {
+ "Type": "AWS::ApiGatewayV2::Integration",
+ "Properties": {
+ "ApiId": { "Ref": "HttpApi" },
+ "IntegrationType": "HTTP_PROXY",
+ "IntegrationUri": "https://example.com",
+ "PayloadFormatVersion": "1.0"
+ }
+ },
+ "Route": {
+ "Type": "AWS::ApiGatewayV2::Route",
+ "Properties": {
+ "ApiId": { "Ref": "HttpApi" },
+ "RouteKey": "GET /hello",
+ "AuthorizationType": "JWT",
+ "AuthorizerId": { "Fn::GetAtt": ["Authorizer", "AuthorizerId"] },
+ "Target": { "Fn::Join": ["/", ["integrations", { "Ref": "Integration" }]] }
+ }
+ }
+ },
+ "Outputs": {
+ "ApiId": { "Value": { "Ref": "HttpApi" } },
+ "AuthorizerId": { "Value": { "Ref": "Authorizer" } }
+ }
+ }
+ """;
+
+ String stackName = "cfn-apigwv2-authorizer-getatt-stack";
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String createXml = apigwv2DescribeStacks(stackName);
+ String apiId = apigwOutputValue(createXml, "ApiId");
+ String authorizerId = apigwOutputValue(createXml, "AuthorizerId");
+
+ // The route's GetAtt resolved to the real authorizer id, not the literal placeholder.
+ getRoutes(apiId).body("Items.size()", equalTo(1))
+ .body("Items[0].AuthorizerId", equalTo(authorizerId));
+ }
+
+ @Test
+ void deleteStack_apiGatewayV2AuthorizerOnNonStackOwnedApiIsRemoved() {
+ // The API is created out-of-band (not by this stack) and referenced by a plain literal
+ // id, the same shape as a template parameter — deliberately not { "Ref": ... } to an
+ // AWS::ApiGatewayV2::Api resource in this stack. This is the scenario the scoped delete
+ // path exists for: AWS::ApiGatewayV2::Api's own delete cascades to its authorizers, which
+ // would make a stack-owned-API test pass even with no delete case for the authorizer at
+ // all. Here the API survives stack deletion, so the authorizer's removal can only be
+ // attributed to the authorizer's own scoped delete case actually running.
+ String apiId = given()
+ .header("X-Amz-Target", "AmazonApiGatewayV2.CreateApi")
+ .contentType(APIGWV2_CONTENT_TYPE)
+ .body("{\"Name\": \"cfn-apigwv2-authz-delete-external-api\", \"ProtocolType\": \"HTTP\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(201)
+ .extract().path("ApiId");
+
+ String template = """
+ {
+ "Resources": {
+ "Authorizer": {
+ "Type": "AWS::ApiGatewayV2::Authorizer",
+ "Properties": {
+ "ApiId": "%s",
+ "Name": "cfn-jwt-authorizer-delete",
+ "AuthorizerType": "JWT",
+ "IdentitySource": ["$request.header.Authorization"],
+ "JwtConfiguration": {
+ "Audience": ["my-client-id"],
+ "Issuer": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_xxxxx"
+ }
+ }
+ }
+ }
+ }
+ """.formatted(apiId);
+
+ String stackName = "cfn-apigwv2-authorizer-delete-stack";
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ getAuthorizers(apiId).body("Items.size()", equalTo(1));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ // The API was never part of the stack, so it (and GetAuthorizers against it) still works
+ // — the authorizer itself must be gone.
+ getAuthorizers(apiId).body("Items.size()", equalTo(0));
+ }
+
// ── SAM AWS::Serverless::Function PackageType: Image dropped by the transform ──
@Test