Light, fluffy, and always free - The AWS Local Emulator alternative
fix(apigateway): map authorizer context in HTTP integrations (#4992)
Abhigya036f55b196a3
diff --git a/docs/services/api-gateway.md b/docs/services/api-gateway.mdindex 33201414bc..c3363d6fa1 100644--- a/docs/services/api-gateway.md+++ b/docs/services/api-gateway.md@@ -309,6 +309,31 @@ A greedy resource captures only the path segments after its parent. For example,`/api/v1/auth/signup/{proxy}` forwards the prefix once. Greedy parameter names otherthan `proxy` are supported, including in `integration.request.path.*` mappings.+REST `HTTP_PROXY` and `HTTP` integrations also accept `context.*` sources in header, query+and path parameter mappings. Supported request fields are `accountId`, `apiId`, `deploymentId`,+`httpMethod`, `path` (including the stage), `protocol`, `requestId`, `resourceId`, `resourcePath`,+`stage`, `identity.sourceIp` and `identity.userAgent`. `context.requestId` uses the same ID as+the HTTP integration's VTL templates. `context.authorizer.principalId` and+`context.authorizer.<property>` come from the successful authorizer result; authenticated Cognito+claims are available as `context.authorizer.claims.<property>`. String, number and boolean values+are forwarded as strings. Missing values and objects are not mapped. An explicit header mapping+replaces all inbound values of that header, regardless of casing.++For a header mapped from `context.*`, inbound values are also removed when the context value is+missing or is not a scalar. The backend therefore cannot receive a client-supplied value in place+of an absent authorizer claim. An unresolved `method.request.*` mapping retains the existing+HTTP proxy passthrough behavior.++`method.request.*` sources always read the original inbound headers, query parameters and path+parameters. Mapped destinations do not change another mapping's source, regardless of mapping order.++Use alphanumeric or underscore authorizer context keys, as required by the+[AWS mapping contract](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html).+For example, return `userClaims` in the authorizer context and map+`integration.request.header.X-User-Claims` from `context.authorizer.userClaims`. The HTTP header+name can contain hyphens. REST Lambda authorizer result caching is not implemented; setting+`authorizerResultTtlInSeconds` does not currently suppress repeat Lambda invocations.+A backend response body larger than the 10 MB API Gateway payload quota yields `413` with `{"message":"Request Entity Too Large"}`. The same limit applies to HTTP API `HTTP_PROXY` integrations.Passthrough keeps repeated values repeated, in both directions: `?tag=a&tag=b` reaches the backend as two `tag` parameters rather than one `tag=a,b`, a header sent twice arrives twice, and a backend that returns two `Set-Cookie` headers relays two to the caller. Comma-joining them would not be reversible, since a cookie's `Expires` attribute contains a comma of its own. An explicit `integration.request.header.X` or `integration.request.querystring.X` mapping overwrites, so it replaces any repeated inbound values with the single mapped one.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 08d7504729..e6611e8a92 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@@ -468,7 +468,7 @@ public class ApiGatewayExecuteController {case "AWS" -> invokeAwsIntegration(scope, region, httpMethod, path, stageName,matched, integration, headers, uriInfo, body, authorizerResult);case "HTTP_PROXY" -> invokeHttpProxy(scope, apiId, httpMethod, path, stageName,- matched, integration, headers, uriInfo, body, iamIdentity);+ matched, integration, headers, uriInfo, body, authorizerResult, iamIdentity);case "HTTP" -> invokeHttpIntegration(scope, region, apiId, httpMethod, path, proxy, stageName,matched, integration, headers, uriInfo, body, authorizerResult);case "MOCK" -> invokeMock(scope, region, httpMethod, path, stageName,@@ -545,6 +545,7 @@ public class ApiGatewayExecuteController {String stageName, ApiGatewayResource resource,Integration integration, HttpHeaders headers,UriInfo uriInfo, byte[] body,+ AuthorizerResult authorizerResult,ExecuteApiSigV4Authorizer.CallerIdentity iamIdentity) {String uri = integration.getUri();if (uri == null || uri.isBlank()) {@@ -552,6 +553,9 @@ public class ApiGatewayExecuteController {"No integration URI configured");}+ String requestId = UUID.randomUUID().toString();+ Map<String, Object> mappingContext = httpRequestMappingContext(scope, requestId, authorizerResult);+// Two views of the same inbound data. The multi-value maps are what gets forwarded: a// proxy integration passes the request through, so "?tag=a&tag=b" has to arrive as two// tag parameters and not as "tag=a,b". The joined single-value maps are only the lookup@@ -573,26 +577,41 @@ public class ApiGatewayExecuteController {pathMap.putAll(extractPathParams(resource.getPath(), path));pathMap.putAll(greedyPathParam(resource.getPath(), path));- // integration.request.{header,querystring,path}.X ← method.request.*, applied here rather+ // Mapping sources always read the original request, independent of destination order.+ Map<String, String> outHeaders = new LinkedHashMap<>(headerMap);+ Map<String, String> outQuery = new LinkedHashMap<>(queryMap);+ Map<String, String> outPath = new LinkedHashMap<>(pathMap);++ // REST integration.request.* mappings are applied here rather// than by the v2 RequestParameterMapper: that mapper reads the unrelated v2 syntax// ("append:header.x" → "$request.header.y") and would silently ignore these REST mappings.Map<String, String> requestParameters = integration.getRequestParameters();if (requestParameters != null) {for (Map.Entry<String, String> param : requestParameters.entrySet()) {String dest = param.getKey();- String resolved = resolveRequestParameter(param.getValue(), queryMap, pathMap, headerMap);- if (resolved == null) continue;+ String source = param.getValue();+ String resolved = resolveRequestParameter(source, queryMap, pathMap, headerMap, mappingContext);+ boolean isContextHeader = dest.startsWith("integration.request.header.")+ && source != null && source.startsWith("context.");+ if (resolved == null && !isContextHeader) {+ continue;+ }// An explicit mapping overwrites, so it replaces any repeated inbound values too.if (dest.startsWith("integration.request.header.")) {String name = dest.substring("integration.request.header.".length());- headerMap.put(name, resolved);- multiValueHeaders.put(name, List.of(resolved));+ // A missing context value must not fall back to a client-supplied trusted header.+ outHeaders.keySet().removeIf(existing -> existing.equalsIgnoreCase(name));+ multiValueHeaders.keySet().removeIf(existing -> existing.equalsIgnoreCase(name));+ if (resolved != null) {+ outHeaders.put(name, resolved);+ multiValueHeaders.put(name, List.of(resolved));+ }} else if (dest.startsWith("integration.request.querystring.")) {String name = dest.substring("integration.request.querystring.".length());- queryMap.put(name, resolved);+ outQuery.put(name, resolved);multiValueQuery.put(name, List.of(resolved));} else if (dest.startsWith("integration.request.path.")) {- pathMap.put(dest.substring("integration.request.path.".length()), resolved);+ outPath.put(dest.substring("integration.request.path.".length()), resolved);}}}@@ -609,10 +628,10 @@ public class ApiGatewayExecuteController {io.github.hectorvent.floci.services.apigatewayv2.proxy.RequestContext ctx =new io.github.hectorvent.floci.services.apigatewayv2.proxy.RequestContext(apiId, stageName, httpMethod, path,- pathMap.getOrDefault("proxy", ""), resource.getPath(),- UUID.randomUUID().toString(),+ outPath.getOrDefault("proxy", ""), resource.getPath(),+ requestId,headerMap.getOrDefault("X-Forwarded-For", "127.0.0.1"),- headerMap, queryMap, pathMap, body,+ outHeaders, outQuery, outPath, body,Map.of(), Map.of(),multiValueHeaders, multiValueQuery);@@ -847,6 +866,7 @@ public class ApiGatewayExecuteController {}String requestId = UUID.randomUUID().toString();+ Map<String, Object> mappingContext = httpRequestMappingContext(scope, requestId, authorizerResult);boolean binaryRequest = isBinaryMediaType(region, apiId,headers.getHeaderString(HttpHeaders.CONTENT_TYPE));String bodyStr = templateBody(integration, body, binaryRequest);@@ -876,14 +896,14 @@ public class ApiGatewayExecuteController {// Only explicitly mapped parameters reach the backend — the defining difference from// HTTP_PROXY, which seeds the outgoing request with every inbound header and query param.- Map<String, String> outHeaders = new LinkedHashMap<>();+ Map<String, String> outHeaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);Map<String, String> outQuery = new LinkedHashMap<>();Map<String, String> outPath = new LinkedHashMap<>(pathMap);Map<String, String> requestParameters = integration.getRequestParameters();if (requestParameters != null) {for (Map.Entry<String, String> param : requestParameters.entrySet()) {String dest = param.getKey();- String resolved = resolveRequestParameter(param.getValue(), queryMap, pathMap, headerMap);+ String resolved = resolveRequestParameter(param.getValue(), queryMap, pathMap, headerMap, mappingContext);if (resolved == null) continue;if (dest.startsWith("integration.request.header.")) {outHeaders.put(dest.substring("integration.request.header.".length()), resolved);@@ -1626,7 +1646,7 @@ public class ApiGatewayExecuteController {for (Map.Entry<String, String> param : integrationReqParams.entrySet()) {String dest = param.getKey(); // integration.request.header.X-Foo or integration.request.querystring.barString source = param.getValue(); // method.request.querystring.q or method.request.header.Auth or method.request.path.id- String resolvedValue = resolveRequestParameter(source, queryMap, pathMap, headerMap);+ String resolvedValue = resolveRequestParameter(source, queryMap, pathMap, headerMap, Map.of());if (resolvedValue != null) {if (dest.startsWith("integration.request.header.")) {headerMap.put(dest.substring("integration.request.header.".length()), resolvedValue);@@ -1987,8 +2007,39 @@ public class ApiGatewayExecuteController {return null;}+ private Map<String, Object> httpRequestMappingContext(GatewayResponseScope scope, String requestId,+ AuthorizerResult authorizerResult) {+ Map<String, Object> context = new LinkedHashMap<>();+ context.put("accountId", regionResolver.getAccountId());+ context.put("apiId", scope.apiId());+ context.put("deploymentId", scope.stage().getDeploymentId());+ context.put("httpMethod", scope.httpMethod());+ context.put("path", "/" + scope.stageName() + scope.path());+ context.put("protocol", "HTTP/1.1");+ context.put("requestId", requestId);+ context.put("resourceId", scope.resource().getId());+ context.put("resourcePath", scope.resource().getPath());+ context.put("stage", scope.stageName());++ Map<String, Object> identity = new LinkedHashMap<>();+ identity.put("sourceIp", "127.0.0.1");+ identity.put("userAgent", scope.headers().getHeaderString("User-Agent"));+ context.put("identity", identity);++ Map<String, Object> authorizer = new LinkedHashMap<>();+ if (authorizerResult.context() != null) {+ authorizer.putAll(authorizerResult.context());+ }+ if (authorizerResult.principalId() != null) {+ authorizer.put("principalId", authorizerResult.principalId());+ }+ context.put("authorizer", authorizer);+ return context;+ }+private String resolveRequestParameter(String source, Map<String, String> queryParams,- Map<String, String> pathParams, Map<String, String> headers) {+ Map<String, String> pathParams, Map<String, String> headers,+ Map<String, Object> context) {if (source == null) return null;if (source.startsWith("method.request.querystring.")) {return queryParams.get(source.substring("method.request.querystring.".length()));@@ -1999,6 +2050,11 @@ public class ApiGatewayExecuteController {if (source.startsWith("method.request.header.")) {return headers.get(source.substring("method.request.header.".length()));}+ if (source.startsWith("context.")) {+ Object value = contextValue(context, source.substring("context.".length()));+ return value instanceof String || value instanceof Number || value instanceof Boolean+ ? value.toString() : null;+ }// Static valueif (source.startsWith("'") && source.endsWith("'")) {return source.substring(1, source.length() - 1);diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayHttpContextMappingIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayHttpContextMappingIntegrationTest.javanew file mode 100644index 0000000000..c89fa2d8ac--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayHttpContextMappingIntegrationTest.java@@ -0,0 +1,343 @@+package io.github.hectorvent.floci.services.apigateway;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.sun.net.httpserver.HttpExchange;+import com.sun.net.httpserver.HttpServer;+import io.github.hectorvent.floci.services.lambda.LambdaService;+import io.github.hectorvent.floci.services.lambda.model.InvocationType;+import io.github.hectorvent.floci.services.lambda.model.InvokeResult;+import io.quarkus.test.InjectMock;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.http.ContentType;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import org.junit.jupiter.params.provider.ValueSource;++import java.io.IOException;+import java.net.InetSocketAddress;+import java.nio.charset.StandardCharsets;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Locale;+import java.util.Map;+import java.util.UUID;+import java.util.concurrent.atomic.AtomicInteger;++import static io.restassured.RestAssured.given;+import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.when;++@QuarkusTest+class ApiGatewayHttpContextMappingIntegrationTest {++ private static final ObjectMapper MAPPER = new ObjectMapper();+ private static final String FUNCTION = "http-context-authorizer";+ private static final String AUTHORIZER_URI = "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:us-east-1:000000000000:function:" + FUNCTION + "/invocations";+ private static final AtomicInteger backendRequests = new AtomicInteger();+ private static HttpServer backend;++ @InjectMock+ LambdaService lambdaService;++ private String apiId;+ private String resourceId;+ private String methodPath;++ @BeforeAll+ static void startBackend() throws IOException {+ backend = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ backend.createContext("/", ApiGatewayHttpContextMappingIntegrationTest::echo);+ backend.start();+ }++ @AfterAll+ static void stopBackend() {+ backend.stop(0);+ }++ private static void echo(HttpExchange exchange) throws IOException {+ backendRequests.incrementAndGet();+ Map<String, Object> response = new LinkedHashMap<>();+ Map<String, List<String>> headers = new LinkedHashMap<>();+ exchange.getRequestHeaders().forEach((name, values) -> headers.put(name.toLowerCase(Locale.ROOT), values));+ response.put("headers", headers);+ response.put("path", exchange.getRequestURI().getPath());+ response.put("query", exchange.getRequestURI().getQuery());+ response.put("body", new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8));+ byte[] payload = MAPPER.writeValueAsBytes(response);+ exchange.getResponseHeaders().set("Content-Type", "application/json");+ exchange.sendResponseHeaders(200, payload.length);+ exchange.getResponseBody().write(payload);+ exchange.close();+ }++ @BeforeEach+ void createApi() {+ backendRequests.set(0);+ apiId = given().contentType(ContentType.JSON).body(Map.of("name", "http-context-mapping"))+ .post("/restapis").then().statusCode(201).extract().path("id");+ String rootId = given().get("/restapis/" + apiId + "/resources")+ .then().statusCode(200).extract().path("item[0].id");+ resourceId = given().contentType(ContentType.JSON).body(Map.of("pathPart", "{proxy+}"))+ .post("/restapis/" + apiId + "/resources/" + rootId)+ .then().statusCode(201).extract().path("id");+ methodPath = "/restapis/" + apiId + "/resources/" + resourceId + "/methods/";+ }++ @AfterEach+ void deleteApi() {+ if (apiId != null) {+ given().delete("/restapis/" + apiId).then().statusCode(202);+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"HTTP_PROXY", "HTTP"})+ void forwardsVerifiedAuthorizerScalarsAndRequestContext(String type) throws Exception {+ configureAuthorizer(0);+ configureIntegration(type, "GET");+ deploy();++ for (String endpoint : List.of("/execute-api/" + apiId + "/test/",+ "/restapis/" + apiId + "/test/_user_request_/")) {+ JsonNode response = MAPPER.readTree(given().header("Authorization", "Bearer allowed")+ .header("x-user-claims", "forged", "also-forged")+ .header("x-missing", "forged-missing")+ .header("x-object", "forged-object")+ .header("x-request-id", "client-id")+ .header("X-Source", "client-value")+ .get(endpoint + "orders/42?client=acme")+ .then().statusCode(200).extract().asByteArray());+ assertMappedContext(response);+ assertEquals("/test/orders/42", response.path("headers").path("x-context-path").get(0).asText());+ assertEquals("GET", response.path("headers").path("x-context-method").get(0).asText());+ assertEquals(apiId, response.path("headers").path("x-context-api").get(0).asText());+ assertEquals(resourceId, response.path("headers").path("x-context-resource").get(0).asText());+ assertEquals("/users/verified-user/orders/42", response.path("path").asText());+ assertTrue(response.path("query").asText().contains("claims=verified-claims"));+ assertTrue(response.path("query").asText().contains("client=acme"));+ assertEquals("client-value", response.path("headers").path("x-from-client").get(0).asText());+ assertEquals("static-value", response.path("headers").path("x-static").get(0).asText());+ if ("HTTP".equals(type)) {+ assertEquals(response.path("headers").path("x-request-id").get(0).asText(),+ MAPPER.readTree(response.path("body").asText()).path("requestId").asText());+ }+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"HTTP_PROXY", "HTTP"})+ void missingAuthorizerClaimDoesNotFallBackToClientHeader(String type) throws Exception {+ configureAuthorizer(0, Map.of());+ configureIntegration(type, "GET");+ deploy();++ for (String endpoint : List.of("/execute-api/" + apiId + "/test/",+ "/restapis/" + apiId + "/test/_user_request_/")) {+ JsonNode response = MAPPER.readTree(given().header("Authorization", "Bearer allowed")+ .header("x-user-claims", "forged", "also-forged")+ .get(endpoint + "orders/42")+ .then().statusCode(200).extract().asByteArray());+ assertFalse(response.path("headers").has("x-user-claims"));+ assertEquals(MAPPER.valueToTree(List.of("verified-user")), response.path("headers").path("x-principal"));+ }+ }++ @Test+ void missingMethodRequestMappingPreservesInboundProxyHeader() throws Exception {+ configureAuthorizer(0);+ configureIntegration("HTTP_PROXY", "GET");+ deploy();+ JsonNode response = MAPPER.readTree(given().header("Authorization", "Bearer allowed")+ .header("X-Unresolved", "client-value")+ .get("/execute-api/" + apiId + "/test/orders/42")+ .then().statusCode(200).extract().asByteArray());+ assertEquals(MAPPER.valueToTree(List.of("client-value")), response.path("headers").path("x-unresolved"));+ }++ @ParameterizedTest+ @CsvSource({"HTTP_PROXY,true,true", "HTTP_PROXY,true,false", "HTTP_PROXY,false,true", "HTTP_PROXY,false,false",+ "HTTP,true,true", "HTTP,true,false", "HTTP,false,true", "HTTP,false,false"})+ void requestMappingsReadOriginalInputs(String type, boolean hasClaim, boolean copiesFirst) throws Exception {+ configureAuthorizer(0, hasClaim ? Map.of("userClaims", "verified-claims") : Map.of());+ Map<String, String> replacements = new LinkedHashMap<>();+ replacements.put("integration.request.header.X-User-Claims", "context.authorizer.userClaims");+ replacements.put("integration.request.header.X-Principal", "context.authorizer.principalId");+ replacements.put("integration.request.querystring.claims", "'mapped-query'");+ replacements.put("integration.request.path.principal", "context.authorizer.principalId");+ replacements.put("integration.request.path.proxy", "'mapped-path'");+ Map<String, String> copies = new LinkedHashMap<>();+ copies.put("integration.request.header.X-Original-Claims", "method.request.header.x-user-claims");+ copies.put("integration.request.header.X-Original-Query", "method.request.querystring.claims");+ copies.put("integration.request.header.X-Original-Path", "method.request.path.proxy");+ Map<String, String> parameters = new LinkedHashMap<>();+ parameters.putAll(copiesFirst ? copies : replacements);+ parameters.putAll(copiesFirst ? replacements : copies);+ configureIntegration(type, "GET", parameters);+ deploy();++ for (String endpoint : List.of("/execute-api/" + apiId + "/test/",+ "/restapis/" + apiId + "/test/_user_request_/")) {+ JsonNode response = MAPPER.readTree(given().header("Authorization", "Bearer allowed")+ .header("x-user-claims", "client-claims")+ .get(endpoint + "orders/42?claims=client-query")+ .then().statusCode(200).extract().asByteArray());+ JsonNode headers = response.path("headers");+ assertEquals("client-claims", headers.path("x-original-claims").path(0).asText());+ assertEquals("client-query", headers.path("x-original-query").path(0).asText());+ assertEquals("orders/42", headers.path("x-original-path").path(0).asText());+ assertEquals("/users/verified-user/mapped-path", response.path("path").asText());+ assertEquals("claims=mapped-query", response.path("query").asText());+ if (hasClaim) {+ assertEquals(MAPPER.valueToTree(List.of("verified-claims")), headers.path("x-user-claims"));+ } else {+ assertFalse(headers.has("x-user-claims"));+ }+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"HTTP_PROXY", "HTTP"})+ void retainsContextOnRepeatedRequestsWithAuthorizerTtl(String type) throws Exception {+ configureAuthorizer(300);+ configureIntegration(type, "GET");+ deploy();+ String previousRequestId = null;+ for (int request = 0; request < 2; request++) {+ JsonNode response = MAPPER.readTree(given().header("Authorization", "Bearer allowed")+ .header("X-User-Claims", "forged")+ .get("/execute-api/" + apiId + "/test/orders/42")+ .then().statusCode(200).extract().asByteArray());+ assertMappedContext(response);+ String requestId = response.path("headers").path("x-request-id").get(0).asText();+ assertNotEquals(previousRequestId, requestId);+ previousRequestId = requestId;+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"HTTP_PROXY", "HTTP"})+ void rejectedTokensNeverReachBackend(String type) throws Exception {+ configureAuthorizer(0);+ configureIntegration(type, "GET");+ deploy();+ for (String token : List.of("", "Bearer forged")) {+ RequestSpecification request = given().header("X-User-Claims", "forged");+ if (!token.isEmpty()) {+ request.header("Authorization", token);+ }+ request.get("/execute-api/" + apiId + "/test/orders/42").then().statusCode(403);+ }+ assertEquals(0, backendRequests.get());+ }++ @ParameterizedTest+ @ValueSource(strings = {"HTTP_PROXY", "HTTP"})+ void unauthenticatedOptionsHasRequestContextWithoutBearerClaims(String type) throws Exception {+ configureAuthorizer(0);+ configureIntegration(type, "GET");+ given().contentType(ContentType.JSON).body(Map.of("authorizationType", "NONE"))+ .put(methodPath + "OPTIONS").then().statusCode(201);+ configureIntegration(type, "OPTIONS");+ deploy();+ JsonNode response = MAPPER.readTree(given().header("Authorization", "Bearer forged")+ .header("x-user-claims", "forged", "also-forged")+ .options("/execute-api/" + apiId + "/test/orders/42")+ .then().statusCode(200).extract().asByteArray());+ assertFalse(response.path("headers").has("x-user-claims"));+ assertFalse(response.path("headers").has("x-principal"));+ assertFalse(response.path("headers").has("x-missing"));+ assertFalse(response.path("headers").has("x-object"));+ assertEquals("OPTIONS", response.path("headers").path("x-context-method").path(0).asText());+ assertDoesNotThrow(() -> UUID.fromString(response.path("headers").path("x-request-id").path(0).asText()));+ }++ private void assertMappedContext(JsonNode response) {+ JsonNode headers = response.path("headers");+ assertEquals(MAPPER.valueToTree(List.of("verified-claims")), headers.path("x-user-claims"));+ assertEquals(MAPPER.valueToTree(List.of("verified-user")), headers.path("x-principal"));+ assertEquals(MAPPER.valueToTree(List.of("123")), headers.path("x-number"));+ assertEquals(MAPPER.valueToTree(List.of("true")), headers.path("x-boolean"));+ assertEquals(MAPPER.valueToTree(List.of("test")), headers.path("x-context-stage"));+ assertFalse(headers.has("x-missing"));+ assertFalse(headers.has("x-object"));+ assertEquals(1, headers.path("x-request-id").size());+ assertDoesNotThrow(() -> UUID.fromString(headers.path("x-request-id").get(0).asText()));+ }++ private void configureAuthorizer(int ttl) throws Exception {+ configureAuthorizer(ttl, Map.of("userClaims", "verified-claims", "principalId", "forged-principal",+ "numberKey", 123, "booleanKey", true, "objectKey", Map.of("nested", "value")));+ }++ private void configureAuthorizer(int ttl, Map<String, Object> context) throws Exception {+ String authorizerId = given().contentType(ContentType.JSON)+ .body(Map.of("name", "claims", "type", "TOKEN", "authorizerUri", AUTHORIZER_URI,+ "identitySource", "method.request.header.Authorization", "authorizerResultTtlInSeconds", ttl))+ .post("/restapis/" + apiId + "/authorizers")+ .then().statusCode(201).extract().path("id");+ given().contentType(ContentType.JSON)+ .body(Map.of("authorizationType", "CUSTOM", "authorizerId", authorizerId))+ .put(methodPath + "GET").then().statusCode(201);+ when(lambdaService.invoke(eq("us-east-1"), eq(FUNCTION), any(byte[].class), eq(InvocationType.RequestResponse)))+ .thenAnswer(invocation -> {+ JsonNode event = MAPPER.readTree((byte[]) invocation.getArgument(2));+ String effect = "Bearer allowed".equals(event.path("authorizationToken").asText()) ? "Allow" : "Deny";+ byte[] payload = MAPPER.writeValueAsBytes(Map.of("principalId", "verified-user",+ "policyDocument", Map.of("Version", "2012-10-17", "Statement", List.of(Map.of(+ "Action", "execute-api:Invoke", "Effect", effect, "Resource", "*"))),+ "context", context));+ return new InvokeResult(200, null, payload, null, "authorizer-request");+ });+ }++ private void configureIntegration(String type, String method) {+ Map<String, String> parameters = new LinkedHashMap<>();+ parameters.put("integration.request.header.X-User-Claims", "context.authorizer.userClaims");+ parameters.put("integration.request.header.X-Principal", "context.authorizer.principalId");+ parameters.put("integration.request.header.X-Number", "context.authorizer.numberKey");+ parameters.put("integration.request.header.X-Boolean", "context.authorizer.booleanKey");+ parameters.put("integration.request.header.X-Missing", "context.authorizer.missing");+ parameters.put("integration.request.header.X-Object", "context.authorizer.objectKey");+ parameters.put("integration.request.header.X-Request-Id", "context.requestId");+ parameters.put("integration.request.header.X-Context-Stage", "context.stage");+ parameters.put("integration.request.header.X-Context-Path", "context.path");+ parameters.put("integration.request.header.X-Context-Method", "context.httpMethod");+ parameters.put("integration.request.header.X-Context-Api", "context.apiId");+ parameters.put("integration.request.header.X-Context-Resource", "context.resourceId");+ parameters.put("integration.request.header.X-From-Client", "method.request.header.X-Source");+ parameters.put("integration.request.header.X-Unresolved", "method.request.querystring.missing");+ parameters.put("integration.request.header.X-Static", "'static-value'");+ parameters.put("integration.request.querystring.claims", "context.authorizer.userClaims");+ parameters.put("integration.request.querystring.client", "method.request.querystring.client");+ parameters.put("integration.request.path.principal", "context.authorizer.principalId");+ parameters.put("integration.request.path.proxy", "method.request.path.proxy");+ configureIntegration(type, method, parameters);+ }++ private void configureIntegration(String type, String method, Map<String, String> parameters) {+ // POST makes the HTTP integration's rendered request body observable at the echo backend.+ String integrationMethod = "HTTP".equals(type) && "GET".equals(method) ? "POST" : method;+ given().contentType(ContentType.JSON)+ .body(Map.of("type", type, "httpMethod", integrationMethod,+ "uri", "http://127.0.0.1:" + backend.getAddress().getPort() + "/users/{principal}/{proxy}",+ "requestParameters", parameters, "requestTemplates", Map.of("application/json",+ "{\"requestId\":\"$context.requestId\"}")))+ .put(methodPath + method + "/integration").then().statusCode(201);+ }++ private void deploy() {+ given().contentType(ContentType.JSON).body(Map.of("stageName", "test"))+ .post("/restapis/" + apiId + "/deployments").then().statusCode(201);+ }+}