Light, fluffy, and always free - The AWS Local Emulator alternative
fix(apigatewayv2): answer the Lambda proxy results an HTTP API cannot read with 500 (#5985)
Alessandro Lattao49d2d74f3f38
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ApiGatewayV2LambdaProxyResponseTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ApiGatewayV2LambdaProxyResponseTest.javanew file mode 100644index 0000000000..2853601a7e--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/ApiGatewayV2LambdaProxyResponseTest.java@@ -0,0 +1,135 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.Assumptions;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import software.amazon.awssdk.core.SdkBytes;+import software.amazon.awssdk.services.apigatewayv2.ApiGatewayV2Client;+import software.amazon.awssdk.services.apigatewayv2.model.IntegrationType;+import software.amazon.awssdk.services.lambda.LambdaClient;+import software.amazon.awssdk.services.lambda.model.Runtime;++import java.io.IOException;+import java.net.URI;+import java.net.http.HttpClient;+import java.net.http.HttpRequest;+import java.net.http.HttpResponse;+import java.time.Duration;++import static org.assertj.core.api.Assertions.assertThat;++/**+ * How an HTTP API answers the Lambda proxy results it cannot read, in payload formats 1.0 and 2.0.+ * Measured on AWS (eu-west-1, 2026-10-19): a function that raises, a 1.0 result without a+ * statusCode, and a statusCode that is not a whole number from 100 to 599 are answered 500 with+ * {"message":"Internal Server Error"}; a statusCode given as text that spells one is taken; format+ * 2.0 takes a result without a statusCode as a 200 whose body is the result itself.+ */+@DisplayName("API Gateway V2 Lambda proxy responses")+class ApiGatewayV2LambdaProxyResponseTest {++ private static final String ROLE = "arn:aws:iam::000000000000:role/lambda-role";+ private static final String ERROR = "{\"message\":\"Internal Server Error\"}";+ private static final String STAGE = "test";++ private static ApiGatewayV2Client apiGatewayV2;+ private static LambdaClient lambda;+ private static HttpClient http;+ private static String functionName;+ private static String apiId;++ @BeforeAll+ static void setup() {+ Assumptions.assumeTrue(TestFixtures.isLambdaDispatchAvailable(), "Lambda dispatch is unavailable here");+ apiGatewayV2 = TestFixtures.apiGatewayV2Client();+ lambda = TestFixtures.lambdaClient();+ http = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(5)).build();+ functionName = TestFixtures.uniqueName("http-api-proxy-fn");++ String functionArn = lambda.createFunction(request -> request+ .functionName(functionName)+ .runtime(Runtime.NODEJS20_X)+ .role(ROLE)+ .handler("index.handler")+ .timeout(30)+ .code(code -> code.zipFile(SdkBytes.fromByteArray(LambdaUtils.proxyResponseZip())))).functionArn();+ apiId = apiGatewayV2.createApi(request -> request+ .name(TestFixtures.uniqueName("http-api-proxy"))+ .protocolType("HTTP")).apiId();+ for (String format : new String[] {"1.0", "2.0"}) {+ String integrationId = apiGatewayV2.createIntegration(request -> request+ .apiId(apiId)+ .integrationType(IntegrationType.AWS_PROXY)+ .integrationUri(functionArn)+ .payloadFormatVersion(format)).integrationId();+ apiGatewayV2.createRoute(request -> request+ .apiId(apiId)+ .routeKey("GET /v" + format.charAt(0) + "/{mode}")+ .target("integrations/" + integrationId));+ }+ apiGatewayV2.createStage(request -> request.apiId(apiId).stageName(STAGE).autoDeploy(true));++ // As ApiGatewayV2ExecuteTest does: a result the gateway can read must come back through the+ // API before the cases run, or this environment cannot dispatch from API Gateway to Lambda.+ boolean dispatches;+ try {+ HttpResponse<String> warmup = get("2.0", "ok");+ dispatches = warmup.statusCode() == 200 && "ok".equals(warmup.body());+ } catch (IOException e) {+ dispatches = false;+ }+ Assumptions.assumeTrue(dispatches, "API Gateway does not dispatch to Lambda here");+ }++ @AfterAll+ static void cleanup() {+ if (apiGatewayV2 != null) {+ if (apiId != null) {+ apiGatewayV2.deleteApi(request -> request.apiId(apiId));+ }+ apiGatewayV2.close();+ }+ if (lambda != null) {+ lambda.deleteFunction(request -> request.functionName(functionName));+ lambda.close();+ }+ }++ @ParameterizedTest(name = "{1} in payload {0}")+ @CsvSource(delimiter = '|', value = {+ "1.0|raise|500|" + ERROR,+ "2.0|raise|500|" + ERROR,+ "1.0|nostatus|500|" + ERROR,+ "1.0|badstatus|500|" + ERROR,+ "2.0|badstatus|500|" + ERROR,+ "1.0|highstatus|500|" + ERROR,+ "2.0|highstatus|500|" + ERROR,+ "1.0|textstatus|201|x",+ "2.0|textstatus|201|x",+ "2.0|nostatus|200|{\"body\":\"x\",\"headers\":{\"x-probe\":\"1\"}}"+ })+ void aResultIsAnsweredAsAwsReadsIt(String format, String mode, int status, String body) throws Exception {+ HttpResponse<String> response = get(format, mode);++ assertThat(response.statusCode()).isEqualTo(status);+ assertThat(response.body()).isEqualTo(body);+ }++ private static HttpResponse<String> get(String format, String mode) throws IOException {+ HttpRequest request = HttpRequest.newBuilder()+ .uri(URI.create(TestFixtures.endpoint() + "/execute-api/" + apiId + "/" + STAGE + "/v"+ + format.charAt(0) + "/" + mode))+ .timeout(Duration.ofSeconds(30))+ .GET()+ .build();+ try {+ return http.send(request, HttpResponse.BodyHandlers.ofString());+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IOException("interrupted waiting for " + request.uri(), e);+ }+ }+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaUtils.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaUtils.javaindex 8ec6954f46..d8d132f5a7 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaUtils.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/LambdaUtils.java@@ -334,6 +334,26 @@ public final class LambdaUtils {return createZip("lambda_function.py", code);}+ /**+ * ZIP containing a Node.js handler that returns the Lambda proxy result its {@code mode} path+ * parameter names: one that raises, one without a statusCode, one whose statusCode is not a+ * number, one whose statusCode is text that spells one, and one outside 100 to 599.+ */+ public static byte[] proxyResponseZip() {+ String code = """+ exports.handler = async (event) => {+ const mode = (event.pathParameters || {}).mode;+ if (mode === 'raise') throw new Error('boom');+ if (mode === 'nostatus') return { body: 'x', headers: { 'x-probe': '1' } };+ if (mode === 'badstatus') return { statusCode: 'abc', body: 'x' };+ if (mode === 'textstatus') return { statusCode: '201', body: 'x' };+ if (mode === 'highstatus') return { statusCode: 600, body: 'x' };+ return { statusCode: 200, body: 'ok' };+ };+ """;+ return createZip("index.js", code);+ }+private static byte[] createZip(String filename, String content) {try {ByteArrayOutputStream baos = new ByteArrayOutputStream();diff --git a/docs/services/api-gateway.md b/docs/services/api-gateway.mdindex 7a8ab4a1ed..9635144a07 100644--- a/docs/services/api-gateway.md+++ b/docs/services/api-gateway.md@@ -656,6 +656,12 @@ curl http://{apiId}.execute-api.{region}.localhost.floci.io:4566/{stageName}/{paAPIs created or updated with `disableExecuteApiEndpoint` reject requests tothis default hostname with `404 Not Found`, matching AWS HTTP API behavior.+A Lambda proxy integration's response is read as AWS reads it (measured): a function that raises, a+format 1.0 result that is not an object with a `statusCode`, and a `statusCode` that is not a whole+number from 100 to 599 (text that spells one, such as `"201"`, is taken) are answered `500` with+`{"message":"Internal Server Error"}`. Format 2.0 takes a result without a `statusCode` as a `200`+whose body is the result itself.+An API with a `corsConfiguration` applies it as AWS does (measured). It ignores the CORS headers anintegration returns, and sets its own on whatever answers a route: the integration, or API Gatewayitself refusing the request (a JWT or Lambda authorizer's `401` or `403`, an unsigned call to andiff --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 6292fdaabd..13db68e896 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@@ -1586,9 +1586,9 @@ public class ApiGatewayExecuteController {// response rules (inference and cookies). An HTTP API integration can still use format 1.0.Response buildProxyResponse(InvokeResult result, boolean httpApi, boolean payloadV2) {if (httpApi && result.getFunctionError() != null) {- // An HTTP API never relays the error payload: the client gets AWS's generic message.- return Response.status(502).entity(jsonMessage("Internal Server Error"))- .type(MediaType.APPLICATION_JSON).build();+ // An HTTP API never relays the error payload: the client gets AWS's generic message, as+ // a 500 (measured, both payload formats, eu-west-1, 2026-10-19).+ return httpApiError(500, "Internal Server Error");}if (result.getPayload() == null || result.getPayload().length == 0) {return Response.status(result.getFunctionError() != null ? 502 : result.getStatusCode()).build();@@ -1605,7 +1605,14 @@ public class ApiGatewayExecuteController {: result.getPayload();return Response.status(200).entity(inferredBody).type(MediaType.APPLICATION_JSON).build();}- int statusCode = node.path("statusCode").asInt(200);+ if (httpApi && httpApiStatusCode(node) == null) {+ // Measured (eu-west-1, 2026-10-19): an HTTP API answers a response it cannot read+ // with 500 and its generic message, in format 1.0 a result that is not an object with+ // a statusCode, and in either format a statusCode that is not a whole number from 100+ // to 599, though text spelling one ("201") is taken.+ return httpApiError(500, "Internal Server Error");+ }+ int statusCode = httpApi ? httpApiStatusCode(node) : node.path("statusCode").asInt(200);if (result.getFunctionError() != null && !node.has("statusCode")) statusCode = 502;Response.ResponseBuilder builder = Response.status(statusCode);@@ -1644,6 +1651,27 @@ public class ApiGatewayExecuteController {}}+ /** The status and generic message an HTTP API answers with when its Lambda integration fails. */+ private Response httpApiError(int status, String message) {+ return Response.status(status).entity(jsonMessage(message)).type(MediaType.APPLICATION_JSON).build();+ }++ private static final Pattern WHOLE_STATUS = Pattern.compile("\\d{1,3}");++ /**+ * The status an HTTP API takes from a Lambda proxy response, or null when it cannot read one: a+ * whole number from 100 to 599, or text that spells one.+ */+ private static Integer httpApiStatusCode(JsonNode response) {+ JsonNode status = response.path("statusCode");+ String text = status.isIntegralNumber() ? status.asText() : status.isTextual() ? status.textValue() : "";+ if (!WHOLE_STATUS.matcher(text).matches()) {+ return null;+ }+ int code = Integer.parseInt(text);+ return code >= 100 && code <= 599 ? code : null;+ }+/*** HTTP header names are case-insensitive on the wire (RFC 7230 §3.2), and Lambda proxy* integrations commonly return lowercased names (e.g. the AWS Lambda Web Adapter emits@@ -2776,9 +2804,7 @@ public class ApiGatewayExecuteController {// function that is gone, or one API Gateway may not invoke).LOG.debugv("execute-api v2: invoking {0} failed: {1}", functionName, e.getMessage());boolean throttled = e.getHttpStatus() == 429;- return Response.status(throttled ? 503 : 500)- .entity(jsonMessage(throttled ? "Service Unavailable" : "Internal Server Error"))- .type(MediaType.APPLICATION_JSON).build();+ return throttled ? httpApiError(503, "Service Unavailable") : httpApiError(500, "Internal Server Error");}}diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteControllerTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteControllerTest.javaindex 919002796d..71c52dcd8a 100644--- a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteControllerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteControllerTest.java@@ -14,6 +14,9 @@ import jakarta.ws.rs.core.MultivaluedMap;import jakarta.ws.rs.core.Response;import jakarta.ws.rs.core.UriInfo;import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.Arguments;+import org.junit.jupiter.params.provider.MethodSource;import java.net.URI;import java.nio.charset.StandardCharsets;@@ -27,6 +30,7 @@ import java.util.Locale;import java.util.Map;import java.util.TimeZone;import java.util.function.Supplier;+import java.util.stream.Stream;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNull;@@ -247,6 +251,47 @@ class ApiGatewayExecuteControllerTest {assertNull(ApiGatewayExecuteController.vtlAuthorizerContext(null, Map.of()));}+ // ── HTTP API Lambda proxy responses AWS cannot read ──────++ /**+ * Measured on HTTP APIs (eu-west-1, 2026-10-19), for payload formats 1.0 and 2.0: a 1.0 result+ * that is not an object with a statusCode, and a statusCode that is not a whole number from 100+ * to 599, are answered with 500 and the generic message; a statusCode given as text that spells+ * one is taken, and headers that are not an object are left out. A function that raises is+ * covered below.+ */+ @ParameterizedTest(name = "{0} payload {1}")+ @MethodSource("httpApiProxyResponses")+ void httpApiAnswersAProxyResponseAsAwsReadsIt(String result, String format, int status, String body) {+ ApiGatewayExecuteController controller = controller(new ObjectMapper());+ try (Response response = controller.buildProxyResponse(proxyPayload(result), true, "2.0".equals(format))) {+ assertEquals(status, response.getStatus());+ assertEquals(body, bodyOf(response));+ }+ }++ static Stream<Arguments> httpApiProxyResponses() {+ String error = "{\"message\":\"Internal Server Error\"}";+ return Stream.of(+ Arguments.of("\"hello\"", "1.0", 500, error),+ Arguments.of("null", "1.0", 500, error),+ Arguments.of("5", "1.0", 500, error),+ Arguments.of("{\"statusCode\":\"abc\",\"body\":\"x\"}", "1.0", 500, error),+ Arguments.of("{\"statusCode\":\"abc\",\"body\":\"x\"}", "2.0", 500, error),+ Arguments.of("{\"statusCode\":99,\"body\":\"x\"}", "1.0", 500, error),+ Arguments.of("{\"statusCode\":99,\"body\":\"x\"}", "2.0", 500, error),+ Arguments.of("{\"statusCode\":600,\"body\":\"x\"}", "1.0", 500, error),+ Arguments.of("{\"statusCode\":600,\"body\":\"x\"}", "2.0", 500, error),+ Arguments.of("{\"statusCode\":201.5,\"body\":\"x\"}", "1.0", 500, error),+ Arguments.of("{\"statusCode\":201.5,\"body\":\"x\"}", "2.0", 500, error),+ Arguments.of("{\"statusCode\":\"201\",\"body\":\"x\"}", "1.0", 201, "x"),+ Arguments.of("{\"statusCode\":\"201\",\"body\":\"x\"}", "2.0", 201, "x"),+ Arguments.of("{\"statusCode\":201,\"headers\":\"x\",\"body\":\"x\"}", "1.0", 201, "x"),+ Arguments.of("{\"statusCode\":201,\"headers\":\"x\",\"body\":\"x\"}", "2.0", 201, "x"),+ Arguments.of("null", "2.0", 200, "null"),+ Arguments.of("5", "2.0", 200, "5"));+ }+// ── Lambda proxy response Content-Type header matching ──────private static InvokeResult proxyPayload(String payloadJson) {@@ -552,21 +597,21 @@ class ApiGatewayExecuteControllerTest {ApiGatewayExecuteController controller = controller(new ObjectMapper());try (Response response = controller.buildProxyResponse(functionError("{\"errorType\":\"Error\",\"errorMessage\":\"boom\",\"trace\":[]}"), true)) {- assertEquals(502, response.getStatus());+ assertEquals(500, response.getStatus());assertEquals("application/json", String.valueOf(response.getMediaType()));assertEquals("{\"message\":\"Internal Server Error\"}", bodyOf(response));}}@Test- void httpApiPayloadV1ResponseWithoutStatusCodeIsNotInferred() {- // An HTTP API integration configured with payloadFormatVersion 1.0 keeps the 1.0 response rules.+ void httpApiPayloadV1ResponseWithoutStatusCodeAnswersInternalServerErrorMessage() {+ // Format 1.0 infers nothing, so a result without a statusCode is one the HTTP API cannot read.String payload = "{\"headers\":{\"X-Trace\":\"value\"},\"body\":\"inner\"}";ApiGatewayExecuteController controller = controller(new ObjectMapper());try (Response response = controller.buildProxyResponse(proxyPayload(payload), true, false)) {- assertEquals(200, response.getStatus());- assertEquals("inner", bodyOf(response));- assertEquals("value", response.getHeaderString("X-Trace"));+ assertEquals(500, response.getStatus());+ assertEquals("{\"message\":\"Internal Server Error\"}", bodyOf(response));+ assertNull(response.getHeaderString("X-Trace"));}}@@ -575,7 +620,7 @@ class ApiGatewayExecuteControllerTest {ApiGatewayExecuteController controller = controller(new ObjectMapper());try (Response response = controller.buildProxyResponse(functionError("{\"errorType\":\"Error\",\"errorMessage\":\"boom\",\"trace\":[]}"), true, false)) {- assertEquals(502, response.getStatus());+ assertEquals(500, response.getStatus());assertEquals("{\"message\":\"Internal Server Error\"}", bodyOf(response));}}diff --git a/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiLambdaProxyResponseInferenceIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiLambdaProxyResponseInferenceIntegrationTest.javaindex da364214c0..978e064be7 100644--- a/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiLambdaProxyResponseInferenceIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiLambdaProxyResponseInferenceIntegrationTest.java@@ -10,6 +10,7 @@ import org.junit.jupiter.api.TestMethodOrder;import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.equalTo;import static org.hamcrest.Matchers.notNullValue;+import static org.hamcrest.Matchers.nullValue;import static org.hamcrest.Matchers.startsWith;/**@@ -121,23 +122,27 @@ class HttpApiLambdaProxyResponseInferenceIntegrationTest {@Test@Order(12)void functionErrorAnswersInternalServerErrorMessage() {+ // Measured on HTTP APIs (eu-west-1, 2026-10-19): 500, in both payload formats.given().when().get("/execute-api/" + apiId + "/test/throw").then()- .statusCode(502)+ .statusCode(500).contentType(startsWith("application/json")).body("message", equalTo("Internal Server Error"));}@Test@Order(13)- void payloadV1ResponseFieldsAreNotInferred() {+ void payloadV1ResponseWithoutStatusCodeAnswersInternalServerErrorMessage() {+ // Format 1.0 infers nothing: a result with headers and a body but no statusCode is one+ // the HTTP API cannot read, and it answers 500 (measured, eu-west-1, 2026-10-19).given().when().get("/execute-api/" + apiId + "/test/v1").then()- .statusCode(200)- .header("X-Trace", "value")- .body(equalTo("inner"));+ .statusCode(500)+ .contentType(startsWith("application/json"))+ .header("X-Trace", nullValue())+ .body("message", equalTo("Internal Server Error"));}@Test