Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(apigateway): support HTTP and HTTP_PROXY integrations on REST APIs (#3433)

Abhigya96707f6d5a1d
diff --git a/docs/services/api-gateway.md b/docs/services/api-gateway.md
index a767cba06c..fe853d255d 100644
--- a/docs/services/api-gateway.md
+++ b/docs/services/api-gateway.md
@@ -186,7 +186,26 @@ These management-plane operations have no handler in v1. Calls will return `404`
- Client Certificates (5 operations)
- `GetExport` / `ImportDocumentationParts`
-The execute plane (actual proxied HTTP traffic via `/restapis/{id}/{stage}/_user_request_/…`) is implemented separately and is not counted as management-plane operations. It supports `AWS_PROXY` (Lambda proxy), `AWS` (Lambda with VTL request/response templates), and `MOCK` integrations; other integration types return an error. A `MOCK` integration renders its request template and uses the `statusCode` it produces to pick the integration response, exactly as AWS does: the first response whose `selectionPattern` matches wins, otherwise the response without a pattern (the default) answers. This is what makes CORS preflights declared with a `204` response (CDK's `addCorsPreflight`) carry their `Access-Control-*` headers.
+The execute plane (actual proxied HTTP traffic via `/restapis/{id}/{stage}/_user_request_/…`) is implemented separately and is not counted as management-plane operations. It supports these integration types; others return an error:
+
+| Type | Support |
+| --- | --- |
+| `AWS_PROXY` (Lambda proxy) | ✅ |
+| `AWS` (Lambda / AWS service with VTL request/response templates) | ✅ |
+| `HTTP_PROXY` (passthrough to an arbitrary HTTP backend) | ✅ |
+| `HTTP` (non-proxy, with VTL request/response templates) | ✅ |
+| `MOCK` | ✅ |
+
+A `MOCK` integration renders its request template and uses the `statusCode` it produces to pick the integration response, exactly as AWS does: the first response whose `selectionPattern` matches wins, otherwise the response without a pattern (the default) answers. This is what makes CORS preflights declared with a `204` response (CDK's `addCorsPreflight`) carry their `Access-Control-*` headers.
+
+`HTTP_PROXY` forwards the request to the integration's `uri` — with `{param}` placeholders resolved from the matched resource's path parameters — and relays the backend's status, headers and body unchanged. Per AWS, no request templates and no integration-response selection apply to `HTTP_PROXY`, so a backend `4xx`/`5xx` reaches the caller verbatim rather than being remapped. `integration.request.{header,querystring,path}.*` → `method.request.*` mappings are applied. Hop-by-hop headers (including `Host`) are stripped. An unreachable or failing backend yields `502`.
+
+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.
+
+`HTTP` (non-proxy) transforms in both directions instead:
+
+- **Request** — the body is the rendered `requestTemplates` entry selected by the incoming `Content-Type` (falling back to the type without its charset), subject to `passthroughBehavior` (`NEVER` and `WHEN_NO_TEMPLATES` return `415`). Only headers and query parameters named by `integration.request.*` mappings are forwarded; unmapped inbound headers are **not** passed through — that passthrough is `HTTP_PROXY`'s job.
+- **Response** — the backend's reply runs through the method's integration responses. As in AWS, `selectionPattern` is matched against the backend's **HTTP status code** (for `AWS`/Lambda integrations it is matched against the error message instead), so `"5\\d{2}"` on a `502` integration response remaps any backend `5xx` to `502`. The matched response's `responseTemplates` render the body, `responseParameters` map `integration.response.header.*` (case-insensitively) or `integration.response.body.<jsonpath>` onto `method.response.header.*`, and `$context.responseOverride` assignments take precedence. With no integration responses configured, the backend's status and body are relayed as-is.
### Examples
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 3a3a608849..60665cd16f 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
@@ -49,6 +49,7 @@ import java.util.Base64;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
@@ -63,7 +64,7 @@ import java.util.regex.PatternSyntaxException;
/**
* Executes API Gateway stage requests, routing them through the configured
- * integration (AWS_PROXY or MOCK).
+ * integration (AWS_PROXY, AWS, HTTP_PROXY, HTTP or MOCK).
*
* <p>Endpoint: {@code /{apiId}/{stageName}/{proxy+}}
*
@@ -414,6 +415,10 @@ public class ApiGatewayExecuteController {
iamIdentity);
case "AWS" -> invokeAwsIntegration(region, httpMethod, path, stageName,
matched, integration, headers, uriInfo, body, authorizerResult);
+ case "HTTP_PROXY" -> invokeHttpProxy(apiId, httpMethod, path, proxy, stageName,
+ matched, integration, headers, uriInfo, body);
+ case "HTTP" -> invokeHttpIntegration(apiId, httpMethod, path, proxy, stageName,
+ matched, integration, headers, uriInfo, body, authorizerResult);
case "MOCK" -> invokeMock(region, httpMethod, path, stageName,
matched, integration, headers, uriInfo, body, authorizerResult);
default -> Response.status(500)
@@ -462,6 +467,246 @@ public class ApiGatewayExecuteController {
}
}
+ // ──────────────────────────── HTTP_PROXY ────────────────────────────
+
+ /**
+ * Forwards the request to an arbitrary HTTP backend and relays that backend's response.
+ *
+ * <p>HTTP_PROXY is a passthrough: AWS applies neither request templates nor integration-response
+ * selection to it, so the backend's status, headers and body come back untouched — including
+ * error statuses, which must not be remapped into a gateway error. Only
+ * {@code integration.request.*} parameter mapping applies on the way out.
+ */
+ private Response invokeHttpProxy(String apiId, String httpMethod, String path, String proxy,
+ String stageName, ApiGatewayResource resource,
+ Integration integration, HttpHeaders headers,
+ UriInfo uriInfo, byte[] body) {
+ String uri = integration.getUri();
+ if (uri == null || uri.isBlank()) {
+ return Response.status(500)
+ .entity(jsonMessage("No integration URI configured"))
+ .type(MediaType.APPLICATION_JSON).build();
+ }
+
+ // 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
+ // surface for method.request.* parameter mapping, which resolves to one value in AWS too.
+ Map<String, List<String>> multiValueHeaders = new LinkedHashMap<>();
+ Map<String, String> headerMap = new LinkedHashMap<>();
+ for (Map.Entry<String, List<String>> e : headers.getRequestHeaders().entrySet()) {
+ if (e.getValue().isEmpty()) continue;
+ multiValueHeaders.put(e.getKey(), List.copyOf(e.getValue()));
+ headerMap.put(e.getKey(), String.join(",", e.getValue()));
+ }
+ Map<String, List<String>> multiValueQuery = new LinkedHashMap<>();
+ Map<String, String> queryMap = new LinkedHashMap<>();
+ for (Map.Entry<String, List<String>> e : uriInfo.getQueryParameters().entrySet()) {
+ if (e.getValue().isEmpty()) continue;
+ multiValueQuery.put(e.getKey(), List.copyOf(e.getValue()));
+ queryMap.put(e.getKey(), String.join(",", e.getValue()));
+ }
+ Map<String, String> pathMap = new LinkedHashMap<>();
+ if (proxy != null && !proxy.isEmpty()) pathMap.put("proxy", proxy);
+ pathMap.putAll(extractPathParams(resource.getPath(), path));
+
+ // integration.request.{header,querystring,path}.X ← method.request.*, 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;
+ // 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));
+ } else if (dest.startsWith("integration.request.querystring.")) {
+ String name = dest.substring("integration.request.querystring.".length());
+ queryMap.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);
+ }
+ }
+ }
+
+ // HttpProxyInvoker speaks the v2 integration model. The REST parameter mapping above is
+ // already folded into the header/query/path maps, so this adapter deliberately carries no
+ // requestParameters of its own — leaving them set would re-apply them under v2 semantics.
+ io.github.hectorvent.floci.services.apigatewayv2.model.Integration target =
+ new io.github.hectorvent.floci.services.apigatewayv2.model.Integration();
+ target.setIntegrationType("HTTP_PROXY");
+ target.setIntegrationUri(uri);
+ target.setIntegrationMethod(integration.getHttpMethod());
+
+ 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(),
+ headerMap.getOrDefault("X-Forwarded-For", "127.0.0.1"),
+ headerMap, queryMap, pathMap, body,
+ Map.of(), Map.of(),
+ multiValueHeaders, multiValueQuery);
+
+ LOG.debugv("execute-api: {0} {1}/{2}{3} → HTTP_PROXY {4}",
+ httpMethod, apiId, stageName, path, uri);
+
+ io.github.hectorvent.floci.services.apigatewayv2.proxy.ProxyResult result =
+ httpProxyInvoker.invoke(target, ctx);
+
+ Response.ResponseBuilder rb = Response.status(result.statusCode());
+ if (result.body() != null) rb.entity(result.body());
+ if (result.headers() != null) {
+ // One header line per value, so a backend that sent two Set-Cookie headers relays as
+ // two. Joining them would be lossy: a cookie's Expires attribute contains a comma.
+ for (Map.Entry<String, List<String>> e : result.headers().entrySet()) {
+ for (String value : e.getValue()) {
+ rb.header(e.getKey(), value);
+ }
+ }
+ }
+ return rb.build();
+ }
+
+ // ──────────────────────────── HTTP (non-proxy) ────────────────────────────
+
+ /**
+ * Invokes an arbitrary HTTP backend with VTL request/response mapping applied.
+ *
+ * <p>Unlike {@code HTTP_PROXY}, a non-proxy {@code HTTP} integration builds its backend request
+ * entirely from mapping templates and explicit {@code integration.request.*} parameter
+ * mappings — inbound headers and query parameters that were <em>not</em> mapped are not
+ * forwarded. The backend's response then runs through the method's integration responses, where
+ * {@code selectionPattern} is matched against the backend's HTTP status code (for
+ * {@code AWS}/Lambda integrations it is matched against the error message instead).
+ */
+ private Response invokeHttpIntegration(String apiId, String httpMethod, String path, String proxy,
+ String stageName, ApiGatewayResource resource,
+ Integration integration, HttpHeaders headers,
+ UriInfo uriInfo, byte[] body,
+ AuthorizerResult authorizerResult) {
+ String uri = integration.getUri();
+ if (uri == null || uri.isBlank()) {
+ return Response.status(500)
+ .entity(jsonMessage("No integration URI configured"))
+ .type(MediaType.APPLICATION_JSON).build();
+ }
+
+ String requestId = UUID.randomUUID().toString();
+ String bodyStr = body != null && body.length > 0 ? new String(body, StandardCharsets.UTF_8) : null;
+
+ Map<String, String> headerMap = new HashMap<>();
+ for (Map.Entry<String, List<String>> e : headers.getRequestHeaders().entrySet()) {
+ if (!e.getValue().isEmpty()) headerMap.put(e.getKey(), e.getValue().get(0));
+ }
+ Map<String, String> queryMap = new HashMap<>();
+ for (Map.Entry<String, List<String>> e : uriInfo.getQueryParameters().entrySet()) {
+ if (!e.getValue().isEmpty()) queryMap.put(e.getKey(), e.getValue().get(0));
+ }
+ Map<String, String> pathMap = new HashMap<>();
+ if (proxy != null && !proxy.isEmpty()) pathMap.put("proxy", proxy);
+ pathMap.putAll(extractPathParams(resource.getPath(), path));
+
+ String incomingContentType = headerMap.getOrDefault("Content-Type",
+ headerMap.getOrDefault("content-type", "application/json"));
+
+ Map<String, Object> vtlAuthorizerContext = vtlAuthorizerContext(
+ authorizerResult.principalId(), authorizerResult.context());
+
+ VtlTemplateEngine.VtlContext vtlCtx = new VtlTemplateEngine.VtlContext(
+ bodyStr, headerMap, queryMap, pathMap, stageName, httpMethod,
+ resource.getPath(), requestId, regionResolver.getAccountId(), null,
+ vtlAuthorizerContext);
+
+ // 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> 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);
+ if (resolved == null) continue;
+ if (dest.startsWith("integration.request.header.")) {
+ outHeaders.put(dest.substring("integration.request.header.".length()), resolved);
+ } else if (dest.startsWith("integration.request.querystring.")) {
+ outQuery.put(dest.substring("integration.request.querystring.".length()), resolved);
+ } else if (dest.startsWith("integration.request.path.")) {
+ outPath.put(dest.substring("integration.request.path.".length()), resolved);
+ }
+ }
+ }
+
+ RequestTemplateResult requestTemplateResult =
+ applyRequestTemplates(integration, incomingContentType, bodyStr, vtlCtx);
+ if (requestTemplateResult.rejection() != null) return requestTemplateResult.rejection();
+ String transformedBody = requestTemplateResult.body();
+
+ // The payload is the rendered template, so the backend is told the media type that template
+ // was keyed under — unless a requestParameters mapping already set one explicitly.
+ outHeaders.putIfAbsent("Content-Type",
+ requestTemplateResult.contentType() != null
+ ? requestTemplateResult.contentType() : MediaType.APPLICATION_JSON);
+
+ // Reuses the HTTP_PROXY transport (hop-by-hop stripping, chunked decoding, 502-on-failure).
+ // The non-proxy semantics live in what this hands it: a mapped header/query set and a
+ // VTL-rendered body, rather than the inbound request verbatim.
+ io.github.hectorvent.floci.services.apigatewayv2.model.Integration target =
+ new io.github.hectorvent.floci.services.apigatewayv2.model.Integration();
+ target.setIntegrationType("HTTP_PROXY");
+ target.setIntegrationUri(uri);
+ target.setIntegrationMethod(integration.getHttpMethod());
+
+ byte[] payload = transformedBody != null
+ ? transformedBody.getBytes(StandardCharsets.UTF_8) : new byte[0];
+
+ io.github.hectorvent.floci.services.apigatewayv2.proxy.RequestContext ctx =
+ new io.github.hectorvent.floci.services.apigatewayv2.proxy.RequestContext(
+ apiId, stageName, httpMethod, path,
+ outPath.getOrDefault("proxy", ""), resource.getPath(),
+ requestId, headerMap.getOrDefault("X-Forwarded-For", "127.0.0.1"),
+ outHeaders, outQuery, outPath, payload,
+ Map.of(), Map.of());
+
+ LOG.debugv("execute-api: {0} {1}/{2}{3} → HTTP {4}", httpMethod, apiId, stageName, path, uri);
+
+ io.github.hectorvent.floci.services.apigatewayv2.proxy.ProxyResult result =
+ httpProxyInvoker.invoke(target, ctx);
+
+ String responseBodyStr = result.body() != null
+ ? new String(result.body(), StandardCharsets.UTF_8) : "";
+ // java.net.http lowercases response header names, so this must be case-insensitive for an
+ // integration.response.header.X-Backend-Id mapping to resolve.
+ // Non-proxy responses run through integration responses, whose
+ // integration.response.header.X mappings resolve to a single value, so the multi-valued
+ // backend headers collapse here rather than on the way out of the transport.
+ Map<String, String> responseHeaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+ if (result.headers() != null) {
+ result.headers().forEach((name, values) -> responseHeaders.put(name, String.join(",", values)));
+ }
+
+ VtlTemplateEngine.VtlContext responseMappingCtx = new VtlTemplateEngine.VtlContext(
+ responseBodyStr, headerMap, queryMap, pathMap, stageName, httpMethod,
+ resource.getPath(), requestId, regionResolver.getAccountId(), null,
+ vtlAuthorizerContext);
+
+ // responseHeaders is already case-insensitive, so a plain lookup suffices.
+ String defaultContentType =
+ responseHeaders.getOrDefault("Content-Type", MediaType.APPLICATION_JSON);
+
+ // For HTTP integrations selectionPattern is matched against the backend's status code.
+ return mapIntegrationResponse(integration, String.valueOf(result.statusCode()),
+ responseBodyStr, result.statusCode(), responseHeaders, responseMappingCtx,
+ defaultContentType);
+ }
+
private AuthorizerResult invokeAuthorizer(String region, String apiId, String stageName,
String httpMethod, String requestPath, String resourcePath,
String resourceId,
@@ -1073,49 +1318,10 @@ public class ApiGatewayExecuteController {
}
// Content-Type negotiation and passthrough behavior
- String transformedBody;
- Map<String, String> requestTemplates = integration.getRequestTemplates();
-
- if (requestTemplates != null && !requestTemplates.isEmpty()) {
- // Try exact match first, then wildcard fallback
- String template = requestTemplates.get(incomingContentType);
- if (template == null) {
- // Try without charset: "application/json; charset=utf-8" → "application/json"
- String baseType = incomingContentType.contains(";")
- ? incomingContentType.substring(0, incomingContentType.indexOf(';')).trim()
- : incomingContentType;
- template = requestTemplates.get(baseType);
- }
-
- if (template != null) {
- transformedBody = vtlEngine.evaluate(template, vtlCtx).body();
- } else {
- // No matching template for this Content-Type
- String behavior = integration.getPassthroughBehavior();
- if ("NEVER".equalsIgnoreCase(behavior)) {
- return Response.status(415)
- .entity(jsonMessage("Unsupported Media Type"))
- .type(MediaType.APPLICATION_JSON).build();
- } else if ("WHEN_NO_TEMPLATES".equalsIgnoreCase(behavior)) {
- // Templates exist but none match → reject
- return Response.status(415)
- .entity(jsonMessage("Unsupported Media Type"))
- .type(MediaType.APPLICATION_JSON).build();
- } else {
- // WHEN_NO_MATCH (default) — passthrough
- transformedBody = bodyStr != null ? bodyStr : "";
- }
- }
- } else {
- // No templates defined at all
- String behavior = integration.getPassthroughBehavior();
- if ("NEVER".equalsIgnoreCase(behavior)) {
- return Response.status(415)
- .entity(jsonMessage("Unsupported Media Type"))
- .type(MediaType.APPLICATION_JSON).build();
- }
- transformedBody = bodyStr != null ? bodyStr : "";
- }
+ RequestTemplateResult requestTemplateResult =
+ applyRequestTemplates(integration, incomingContentType, bodyStr, vtlCtx);
+ if (requestTemplateResult.rejection() != null) return requestTemplateResult.rejection();
+ String transformedBody = requestTemplateResult.body();
// Dispatch to service.
//
@@ -1218,25 +1424,112 @@ public class ApiGatewayExecuteController {
errorType != null ? errorType : "UnknownError");
}
- // Select integration response
- Map<String, IntegrationResponse> integrationResponses = integration.getIntegrationResponses();
- IntegrationResponse matchedResponse = null;
- IntegrationResponse defaultResponse = null;
-
- // Build the error string to match selectionPattern against.
- // AWS matches against the error response body/message. We match against
- // both errorType and errorMessage to catch patterns like ".*ResourceNotFoundException.*".
+ // AWS matches selectionPattern against the error response body/message for AWS/Lambda
+ // integrations. We match against both errorType and errorMessage to catch patterns like
+ // ".*ResourceNotFoundException.*". (HTTP integrations match the status code instead —
+ // see invokeHttpIntegration.)
String errorMatchString = errorType != null
? errorType + (errorMessage != null ? ": " + errorMessage : "")
: errorMessage;
+ // Case-insensitive: an integration.response.header.X-Foo mapping must resolve regardless of
+ // the casing the backend or client library used for the header name.
+ Map<String, String> serviceResponseHeaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+ if (serviceResponse != null) {
+ for (Map.Entry<String, List<String>> e : serviceResponse.getStringHeaders().entrySet()) {
+ if (!e.getValue().isEmpty()) serviceResponseHeaders.put(e.getKey(), e.getValue().get(0));
+ }
+ }
+
+ VtlTemplateEngine.VtlContext responseMappingCtx = new VtlTemplateEngine.VtlContext(
+ responseBodyStr, headerMap, queryMap, pathMap, stageName, httpMethod,
+ resource.getPath(), requestId, regionResolver.getAccountId(), null,
+ vtlAuthorizerContext);
+
+ int fallbackStatus = errorType != null ? 500 : (serviceStatus >= 400 ? serviceStatus : 200);
+ return mapIntegrationResponse(integration, errorMatchString, responseBodyStr, fallbackStatus,
+ serviceResponseHeaders, responseMappingCtx, MediaType.APPLICATION_JSON);
+ }
+
+ /**
+ * Outcome of request-template negotiation: either a rendered request body plus the media type
+ * it was rendered as, or a ready-made rejection when {@code passthroughBehavior} forbids
+ * passing the payload through untransformed.
+ */
+ private record RequestTemplateResult(String body, String contentType, Response rejection) {}
+
+ /**
+ * Selects a request template by the incoming {@code Content-Type} and renders it, applying
+ * {@code passthroughBehavior} when no template matches. Shared by the {@code AWS} and
+ * {@code HTTP} (non-proxy) integration types, which negotiate identically.
+ */
+ private RequestTemplateResult applyRequestTemplates(Integration integration, String incomingContentType,
+ String bodyStr, VtlTemplateEngine.VtlContext vtlCtx) {
+ Response unsupportedMediaType = Response.status(415)
+ .entity(jsonMessage("Unsupported Media Type"))
+ .type(MediaType.APPLICATION_JSON).build();
+ Map<String, String> requestTemplates = integration.getRequestTemplates();
+
+ if (requestTemplates == null || requestTemplates.isEmpty()) {
+ // No templates defined at all
+ if ("NEVER".equalsIgnoreCase(integration.getPassthroughBehavior())) {
+ return new RequestTemplateResult(null, null, unsupportedMediaType);
+ }
+ return new RequestTemplateResult(bodyStr != null ? bodyStr : "", incomingContentType, null);
+ }
+
+ // Try exact match first, then without charset: "application/json; charset=utf-8" → "application/json"
+ String matchedType = incomingContentType;
+ String template = requestTemplates.get(incomingContentType);
+ if (template == null) {
+ String baseType = incomingContentType.contains(";")
+ ? incomingContentType.substring(0, incomingContentType.indexOf(';')).trim()
+ : incomingContentType;
+ template = requestTemplates.get(baseType);
+ if (template != null) matchedType = baseType;
+ }
+
+ if (template != null) {
+ // The template's own key is the media type the backend should be told it is receiving.
+ return new RequestTemplateResult(vtlEngine.evaluate(template, vtlCtx).body(), matchedType, null);
+ }
+
+ // No matching template for this Content-Type. NEVER forbids passthrough outright;
+ // WHEN_NO_TEMPLATES rejects because templates exist but none matched.
+ String behavior = integration.getPassthroughBehavior();
+ if ("NEVER".equalsIgnoreCase(behavior) || "WHEN_NO_TEMPLATES".equalsIgnoreCase(behavior)) {
+ return new RequestTemplateResult(null, null, unsupportedMediaType);
+ }
+ // WHEN_NO_MATCH (default) — passthrough
+ return new RequestTemplateResult(bodyStr != null ? bodyStr : "", incomingContentType, null);
+ }
+
+ /**
+ * Maps an integration result onto the method response: selects the matching
+ * {@link IntegrationResponse}, renders its response template, then applies
+ * {@code $context.responseOverride} assignments and {@code responseParameters} header mappings.
+ *
+ * @param selectionMatchString what {@code selectionPattern} regexes are tested against — the
+ * error message for {@code AWS}/Lambda integrations, the backend's
+ * HTTP status code for {@code HTTP} integrations
+ * @param fallbackStatus status used when no integration response is configured or matched
+ */
+ private Response mapIntegrationResponse(Integration integration, String selectionMatchString,
+ String responseBodyStr, int fallbackStatus,
+ Map<String, String> integrationResponseHeaders,
+ VtlTemplateEngine.VtlContext responseMappingCtx,
+ String defaultContentType) {
+ Map<String, IntegrationResponse> integrationResponses = integration.getIntegrationResponses();
+ IntegrationResponse matchedResponse = null;
+ IntegrationResponse defaultResponse = null;
+
if (integrationResponses != null && !integrationResponses.isEmpty()) {
for (IntegrationResponse ir : integrationResponses.values()) {
if (ir.selectionPattern() == null || ir.selectionPattern().isEmpty()) {
defaultResponse = ir;
- } else if (errorMatchString != null) {
+ } else if (selectionMatchString != null) {
try {
- if (Pattern.matches(ir.selectionPattern(), errorMatchString)) {
+ if (Pattern.matches(ir.selectionPattern(), selectionMatchString)) {
matchedResponse = ir;
break;
}
@@ -1263,10 +1556,6 @@ public class ApiGatewayExecuteController {
String responseTemplate = responseTemplates.getOrDefault("application/json",
responseTemplates.values().iterator().next());
if (responseTemplate != null && !responseTemplate.isEmpty()) {
- VtlTemplateEngine.VtlContext responseMappingCtx = new VtlTemplateEngine.VtlContext(
- responseBodyStr, headerMap, queryMap, pathMap, stageName, httpMethod,
- resource.getPath(), requestId, regionResolver.getAccountId(), null,
- vtlAuthorizerContext);
templateResult = vtlEngine.evaluate(responseTemplate, responseMappingCtx);
finalBody = templateResult.body();
} else {
@@ -1276,15 +1565,13 @@ public class ApiGatewayExecuteController {
finalBody = responseBodyStr;
}
} else {
- finalStatus = errorType != null ? 500 : (serviceStatus >= 400 ? serviceStatus : 200);
+ finalStatus = fallbackStatus;
finalBody = responseBodyStr;
}
// Apply $context.responseOverride assignments from the response template (if any).
- if (templateResult != null) {
- if (templateResult.statusOverride() != null) {
- finalStatus = templateResult.statusOverride();
- }
+ if (templateResult != null && templateResult.statusOverride() != null) {
+ finalStatus = templateResult.statusOverride();
}
Response.ResponseBuilder rb = Response.status(finalStatus)
@@ -1305,20 +1592,12 @@ public class ApiGatewayExecuteController {
// Apply response parameter mapping (header mapping from responseParameters config).
if (matchedResponse != null && matchedResponse.responseParameters() != null) {
- // Case-insensitive: an integration.response.header.X-Foo mapping must resolve
- // regardless of the casing the backend or client library used for the header name.
- Map<String, String> serviceResponseHeaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
- if (serviceResponse != null) {
- for (Map.Entry<String, List<String>> e : serviceResponse.getStringHeaders().entrySet()) {
- if (!e.getValue().isEmpty()) serviceResponseHeaders.put(e.getKey(), e.getValue().get(0));
- }
- }
for (Map.Entry<String, String> param : matchedResponse.responseParameters().entrySet()) {
String dest = param.getKey(); // method.response.header.X-Foo
String source = param.getValue(); // integration.response.header.X-Bar or 'static' or integration.response.body.jsonpath
if (!dest.startsWith("method.response.header.")) continue;
String headerName = dest.substring("method.response.header.".length());
- String headerValue = resolveResponseParameter(source, serviceResponseHeaders, responseBodyStr);
+ String headerValue = resolveResponseParameter(source, integrationResponseHeaders, responseBodyStr);
if (headerValue != null) {
if ("Content-Type".equalsIgnoreCase(headerName)) {
contentType = headerValue;
@@ -1329,7 +1608,7 @@ public class ApiGatewayExecuteController {
}
}
- rb.type(contentType != null ? contentType : MediaType.APPLICATION_JSON);
+ rb.type(contentType != null ? contentType : defaultContentType);
return rb.build();
}
@@ -1791,12 +2070,26 @@ public class ApiGatewayExecuteController {
}
}
- Map<String, String> requestHeaders = new java.util.LinkedHashMap<>();
+ // Same two views of the inbound data as the REST proxy path: the multi-value maps are what
+ // reaches the backend, so "?tag=a&tag=b" stays two parameters, while the joined single-value
+ // maps are the lookup surface for $request.header.X / $request.querystring.X, which resolve
+ // to one value in AWS.
+ Map<String, List<String>> multiValueHeaders = new LinkedHashMap<>();
+ Map<String, String> requestHeaders = new LinkedHashMap<>();
for (Map.Entry<String, List<String>> e : headers.getRequestHeaders().entrySet()) {
+ if (e.getValue().isEmpty()) {
+ continue;
+ }
+ multiValueHeaders.put(e.getKey(), List.copyOf(e.getValue()));
requestHeaders.put(e.getKey(), String.join(",", e.getValue()));
}
- Map<String, String> queryParams = new java.util.LinkedHashMap<>();
+ Map<String, List<String>> multiValueQueryParams = new LinkedHashMap<>();
+ Map<String, String> queryParams = new LinkedHashMap<>();
for (Map.Entry<String, List<String>> e : uriInfo.getQueryParameters().entrySet()) {
+ if (e.getValue().isEmpty()) {
+ continue;
+ }
+ multiValueQueryParams.put(e.getKey(), List.copyOf(e.getValue()));
queryParams.put(e.getKey(), String.join(",", e.getValue()));
}
Map<String, String> pathParams = extractV2PathParams(route.getRouteKey(), path);
@@ -1817,7 +2110,7 @@ public class ApiGatewayExecuteController {
pathParams.getOrDefault("proxy", ""), route.getRouteKey(),
UUID.randomUUID().toString(), sourceIp,
requestHeaders, queryParams, pathParams, body,
- claims, Map.of());
+ claims, Map.of(), multiValueHeaders, multiValueQueryParams);
LOG.debugv("execute-api v2: {0} {1}/{2}{3} → HTTP_PROXY {4}",
httpMethod, apiId, stageName, path, effective.getIntegrationUri());
@@ -1828,8 +2121,10 @@ public class ApiGatewayExecuteController {
Response.ResponseBuilder rb = Response.status(result.statusCode());
if (result.body() != null) rb.entity(result.body());
if (result.headers() != null) {
- for (Map.Entry<String, String> e : result.headers().entrySet()) {
- rb.header(e.getKey(), e.getValue());
+ for (Map.Entry<String, List<String>> e : result.headers().entrySet()) {
+ for (String value : e.getValue()) {
+ rb.header(e.getKey(), value);
+ }
}
}
return rb.build();
@@ -1865,7 +2160,7 @@ public class ApiGatewayExecuteController {
private static io.github.hectorvent.floci.services.apigatewayv2.model.Integration withResolvedUriAndHost(
io.github.hectorvent.floci.services.apigatewayv2.model.Integration original, String targetUri, String host) {
io.github.hectorvent.floci.services.apigatewayv2.model.Integration copy = withResolvedUri(original, targetUri);
- Map<String, String> requestParameters = new java.util.LinkedHashMap<>();
+ Map<String, String> requestParameters = new LinkedHashMap<>();
if (copy.getRequestParameters() != null) {
requestParameters.putAll(copy.getRequestParameters());
}
@@ -1890,7 +2185,7 @@ public class ApiGatewayExecuteController {
Matcher m = compiled.pattern().matcher(actualPath);
if (!m.matches()) return Map.of();
- Map<String, String> result = new java.util.LinkedHashMap<>();
+ Map<String, String> result = new LinkedHashMap<>();
for (int i = 0; i < compiled.parameterNames().size(); i++) {
result.put(compiled.parameterNames().get(i), m.group(i + 1));
}
@@ -2423,7 +2718,7 @@ public class ApiGatewayExecuteController {
// - mirrored here rather than dropping or restructuring anything, since callers may
// read any claim name, not just the ones this method itself validates. The exact
// per-type rendering is renderClaimValue's (measured, not JSON for arrays/nulls).
- Map<String, String> raw = new java.util.LinkedHashMap<>();
+ Map<String, String> raw = new LinkedHashMap<>();
java.util.Iterator<Map.Entry<String, JsonNode>> fields = claims.fields();
while (fields.hasNext()) {
Map.Entry<String, JsonNode> field = fields.next();
diff --git a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/HttpProxyInvoker.java b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/HttpProxyInvoker.java
index 7c41aa937d..b8ead7aace 100644
--- a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/HttpProxyInvoker.java
+++ b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/HttpProxyInvoker.java
@@ -69,17 +69,19 @@ public class HttpProxyInvoker {
method = ctx.httpMethod();
}
- // 3. Build mutable request, seed with inbound headers/query (excluding hop-by-hop)
+ // 3. Build mutable request, seed with inbound headers/query (excluding hop-by-hop).
+ // Seeded from the multi-valued view so repeated inbound headers and query parameters
+ // reach the backend repeated rather than comma-joined.
ProxyRequestBuilder builder = new ProxyRequestBuilder(resolvedUrl, method);
- if (ctx.requestHeaders() != null) {
- for (Map.Entry<String, String> e : ctx.requestHeaders().entrySet()) {
+ if (ctx.multiValueHeaders() != null) {
+ for (Map.Entry<String, List<String>> e : ctx.multiValueHeaders().entrySet()) {
if (!HOP_BY_HOP.contains(e.getKey().toLowerCase())) {
builder.overwriteHeader(e.getKey(), e.getValue());
}
}
}
- if (ctx.queryParams() != null) {
- for (Map.Entry<String, String> e : ctx.queryParams().entrySet()) {
+ if (ctx.multiValueQueryParams() != null) {
+ for (Map.Entry<String, List<String>> e : ctx.multiValueQueryParams().entrySet()) {
builder.overwriteQuery(e.getKey(), e.getValue());
}
}
@@ -129,10 +131,10 @@ public class HttpProxyInvoker {
try {
HttpResponse<byte[]> resp = client.send(hrb.build(), HttpResponse.BodyHandlers.ofByteArray());
- Map<String, String> respHeaders = new LinkedHashMap<>();
+ Map<String, List<String>> respHeaders = new LinkedHashMap<>();
for (Map.Entry<String, List<String>> e : resp.headers().map().entrySet()) {
if (HOP_BY_HOP.contains(e.getKey().toLowerCase())) continue;
- respHeaders.put(e.getKey(), String.join(",", e.getValue()));
+ respHeaders.put(e.getKey(), List.copyOf(e.getValue()));
}
return new ProxyResult(resp.statusCode(), respHeaders, resp.body());
} catch (Exception e) {
@@ -221,7 +223,7 @@ public class HttpProxyInvoker {
}
String[] status = lines[0].split(" ", 3);
int statusCode = Integer.parseInt(status[1]);
- Map<String, String> headers = new LinkedHashMap<>();
+ Map<String, List<String>> headers = new LinkedHashMap<>();
String transferEncoding = null;
int contentLength = -1;
for (int i = 1; i < lines.length; i++) {
@@ -238,7 +240,8 @@ public class HttpProxyInvoker {
contentLength = Integer.parseInt(value);
}
if (!HOP_BY_HOP.contains(name.toLowerCase(Locale.ROOT))) {
- headers.put(name, value);
+ // Repeated header lines (Set-Cookie) accumulate rather than overwrite.
+ headers.computeIfAbsent(name, k -> new java.util.ArrayList<>()).add(value);
}
}
byte[] body = transferEncoding != null && transferEncoding.toLowerCase(Locale.ROOT).contains("chunked")
@@ -319,7 +322,7 @@ public class HttpProxyInvoker {
private static ProxyResult errorResult(String message) {
String body = "{\"message\":\"" + message.replace("\"", "\\\"") + "\"}";
- return new ProxyResult(502,
+ return ProxyResult.withSingleValueHeaders(502,
Map.of("Content-Type", "application/json"),
body.getBytes(StandardCharsets.UTF_8));
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/ProxyRequestBuilder.java b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/ProxyRequestBuilder.java
index d0d11238dc..d98424e28e 100644
--- a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/ProxyRequestBuilder.java
+++ b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/ProxyRequestBuilder.java
@@ -35,6 +35,10 @@ public class ProxyRequestBuilder {
list.add(value);
headers.put(name, list);
}
+ public void overwriteHeader(String name, List<String> values) {
+ if (values == null) { headers.remove(name); return; }
+ headers.put(name, new ArrayList<>(values));
+ }
public void appendHeader(String name, String value) {
if (value == null) return;
headers.computeIfAbsent(name, k -> new ArrayList<>()).add(value);
@@ -47,6 +51,10 @@ public class ProxyRequestBuilder {
list.add(value);
queryParams.put(name, list);
}
+ public void overwriteQuery(String name, List<String> values) {
+ if (values == null) { queryParams.remove(name); return; }
+ queryParams.put(name, new ArrayList<>(values));
+ }
public void appendQuery(String name, String value) {
if (value == null) return;
queryParams.computeIfAbsent(name, k -> new ArrayList<>()).add(value);
diff --git a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/ProxyResult.java b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/ProxyResult.java
index 351f8d58d4..17588f4b35 100644
--- a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/ProxyResult.java
+++ b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/ProxyResult.java
@@ -1,10 +1,26 @@
package io.github.hectorvent.floci.services.apigatewayv2.proxy;
+import java.util.LinkedHashMap;
+import java.util.List;
import java.util.Map;
/**
* Result of an HTTP_PROXY integration invocation. Carries the backend's
- * response status, headers (combined when multi-valued), and body bytes
- * back to the API Gateway dispatcher for relay to the original caller.
+ * response status, headers and body bytes back to the API Gateway dispatcher
+ * for relay to the original caller.
+ *
+ * <p>Headers are multi-valued: a backend may legitimately send the same header
+ * name more than once (most commonly {@code Set-Cookie}), and a proxy that
+ * folds those into one comma-joined value corrupts them. Cookie values may
+ * themselves contain commas (an {@code Expires} date does), so the joined form
+ * cannot be split back apart by the client.
*/
-public record ProxyResult(int statusCode, Map<String, String> headers, byte[] body) {}
+public record ProxyResult(int statusCode, Map<String, List<String>> headers, byte[] body) {
+
+ /** Convenience for a response whose headers are all single-valued. */
+ public static ProxyResult withSingleValueHeaders(int statusCode, Map<String, String> headers, byte[] body) {
+ Map<String, List<String>> expanded = new LinkedHashMap<>();
+ headers.forEach((name, value) -> expanded.put(name, List.of(value)));
+ return new ProxyResult(statusCode, expanded, body);
+ }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/RequestContext.java b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/RequestContext.java
index 6da827e2bd..a9bf413b5f 100644
--- a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/RequestContext.java
+++ b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/RequestContext.java
@@ -1,10 +1,22 @@
package io.github.hectorvent.floci.services.apigatewayv2.proxy;
+import java.util.LinkedHashMap;
+import java.util.List;
import java.util.Map;
/**
* Bundles the inbound request data and authorizer-derived context that an
* HTTP_PROXY integration may reference via $context.* / $request.* expressions.
+ *
+ * <p>Headers and query parameters appear twice, in two different shapes, because
+ * the two consumers want different things. {@code requestHeaders} /
+ * {@code queryParams} are the single-valued view that {@code $request.header.X}
+ * and {@code $request.querystring.X} resolve against, matching AWS, where those
+ * expressions yield one value. {@code multiValueHeaders} /
+ * {@code multiValueQueryParams} are what actually gets forwarded to the backend,
+ * and they keep repeated values separate: REST HTTP_PROXY passes the request
+ * through, and {@code ?tag=a&tag=b} must not reach the backend as
+ * {@code ?tag=a,b}, which is a different request to most servers.
*/
public record RequestContext(
String apiId,
@@ -20,5 +32,35 @@ public record RequestContext(
Map<String, String> pathParams,
byte[] body,
Map<String, Object> authorizerClaims,
- Map<String, Object> authorizerContext) {
+ Map<String, Object> authorizerContext,
+ Map<String, List<String>> multiValueHeaders,
+ Map<String, List<String>> multiValueQueryParams) {
+
+ /**
+ * For callers whose headers and query parameters are single-valued by
+ * construction, such as a non-proxy HTTP integration that forwards only the
+ * parameters its {@code requestParameters} mapping named.
+ */
+ public RequestContext(String apiId, String stageName, String httpMethod, String path, String proxy,
+ String routeKey, String requestId, String sourceIp,
+ Map<String, String> requestHeaders, Map<String, String> queryParams,
+ Map<String, String> pathParams, byte[] body,
+ Map<String, Object> authorizerClaims, Map<String, Object> authorizerContext) {
+ this(apiId, stageName, httpMethod, path, proxy, routeKey, requestId, sourceIp,
+ requestHeaders, queryParams, pathParams, body, authorizerClaims, authorizerContext,
+ expand(requestHeaders), expand(queryParams));
+ }
+
+ private static Map<String, List<String>> expand(Map<String, String> single) {
+ if (single == null) {
+ return null;
+ }
+ Map<String, List<String>> expanded = new LinkedHashMap<>();
+ single.forEach((name, value) -> {
+ if (value != null) {
+ expanded.put(name, List.of(value));
+ }
+ });
+ return expanded;
+ }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayHttpNonProxyIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayHttpNonProxyIntegrationTest.java
new file mode 100644
index 0000000000..85394caa9c
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayHttpNonProxyIntegrationTest.java
@@ -0,0 +1,324 @@
+package io.github.hectorvent.floci.services.apigateway;
+
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpServer;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.http.ContentType;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * Covers the REST (v1) {@code HTTP} integration type, the non-proxy form, where API Gateway builds
+ * the backend request from mapping templates and explicit parameter mappings, then maps the
+ * backend's response back through the method's integration responses.
+ *
+ * <p>This is the counterpart to {@link ApiGatewayHttpProxyIntegrationTest}: {@code HTTP_PROXY} is a
+ * passthrough, whereas {@code HTTP} transforms in both directions. The distinguishing AWS behaviours
+ * pinned here are (a) unmapped inbound headers are <em>not</em> forwarded, and (b) an integration
+ * response's {@code selectionPattern} is matched against the backend's <em>HTTP status code</em>,
+ * not against an error message as it is for {@code AWS}/Lambda integrations.
+ */
+@QuarkusTest
+class ApiGatewayHttpNonProxyIntegrationTest {
+
+ private static HttpServer backendServer;
+ private static int backendPort;
+
+ private static final AtomicReference<String> lastBody = new AtomicReference<>();
+ private static final AtomicReference<String> lastQuery = new AtomicReference<>();
+ private static final AtomicReference<String> lastTenantHeader = new AtomicReference<>();
+ private static final AtomicReference<String> lastUnmappedHeader = new AtomicReference<>();
+ private static final AtomicReference<String> lastMethod = new AtomicReference<>();
+ private static final AtomicReference<String> lastContentType = new AtomicReference<>();
+
+ private final List<String> createdApis = new ArrayList<>();
+
+ @BeforeAll
+ static void startBackend() throws IOException {
+ backendServer = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
+ backendServer.createContext("/", ApiGatewayHttpNonProxyIntegrationTest::handle);
+ backendServer.start();
+ backendPort = backendServer.getAddress().getPort();
+ }
+
+ @AfterAll
+ static void stopBackend() {
+ if (backendServer != null) backendServer.stop(0);
+ }
+
+ private static void handle(HttpExchange exchange) throws IOException {
+ lastMethod.set(exchange.getRequestMethod());
+ lastBody.set(new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8));
+ lastQuery.set(exchange.getRequestURI().getQuery());
+ lastTenantHeader.set(exchange.getRequestHeaders().getFirst("X-Tenant"));
+ lastUnmappedHeader.set(exchange.getRequestHeaders().getFirst("X-Client-Trace"));
+ lastContentType.set(exchange.getRequestHeaders().getFirst("Content-Type"));
+
+ String query = exchange.getRequestURI().getQuery();
+ String mode = query == null ? "" : query;
+ int status = mode.contains("mode=missing") ? 404 : mode.contains("mode=boom") ? 500 : 200;
+
+ byte[] response = ("{\"backendStatus\":" + status + ",\"widget\":\"cog\"}")
+ .getBytes(StandardCharsets.UTF_8);
+ exchange.getResponseHeaders().add("Content-Type", "application/json");
+ exchange.getResponseHeaders().add("X-Backend-Id", "backend-7");
+ exchange.sendResponseHeaders(status, response.length);
+ exchange.getResponseBody().write(response);
+ exchange.close();
+ }
+
+ private void resetRecordings() {
+ lastBody.set(null);
+ lastQuery.set(null);
+ lastTenantHeader.set(null);
+ lastUnmappedHeader.set(null);
+ lastMethod.set(null);
+ lastContentType.set(null);
+ }
+
+ /**
+ * Creates a REST API with a POST {@code /widget} method backed by an HTTP (non-proxy)
+ * integration, wiring request/response templates, parameter mappings and integration responses.
+ */
+ private String createHttpApi(String name, String integrationExtras, boolean withIntegrationResponses) {
+ String apiId = given()
+ .contentType(ContentType.JSON)
+ .body("{\"name\":\"" + name + "\"}")
+ .when().post("/restapis")
+ .then().statusCode(201).body("id", notNullValue())
+ .extract().path("id");
+ createdApis.add(apiId);
+
+ String rootId = given().when().get("/restapis/" + apiId + "/resources")
+ .then().statusCode(200).extract().path("item[0].id");
+
+ String resourceId = given()
+ .contentType(ContentType.JSON)
+ .body("{\"pathPart\":\"widget\"}")
+ .when().post("/restapis/" + apiId + "/resources/" + rootId)
+ .then().statusCode(201).extract().path("id");
+
+ given().contentType(ContentType.JSON)
+ .body("{\"authorizationType\":\"NONE\"}")
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId + "/methods/POST")
+ .then().statusCode(201);
+
+ String backendUrl = "http://127.0.0.1:" + backendPort + "/widget";
+ given().contentType(ContentType.JSON)
+ .body("{\"type\":\"HTTP\",\"httpMethod\":\"POST\",\"uri\":\"" + backendUrl + "\""
+ + integrationExtras + "}")
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId + "/methods/POST/integration")
+ .then().statusCode(201);
+
+ if (withIntegrationResponses) {
+ // Default (empty selectionPattern) → 200.
+ given().contentType(ContentType.JSON)
+ .body("{\"selectionPattern\":\"\"}")
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId
+ + "/methods/POST/integration/responses/200")
+ .then().statusCode(201);
+ // Backend 404 → method 404.
+ given().contentType(ContentType.JSON)
+ .body("{\"selectionPattern\":\"404\"}")
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId
+ + "/methods/POST/integration/responses/404")
+ .then().statusCode(201);
+ // Any backend 5xx → method 502.
+ given().contentType(ContentType.JSON)
+ .body("{\"selectionPattern\":\"5\\\\d{2}\"}")
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId
+ + "/methods/POST/integration/responses/502")
+ .then().statusCode(201);
+ }
+
+ String deploymentId = given().contentType(ContentType.JSON)
+ .body("{\"description\":\"v1\"}")
+ .when().post("/restapis/" + apiId + "/deployments")
+ .then().statusCode(201).extract().path("id");
+ given().contentType(ContentType.JSON)
+ .body("{\"stageName\":\"test\",\"deploymentId\":\"" + deploymentId + "\"}")
+ .when().post("/restapis/" + apiId + "/stages")
+ .then().statusCode(201);
+
+ return apiId;
+ }
+
+ @AfterEach
+ void cleanup() {
+ for (String apiId : createdApis) {
+ given().when().delete("/restapis/" + apiId).then().statusCode(202);
+ }
+ createdApis.clear();
+ }
+
+ @Test
+ void rendersRequestTemplateBeforeSendingToTheBackend() {
+ resetRecordings();
+ String apiId = createHttpApi("http-nonproxy-reqtemplate",
+ ",\"requestTemplates\":{\"application/json\":"
+ + "\"{\\\"wrapped\\\":$input.json('$.value')}\"}", false);
+
+ given().contentType(ContentType.JSON).body("{\"value\":42}")
+ .when().post("/execute-api/" + apiId + "/test/widget")
+ .then().statusCode(200);
+
+ assertEquals("POST", lastMethod.get());
+ assertEquals("{\"wrapped\":42}", lastBody.get());
+ }
+
+ @Test
+ void forwardsOnlyExplicitlyMappedHeadersAndQueryParameters() {
+ resetRecordings();
+ String apiId = createHttpApi("http-nonproxy-params",
+ ",\"requestParameters\":{"
+ + "\"integration.request.header.X-Tenant\":\"method.request.querystring.tenant\","
+ + "\"integration.request.querystring.mode\":\"method.request.querystring.mode\"}", false);
+
+ given().contentType(ContentType.JSON).body("{}")
+ .header("X-Client-Trace", "should-not-be-forwarded")
+ .when().post("/execute-api/" + apiId + "/test/widget?tenant=acme&mode=ok")
+ .then().statusCode(200);
+
+ assertEquals("acme", lastTenantHeader.get());
+ assertEquals("mode=ok", lastQuery.get());
+ // A non-proxy HTTP integration builds its request from mappings alone; inbound headers that
+ // were not mapped must not leak to the backend (that passthrough is HTTP_PROXY's job).
+ assertNull(lastUnmappedHeader.get(),
+ "unmapped inbound header leaked to backend: " + lastUnmappedHeader.get());
+ }
+
+ @Test
+ void selectionPatternMatchesTheBackendStatusCode() {
+ resetRecordings();
+ String apiId = createHttpApi("http-nonproxy-selection",
+ ",\"requestParameters\":{"
+ + "\"integration.request.querystring.mode\":\"method.request.querystring.mode\"}", true);
+
+ // Backend 200 → default integration response → 200
+ given().contentType(ContentType.JSON).body("{}")
+ .when().post("/execute-api/" + apiId + "/test/widget?mode=ok")
+ .then().statusCode(200);
+
+ // Backend 404 → selectionPattern "404" → 404
+ given().contentType(ContentType.JSON).body("{}")
+ .when().post("/execute-api/" + apiId + "/test/widget?mode=missing")
+ .then().statusCode(404);
+
+ // Backend 500 → selectionPattern "5\d{2}" → remapped to 502
+ given().contentType(ContentType.JSON).body("{}")
+ .when().post("/execute-api/" + apiId + "/test/widget?mode=boom")
+ .then().statusCode(502);
+ }
+
+ @Test
+ void appliesResponseTemplateToTheBackendBody() {
+ resetRecordings();
+ String apiId = createHttpApi("http-nonproxy-resptemplate", "", false);
+
+ String resourceId = given().when().get("/restapis/" + apiId + "/resources")
+ .then().statusCode(200).extract().path("item.find { it.pathPart == 'widget' }.id");
+
+ given().contentType(ContentType.JSON)
+ .body("{\"selectionPattern\":\"\",\"responseTemplates\":{\"application/json\":"
+ + "\"{\\\"renamed\\\":$input.json('$.widget')}\"}}")
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId
+ + "/methods/POST/integration/responses/200")
+ .then().statusCode(201);
+
+ given().contentType(ContentType.JSON).body("{}")
+ .when().post("/execute-api/" + apiId + "/test/widget")
+ .then().statusCode(200)
+ .body("renamed", equalTo("cog"));
+ }
+
+ @Test
+ void mapsBackendResponseHeaderToMethodResponseHeader() {
+ resetRecordings();
+ String apiId = createHttpApi("http-nonproxy-respparams", "", false);
+
+ String resourceId = given().when().get("/restapis/" + apiId + "/resources")
+ .then().statusCode(200).extract().path("item.find { it.pathPart == 'widget' }.id");
+
+ given().contentType(ContentType.JSON)
+ .body("{\"selectionPattern\":\"\",\"responseParameters\":"
+ + "{\"method.response.header.X-Out\":\"integration.response.header.X-Backend-Id\"}}")
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId
+ + "/methods/POST/integration/responses/200")
+ .then().statusCode(201);
+
+ given().contentType(ContentType.JSON).body("{}")
+ .when().post("/execute-api/" + apiId + "/test/widget")
+ .then().statusCode(200)
+ .header("X-Out", "backend-7");
+ }
+
+ @Test
+ void passthroughNeverRejectsAnUnmatchedContentType() {
+ resetRecordings();
+ String apiId = createHttpApi("http-nonproxy-passthrough",
+ ",\"passthroughBehavior\":\"NEVER\","
+ + "\"requestTemplates\":{\"application/xml\":\"<x/>\"}", false);
+
+ given().contentType(ContentType.JSON).body("{}")
+ .when().post("/execute-api/" + apiId + "/test/widget")
+ .then().statusCode(415);
+ }
+
+ @Test
+ void tellsTheBackendTheMediaTypeOfTheTemplateItRendered() {
+ resetRecordings();
+ // The template is keyed under text/plain, so the rendered payload is text/plain: the
+ // backend must be told that, not the JSON default.
+ String apiId = createHttpApi("http-nonproxy-contenttype",
+ ",\"requestTemplates\":{\"text/plain\":\"rendered-as-plain\"}", false);
+
+ given().contentType("text/plain").body("ignored")
+ .when().post("/execute-api/" + apiId + "/test/widget")
+ .then().statusCode(200);
+
+ assertEquals("rendered-as-plain", lastBody.get());
+ assertEquals("text/plain", lastContentType.get());
+ }
+
+ @Test
+ void selectsTheTemplateByBaseTypeWhenTheRequestCarriesACharset() {
+ resetRecordings();
+ String apiId = createHttpApi("http-nonproxy-charset",
+ ",\"requestTemplates\":{\"application/json\":"
+ + "\"{\\\"wrapped\\\":$input.json('$.value')}\"}", false);
+
+ given().contentType("application/json; charset=utf-8").body("{\"value\":7}")
+ .when().post("/execute-api/" + apiId + "/test/widget")
+ .then().statusCode(200);
+
+ assertEquals("{\"wrapped\":7}", lastBody.get());
+ assertEquals("application/json", lastContentType.get());
+ }
+
+ @Test
+ void relaysBackendStatusWhenNoIntegrationResponsesAreConfigured() {
+ resetRecordings();
+ String apiId = createHttpApi("http-nonproxy-nointegresp",
+ ",\"requestParameters\":{"
+ + "\"integration.request.querystring.mode\":\"method.request.querystring.mode\"}", false);
+
+ given().contentType(ContentType.JSON).body("{}")
+ .when().post("/execute-api/" + apiId + "/test/widget?mode=missing")
+ .then().statusCode(404);
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayHttpProxyIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayHttpProxyIntegrationTest.java
new file mode 100644
index 0000000000..4b4b8522d1
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayHttpProxyIntegrationTest.java
@@ -0,0 +1,330 @@
+package io.github.hectorvent.floci.services.apigateway;
+
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpServer;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.http.ContentType;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Covers the REST (v1) {@code HTTP_PROXY} integration type: API Gateway forwards the request to an
+ * arbitrary HTTP backend and relays the backend's response verbatim, with no VTL mapping and no
+ * integration-response selection (AWS applies neither to {@code HTTP_PROXY}).
+ *
+ * <p>{@code putIntegration} already accepted {@code "type":"HTTP_PROXY"}, but dispatch handled only
+ * {@code AWS_PROXY}/{@code AWS}/{@code MOCK} and fell through to a 500 "Unsupported integration
+ * type": so a REST API fronting an HTTP microservice, the shape CDK's
+ * {@code HttpIntegration}/{@code addProxy} emits, could be created but never invoked.
+ */
+@QuarkusTest
+class ApiGatewayHttpProxyIntegrationTest {
+
+ private static HttpServer backendServer;
+ private static int backendPort;
+ /** A port nothing is listening on, for the connection-failure case. */
+ private static int deadPort;
+
+ private static final AtomicReference<String> lastMethod = new AtomicReference<>();
+ private static final AtomicReference<String> lastPath = new AtomicReference<>();
+ private static final AtomicReference<String> lastQuery = new AtomicReference<>();
+ private static final AtomicReference<String> lastBody = new AtomicReference<>();
+ private static final AtomicReference<String> lastForwardedHeader = new AtomicReference<>();
+ private static final AtomicReference<String> lastAuthorization = new AtomicReference<>();
+ private static final AtomicReference<String> lastHost = new AtomicReference<>();
+ private static final AtomicReference<List<String>> lastTraceHeaders = new AtomicReference<>();
+
+ private final List<String> createdApis = new ArrayList<>();
+
+ @BeforeAll
+ static void startBackend() throws IOException {
+ backendServer = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
+ backendServer.createContext("/", ApiGatewayHttpProxyIntegrationTest::handle);
+ backendServer.start();
+ backendPort = backendServer.getAddress().getPort();
+
+ try (ServerSocket probe = new ServerSocket(0)) {
+ deadPort = probe.getLocalPort();
+ }
+ }
+
+ @AfterAll
+ static void stopBackend() {
+ if (backendServer != null) backendServer.stop(0);
+ }
+
+ private static void handle(HttpExchange exchange) throws IOException {
+ lastMethod.set(exchange.getRequestMethod());
+ lastPath.set(exchange.getRequestURI().getPath());
+ lastQuery.set(exchange.getRequestURI().getQuery());
+ lastBody.set(new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8));
+ lastForwardedHeader.set(exchange.getRequestHeaders().getFirst("X-Forwarded-Tenant"));
+ lastAuthorization.set(exchange.getRequestHeaders().getFirst("Authorization"));
+ lastHost.set(exchange.getRequestHeaders().getFirst("Host"));
+ List<String> trace = exchange.getRequestHeaders().get("X-Trace");
+ lastTraceHeaders.set(trace == null ? null : List.copyOf(trace));
+
+ // /missing exercises relaying a backend error status untouched.
+ int status = exchange.getRequestURI().getPath().endsWith("/missing") ? 404 : 200;
+ byte[] response = ("{\"from\":\"backend\",\"path\":\"" + exchange.getRequestURI().getPath() + "\"}")
+ .getBytes(StandardCharsets.UTF_8);
+ exchange.getResponseHeaders().add("Content-Type", "application/json");
+ exchange.getResponseHeaders().add("X-Backend-Marker", "hit");
+ // Two separate Set-Cookie lines, the canonical repeated response header. The Expires
+ // attribute carries its own comma, so a comma-joined relay cannot be split back apart.
+ exchange.getResponseHeaders().add("Set-Cookie",
+ "session=abc; Path=/; Expires=Wed, 21 Oct 2026 07:28:00 GMT");
+ exchange.getResponseHeaders().add("Set-Cookie", "tracking=xyz; Path=/");
+ exchange.sendResponseHeaders(status, response.length);
+ exchange.getResponseBody().write(response);
+ exchange.close();
+ }
+
+ private void resetRecordings() {
+ lastMethod.set(null);
+ lastPath.set(null);
+ lastQuery.set(null);
+ lastBody.set(null);
+ lastForwardedHeader.set(null);
+ lastAuthorization.set(null);
+ lastHost.set(null);
+ lastTraceHeaders.set(null);
+ }
+
+ /**
+ * Creates a REST API with a greedy {@code /{proxy+}} resource whose ANY method is an
+ * HTTP_PROXY integration pointing at {@code targetUri}, deployed to stage {@code test}.
+ */
+ private String createProxyApi(String name, String targetUri, String requestParametersJson) {
+ String apiId = given()
+ .contentType(ContentType.JSON)
+ .body("{\"name\":\"" + name + "\"}")
+ .when().post("/restapis")
+ .then().statusCode(201).body("id", notNullValue())
+ .extract().path("id");
+ createdApis.add(apiId);
+
+ String rootId = given().when().get("/restapis/" + apiId + "/resources")
+ .then().statusCode(200).extract().path("item[0].id");
+
+ String resourceId = given()
+ .contentType(ContentType.JSON)
+ .body("{\"pathPart\":\"{proxy+}\"}")
+ .when().post("/restapis/" + apiId + "/resources/" + rootId)
+ .then().statusCode(201).extract().path("id");
+
+ given().contentType(ContentType.JSON)
+ .body("{\"authorizationType\":\"NONE\"}")
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId + "/methods/ANY")
+ .then().statusCode(201);
+
+ String integrationBody = "{\"type\":\"HTTP_PROXY\",\"httpMethod\":\"ANY\",\"uri\":\"" + targetUri + "\""
+ + (requestParametersJson == null ? "" : ",\"requestParameters\":" + requestParametersJson)
+ + "}";
+ given().contentType(ContentType.JSON)
+ .body(integrationBody)
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId + "/methods/ANY/integration")
+ .then().statusCode(201);
+
+ String deploymentId = given().contentType(ContentType.JSON)
+ .body("{\"description\":\"v1\"}")
+ .when().post("/restapis/" + apiId + "/deployments")
+ .then().statusCode(201).extract().path("id");
+ given().contentType(ContentType.JSON)
+ .body("{\"stageName\":\"test\",\"deploymentId\":\"" + deploymentId + "\"}")
+ .when().post("/restapis/" + apiId + "/stages")
+ .then().statusCode(201);
+
+ return apiId;
+ }
+
+ private String backendUri() {
+ return "http://127.0.0.1:" + backendPort + "/{proxy}";
+ }
+
+ @AfterEach
+ void cleanup() {
+ for (String apiId : createdApis) {
+ given().when().delete("/restapis/" + apiId).then().statusCode(202);
+ }
+ createdApis.clear();
+ }
+
+ @Test
+ void forwardsPathAndQueryToTheBackendAndRelaysItsResponse() {
+ resetRecordings();
+ String apiId = createProxyApi("http-proxy-get-api", backendUri(), null);
+
+ given()
+ .when().get("/execute-api/" + apiId + "/test/orders/42?limit=5")
+ .then().statusCode(200)
+ .header("X-Backend-Marker", "hit")
+ .body("from", org.hamcrest.Matchers.equalTo("backend"));
+
+ assertEquals("GET", lastMethod.get());
+ assertEquals("/orders/42", lastPath.get());
+ assertEquals("limit=5", lastQuery.get());
+ }
+
+ @Test
+ void forwardsRequestBodyOnPost() {
+ resetRecordings();
+ String apiId = createProxyApi("http-proxy-post-api", backendUri(), null);
+
+ given()
+ .contentType(ContentType.JSON)
+ .body("{\"symbol\":\"ACME\"}")
+ .when().post("/execute-api/" + apiId + "/test/orders")
+ .then().statusCode(200);
+
+ assertEquals("POST", lastMethod.get());
+ assertEquals("/orders", lastPath.get());
+ assertEquals("{\"symbol\":\"ACME\"}", lastBody.get());
+ }
+
+ @Test
+ void relaysBackendErrorStatusVerbatim() {
+ resetRecordings();
+ String apiId = createProxyApi("http-proxy-error-api", backendUri(), null);
+
+ // HTTP_PROXY performs no integration-response selection, so a backend 404 must reach the
+ // caller as a 404 carrying the backend's own body, not be remapped to a gateway error.
+ given()
+ .when().get("/execute-api/" + apiId + "/test/orders/missing")
+ .then().statusCode(404)
+ .body("from", org.hamcrest.Matchers.equalTo("backend"));
+ }
+
+ @Test
+ void unreachableBackendYields502() {
+ String apiId = createProxyApi("http-proxy-dead-api", "http://127.0.0.1:" + deadPort + "/{proxy}", null);
+
+ given()
+ .when().get("/execute-api/" + apiId + "/test/anything")
+ .then().statusCode(502);
+ }
+
+ @Test
+ void appliesIntegrationRequestParameterMappingToOutgoingHeaders() {
+ resetRecordings();
+ String apiId = createProxyApi("http-proxy-params-api", backendUri(),
+ "{\"integration.request.header.X-Forwarded-Tenant\":\"method.request.querystring.tenant\"}");
+
+ given()
+ .when().get("/execute-api/" + apiId + "/test/orders?tenant=acme")
+ .then().statusCode(200);
+
+ assertEquals("acme", lastForwardedHeader.get());
+ }
+
+ @Test
+ void forwardsAuthorizationHeaderUnchangedOnNoneAuthRoute() {
+ resetRecordings();
+ String apiId = createProxyApi("http-proxy-auth-passthrough-api", backendUri(), null);
+
+ // A NONE-auth route must not have SigV4 applied to it; the caller's Authorization header is
+ // the backend's to interpret and has to arrive byte-for-byte.
+ given()
+ .header("Authorization", "Bearer caller-supplied-token")
+ .when().get("/execute-api/" + apiId + "/test/orders")
+ .then().statusCode(200);
+
+ assertEquals("Bearer caller-supplied-token", lastAuthorization.get());
+ }
+
+ @Test
+ void doesNotForwardTheInboundHostHeaderToTheBackend() {
+ resetRecordings();
+ String apiId = createProxyApi("http-proxy-host-api", backendUri(), null);
+
+ given()
+ .when().get("/execute-api/" + apiId + "/test/orders")
+ .then().statusCode(200);
+
+ // Host is hop-by-hop for this proxy: the backend must see its own authority, not the
+ // gateway's, or virtual-hosted backends route the request to the wrong vhost.
+ assertTrue(lastHost.get() != null && lastHost.get().contains(String.valueOf(backendPort)),
+ "backend should see its own Host authority, saw: " + lastHost.get());
+ }
+
+ @Test
+ void repeatedQueryParametersReachTheBackendSeparately() {
+ resetRecordings();
+ String apiId = createProxyApi("http-proxy-multi-query-api", backendUri(), null);
+
+ given()
+ .when().get("/execute-api/" + apiId + "/test/orders?tag=a&tag=b&limit=5")
+ .then().statusCode(200);
+
+ // AWS documents HTTP_PROXY as passing the request through, and multi-valued query strings
+ // are explicitly supported. Collapsing these to "tag=a,b" is a different request: most
+ // frameworks parse it as one value containing a comma, not as two values.
+ //
+ // Asserted per parameter rather than on the whole query string: the relative order of two
+ // differently named parameters is not part of the contract and is not stable across runs.
+ // The order of repeated values for one name is, and is checked.
+ Map<String, List<String>> received = parseQuery(lastQuery.get());
+ assertEquals(List.of("a", "b"), received.get("tag"));
+ assertEquals(List.of("5"), received.get("limit"));
+ }
+
+ /** Query string to name → values, preserving the order values appear in for a given name. */
+ private static Map<String, List<String>> parseQuery(String query) {
+ Map<String, List<String>> parsed = new LinkedHashMap<>();
+ if (query == null || query.isEmpty()) return parsed;
+ for (String pair : query.split("&")) {
+ int eq = pair.indexOf('=');
+ String name = eq < 0 ? pair : pair.substring(0, eq);
+ String value = eq < 0 ? "" : pair.substring(eq + 1);
+ parsed.computeIfAbsent(name, k -> new ArrayList<>()).add(value);
+ }
+ return parsed;
+ }
+
+ @Test
+ void repeatedRequestHeadersReachTheBackendSeparately() {
+ resetRecordings();
+ String apiId = createProxyApi("http-proxy-multi-header-api", backendUri(), null);
+
+ given()
+ .header("X-Trace", "first")
+ .header("X-Trace", "second")
+ .when().get("/execute-api/" + apiId + "/test/orders")
+ .then().statusCode(200);
+
+ assertEquals(List.of("first", "second"), lastTraceHeaders.get());
+ }
+
+ @Test
+ void repeatedResponseHeadersRelayToTheCallerSeparately() {
+ resetRecordings();
+ String apiId = createProxyApi("http-proxy-multi-response-header-api", backendUri(), null);
+
+ List<String> cookies = given()
+ .when().get("/execute-api/" + apiId + "/test/orders")
+ .then().statusCode(200)
+ .extract().headers().getValues("Set-Cookie");
+
+ assertEquals(2, cookies.size(), "expected both Set-Cookie headers, got: " + cookies);
+ assertTrue(cookies.contains("session=abc; Path=/; Expires=Wed, 21 Oct 2026 07:28:00 GMT"),
+ "session cookie should relay with its Expires comma intact, got: " + cookies);
+ assertTrue(cookies.contains("tracking=xyz; Path=/"), "got: " + cookies);
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiHttpProxyMultiValueIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiHttpProxyMultiValueIntegrationTest.java
new file mode 100644
index 0000000000..493bee3de2
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/HttpApiHttpProxyMultiValueIntegrationTest.java
@@ -0,0 +1,178 @@
+package io.github.hectorvent.floci.services.apigatewayv2;
+
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpServer;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.http.ContentType;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static io.restassured.RestAssured.given;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * The HTTP API (v2) counterpart of the REST multi-value coverage in
+ * {@code ApiGatewayHttpProxyIntegrationTest}: {@code dispatchHttpProxyV2} is a second entry point
+ * into the same {@code HttpProxyInvoker} / {@code RequestContext} / {@code ProxyResult} transport,
+ * and it built its request context from comma-joined single-value maps. So an HTTP API with an
+ * HTTP_PROXY integration still sent {@code ?tag=a,b} for {@code ?tag=a&tag=b} after the REST path
+ * was fixed, because the transport's multi-value support was never populated from here.
+ *
+ * <p>AWS documents HTTP_PROXY as passing the request through, with multi-valued headers and query
+ * strings explicitly supported, so the two shapes are not interchangeable: most servers parse
+ * {@code tag=a,b} as one value containing a comma rather than as two values.
+ */
+@QuarkusTest
+class HttpApiHttpProxyMultiValueIntegrationTest {
+
+ private static HttpServer backendServer;
+ private static int backendPort;
+
+ private static final AtomicReference<String> lastQuery = new AtomicReference<>();
+ private static final AtomicReference<List<String>> lastTraceHeaders = new AtomicReference<>();
+
+ @BeforeAll
+ static void startBackend() throws IOException {
+ backendServer = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
+ backendServer.createContext("/", HttpApiHttpProxyMultiValueIntegrationTest::handle);
+ backendServer.start();
+ backendPort = backendServer.getAddress().getPort();
+ }
+
+ @AfterAll
+ static void stopBackend() {
+ if (backendServer != null) {
+ backendServer.stop(0);
+ }
+ }
+
+ private static void handle(HttpExchange exchange) throws IOException {
+ lastQuery.set(exchange.getRequestURI().getQuery());
+ List<String> trace = exchange.getRequestHeaders().get("X-Trace");
+ lastTraceHeaders.set(trace == null ? null : List.copyOf(trace));
+
+ byte[] response = "{\"from\":\"backend\"}".getBytes(StandardCharsets.UTF_8);
+ exchange.getResponseHeaders().add("Content-Type", "application/json");
+ // Two separate Set-Cookie lines, the canonical repeated response header. The Expires
+ // attribute carries its own comma, so a comma-joined relay cannot be split back apart.
+ exchange.getResponseHeaders().add("Set-Cookie",
+ "session=abc; Path=/; Expires=Wed, 21 Oct 2026 07:28:00 GMT");
+ exchange.getResponseHeaders().add("Set-Cookie", "tracking=xyz; Path=/");
+ exchange.sendResponseHeaders(200, response.length);
+ exchange.getResponseBody().write(response);
+ exchange.close();
+ }
+
+ private void resetRecordings() {
+ lastQuery.set(null);
+ lastTraceHeaders.set(null);
+ }
+
+ /**
+ * Creates an HTTP API whose {@code GET /orders} route is an HTTP_PROXY integration pointing at
+ * the fixture backend, deployed to stage {@code test}.
+ */
+ private String createProxyApi(String name) {
+ String apiId = given()
+ .contentType(ContentType.JSON)
+ .body("{\"name\":\"" + name + "\",\"protocolType\":\"HTTP\"}")
+ .when().post("/v2/apis")
+ .then().statusCode(201)
+ .extract().path("apiId");
+
+ given()
+ .contentType(ContentType.JSON)
+ .body("{\"stageName\":\"test\"}")
+ .when().post("/v2/apis/" + apiId + "/stages")
+ .then().statusCode(201);
+
+ String integrationId = given()
+ .contentType(ContentType.JSON)
+ .body("{\"integrationType\":\"HTTP_PROXY\",\"integrationUri\":\"http://127.0.0.1:"
+ + backendPort + "/orders\",\"payloadFormatVersion\":\"1.0\"}")
+ .when().post("/v2/apis/" + apiId + "/integrations")
+ .then().statusCode(201)
+ .extract().path("integrationId");
+
+ given()
+ .contentType(ContentType.JSON)
+ .body("{\"routeKey\":\"GET /orders\",\"target\":\"integrations/" + integrationId + "\"}")
+ .when().post("/v2/apis/" + apiId + "/routes")
+ .then().statusCode(201);
+
+ return apiId;
+ }
+
+ @Test
+ void repeatedQueryParametersReachTheBackendSeparately() {
+ resetRecordings();
+ String apiId = createProxyApi("v2-http-proxy-multi-query-api");
+
+ given()
+ .when().get("/execute-api/" + apiId + "/test/orders?tag=a&tag=b&limit=5")
+ .then().statusCode(200);
+
+ // Asserted per parameter rather than on the whole query string: the relative order of two
+ // differently named parameters is not part of the contract and is not stable across runs.
+ // The order of repeated values for one name is, and is checked.
+ Map<String, List<String>> received = parseQuery(lastQuery.get());
+ assertEquals(List.of("a", "b"), received.get("tag"));
+ assertEquals(List.of("5"), received.get("limit"));
+ }
+
+ @Test
+ void repeatedRequestHeadersReachTheBackendSeparately() {
+ resetRecordings();
+ String apiId = createProxyApi("v2-http-proxy-multi-header-api");
+
+ given()
+ .header("X-Trace", "first")
+ .header("X-Trace", "second")
+ .when().get("/execute-api/" + apiId + "/test/orders")
+ .then().statusCode(200);
+
+ assertEquals(List.of("first", "second"), lastTraceHeaders.get());
+ }
+
+ @Test
+ void repeatedResponseHeadersRelayToTheCallerSeparately() {
+ resetRecordings();
+ String apiId = createProxyApi("v2-http-proxy-multi-response-header-api");
+
+ List<String> cookies = given()
+ .when().get("/execute-api/" + apiId + "/test/orders")
+ .then().statusCode(200)
+ .extract().headers().getValues("Set-Cookie");
+
+ assertEquals(2, cookies.size(), "expected both Set-Cookie headers, got: " + cookies);
+ assertTrue(cookies.contains("session=abc; Path=/; Expires=Wed, 21 Oct 2026 07:28:00 GMT"),
+ "session cookie should relay with its Expires comma intact, got: " + cookies);
+ assertTrue(cookies.contains("tracking=xyz; Path=/"), "got: " + cookies);
+ }
+
+ /** Query string to name to values, preserving the order values appear in for a given name. */
+ private static Map<String, List<String>> parseQuery(String query) {
+ Map<String, List<String>> parsed = new LinkedHashMap<>();
+ if (query == null || query.isEmpty()) {
+ return parsed;
+ }
+ for (String pair : query.split("&")) {
+ int eq = pair.indexOf('=');
+ String name = eq < 0 ? pair : pair.substring(0, eq);
+ String value = eq < 0 ? "" : pair.substring(eq + 1);
+ parsed.computeIfAbsent(name, k -> new ArrayList<>()).add(value);
+ }
+ return parsed;
+ }
+}