Light, fluffy, and always free - The AWS Local Emulator alternative
feat(apigateway): add Lambda REQUEST authorizer support for HTTP API v2 routes (#1011)
Dixit R Jain5772e4947077
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.javaindex ea2c644109..340963a492 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@@ -1149,6 +1149,11 @@ public class ApiGatewayExecuteController {if (authError != null) return authError;}+ if ("CUSTOM".equalsIgnoreCase(route.getAuthorizationType()) && route.getAuthorizerId() != null) {+ Response authError = enforceRequestAuthorizerV2(region, apiId, stageName, route, httpMethod, path, headers, uriInfo);+ if (authError != null) return authError;+ }+if (route.getTarget() == null) {return Response.status(500).entity(jsonMessage("No integration configured"))@@ -1409,6 +1414,273 @@ public class ApiGatewayExecuteController {return null; // authorized}+ // ──────────────────────────── HTTP API v2 Lambda REQUEST authorizer ────────────────────────────++ /**+ * Enforces a Lambda REQUEST authorizer on an HTTP API (v2) route.+ * Supports both payload format versions (1.0 and 2.0) and simple responses.+ *+ * @return null if authorized, or an error Response if denied/unauthorized+ */+ private Response enforceRequestAuthorizerV2(String region, String apiId, String stageName,+ Route route, String httpMethod, String path,+ HttpHeaders headers, UriInfo uriInfo) {+ Authorizer authorizer;+ try {+ authorizer = apiGatewayV2Service.getAuthorizer(region, apiId, route.getAuthorizerId());+ } catch (AwsException e) {+ return Response.status(500)+ .entity(jsonMessage("Authorizer not found"))+ .type(MediaType.APPLICATION_JSON).build();+ }++ if (!"REQUEST".equalsIgnoreCase(authorizer.getAuthorizerType())) {+ return null; // Not a REQUEST authorizer — skip+ }++ // Validate identity sources — if any configured source is missing, return 401 without invoking Lambda+ List<String> identitySources = authorizer.getIdentitySource();+ if (identitySources != null && !identitySources.isEmpty()) {+ MultivaluedMap<String, String> queryParams = uriInfo.getQueryParameters();+ for (String expression : identitySources) {+ if (expression.startsWith("$request.header.")) {+ String headerName = expression.substring("$request.header.".length());+ String value = headers.getHeaderString(headerName);+ if (value == null || value.isEmpty()) {+ return Response.status(401)+ .entity(jsonMessage("Unauthorized"))+ .type(MediaType.APPLICATION_JSON).build();+ }+ } else if (expression.startsWith("$request.querystring.")) {+ String paramName = expression.substring("$request.querystring.".length());+ String value = queryParams.getFirst(paramName);+ if (value == null || value.isEmpty()) {+ return Response.status(401)+ .entity(jsonMessage("Unauthorized"))+ .type(MediaType.APPLICATION_JSON).build();+ }+ }+ // $context.* identity sources are always present — no validation needed+ }+ }++ // Build the authorizer event payload based on the configured payload format version+ String payloadFormatVersion = authorizer.getAuthorizerPayloadFormatVersion();+ String eventJson;+ if ("2.0".equals(payloadFormatVersion)) {+ eventJson = buildRequestAuthorizerEventV2(httpMethod, path, route.getRouteKey(),+ apiId, stageName, region, headers, uriInfo);+ } else {+ // Default to 1.0 format+ eventJson = buildRequestAuthorizerEventV1(httpMethod, path, apiId, stageName, region, headers, uriInfo);+ }++ // Extract the Lambda function name from the authorizer URI+ String functionName = functionNameFromUri(authorizer.getAuthorizerUri());+ if (functionName == null) {+ LOG.warnv("Cannot extract function name from authorizer URI: {0}", authorizer.getAuthorizerUri());+ return Response.status(500)+ .entity(jsonMessage("Internal Server Error"))+ .type(MediaType.APPLICATION_JSON).build();+ }++ // Invoke the authorizer Lambda+ InvokeResult invokeResult;+ try {+ invokeResult = lambdaService.invoke(region, functionName,+ eventJson.getBytes(StandardCharsets.UTF_8), InvocationType.RequestResponse);+ } catch (Exception e) {+ LOG.warnv("Lambda REQUEST authorizer invocation failed for API {0}: {1}", apiId, e.getMessage());+ return Response.status(500)+ .entity(jsonMessage("Internal Server Error"))+ .type(MediaType.APPLICATION_JSON).build();+ }++ // Check for function error (Lambda threw an exception)+ if (invokeResult.getFunctionError() != null) {+ LOG.warnv("Lambda REQUEST authorizer returned function error for API {0}: {1}",+ apiId, invokeResult.getFunctionError());+ return Response.status(500)+ .entity(jsonMessage("Internal Server Error"))+ .type(MediaType.APPLICATION_JSON).build();+ }++ byte[] payload = invokeResult.getPayload();+ if (payload == null || payload.length == 0) {+ LOG.warnv("Lambda REQUEST authorizer returned empty payload for API {0}", apiId);+ return Response.status(500)+ .entity(jsonMessage("Internal Server Error"))+ .type(MediaType.APPLICATION_JSON).build();+ }++ // Parse the authorizer response+ try {+ JsonNode response = objectMapper.readTree(payload);++ // Check if simple responses are enabled (format 2.0 feature)+ Boolean enableSimpleResponses = authorizer.getEnableSimpleResponses();+ if (Boolean.TRUE.equals(enableSimpleResponses)) {+ // Simple response format: {"isAuthorized": true/false, "context": {...}}+ JsonNode isAuthorized = response.path("isAuthorized");+ if (isAuthorized.isMissingNode() || isAuthorized.isNull()) {+ LOG.warnv("Lambda REQUEST authorizer simple response missing isAuthorized for API {0}", apiId);+ return Response.status(500)+ .entity(jsonMessage("Internal Server Error"))+ .type(MediaType.APPLICATION_JSON).build();+ }+ if (!isAuthorized.asBoolean(false)) {+ return Response.status(403)+ .entity(jsonMessage("Forbidden"))+ .type(MediaType.APPLICATION_JSON).build();+ }+ return null; // authorized+ }++ // IAM policy document format+ JsonNode policyDocument = response.path("policyDocument");+ if (policyDocument.isMissingNode() || policyDocument.isNull()) {+ LOG.warnv("Authorizer response missing policyDocument for API {0}", apiId);+ return Response.status(500)+ .entity(jsonMessage("Internal Server Error"))+ .type(MediaType.APPLICATION_JSON).build();+ }++ JsonNode statements = policyDocument.path("Statement");+ if (statements.isMissingNode() || statements.isNull()+ || !statements.isArray() || statements.isEmpty()) {+ LOG.warnv("Authorizer response missing or empty Statement array for API {0}", apiId);+ return Response.status(500)+ .entity(jsonMessage("Internal Server Error"))+ .type(MediaType.APPLICATION_JSON).build();+ }++ String effect = statements.get(0).path("Effect").asText("Deny");+ if ("Deny".equalsIgnoreCase(effect)) {+ return Response.status(403)+ .entity(jsonMessage("User is not authorized to access this resource"))+ .type(MediaType.APPLICATION_JSON).build();+ }++ if (!"Allow".equalsIgnoreCase(effect)) {+ LOG.warnv("Authorizer response has unrecognized Effect '{0}' for API {1}", effect, apiId);+ return Response.status(500)+ .entity(jsonMessage("Internal Server Error"))+ .type(MediaType.APPLICATION_JSON).build();+ }++ return null; // authorized+ } catch (Exception e) {+ LOG.warnv("Failed to parse authorizer response for API {0}: {1}", apiId, e.getMessage());+ return Response.status(500)+ .entity(jsonMessage("Internal Server Error"))+ .type(MediaType.APPLICATION_JSON).build();+ }+ }++ /**+ * Builds a REQUEST authorizer event in payload format version 1.0.+ * Compatible with REST API (v1) REQUEST authorizer shape.+ */+ private String buildRequestAuthorizerEventV1(String httpMethod, String path,+ String apiId, String stageName, String region,+ HttpHeaders headers, UriInfo uriInfo) {+ ObjectNode event = objectMapper.createObjectNode();+ event.put("version", "1.0");+ event.put("type", "REQUEST");+ event.put("methodArn", buildMethodArn(region, apiId, stageName, httpMethod, path));+ event.put("resource", path);+ event.put("path", path);+ event.put("httpMethod", httpMethod);++ putSingleValueHeaders(event, headers);+ putMultiValueHeaders(event, headers);+ putQueryStringParameters(event, uriInfo);+ putMultiValueQueryStringParameters(event, uriInfo);++ event.putObject("pathParameters");+ event.putNull("stageVariables");++ // Request context+ ObjectNode ctx = event.putObject("requestContext");+ ctx.put("accountId", regionResolver.getAccountId());+ ctx.put("apiId", apiId);+ ctx.put("httpMethod", httpMethod);+ ctx.put("path", path);+ ctx.put("resourcePath", path);+ ctx.put("stage", stageName);+ ctx.put("requestId", UUID.randomUUID().toString());++ try {+ return objectMapper.writeValueAsString(event);+ } catch (Exception e) {+ throw new RuntimeException("Failed to serialize v1 authorizer event", e);+ }+ }++ /**+ * Builds a REQUEST authorizer event in payload format version 2.0.+ * Uses the newer HTTP API-native shape with routeArn, routeKey, rawPath, and requestContext.http.+ */+ private String buildRequestAuthorizerEventV2(String httpMethod, String path, String routeKey,+ String apiId, String stageName, String region,+ HttpHeaders headers, UriInfo uriInfo) {+ ObjectNode event = objectMapper.createObjectNode();+ event.put("version", "2.0");+ event.put("type", "REQUEST");+ event.put("routeArn", buildMethodArn(region, apiId, stageName, httpMethod, path));+ event.put("routeKey", routeKey != null ? routeKey : "$default");+ event.put("rawPath", path);+ event.put("rawQueryString", uriInfo.getRequestUri().getRawQuery() != null+ ? uriInfo.getRequestUri().getRawQuery() : "");++ // Headers (lowercase keys for v2)+ ObjectNode headersNode = event.putObject("headers");+ MultivaluedMap<String, String> reqHeaders = headers.getRequestHeaders();+ for (Map.Entry<String, List<String>> e : reqHeaders.entrySet()) {+ if (!e.getValue().isEmpty()) headersNode.put(e.getKey().toLowerCase(), e.getValue().get(0));+ }++ // Query string parameters+ MultivaluedMap<String, String> queryParams = uriInfo.getQueryParameters();+ if (!queryParams.isEmpty()) {+ ObjectNode qsp = event.putObject("queryStringParameters");+ for (Map.Entry<String, List<String>> e : queryParams.entrySet()) {+ if (!e.getValue().isEmpty()) qsp.put(e.getKey(), e.getValue().get(0));+ }+ }++ event.putObject("pathParameters");+ event.putNull("stageVariables");++ // Request context+ ObjectNode ctx = event.putObject("requestContext");+ String arnRegion = region != null ? region : regionResolver.getDefaultRegion();+ ctx.put("accountId", regionResolver.getAccountId());+ ctx.put("apiId", apiId);+ ctx.put("domainName", apiId + ".execute-api." + arnRegion + ".amazonaws.com");+ ctx.put("domainPrefix", apiId);+ ctx.put("requestId", UUID.randomUUID().toString());+ ctx.put("routeKey", routeKey != null ? routeKey : "$default");+ ctx.put("stage", stageName);+ ctx.put("time", java.time.format.DateTimeFormatter.ofPattern("dd/MMM/yyyy:HH:mm:ss Z")+ .format(java.time.ZonedDateTime.now()));+ ctx.put("timeEpoch", System.currentTimeMillis());++ ObjectNode http = ctx.putObject("http");+ http.put("method", httpMethod);+ http.put("path", path);+ http.put("protocol", "HTTP/1.1");+ http.put("sourceIp", "127.0.0.1");+ http.put("userAgent", headers.getHeaderString("User-Agent") != null+ ? headers.getHeaderString("User-Agent") : "");++ try {+ return objectMapper.writeValueAsString(event);+ } catch (Exception e) {+ throw new RuntimeException("Failed to serialize v2 authorizer event", e);+ }+ }+private String extractToken(Authorizer authorizer, HttpHeaders headers) {List<String> sources = authorizer.getIdentitySource();if (sources == null || sources.isEmpty()) {diff --git a/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiRequestAuthorizerTest.java b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiRequestAuthorizerTest.javanew file mode 100644index 0000000000..0c4bb62f2a--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiRequestAuthorizerTest.java@@ -0,0 +1,580 @@+package io.github.hectorvent.floci.services.apigatewayv2;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+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.io.ByteArrayOutputStream;+import java.nio.charset.StandardCharsets;+import java.util.Base64;+import java.util.Map;+import java.util.zip.ZipEntry;+import java.util.zip.ZipOutputStream;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.notNullValue;+import static org.junit.jupiter.api.Assertions.*;++/**+ * Integration tests for Lambda REQUEST authorizer on HTTP API (v2) routes (issue #812).+ *+ * <p>Covers payload format versions 1.0 and 2.0, simple responses, identity source+ * validation, and deny/allow/error scenarios.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class HttpApiRequestAuthorizerTest {++ private static final ObjectMapper MAPPER = new ObjectMapper();++ private static String httpApiId;+ private static String integrationId;+ private static String routeId;+ private static String allowAuthorizerId;+ private static String denyAuthorizerId;+ private static String errorAuthorizerId;+ private static String simpleAllowAuthorizerId;+ private static String simpleDenyAuthorizerId;+ private static String identitySourceAuthorizerId;+ private static String echoV1AuthorizerId;+ private static String echoV2AuthorizerId;++ private static final String ALLOW_FN = "httpv2-auth-allow-fn";+ private static final String DENY_FN = "httpv2-auth-deny-fn";+ private static final String ERROR_FN = "httpv2-auth-error-fn";+ private static final String SIMPLE_ALLOW_FN = "httpv2-auth-simple-allow-fn";+ private static final String SIMPLE_DENY_FN = "httpv2-auth-simple-deny-fn";+ private static final String ECHO_FN = "httpv2-auth-echo-fn";+ private static final String BACKEND_FN = "httpv2-auth-backend-fn";++ // ──────────────────────────── Setup ────────────────────────────++ @Test+ @Order(1)+ void setupHttpApi() {+ httpApiId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"http-v2-authorizer-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);+ }++ @Test+ @Order(2)+ void setupLambdaFunctions() throws Exception {+ // Backend Lambda+ createNodeLambda(BACKEND_FN, """+ exports.handler = async (event) => ({+ statusCode: 200,+ body: JSON.stringify({ message: "Hello from backend", path: event.rawPath })+ });+ """);++ // Authorizer that returns Allow policy (IAM policy format)+ createNodeLambda(ALLOW_FN, """+ exports.handler = async (event) => ({+ principalId: "user123",+ policyDocument: {+ Version: "2012-10-17",+ Statement: [{ Action: "execute-api:Invoke", Effect: "Allow", Resource: event.methodArn || event.routeArn || "*" }]+ },+ context: { userId: "user123", role: "admin" }+ });+ """);++ // Authorizer that returns Deny policy+ createNodeLambda(DENY_FN, """+ exports.handler = async (event) => ({+ principalId: "user123",+ policyDocument: {+ Version: "2012-10-17",+ Statement: [{ Action: "execute-api:Invoke", Effect: "Deny", Resource: event.methodArn || event.routeArn || "*" }]+ }+ });+ """);++ // Authorizer that throws an error+ createNodeLambda(ERROR_FN, """+ exports.handler = async (event) => { throw new Error("Authorizer error"); };+ """);++ // Authorizer that returns simple Allow response (format 2.0)+ createNodeLambda(SIMPLE_ALLOW_FN, """+ exports.handler = async (event) => ({+ isAuthorized: true,+ context: { userId: "simple-user", plan: "premium" }+ });+ """);++ // Authorizer that returns simple Deny response (format 2.0)+ createNodeLambda(SIMPLE_DENY_FN, """+ exports.handler = async (event) => ({+ isAuthorized: false+ });+ """);++ // Echo authorizer that returns the event payload in context+ createNodeLambda(ECHO_FN, """+ exports.handler = async (event) => ({+ principalId: "echo-user",+ policyDocument: {+ Version: "2012-10-17",+ Statement: [{ Action: "execute-api:Invoke", Effect: "Allow", Resource: event.methodArn || event.routeArn || "*" }]+ },+ context: { receivedEvent: JSON.stringify(event) }+ });+ """);+ }++ @Test+ @Order(3)+ void prewarmLambdaFunctions() {+ for (String fn : new String[]{BACKEND_FN, ALLOW_FN, DENY_FN, ERROR_FN, SIMPLE_ALLOW_FN, SIMPLE_DENY_FN, ECHO_FN}) {+ given().contentType(ContentType.JSON).body("{}")+ .when().post("/2015-03-31/functions/" + fn + "/invocations")+ .then().statusCode(200);+ }+ }++ @Test+ @Order(4)+ void setupIntegrationAndRoute() {+ integrationId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"integrationType":"AWS_PROXY","integrationUri":"arn:aws:lambda:us-east-1:000000000000:function:%s/invocations","integrationMethod":"POST","payloadFormatVersion":"2.0"}+ """.formatted(BACKEND_FN))+ .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");+ }++ @Test+ @Order(5)+ void setupAuthorizers() {+ // Allow authorizer (IAM policy format, payload version 1.0)+ allowAuthorizerId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"allow-auth","authorizerType":"REQUEST","authorizerPayloadFormatVersion":"1.0","authorizerUri":"arn:aws:lambda:us-east-1:000000000000:function:%s/invocations"}+ """.formatted(ALLOW_FN))+ .when().post("/v2/apis/" + httpApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("authorizerId");++ // Deny authorizer (IAM policy format, payload version 1.0)+ denyAuthorizerId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"deny-auth","authorizerType":"REQUEST","authorizerPayloadFormatVersion":"1.0","authorizerUri":"arn:aws:lambda:us-east-1:000000000000:function:%s/invocations"}+ """.formatted(DENY_FN))+ .when().post("/v2/apis/" + httpApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("authorizerId");++ // Error authorizer+ errorAuthorizerId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"error-auth","authorizerType":"REQUEST","authorizerPayloadFormatVersion":"1.0","authorizerUri":"arn:aws:lambda:us-east-1:000000000000:function:%s/invocations"}+ """.formatted(ERROR_FN))+ .when().post("/v2/apis/" + httpApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("authorizerId");++ // Simple allow authorizer (format 2.0 with enableSimpleResponses)+ simpleAllowAuthorizerId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"simple-allow-auth","authorizerType":"REQUEST","authorizerPayloadFormatVersion":"2.0","enableSimpleResponses":true,"authorizerUri":"arn:aws:lambda:us-east-1:000000000000:function:%s/invocations"}+ """.formatted(SIMPLE_ALLOW_FN))+ .when().post("/v2/apis/" + httpApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("authorizerId");++ // Simple deny authorizer (format 2.0 with enableSimpleResponses)+ simpleDenyAuthorizerId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"simple-deny-auth","authorizerType":"REQUEST","authorizerPayloadFormatVersion":"2.0","enableSimpleResponses":true,"authorizerUri":"arn:aws:lambda:us-east-1:000000000000:function:%s/invocations"}+ """.formatted(SIMPLE_DENY_FN))+ .when().post("/v2/apis/" + httpApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("authorizerId");++ // Identity source authorizer (requires Authorization header)+ identitySourceAuthorizerId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"identity-auth","authorizerType":"REQUEST","authorizerPayloadFormatVersion":"1.0","identitySource":"$request.header.Authorization","authorizerUri":"arn:aws:lambda:us-east-1:000000000000:function:%s/invocations"}+ """.formatted(ALLOW_FN))+ .when().post("/v2/apis/" + httpApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("authorizerId");++ // Echo authorizer (format 1.0)+ echoV1AuthorizerId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"echo-auth-v1","authorizerType":"REQUEST","authorizerPayloadFormatVersion":"1.0","authorizerUri":"arn:aws:lambda:us-east-1:000000000000:function:%s/invocations"}+ """.formatted(ECHO_FN))+ .when().post("/v2/apis/" + httpApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("authorizerId");++ // Echo authorizer (format 2.0)+ echoV2AuthorizerId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"echo-auth-v2","authorizerType":"REQUEST","authorizerPayloadFormatVersion":"2.0","authorizerUri":"arn:aws:lambda:us-east-1:000000000000:function:%s/invocations"}+ """.formatted(ECHO_FN))+ .when().post("/v2/apis/" + httpApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("authorizerId");+ }++ // ──────────────────────────── Test: Allow with IAM policy (format 1.0) ────────────────────────────++ @Test+ @Order(10)+ void requestAuthorizerAllowsWithIamPolicy() {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(allowAuthorizerId))+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)+ .then().statusCode(200);++ given()+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(200);+ }++ // ──────────────────────────── Test: Deny with IAM policy (format 1.0) ────────────────────────────++ @Test+ @Order(20)+ void requestAuthorizerDeniesWithIamPolicy() {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(denyAuthorizerId))+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)+ .then().statusCode(200);++ given()+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(403);+ }++ // ──────────────────────────── Test: Authorizer invocation error returns 500 ────────────────────────────++ @Test+ @Order(30)+ void requestAuthorizerErrorReturns500() {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(errorAuthorizerId))+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)+ .then().statusCode(200);++ given()+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(500);+ }++ // ──────────────────────────── Test: Simple response Allow (format 2.0) ────────────────────────────++ @Test+ @Order(40)+ void simpleResponseAllows() {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(simpleAllowAuthorizerId))+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)+ .then().statusCode(200);++ given()+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(200);+ }++ // ──────────────────────────── Test: Simple response Deny (format 2.0) ────────────────────────────++ @Test+ @Order(50)+ void simpleResponseDenies() {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(simpleDenyAuthorizerId))+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)+ .then().statusCode(200);++ given()+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(403);+ }++ // ──────────────────────────── Test: Missing identity source returns 401 ────────────────────────────++ @Test+ @Order(60)+ void missingIdentitySourceReturns401() {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(identitySourceAuthorizerId))+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)+ .then().statusCode(200);++ // Request WITHOUT the required Authorization header — should get 401+ given()+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(401);+ }++ // ──────────────────────────── Test: Present identity source allows invocation ────────────────────────────++ @Test+ @Order(61)+ void presentIdentitySourceAllowsInvocation() {+ // Route still has identitySourceAuthorizerId from previous test+ given()+ .header("Authorization", "Bearer my-token")+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(200);+ }++ // ──────────────────────────── Test: Query string identity source validation ────────────────────────────++ @Test+ @Order(70)+ void queryStringIdentitySourceValidation() {+ String qsAuthorizerId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"qs-identity-auth","authorizerType":"REQUEST","authorizerPayloadFormatVersion":"1.0","identitySource":"$request.querystring.token","authorizerUri":"arn:aws:lambda:us-east-1:000000000000:function:%s/invocations"}+ """.formatted(ALLOW_FN))+ .when().post("/v2/apis/" + httpApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("authorizerId");++ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(qsAuthorizerId))+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)+ .then().statusCode(200);++ // Without required query param — 401+ given()+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(401);++ // With required query param — succeeds+ given()+ .queryParam("token", "my-secret-token")+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(200);+ }++ // ──────────────────────────── Test: Payload format 1.0 event shape ────────────────────────────++ @Test+ @Order(80)+ void payloadFormat10EventShape() throws Exception {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(echoV1AuthorizerId))+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)+ .then().statusCode(200);++ // The echo authorizer allows the request and embeds the received event in its context.+ // The backend Lambda receives the proxy event which does NOT include authorizer context+ // in the v2 proxy event format. So we verify the authorizer was invoked (200 response)+ // and then invoke the echo function directly with a realistic event to verify format.+ String response = given()+ .header("X-Custom-Header", "test-value")+ .queryParam("foo", "bar")+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(200)+ .extract().body().asString();++ // Backend received the request — authorizer allowed it+ JsonNode backendResponse = MAPPER.readTree(response);+ assertEquals("Hello from backend", backendResponse.path("message").asText());++ // Verify format by invoking echo function with a v1-shaped event+ String testEvent = """+ {"version":"1.0","type":"REQUEST","methodArn":"arn:aws:execute-api:us-east-1:000000000000:%s/test/GET/hello","resource":"/hello","path":"/hello","httpMethod":"GET","headers":{"X-Custom-Header":"test-value"},"queryStringParameters":{"foo":"bar"}}+ """.formatted(httpApiId);+ String echoResponse = given()+ .contentType(ContentType.JSON)+ .body(testEvent)+ .when().post("/2015-03-31/functions/" + ECHO_FN + "/invocations")+ .then().statusCode(200)+ .extract().body().asString();++ JsonNode echoResult = MAPPER.readTree(echoResponse);+ String authEventStr = echoResult.path("context").path("receivedEvent").asText(null);+ assertNotNull(authEventStr, "Echo authorizer should embed receivedEvent in context");+ JsonNode authEvent = MAPPER.readTree(authEventStr);++ assertEquals("REQUEST", authEvent.path("type").asText(), "Event type should be REQUEST");+ assertEquals("1.0", authEvent.path("version").asText(), "Event version should be 1.0");+ assertNotNull(authEvent.path("methodArn").asText(null), "Event should have methodArn");+ assertEquals("/hello", authEvent.path("resource").asText(), "Event should have resource");+ assertEquals("GET", authEvent.path("httpMethod").asText(), "Event should have httpMethod");+ }++ // ──────────────────────────── Test: Payload format 2.0 event shape ────────────────────────────++ @Test+ @Order(90)+ void payloadFormat20EventShape() throws Exception {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(echoV2AuthorizerId))+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)+ .then().statusCode(200);++ String response = given()+ .header("X-Custom-Header", "test-value-v2")+ .queryParam("key", "value")+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(200)+ .extract().body().asString();++ // Backend received the request — authorizer allowed it+ JsonNode backendResponse = MAPPER.readTree(response);+ assertEquals("Hello from backend", backendResponse.path("message").asText());++ // Verify format by invoking echo function with a v2-shaped event+ String testEvent = """+ {"version":"2.0","type":"REQUEST","routeArn":"arn:aws:execute-api:us-east-1:000000000000:%s/test/GET/hello","routeKey":"GET /hello","rawPath":"/hello","rawQueryString":"key=value","headers":{"x-custom-header":"test-value-v2"},"queryStringParameters":{"key":"value"},"requestContext":{"accountId":"000000000000","apiId":"%s","http":{"method":"GET","path":"/hello"}}}+ """.formatted(httpApiId, httpApiId);+ String echoResponse = given()+ .contentType(ContentType.JSON)+ .body(testEvent)+ .when().post("/2015-03-31/functions/" + ECHO_FN + "/invocations")+ .then().statusCode(200)+ .extract().body().asString();++ JsonNode echoResult = MAPPER.readTree(echoResponse);+ String authEventStr = echoResult.path("context").path("receivedEvent").asText(null);+ assertNotNull(authEventStr, "Echo authorizer should embed receivedEvent in context");+ JsonNode authEvent = MAPPER.readTree(authEventStr);++ assertEquals("REQUEST", authEvent.path("type").asText(), "Event type should be REQUEST");+ assertEquals("2.0", authEvent.path("version").asText(), "Event version should be 2.0");+ assertNotNull(authEvent.path("routeArn").asText(null), "Event should have routeArn");+ assertEquals("GET /hello", authEvent.path("routeKey").asText(), "Event should have routeKey");+ assertEquals("/hello", authEvent.path("rawPath").asText(), "Event should have rawPath");+ }++ // ──────────────────────────── Test: No authorizer (NONE) allows request ────────────────────────────++ @Test+ @Order(100)+ void noAuthorizerAllowsRequest() {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"NONE","authorizerId":null}+ """)+ .when().patch("/v2/apis/" + httpApiId + "/routes/" + routeId)+ .then().statusCode(200);++ given()+ .when().get("/execute-api/" + httpApiId + "/test/hello")+ .then().statusCode(200);+ }++ // ──────────────────────────── Cleanup ────────────────────────────++ @Test+ @Order(999)+ void cleanup() {+ if (routeId != null) given().when().delete("/v2/apis/" + httpApiId + "/routes/" + routeId);+ if (httpApiId != null) given().when().delete("/v2/apis/" + httpApiId);+ for (String fn : new String[]{BACKEND_FN, ALLOW_FN, DENY_FN, ERROR_FN, SIMPLE_ALLOW_FN, SIMPLE_DENY_FN, ECHO_FN}) {+ deleteFunction(fn);+ }+ }++ // ──────────────────────────── Helpers ────────────────────────────++ private static void createNodeLambda(String functionName, String handlerSource) throws Exception {+ String zipBase64 = Base64.getEncoder().encodeToString(zipEntries(Map.of("index.js", handlerSource)));+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"FunctionName":"%s","Runtime":"nodejs20.x","Role":"arn:aws:iam::000000000000:role/lambda-role","Handler":"index.handler","Timeout":30,"Code":{"ZipFile":"%s"}}+ """.formatted(functionName, zipBase64))+ .when().post("/2015-03-31/functions")+ .then().statusCode(201);+ }++ private static byte[] zipEntries(Map<String, String> entries) throws Exception {+ ByteArrayOutputStream baos = new ByteArrayOutputStream();+ try (ZipOutputStream zos = new ZipOutputStream(baos)) {+ for (Map.Entry<String, String> entry : entries.entrySet()) {+ zos.putNextEntry(new ZipEntry(entry.getKey()));+ zos.write(entry.getValue().getBytes(StandardCharsets.UTF_8));+ zos.closeEntry();+ }+ }+ return baos.toByteArray();+ }++ private static void deleteFunction(String functionName) {+ int statusCode = given()+ .when().delete("/2015-03-31/functions/" + functionName)+ .then().extract().statusCode();+ assertTrue(statusCode == 204 || statusCode == 404);+ }+}