Light, fluffy, and always free - The AWS Local Emulator alternative
fix(apigateway): populate full APIGatewayRequestAuthorizerEvent for REQUEST authorizers (#1002)
Dixit R Jain3a31c792fae3
diff --git a/compatibility-tests/sdk-test-node/package.json b/compatibility-tests/sdk-test-node/package.jsonindex abfa750b34..fd9bb1faf5 100644--- a/compatibility-tests/sdk-test-node/package.json+++ b/compatibility-tests/sdk-test-node/package.json@@ -8,6 +8,7 @@},"dependencies": {"@aws-sdk/client-acm": "^3.500.0",+ "@aws-sdk/client-api-gateway": "^3.500.0","@aws-sdk/client-apigatewaymanagementapi": "^3.500.0","@aws-sdk/client-apigatewayv2": "^3.500.0","@aws-sdk/client-cloudformation": "^3.500.0",diff --git a/compatibility-tests/sdk-test-node/tests/apigateway.test.ts b/compatibility-tests/sdk-test-node/tests/apigateway.test.tsnew file mode 100644index 0000000000..381f9377f1--- /dev/null+++ b/compatibility-tests/sdk-test-node/tests/apigateway.test.ts@@ -0,0 +1,747 @@+/**+ * API Gateway v1 (REST API) compatibility tests.+ *+ * Covers management-plane CRUD (RestApis, Resources, Methods, Integrations,+ * Authorizers, Deployments, Stages) and execute-api data-plane behaviour,+ * including the REQUEST authorizer full-event shape.+ *+ * Uses @aws-sdk/client-api-gateway for management-plane calls and the native+ * fetch API for execute-api invocations (which are plain HTTP, not SDK calls).+ */++import { describe, it, expect, beforeAll, afterAll } from 'vitest';+import {+ APIGatewayClient,+ CreateRestApiCommand,+ GetRestApiCommand,+ GetRestApisCommand,+ DeleteRestApiCommand,+ GetResourcesCommand,+ CreateAuthorizerCommand,+ GetAuthorizerCommand,+ GetAuthorizersCommand,+ AuthorizerType,+} from '@aws-sdk/client-api-gateway';+import {+ LambdaClient,+ CreateFunctionCommand,+ DeleteFunctionCommand,+} from '@aws-sdk/client-lambda';+import { makeClient, uniqueName, ENDPOINT, ACCOUNT, REGION, buildMinimalZip } from './setup';++// ──────────────────────────── helpers ────────────────────────────++/** POST a raw JSON body to the Floci management plane (no SDK needed for simple calls). */+async function apigwFetch(path: string, method = 'GET', body?: unknown): Promise<Response> {+ return fetch(`${ENDPOINT}${path}`, {+ method,+ headers: { 'Content-Type': 'application/json' },+ body: body !== undefined ? JSON.stringify(body) : undefined,+ });+}++/** Invoke the execute-api data plane and return the raw Response. */+async function executeApi(+ apiId: string,+ stage: string,+ resourcePath: string,+ opts: { method?: string; headers?: Record<string, string>; query?: string } = {}+): Promise<Response> {+ const { method = 'GET', headers = {}, query = '' } = opts;+ const qs = query ? `?${query}` : '';+ return fetch(`${ENDPOINT}/execute-api/${apiId}/${stage}${resourcePath}${qs}`, {+ method,+ headers,+ });+}++/** Create a Node.js Lambda function with the given inline handler source. */+async function createLambda(lambda: LambdaClient, name: string, handlerSrc: string): Promise<void> {+ const zip = buildMinimalZip('index.js', Buffer.from(handlerSrc));+ await lambda.send(new CreateFunctionCommand({+ FunctionName: name,+ Runtime: 'nodejs20.x',+ Role: `arn:aws:iam::${ACCOUNT}:role/lambda-role`,+ Handler: 'index.handler',+ Code: { ZipFile: zip },+ Timeout: 30,+ }));+}++/** Delete a Lambda function, ignoring 404. */+async function deleteLambda(lambda: LambdaClient, name: string): Promise<void> {+ try { await lambda.send(new DeleteFunctionCommand({ FunctionName: name })); } catch { /* ignore */ }+}++// ──────────────────────────── Management-plane CRUD ────────────────────────────++describe('API Gateway v1 — management plane', () => {+ let gw: APIGatewayClient;++ beforeAll(() => {+ gw = makeClient(APIGatewayClient);+ });++ describe('RestApi lifecycle', () => {+ let apiId: string;++ afterAll(async () => {+ try { if (apiId) await gw.send(new DeleteRestApiCommand({ restApiId: apiId })); } catch { /* ignore */ }+ });++ it('should create a REST API', async () => {+ const res = await gw.send(new CreateRestApiCommand({ name: uniqueName('rest-api') }));+ apiId = res.id!;+ expect(apiId).toBeTruthy();+ expect(res.name).toContain('rest-api');+ });++ it('should get the REST API', async () => {+ const res = await gw.send(new GetRestApiCommand({ restApiId: apiId }));+ expect(res.id).toBe(apiId);+ });++ it('should list REST APIs including the created one', async () => {+ const res = await gw.send(new GetRestApisCommand({}));+ expect(res.items?.some(a => a.id === apiId)).toBe(true);+ });++ it('should delete the REST API', async () => {+ await gw.send(new DeleteRestApiCommand({ restApiId: apiId }));+ await expect(gw.send(new GetRestApiCommand({ restApiId: apiId }))).rejects.toThrow();+ apiId = '';+ });+ });++ describe('Authorizer CRUD', () => {+ let apiId: string;+ let authorizerId: string;++ beforeAll(async () => {+ const res = await gw.send(new CreateRestApiCommand({ name: uniqueName('auth-crud') }));+ apiId = res.id!;+ });++ afterAll(async () => {+ try { await gw.send(new DeleteRestApiCommand({ restApiId: apiId })); } catch { /* ignore */ }+ });++ it('should create a TOKEN authorizer', async () => {+ const res = await gw.send(new CreateAuthorizerCommand({+ restApiId: apiId,+ name: 'token-auth',+ type: AuthorizerType.TOKEN,+ authorizerUri: `arn:aws:apigateway:${REGION}:lambda:path/2015-03-31/functions/arn:aws:lambda:${REGION}:${ACCOUNT}:function:dummy/invocations`,+ identitySource: 'method.request.header.Authorization',+ authorizerResultTtlInSeconds: 0,+ }));+ authorizerId = res.id!;+ expect(authorizerId).toBeTruthy();+ expect(res.type).toBe(AuthorizerType.TOKEN);+ });++ it('should get the authorizer', async () => {+ const res = await gw.send(new GetAuthorizerCommand({ restApiId: apiId, authorizerId }));+ expect(res.id).toBe(authorizerId);+ expect(res.type).toBe(AuthorizerType.TOKEN);+ });++ it('should list authorizers', async () => {+ const res = await gw.send(new GetAuthorizersCommand({ restApiId: apiId }));+ expect(res.items?.some(a => a.id === authorizerId)).toBe(true);+ });+ });+});++// ──────────────────────────── Execute-API data plane ────────────────────────────++describe('API Gateway v1 — execute-api data plane', () => {+ let gw: APIGatewayClient;+ let lambda: LambdaClient;++ // Shared API wired up in beforeAll+ let apiId: string;+ let itemResourceId: string;+ let secureResourceId: string;+ let openResourceId: string;++ // Lambda function names+ const echoAuthFn = uniqueName('req-auth-echo');+ const tokenAuthFn = uniqueName('tok-auth-echo');+ const denyAuthFn = uniqueName('deny-auth');+ const proxyFn = uniqueName('proxy-echo');+ const simpleFn = uniqueName('simple-fn');++ beforeAll(async () => {+ gw = makeClient(APIGatewayClient);+ lambda = makeClient(LambdaClient);++ // ── Lambda: REQUEST authorizer — echoes received event into policy context ──+ await createLambda(lambda, echoAuthFn, `+ exports.handler = async (event) => ({+ principalId: 'user',+ policyDocument: {+ Version: '2012-10-17',+ Statement: [{ Action: 'execute-api:Invoke', Effect: 'Allow', Resource: event.methodArn }]+ },+ context: { receivedEvent: JSON.stringify(event) }+ });+ `);++ // ── Lambda: TOKEN authorizer — echoes received event into policy context ──+ await createLambda(lambda, tokenAuthFn, `+ exports.handler = async (event) => ({+ principalId: 'user',+ policyDocument: {+ Version: '2012-10-17',+ Statement: [{ Action: 'execute-api:Invoke', Effect: 'Allow', Resource: event.methodArn }]+ },+ context: { receivedEvent: JSON.stringify(event) }+ });+ `);++ // ── Lambda: REQUEST authorizer — always Deny ──+ await createLambda(lambda, denyAuthFn, `+ exports.handler = async (event) => ({+ principalId: 'user',+ policyDocument: {+ Version: '2012-10-17',+ Statement: [{ Action: 'execute-api:Invoke', Effect: 'Deny', Resource: event.methodArn }]+ }+ });+ `);++ // ── Lambda: proxy integration — returns authorizer context so tests can inspect it ──+ await createLambda(lambda, proxyFn, `+ exports.handler = async (event) => ({+ statusCode: 200,+ body: JSON.stringify({+ authorizer: event.requestContext?.authorizer ?? null+ })+ });+ `);++ // ── Lambda: simple integration — returns { invoked: true } ──+ await createLambda(lambda, simpleFn, `+ exports.handler = async (event) => ({+ statusCode: 200,+ body: JSON.stringify({ invoked: true })+ });+ `);++ // ── Build the REST API ──+ const api = await gw.send(new CreateRestApiCommand({ name: uniqueName('exec-api-test') }));+ apiId = api.id!;++ const resources = await gw.send(new GetResourcesCommand({ restApiId: apiId }));+ const rootId = resources.items![0].id!;++ // /items+ const itemsRes = await apigwFetch(`/restapis/${apiId}/resources/${rootId}`, 'POST', { pathPart: 'items' });+ const itemsId = (await itemsRes.json() as { id: string }).id;++ // /items/{id}+ const itemRes = await apigwFetch(`/restapis/${apiId}/resources/${itemsId}`, 'POST', { pathPart: '{id}' });+ itemResourceId = (await itemRes.json() as { id: string }).id;++ // /secure (TOKEN authorizer)+ const secureRes = await apigwFetch(`/restapis/${apiId}/resources/${rootId}`, 'POST', { pathPart: 'secure' });+ secureResourceId = (await secureRes.json() as { id: string }).id;++ // /open (NONE authorizer)+ const openRes = await apigwFetch(`/restapis/${apiId}/resources/${rootId}`, 'POST', { pathPart: 'open' });+ openResourceId = (await openRes.json() as { id: string }).id;++ // ── REQUEST authorizer ──+ const reqAuthRes = await apigwFetch(`/restapis/${apiId}/authorizers`, 'POST', {+ name: 'req-echo-auth',+ type: 'REQUEST',+ authorizerUri: `arn:aws:apigateway:${REGION}:lambda:path/2015-03-31/functions/arn:aws:lambda:${REGION}:${ACCOUNT}:function:${echoAuthFn}/invocations`,+ identitySource: 'method.request.header.Authorization',+ authorizerResultTtlInSeconds: 0,+ });+ const reqAuthId = (await reqAuthRes.json() as { id: string }).id;++ // ── TOKEN authorizer ──+ const tokAuthRes = await apigwFetch(`/restapis/${apiId}/authorizers`, 'POST', {+ name: 'tok-echo-auth',+ type: 'TOKEN',+ authorizerUri: `arn:aws:apigateway:${REGION}:lambda:path/2015-03-31/functions/arn:aws:lambda:${REGION}:${ACCOUNT}:function:${tokenAuthFn}/invocations`,+ identitySource: 'method.request.header.Authorization',+ authorizerResultTtlInSeconds: 0,+ });+ const tokAuthId = (await tokAuthRes.json() as { id: string }).id;++ const proxyUri = `arn:aws:apigateway:${REGION}:lambda:path/2015-03-31/functions/arn:aws:lambda:${REGION}:${ACCOUNT}:function:${proxyFn}/invocations`;+ const simpleUri = `arn:aws:apigateway:${REGION}:lambda:path/2015-03-31/functions/arn:aws:lambda:${REGION}:${ACCOUNT}:function:${simpleFn}/invocations`;++ // GET /items/{id} — REQUEST authorizer + proxy integration+ await apigwFetch(`/restapis/${apiId}/resources/${itemResourceId}/methods/GET`, 'PUT', {+ authorizationType: 'CUSTOM',+ authorizerId: reqAuthId,+ });+ await apigwFetch(`/restapis/${apiId}/resources/${itemResourceId}/methods/GET/integration`, 'PUT', {+ type: 'AWS_PROXY',+ httpMethod: 'POST',+ uri: proxyUri,+ });++ // GET /secure — TOKEN authorizer + proxy integration+ await apigwFetch(`/restapis/${apiId}/resources/${secureResourceId}/methods/GET`, 'PUT', {+ authorizationType: 'CUSTOM',+ authorizerId: tokAuthId,+ });+ await apigwFetch(`/restapis/${apiId}/resources/${secureResourceId}/methods/GET/integration`, 'PUT', {+ type: 'AWS_PROXY',+ httpMethod: 'POST',+ uri: proxyUri,+ });++ // GET /open — NONE authorizer + simple integration+ await apigwFetch(`/restapis/${apiId}/resources/${openResourceId}/methods/GET`, 'PUT', {+ authorizationType: 'NONE',+ });+ await apigwFetch(`/restapis/${apiId}/resources/${openResourceId}/methods/GET/integration`, 'PUT', {+ type: 'AWS_PROXY',+ httpMethod: 'POST',+ uri: simpleUri,+ });++ // ── Deploy ──+ const depRes = await apigwFetch(`/restapis/${apiId}/deployments`, 'POST', { description: 'compat-test' });+ const depId = (await depRes.json() as { id: string }).id;+ await apigwFetch(`/restapis/${apiId}/stages`, 'POST', { stageName: 'prod', deploymentId: depId });+ });++ afterAll(async () => {+ try { if (apiId) await gw.send(new DeleteRestApiCommand({ restApiId: apiId })); } catch { /* ignore */ }+ await deleteLambda(lambda, echoAuthFn);+ await deleteLambda(lambda, tokenAuthFn);+ await deleteLambda(lambda, denyAuthFn);+ await deleteLambda(lambda, proxyFn);+ await deleteLambda(lambda, simpleFn);+ });++ // ──────────────────────────── REQUEST authorizer event shape ────────────────────────────++ describe('REQUEST authorizer — full event shape', () => {+ let receivedEvent: Record<string, unknown>;++ beforeAll(async () => {+ const res = await executeApi(apiId, 'prod', '/items/42', {+ headers: { Authorization: 'Bearer test-token', 'X-Custom-Header': 'hello' },+ query: 'foo=bar&baz=qux',+ });+ expect(res.status).toBe(200);+ const body = await res.json() as { authorizer: { receivedEvent: string } };+ receivedEvent = JSON.parse(body.authorizer.receivedEvent) as Record<string, unknown>;+ });++ it('should include type=REQUEST and methodArn', () => {+ expect(receivedEvent.type).toBe('REQUEST');+ expect(typeof receivedEvent.methodArn).toBe('string');+ expect(receivedEvent.methodArn as string).toContain(apiId);+ });++ it('should include the matched resource path template', () => {+ expect(receivedEvent.resource).toBe('/items/{id}');+ });++ it('should include the actual request path', () => {+ expect(receivedEvent.path).toBe('/items/42');+ });++ it('should include the HTTP method', () => {+ expect(receivedEvent.httpMethod).toBe('GET');+ });++ it('should include a non-null headers map', () => {+ expect(receivedEvent.headers).toBeTruthy();+ expect(typeof receivedEvent.headers).toBe('object');+ const headers = receivedEvent.headers as Record<string, string>;+ expect(headers['Authorization']).toBe('Bearer test-token');+ expect(headers['X-Custom-Header']).toBe('hello');+ });++ it('should include a multiValueHeaders map', () => {+ expect(receivedEvent.multiValueHeaders).toBeTruthy();+ const mvh = receivedEvent.multiValueHeaders as Record<string, string[]>;+ expect(Array.isArray(mvh['Authorization'])).toBe(true);+ expect(mvh['Authorization'][0]).toBe('Bearer test-token');+ });++ it('should include queryStringParameters with all query params', () => {+ expect(receivedEvent.queryStringParameters).toBeTruthy();+ const qsp = receivedEvent.queryStringParameters as Record<string, string>;+ expect(qsp.foo).toBe('bar');+ expect(qsp.baz).toBe('qux');+ });++ it('should include multiValueQueryStringParameters', () => {+ expect(receivedEvent.multiValueQueryStringParameters).toBeTruthy();+ const mqsp = receivedEvent.multiValueQueryStringParameters as Record<string, string[]>;+ expect(Array.isArray(mqsp.foo)).toBe(true);+ expect(mqsp.foo[0]).toBe('bar');+ });++ it('should include pathParameters with the id segment', () => {+ expect(receivedEvent.pathParameters).toBeTruthy();+ const pp = receivedEvent.pathParameters as Record<string, string>;+ expect(pp.id).toBe('42');+ });++ it('should include stageVariables as null', () => {+ expect(receivedEvent.stageVariables).toBeNull();+ });++ it('should include a requestContext with requestId', () => {+ expect(receivedEvent.requestContext).toBeTruthy();+ const ctx = receivedEvent.requestContext as Record<string, unknown>;+ expect(typeof ctx.requestId).toBe('string');+ expect((ctx.requestId as string).length).toBeGreaterThan(0);+ });++ it('should include requestContext.identity.sourceIp', () => {+ const ctx = receivedEvent.requestContext as Record<string, unknown>;+ const identity = ctx.identity as Record<string, string>;+ expect(identity.sourceIp).toBe('127.0.0.1');+ });++ it('should include requestContext.resourcePath', () => {+ const ctx = receivedEvent.requestContext as Record<string, unknown>;+ expect(ctx.resourcePath).toBe('/items/{id}');+ });++ it('should include requestContext.httpMethod', () => {+ const ctx = receivedEvent.requestContext as Record<string, unknown>;+ expect(ctx.httpMethod).toBe('GET');+ });++ it('should include requestContext.stage', () => {+ const ctx = receivedEvent.requestContext as Record<string, unknown>;+ expect(ctx.stage).toBe('prod');+ });++ it('should include requestContext.accountId', () => {+ const ctx = receivedEvent.requestContext as Record<string, unknown>;+ expect(typeof ctx.accountId).toBe('string');+ expect((ctx.accountId as string).length).toBeGreaterThan(0);+ });++ it('should include requestContext.apiId', () => {+ const ctx = receivedEvent.requestContext as Record<string, unknown>;+ expect(ctx.apiId).toBe(apiId);+ });++ it('should include requestContext.resourceId as a non-empty string', () => {+ const ctx = receivedEvent.requestContext as Record<string, unknown>;+ expect(typeof ctx.resourceId).toBe('string');+ expect((ctx.resourceId as string).length).toBeGreaterThan(0);+ });++ it('should include requestContext.path equal to the actual request path', () => {+ const ctx = receivedEvent.requestContext as Record<string, unknown>;+ expect(ctx.path).toBe('/items/42');+ });++ it('should include requestContext.identity.apiKey as null when no usage plan key matches', () => {+ const ctx = receivedEvent.requestContext as Record<string, unknown>;+ const identity = ctx.identity as Record<string, unknown>;+ expect(Object.prototype.hasOwnProperty.call(identity, 'apiKey')).toBe(true);+ expect(identity.apiKey).toBeNull();+ });+ });++ describe('REQUEST authorizer — no query params', () => {+ it('should set queryStringParameters to null when no query string is present', async () => {+ const res = await executeApi(apiId, 'prod', '/items/99', {+ headers: { Authorization: 'Bearer test' },+ });+ expect(res.status).toBe(200);+ const body = await res.json() as { authorizer: { receivedEvent: string } };+ const event = JSON.parse(body.authorizer.receivedEvent) as Record<string, unknown>;+ expect(event.queryStringParameters).toBeNull();+ expect(event.multiValueQueryStringParameters).toBeNull();+ });+ });++ // ──────────────────────────── TOKEN authorizer preservation ────────────────────────────++ describe('TOKEN authorizer — event shape preserved', () => {+ let receivedEvent: Record<string, unknown>;++ beforeAll(async () => {+ const res = await executeApi(apiId, 'prod', '/secure', {+ headers: { Authorization: 'Bearer my-secret-token' },+ });+ expect(res.status).toBe(200);+ const body = await res.json() as { authorizer: { receivedEvent: string } };+ receivedEvent = JSON.parse(body.authorizer.receivedEvent) as Record<string, unknown>;+ });++ it('should include type=TOKEN', () => {+ expect(receivedEvent.type).toBe('TOKEN');+ });++ it('should include methodArn', () => {+ expect(typeof receivedEvent.methodArn).toBe('string');+ expect((receivedEvent.methodArn as string).length).toBeGreaterThan(0);+ });++ it('should include authorizationToken equal to the Authorization header value', () => {+ expect(receivedEvent.authorizationToken).toBe('Bearer my-secret-token');+ });++ it('should NOT include headers, queryStringParameters, or requestContext', () => {+ // TOKEN authorizer event must contain exactly type, methodArn, authorizationToken+ expect(receivedEvent.headers == null).toBe(true);+ expect(receivedEvent.queryStringParameters == null).toBe(true);+ expect(receivedEvent.requestContext == null).toBe(true);+ });+ });++ // ──────────────────────────── NONE authorizer preservation ────────────────────────────++ describe('NONE authorizer — skips authorizer invocation', () => {+ it('should invoke the integration directly without an Authorization header', async () => {+ const res = await executeApi(apiId, 'prod', '/open');+ expect(res.status).toBe(200);+ const body = await res.json() as { invoked: boolean };+ expect(body.invoked).toBe(true);+ });+ });++ // ──────────────────────────── Allow / Deny policy ────────────────────────────++ describe('REQUEST authorizer — Allow policy forwards to integration', () => {+ it('should return HTTP 200 when the authorizer returns Allow', async () => {+ const res = await executeApi(apiId, 'prod', '/items/1', {+ headers: { Authorization: 'Bearer allow-me' },+ });+ expect(res.status).toBe(200);+ });+ });++ describe('REQUEST authorizer — Deny policy returns 403', () => {+ let denyApiId: string;++ beforeAll(async () => {+ // Build a separate API with only the deny authorizer to avoid interfering with other tests+ const api = await gw.send(new CreateRestApiCommand({ name: uniqueName('deny-api') }));+ denyApiId = api.id!;++ const resources = await gw.send(new GetResourcesCommand({ restApiId: denyApiId }));+ const rootId = resources.items![0].id!;++ const protectedRes = await apigwFetch(`/restapis/${denyApiId}/resources/${rootId}`, 'POST', { pathPart: 'protected' });+ const protectedId = (await protectedRes.json() as { id: string }).id;++ const denyAuthRes = await apigwFetch(`/restapis/${denyApiId}/authorizers`, 'POST', {+ name: 'deny-auth',+ type: 'REQUEST',+ authorizerUri: `arn:aws:apigateway:${REGION}:lambda:path/2015-03-31/functions/arn:aws:lambda:${REGION}:${ACCOUNT}:function:${denyAuthFn}/invocations`,+ identitySource: 'method.request.header.Authorization',+ authorizerResultTtlInSeconds: 0,+ });+ const denyAuthId = (await denyAuthRes.json() as { id: string }).id;++ await apigwFetch(`/restapis/${denyApiId}/resources/${protectedId}/methods/GET`, 'PUT', {+ authorizationType: 'CUSTOM',+ authorizerId: denyAuthId,+ });+ await apigwFetch(`/restapis/${denyApiId}/resources/${protectedId}/methods/GET/integration`, 'PUT', {+ type: 'MOCK',+ requestTemplates: { 'application/json': '{"statusCode": 200}' },+ });+ await apigwFetch(`/restapis/${denyApiId}/resources/${protectedId}/methods/GET/responses/200`, 'PUT', {+ responseParameters: {},+ });+ await apigwFetch(`/restapis/${denyApiId}/resources/${protectedId}/methods/GET/integration/responses/200`, 'PUT', {+ selectionPattern: '',+ responseTemplates: { 'application/json': '{"message":"ok"}' },+ });++ const depRes = await apigwFetch(`/restapis/${denyApiId}/deployments`, 'POST', { description: 'deny-test' });+ const depId = (await depRes.json() as { id: string }).id;+ await apigwFetch(`/restapis/${denyApiId}/stages`, 'POST', { stageName: 'prod', deploymentId: depId });+ });++ afterAll(async () => {+ try { if (denyApiId) await gw.send(new DeleteRestApiCommand({ restApiId: denyApiId })); } catch { /* ignore */ }+ });++ it('should return HTTP 403 when the authorizer returns Deny', async () => {+ const res = await executeApi(denyApiId, 'prod', '/protected', {+ headers: { Authorization: 'Bearer any-token' },+ });+ expect(res.status).toBe(403);+ });+ });++ // ──────────────────────────── Stage Variables ────────────────────────────++ describe('Stage variables — populated in authorizer and proxy events', () => {+ let svApiId: string;++ beforeAll(async () => {+ const svAuthName = uniqueName('sv-auth');+ const svProxyName = uniqueName('sv-proxy');+ await createLambda(lambda, svAuthName, `+ exports.handler = async (event) => ({+ principalId: 'user',+ policyDocument: { Version: '2012-10-17', Statement: [{ Action: 'execute-api:Invoke', Effect: 'Allow', Resource: event.methodArn }] },+ context: { receivedEvent: JSON.stringify(event) }+ });+ `);+ await createLambda(lambda, svProxyName, `+ exports.handler = async (event) => ({+ statusCode: 200,+ body: JSON.stringify({ stageVariables: event.stageVariables, authorizer: event.requestContext?.authorizer ?? null })+ });+ `);++ const api = await gw.send(new CreateRestApiCommand({ name: uniqueName('sv-api') }));+ svApiId = api.id!;+ const resources = await gw.send(new GetResourcesCommand({ restApiId: svApiId }));+ const rootId = resources.items![0].id!;+ const pingRes = await apigwFetch(`/restapis/${svApiId}/resources/${rootId}`, 'POST', { pathPart: 'ping' });+ const pingId = (await pingRes.json() as { id: string }).id;++ const authRes = await apigwFetch(`/restapis/${svApiId}/authorizers`, 'POST', {+ name: 'sv-auth', type: 'REQUEST',+ authorizerUri: `arn:aws:apigateway:${REGION}:lambda:path/2015-03-31/functions/arn:aws:lambda:${REGION}:${ACCOUNT}:function:${svAuthName}/invocations`,+ identitySource: 'method.request.header.Authorization', authorizerResultTtlInSeconds: 0,+ });+ const svAuthId = (await authRes.json() as { id: string }).id;++ await apigwFetch(`/restapis/${svApiId}/resources/${pingId}/methods/GET`, 'PUT', { authorizationType: 'CUSTOM', authorizerId: svAuthId });+ await apigwFetch(`/restapis/${svApiId}/resources/${pingId}/methods/GET/integration`, 'PUT', {+ type: 'AWS_PROXY', httpMethod: 'POST',+ uri: `arn:aws:apigateway:${REGION}:lambda:path/2015-03-31/functions/arn:aws:lambda:${REGION}:${ACCOUNT}:function:${svProxyName}/invocations`,+ });++ const depRes = await apigwFetch(`/restapis/${svApiId}/deployments`, 'POST', { description: 'sv-test' });+ const depId = (await depRes.json() as { id: string }).id;+ // Create stage WITH variables+ await apigwFetch(`/restapis/${svApiId}/stages`, 'POST', {+ stageName: 'prod', deploymentId: depId,+ variables: { env: 'test', version: 'v1' },+ });+ });++ afterAll(async () => {+ try { if (svApiId) await gw.send(new DeleteRestApiCommand({ restApiId: svApiId })); } catch { /* ignore */ }+ });++ it('should populate stageVariables in the proxy event from the stage configuration', async () => {+ const res = await executeApi(svApiId, 'prod', '/ping', { headers: { Authorization: 'Bearer t' } });+ expect(res.status).toBe(200);+ const body = await res.json() as { stageVariables: Record<string, string>; authorizer: { receivedEvent: string } };+ expect(body.stageVariables).toBeTruthy();+ expect(body.stageVariables.env).toBe('test');+ expect(body.stageVariables.version).toBe('v1');+ });++ it('should populate stageVariables in the REQUEST authorizer event', async () => {+ const res = await executeApi(svApiId, 'prod', '/ping', { headers: { Authorization: 'Bearer t' } });+ expect(res.status).toBe(200);+ const body = await res.json() as { authorizer: { receivedEvent: string } };+ const event = JSON.parse(body.authorizer.receivedEvent) as Record<string, unknown>;+ const sv = event.stageVariables as Record<string, string>;+ expect(sv).toBeTruthy();+ expect(sv.env).toBe('test');+ expect(sv.version).toBe('v1');+ });+ });++ // ──────────────────────────── API Key Resolution ────────────────────────────++ describe('API key — identity.apiKey resolved from usage plan', () => {+ let akApiId: string;+ const testKeyValue = uniqueName('ak');++ beforeAll(async () => {+ const akAuthName = uniqueName('ak-auth');+ const akProxyName = uniqueName('ak-proxy');+ await createLambda(lambda, akAuthName, `+ exports.handler = async (event) => ({+ principalId: 'user',+ policyDocument: { Version: '2012-10-17', Statement: [{ Action: 'execute-api:Invoke', Effect: 'Allow', Resource: event.methodArn }] },+ context: { receivedEvent: JSON.stringify(event) }+ });+ `);+ await createLambda(lambda, akProxyName, `+ exports.handler = async (event) => ({+ statusCode: 200,+ body: JSON.stringify({ authorizer: event.requestContext?.authorizer ?? null })+ });+ `);++ const api = await gw.send(new CreateRestApiCommand({ name: uniqueName('ak-api') }));+ akApiId = api.id!;+ const resources = await gw.send(new GetResourcesCommand({ restApiId: akApiId }));+ const rootId = resources.items![0].id!;+ const secRes = await apigwFetch(`/restapis/${akApiId}/resources/${rootId}`, 'POST', { pathPart: 'secure' });+ const secId = (await secRes.json() as { id: string }).id;++ const authRes = await apigwFetch(`/restapis/${akApiId}/authorizers`, 'POST', {+ name: 'ak-auth', type: 'REQUEST',+ authorizerUri: `arn:aws:apigateway:${REGION}:lambda:path/2015-03-31/functions/arn:aws:lambda:${REGION}:${ACCOUNT}:function:${akAuthName}/invocations`,+ identitySource: 'method.request.header.Authorization', authorizerResultTtlInSeconds: 0,+ });+ const akAuthId = (await authRes.json() as { id: string }).id;++ await apigwFetch(`/restapis/${akApiId}/resources/${secId}/methods/GET`, 'PUT', { authorizationType: 'CUSTOM', authorizerId: akAuthId });+ await apigwFetch(`/restapis/${akApiId}/resources/${secId}/methods/GET/integration`, 'PUT', {+ type: 'AWS_PROXY', httpMethod: 'POST',+ uri: `arn:aws:apigateway:${REGION}:lambda:path/2015-03-31/functions/arn:aws:lambda:${REGION}:${ACCOUNT}:function:${akProxyName}/invocations`,+ });++ const depRes = await apigwFetch(`/restapis/${akApiId}/deployments`, 'POST', { description: 'ak-test' });+ const depId = (await depRes.json() as { id: string }).id;+ await apigwFetch(`/restapis/${akApiId}/stages`, 'POST', { stageName: 'prod', deploymentId: depId });++ // Create API key + usage plan linked to (akApiId, prod)+ const keyRes = await apigwFetch('/apikeys', 'POST', { name: uniqueName('key'), value: testKeyValue, enabled: true });+ const keyId = (await keyRes.json() as { id: string }).id;+ const planRes = await apigwFetch('/usageplans', 'POST', { name: uniqueName('plan'), apiStages: [{ apiId: akApiId, stage: 'prod' }] });+ const planId = (await planRes.json() as { id: string }).id;+ await apigwFetch(`/usageplans/${planId}/keys`, 'POST', { keyId, keyType: 'API_KEY' });+ });++ afterAll(async () => {+ try { if (akApiId) await gw.send(new DeleteRestApiCommand({ restApiId: akApiId })); } catch { /* ignore */ }+ });++ it('should populate identity.apiKey when x-api-key header matches a usage plan key', async () => {+ const res = await executeApi(akApiId, 'prod', '/secure', {+ headers: { Authorization: 'Bearer t', 'x-api-key': testKeyValue },+ });+ expect(res.status).toBe(200);+ const body = await res.json() as { authorizer: { receivedEvent: string } };+ const event = JSON.parse(body.authorizer.receivedEvent) as Record<string, unknown>;+ const identity = (event.requestContext as Record<string, unknown>).identity as Record<string, unknown>;+ expect(identity.apiKey).toBe(testKeyValue);+ });++ it('should set identity.apiKey to null when x-api-key header is absent', async () => {+ const res = await executeApi(akApiId, 'prod', '/secure', { headers: { Authorization: 'Bearer t' } });+ expect(res.status).toBe(200);+ const body = await res.json() as { authorizer: { receivedEvent: string } };+ const event = JSON.parse(body.authorizer.receivedEvent) as Record<string, unknown>;+ const identity = (event.requestContext as Record<string, unknown>).identity as Record<string, unknown>;+ expect(identity.apiKey).toBeNull();+ });++ it('should set identity.apiKey to null when x-api-key does not match any plan key', async () => {+ const res = await executeApi(akApiId, 'prod', '/secure', {+ headers: { Authorization: 'Bearer t', 'x-api-key': 'wrong-key' },+ });+ expect(res.status).toBe(200);+ const body = await res.json() as { authorizer: { receivedEvent: string } };+ const event = JSON.parse(body.authorizer.receivedEvent) as Record<string, unknown>;+ const identity = (event.requestContext as Record<string, unknown>).identity as Record<string, unknown>;+ expect(identity.apiKey).toBeNull();+ });+ });+});diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.javaindex 8f8bb12b61..ea2c644109 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@@ -8,6 +8,9 @@ import io.github.hectorvent.floci.services.apigateway.model.ApiGatewayResource;import io.github.hectorvent.floci.services.apigateway.model.Integration;import io.github.hectorvent.floci.services.apigateway.model.IntegrationResponse;import io.github.hectorvent.floci.services.apigateway.model.MethodConfig;+import io.github.hectorvent.floci.services.apigateway.model.Stage;+import io.github.hectorvent.floci.services.apigateway.model.UsagePlan;+import io.github.hectorvent.floci.services.apigateway.model.UsagePlanKey;import io.github.hectorvent.floci.services.apigatewayv2.ApiGatewayV2Service;import io.github.hectorvent.floci.services.apigatewayv2.model.Authorizer;import io.github.hectorvent.floci.services.apigatewayv2.model.Route;@@ -22,6 +25,7 @@ import io.github.hectorvent.floci.services.lambda.model.InvokeResult;import com.fasterxml.jackson.core.type.TypeReference;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;import com.fasterxml.jackson.databind.node.ObjectNode;import io.smallrye.common.annotation.Blocking;import jakarta.enterprise.context.ApplicationScoped;@@ -237,9 +241,10 @@ public class ApiGatewayExecuteController {}// Verify API and stage exist+ Stage stage;try {apiGatewayService.getRestApi(region, apiId);- apiGatewayService.getStage(region, apiId, stageName);+ stage = apiGatewayService.getStage(region, apiId, stageName);} catch (AwsException e) {return Response.status(e.getHttpStatus()).entity(jsonMessage(e.getMessage()))@@ -268,7 +273,8 @@ public class ApiGatewayExecuteController {}// 1. Authorizer- AuthorizerResult authorizerResult = invokeAuthorizer(region, apiId, stageName, httpMethod, path, method, headers, uriInfo);+ String resolvedApiKey = resolveApiKeyForRequest(region, apiId, stageName, headers);+ AuthorizerResult authorizerResult = invokeAuthorizer(region, apiId, stageName, httpMethod, path, matched.getPath(), matched.getId(), stage, method, headers, uriInfo, resolvedApiKey);if (authorizerResult.errorResponse() != null) return authorizerResult.errorResponse();// 2. Request validation@@ -286,8 +292,8 @@ public class ApiGatewayExecuteController {integration.getType());return switch (integration.getType().toUpperCase()) {- case "AWS_PROXY" -> invokeProxy(region, httpMethod, path, proxy, stageName,- matched, integration, headers, uriInfo, body, authorizerResult);+ case "AWS_PROXY" -> invokeProxy(region, apiId, httpMethod, path, proxy, stageName,+ matched, stage, integration, headers, uriInfo, body, authorizerResult, resolvedApiKey);case "AWS" -> invokeAwsIntegration(region, httpMethod, path, proxy, stageName,matched, integration, headers, uriInfo, body);case "MOCK" -> invokeMock(region, httpMethod, path, stageName, matched, integration, headers, uriInfo, body);@@ -299,11 +305,12 @@ public class ApiGatewayExecuteController {// ──────────────────────────── AWS_PROXY ────────────────────────────- private Response invokeProxy(String region, String httpMethod, String path, String proxy,+ private Response invokeProxy(String region, String apiId, String httpMethod, String path, String proxy,String stageName, ApiGatewayResource resource,+ Stage stage,Integration integration, HttpHeaders headers,UriInfo uriInfo, byte[] body,- AuthorizerResult authorizerResult) {+ AuthorizerResult authorizerResult, String resolvedApiKey) {String functionName = functionNameFromUri(integration.getUri());if (functionName == null) {return Response.status(500)@@ -312,9 +319,9 @@ public class ApiGatewayExecuteController {}String requestId = UUID.randomUUID().toString();- String eventJson = buildProxyEvent(httpMethod, path, proxy, resource.getPath(),- stageName, headers, uriInfo, body, requestId,- authorizerResult.principalId(), authorizerResult.context());+ String eventJson = buildProxyEvent(region, apiId, httpMethod, path, proxy, resource.getPath(),+ resource.getId(), stageName, stage, headers, uriInfo, body, requestId,+ authorizerResult.principalId(), authorizerResult.context(), resolvedApiKey);try {InvokeResult result = lambdaService.invoke(region, functionName, eventJson.getBytes(),@@ -331,8 +338,11 @@ public class ApiGatewayExecuteController {}private AuthorizerResult invokeAuthorizer(String region, String apiId, String stageName,- String httpMethod, String requestPath, MethodConfig method,- HttpHeaders headers, UriInfo uriInfo) {+ String httpMethod, String requestPath, String resourcePath,+ String resourceId,+ Stage stage,+ MethodConfig method,+ HttpHeaders headers, UriInfo uriInfo, String resolvedApiKey) {if ("CUSTOM".equals(method.getAuthorizationType())) {String authorizerId = method.getAuthorizerId();if (authorizerId == null) {@@ -345,7 +355,7 @@ public class ApiGatewayExecuteController {return new AuthorizerResult(null, null, null);}- String event = toAuthorizerEvent(auth, headers, region, apiId, stageName, httpMethod, requestPath);+ String event = toAuthorizerEvent(auth, headers, region, apiId, stageName, httpMethod, requestPath, resourcePath, resourceId, stage, uriInfo, resolvedApiKey);try {InvokeResult result = lambdaService.invoke(region, lambdaName, event.getBytes(), InvocationType.RequestResponse);if (result.getFunctionError() != null) {@@ -471,17 +481,91 @@ public class ApiGatewayExecuteController {private String toAuthorizerEvent(io.github.hectorvent.floci.services.apigateway.model.Authorizer auth,HttpHeaders headers, String region, String apiId, String stageName,- String httpMethod, String requestPath) {+ String httpMethod, String requestPath,+ String resourcePath, String resourceId, Stage stage, UriInfo uriInfo,+ String resolvedApiKey) {ObjectNode node = objectMapper.createObjectNode();node.put("type", auth.getType());node.put("methodArn", buildMethodArn(region, apiId, stageName, httpMethod, requestPath));if ("TOKEN".equals(auth.getType())) {String headerName = auth.getIdentitySource().replace("method.request.header.", "");node.put("authorizationToken", headers.getHeaderString(headerName));+ } else if ("REQUEST".equals(auth.getType())) {+ node.put("resource", resourcePath);+ node.put("path", requestPath);+ node.put("httpMethod", httpMethod);+ putSingleValueHeaders(node, headers);+ putMultiValueHeaders(node, headers);+ putQueryStringParameters(node, uriInfo);+ putMultiValueQueryStringParameters(node, uriInfo);++ Map<String, String> pathParams = extractPathParams(resourcePath, requestPath);+ ObjectNode ppNode = node.putObject("pathParameters");+ if (!pathParams.isEmpty()) {+ pathParams.forEach(ppNode::put);+ }++ // stageVariables: populate from the Stage object (null if no variables configured)+ Map<String, String> stageVars = stage != null ? stage.getVariables() : null;+ if (stageVars != null && !stageVars.isEmpty()) {+ ObjectNode svNode = node.putObject("stageVariables");+ stageVars.forEach(svNode::put);+ } else {+ node.putNull("stageVariables");+ }++ ObjectNode ctx = node.putObject("requestContext");+ ctx.put("accountId", regionResolver.getAccountId());+ ctx.put("apiId", apiId);+ ctx.put("resourceId", resourceId != null ? resourceId : "");+ ctx.put("resourcePath", resourcePath);+ ctx.put("path", requestPath);+ ctx.put("httpMethod", httpMethod);+ ctx.put("stage", stageName);+ ctx.put("requestId", UUID.randomUUID().toString());+ ctx.put("requestTimeEpoch", System.currentTimeMillis());++ // identity.apiKey: resolve from usage plans linked to this (apiId, stage)+ ObjectNode identity = ctx.putObject("identity");+ identity.put("sourceIp", "127.0.0.1");+ String userAgent = headers.getHeaderString("User-Agent");+ identity.put("userAgent", userAgent != null ? userAgent : "");+ if (resolvedApiKey != null) {+ identity.put("apiKey", resolvedApiKey);+ } else {+ identity.putNull("apiKey");+ }+ identity.putNull("clientCert"); // null when mTLS is not configured (Floci does not support mTLS)}return node.toString();}+ /**+ * Resolves the API key value for a request by matching the {@code x-api-key} header+ * against usage plan keys linked to this (apiId, stageName) pair.+ *+ * <p>Returns the key value string if a matching enabled key is found, {@code null} otherwise.+ */+ private String resolveApiKeyForRequest(String region, String apiId, String stageName, HttpHeaders headers) {+ String keyHeader = headers.getHeaderString("x-api-key");+ if (keyHeader == null || keyHeader.isBlank()) {+ return null;+ }+ // Find all usage plans that include this (apiId, stage) pair+ for (UsagePlan plan : apiGatewayService.getUsagePlans(region)) {+ boolean planCoversStage = plan.getApiStages().stream()+ .anyMatch(s -> apiId.equals(s.apiId()) && stageName.equals(s.stage()));+ if (!planCoversStage) continue;+ // Check if any key in this plan matches the header value+ for (UsagePlanKey planKey : apiGatewayService.getUsagePlanKeys(region, plan.getId())) {+ if (keyHeader.equals(planKey.getValue())) {+ return planKey.getValue();+ }+ }+ }+ return null;+ }+private String buildMethodArn(String region, String apiId, String stageName, String httpMethod, String requestPath) {String normalizedPath = requestPath == null ? "" : requestPath.replaceFirst("^/", "");String arnRegion = region == null ? regionResolver.getDefaultRegion() : region;@@ -497,45 +581,91 @@ public class ApiGatewayExecuteController {return LambdaArnUtils.extractFunctionNameFromUri(uri);}- private String buildProxyEvent(String httpMethod, String path, String proxy,- String resourcePath, String stageName,+ private String buildProxyEvent(String region, String apiId,+ String httpMethod, String path, String proxy,+ String resourcePath, String resourceId,+ String stageName, Stage stage,HttpHeaders headers, UriInfo uriInfo,byte[] body, String requestId,- String principalId, Map<String, Object> authorizerContext) {+ String principalId, Map<String, Object> authorizerContext,+ String resolvedApiKey) {ObjectNode event = objectMapper.createObjectNode();event.put("resource", resourcePath);event.put("path", path);event.put("httpMethod", httpMethod);- ObjectNode headersNode = event.putObject("headers");- MultivaluedMap<String, String> reqHeaders = headers.getRequestHeaders();- for (Map.Entry<String, java.util.List<String>> e : reqHeaders.entrySet()) {- if (!e.getValue().isEmpty()) headersNode.put(e.getKey(), e.getValue().get(0));- }-- MultivaluedMap<String, String> queryParams = uriInfo.getQueryParameters();- if (!queryParams.isEmpty()) {- ObjectNode qsp = event.putObject("queryStringParameters");- for (Map.Entry<String, java.util.List<String>> e : queryParams.entrySet()) {- if (!e.getValue().isEmpty()) qsp.put(e.getKey(), e.getValue().get(0));- }- } else {- event.putNull("queryStringParameters");- }+ putSingleValueHeaders(event, headers);+ putMultiValueHeaders(event, headers);+ putQueryStringParameters(event, uriInfo);+ putMultiValueQueryStringParameters(event, uriInfo);ObjectNode pathParams = event.putObject("pathParameters");if (proxy != null && !proxy.isEmpty()) pathParams.put("proxy", proxy);extractPathParams(resourcePath, path).forEach(pathParams::put);- event.putNull("stageVariables");+ // stageVariables: populate from the Stage object (null if no variables configured)+ Map<String, String> stageVars = stage != null ? stage.getVariables() : null;+ if (stageVars != null && !stageVars.isEmpty()) {+ ObjectNode svNode = event.putObject("stageVariables");+ stageVars.forEach(svNode::put);+ } else {+ event.putNull("stageVariables");+ }++ String arnRegion = region != null ? region : regionResolver.getDefaultRegion();+ String domainName = apiId + ".execute-api." + arnRegion + ".amazonaws.com";+ long nowMillis = System.currentTimeMillis();+ String requestTime = java.time.format.DateTimeFormatter+ .ofPattern("dd/MMM/yyyy:HH:mm:ss Z")+ .format(java.time.ZonedDateTime.now(java.time.ZoneOffset.UTC));ObjectNode ctx = event.putObject("requestContext");- ctx.put("resourcePath", resourcePath);+ ctx.put("accountId", regionResolver.getAccountId());+ ctx.put("apiId", apiId);+ ctx.put("domainName", domainName);+ ctx.put("domainPrefix", apiId);+ ctx.put("extendedRequestId", requestId);ctx.put("httpMethod", httpMethod);- ctx.put("stage", stageName);+ ctx.put("path", path);+ ctx.put("protocol", "HTTP/1.1");ctx.put("requestId", requestId);- ctx.put("requestTimeEpoch", System.currentTimeMillis());- ctx.putObject("identity").put("sourceIp", "127.0.0.1");+ ctx.put("requestTime", requestTime);+ ctx.put("requestTimeEpoch", nowMillis);+ ctx.put("resourceId", resourceId != null ? resourceId : "");+ ctx.put("resourcePath", resourcePath);+ ctx.put("stage", stageName);++ // identity — full shape matching AWS proxy event spec.+ // Fields that require auth mechanisms not implemented in v1 REST API dispatch:+ // - accessKey, accountId, caller, user, userArn, principalOrgId: only set for AWS_IAM auth+ // (v1 dispatch does not implement AWS_IAM — invokeAuthorizer only handles CUSTOM)+ // - cognitoIdentityId, cognitoIdentityPoolId, cognitoAuthenticationType,+ // cognitoAuthenticationProvider: only set for COGNITO_USER_POOLS auth (not implemented in v1)+ // - clientCert: only set when mutual TLS is configured (not supported in Floci)+ // AWS sends these as explicit JSON null (not absent), so we match that wire format.+ ObjectNode identity = ctx.putObject("identity");+ identity.putNull("accessKey");+ identity.putNull("accountId");+ identity.putNull("caller");+ identity.putNull("cognitoAuthenticationProvider");+ identity.putNull("cognitoAuthenticationType");+ identity.putNull("cognitoIdentityId");+ identity.putNull("cognitoIdentityPoolId");+ identity.putNull("principalOrgId");+ identity.put("sourceIp", "127.0.0.1");+ identity.putNull("user");+ String userAgent = headers.getHeaderString("User-Agent");+ identity.put("userAgent", userAgent != null ? userAgent : "");+ identity.putNull("userArn");+ identity.putNull("clientCert"); // null when mTLS is not configured (Floci does not support mTLS)+ // apiKey: use pre-resolved value from usage plan keys linked to this (apiId, stage)+ if (resolvedApiKey != null) {+ identity.put("apiKey", resolvedApiKey);+ } else {+ identity.putNull("apiKey");+ }++ // authorizer context (set by CUSTOM authorizer)if (principalId != null || (authorizerContext != null && !authorizerContext.isEmpty())) {ObjectNode authorizerNode = ctx.putObject("authorizer");if (principalId != null) {@@ -565,6 +695,46 @@ public class ApiGatewayExecuteController {}}+ private void putSingleValueHeaders(ObjectNode event, HttpHeaders headers) {+ ObjectNode headersNode = event.putObject("headers");+ headers.getRequestHeaders().forEach((name, values) -> {+ if (!values.isEmpty()) headersNode.put(name, values.get(0));+ });+ }++ private void putMultiValueHeaders(ObjectNode event, HttpHeaders headers) {+ ObjectNode mvHeaders = event.putObject("multiValueHeaders");+ headers.getRequestHeaders().forEach((name, values) -> {+ ArrayNode arr = mvHeaders.putArray(name);+ values.forEach(arr::add);+ });+ }++ private void putQueryStringParameters(ObjectNode event, UriInfo uriInfo) {+ MultivaluedMap<String, String> queryParams = uriInfo.getQueryParameters();+ if (!queryParams.isEmpty()) {+ ObjectNode qsp = event.putObject("queryStringParameters");+ queryParams.forEach((name, values) -> {+ if (!values.isEmpty()) qsp.put(name, values.get(0));+ });+ } else {+ event.putNull("queryStringParameters");+ }+ }++ private void putMultiValueQueryStringParameters(ObjectNode event, UriInfo uriInfo) {+ MultivaluedMap<String, String> queryParams = uriInfo.getQueryParameters();+ if (!queryParams.isEmpty()) {+ ObjectNode mqsp = event.putObject("multiValueQueryStringParameters");+ queryParams.forEach((name, values) -> {+ ArrayNode arr = mqsp.putArray(name);+ values.forEach(arr::add);+ });+ } else {+ event.putNull("multiValueQueryStringParameters");+ }+ }+private Response buildProxyResponse(InvokeResult result) {if (result.getPayload() == null || result.getPayload().length == 0) {return Response.status(result.getFunctionError() != null ? 502 : result.getStatusCode()).build();diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayRequestAuthorizerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayRequestAuthorizerIntegrationTest.javanew file mode 100644index 0000000000..02d8e2071b--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayRequestAuthorizerIntegrationTest.java@@ -0,0 +1,956 @@+package io.github.hectorvent.floci.services.apigateway;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.http.ContentType;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import java.io.ByteArrayOutputStream;+import java.nio.charset.StandardCharsets;+import java.util.Base64;+import java.util.Map;+import java.util.zip.ZipEntry;+import java.util.zip.ZipOutputStream;++import static io.restassured.RestAssured.given;+import static org.junit.jupiter.api.Assertions.*;++/**+ * Integration tests for REQUEST authorizer full event shape (issue #807).+ *+ * <p>Validates that {@code toAuthorizerEvent} populates the complete+ * {@code APIGatewayRequestAuthorizerEvent} shape for REQUEST-type authorizers,+ * and that TOKEN and NONE authorizer paths are unaffected.+ *+ * <p>All management-plane setup uses RestAssured against the local Floci endpoint.+ * Execute-api invocations also use RestAssured.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class ApiGatewayRequestAuthorizerIntegrationTest {++ private static final String LAMBDA_BASE_PATH = "/2015-03-31/functions";+ private static final String AUTHORIZER_FUNCTION = "apigw-request-auth-echo";+ private static final String PROXY_FUNCTION = "apigw-request-auth-proxy";+ private static final String TOKEN_AUTHORIZER_FUNCTION = "apigw-token-auth-echo";+ private static final String TOKEN_PROXY_FUNCTION = "apigw-token-auth-proxy";+ private static final String NONE_INTEGRATION_FUNCTION = "apigw-none-auth-integration";+ private static final String DENY_AUTHORIZER_FUNCTION = "apigw-deny-auth";+ private static final String ROLE_ARN = "arn:aws:iam::000000000000:role/lambda-role";+ private static final String REGION = "us-east-1";+ private static final String ACCOUNT = "000000000000";+ private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();++ // State shared across ordered tests+ private static String apiId;+ private static String rootId;+ private static String itemResourceId;+ private static String authorizerId;++ private static String tokenApiId;+ private static String noneApiId;+ private static String denyApiId;++ // ──────────────────────────── Lambda setup ────────────────────────────++ @Test+ @Order(1)+ void createEchoAuthorizerLambda() throws Exception {+ createNodeLambda(AUTHORIZER_FUNCTION, """+ exports.handler = async (event) => ({+ principalId: "test-user",+ policyDocument: {+ Version: "2012-10-17",+ Statement: [{+ Action: "execute-api:Invoke",+ Effect: "Allow",+ Resource: event.methodArn+ }]+ },+ context: {+ receivedEvent: JSON.stringify(event)+ }+ });+ """);+ }++ @Test+ @Order(2)+ void createProxyLambda() throws Exception {+ createNodeLambda(PROXY_FUNCTION, """+ exports.handler = async (event) => ({+ statusCode: 200,+ body: JSON.stringify({+ authorizer: event.requestContext && event.requestContext.authorizer+ ? event.requestContext.authorizer+ : null+ })+ });+ """);+ }++ // ──────────────────────────── REQUEST authorizer API setup ────────────────────────────++ @Test+ @Order(3)+ void createRestApi() {+ apiId = given()+ .contentType(ContentType.JSON)+ .body("{\"name\":\"request-authorizer-test-api\"}")+ .when().post("/restapis")+ .then().statusCode(201)+ .extract().path("id");+ assertNotNull(apiId);+ }++ @Test+ @Order(4)+ void getResources() {+ rootId = given()+ .when().get("/restapis/" + apiId + "/resources")+ .then().statusCode(200)+ .extract().path("item[0].id");+ assertNotNull(rootId);+ }++ @Test+ @Order(5)+ void createResources() {+ String itemsId = given()+ .contentType(ContentType.JSON)+ .body("{\"pathPart\":\"items\"}")+ .when().post("/restapis/" + apiId + "/resources/" + rootId)+ .then().statusCode(201)+ .extract().path("id");++ itemResourceId = given()+ .contentType(ContentType.JSON)+ .body("{\"pathPart\":\"{id}\"}")+ .when().post("/restapis/" + apiId + "/resources/" + itemsId)+ .then().statusCode(201)+ .extract().path("id");+ assertNotNull(itemResourceId);+ }++ @Test+ @Order(6)+ void createRequestAuthorizer() {+ String authorizerUri = "arn:aws:apigateway:" + REGION + ":lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:" + AUTHORIZER_FUNCTION + "/invocations";+ authorizerId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"request-echo-authorizer","type":"REQUEST","authorizerUri":"%s","identitySource":"method.request.header.Authorization","authorizerResultTtlInSeconds":0}+ """.formatted(authorizerUri))+ .when().post("/restapis/" + apiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("id");+ assertNotNull(authorizerId);+ }++ @Test+ @Order(7)+ void configureMethodAndIntegration() {+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(authorizerId))+ .when().put("/restapis/" + apiId + "/resources/" + itemResourceId + "/methods/GET")+ .then().statusCode(201);++ String proxyUri = "arn:aws:apigateway:" + REGION + ":lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:" + PROXY_FUNCTION + "/invocations";+ given()+ .contentType(ContentType.JSON)+ .body("""+ {"type":"AWS_PROXY","httpMethod":"POST","uri":"%s"}+ """.formatted(proxyUri))+ .when().put("/restapis/" + apiId + "/resources/" + itemResourceId + "/methods/GET/integration")+ .then().statusCode(201);+ }++ @Test+ @Order(8)+ void deployApi() {+ String depId = given()+ .contentType(ContentType.JSON)+ .body("{\"description\":\"request-auth-test\"}")+ .when().post("/restapis/" + apiId + "/deployments")+ .then().statusCode(201)+ .extract().path("id");++ given()+ .contentType(ContentType.JSON)+ .body("""+ {"stageName":"prod","deploymentId":"%s"}+ """.formatted(depId))+ .when().post("/restapis/" + apiId + "/stages")+ .then().statusCode(201);+ }++ // ──────────────────────────── Core bug condition test ────────────────────────────++ @Test+ @Order(9)+ void requestAuthorizerReceivesFullEvent() throws Exception {+ String response = given()+ .header("Authorization", "Bearer test")+ .when().get("/execute-api/" + apiId + "/prod/items/42?foo=bar")+ .then()+ .statusCode(200)+ .extract().asString();++ JsonNode payload = OBJECT_MAPPER.readTree(response);+ JsonNode authorizer = payload.path("authorizer");++ assertFalse(authorizer.isNull(), "authorizer context should be present in proxy response");+ assertFalse(authorizer.isMissingNode(), "authorizer context should be present in proxy response");++ String receivedEventStr = authorizer.path("receivedEvent").asText(null);+ assertNotNull(receivedEventStr, "authorizer should have embedded receivedEvent in context");+ assertFalse(receivedEventStr.isEmpty(), "receivedEvent should not be empty");++ JsonNode event = OBJECT_MAPPER.readTree(receivedEventStr);++ // type and methodArn+ assertEquals("REQUEST", event.path("type").asText(null));+ assertFalse(event.path("methodArn").isMissingNode(), "methodArn must be present");+ assertTrue(event.path("methodArn").asText("").contains(apiId), "methodArn must contain apiId");++ // resource (matched template path) and actual path+ assertEquals("/items/{id}", event.path("resource").asText(null),+ "resource should be the matched resource path template");+ assertEquals("/items/42", event.path("path").asText(null),+ "path should be the actual request path");+ assertEquals("GET", event.path("httpMethod").asText(null));++ // headers+ assertFalse(event.path("headers").isNull(), "headers must be non-null");+ assertFalse(event.path("headers").isMissingNode(), "headers must be present");++ // multiValueHeaders+ assertFalse(event.path("multiValueHeaders").isNull(), "multiValueHeaders must be non-null");+ assertFalse(event.path("multiValueHeaders").isMissingNode(), "multiValueHeaders must be present");++ // queryStringParameters+ assertFalse(event.path("queryStringParameters").isNull(),+ "queryStringParameters must be non-null when query params are present");+ assertEquals("bar", event.path("queryStringParameters").path("foo").asText(null));++ // multiValueQueryStringParameters+ assertFalse(event.path("multiValueQueryStringParameters").isNull(),+ "multiValueQueryStringParameters must be non-null when query params are present");+ assertTrue(event.path("multiValueQueryStringParameters").path("foo").isArray());++ // pathParameters+ assertFalse(event.path("pathParameters").isNull(), "pathParameters must be non-null");+ assertEquals("42", event.path("pathParameters").path("id").asText(null));++ // stageVariables must be null (no stage variables configured)+ assertTrue(event.path("stageVariables").isNull(), "stageVariables must be null");++ // requestContext+ JsonNode ctx = event.path("requestContext");+ assertFalse(ctx.isNull(), "requestContext must be present");+ assertFalse(ctx.isMissingNode(), "requestContext must be present");++ String requestId = ctx.path("requestId").asText(null);+ assertNotNull(requestId, "requestContext.requestId must be non-null");+ assertFalse(requestId.isEmpty(), "requestContext.requestId must be non-empty");++ assertEquals("127.0.0.1", ctx.path("identity").path("sourceIp").asText(null),+ "requestContext.identity.sourceIp must equal '127.0.0.1'");+ assertFalse(ctx.path("identity").path("userAgent").isMissingNode(),+ "requestContext.identity.userAgent must be present");+ assertTrue(ctx.path("identity").path("apiKey").isNull(),+ "requestContext.identity.apiKey must be null when no matching usage plan key exists");+ assertTrue(ctx.path("identity").path("clientCert").isNull(),+ "requestContext.identity.clientCert must be null (mTLS not supported)");+ assertEquals("/items/{id}", ctx.path("resourcePath").asText(null));+ assertEquals("/items/42", ctx.path("path").asText(null),+ "requestContext.path must equal the actual request path");+ assertEquals("GET", ctx.path("httpMethod").asText(null));+ assertEquals("prod", ctx.path("stage").asText(null));+ assertEquals(ACCOUNT, ctx.path("accountId").asText(null),+ "requestContext.accountId must be present");+ assertEquals(apiId, ctx.path("apiId").asText(null),+ "requestContext.apiId must be present");++ String resourceId = ctx.path("resourceId").asText(null);+ assertNotNull(resourceId, "requestContext.resourceId must be non-null");+ assertFalse(resourceId.isEmpty(), "requestContext.resourceId must be non-empty");+ }++ @Test+ @Order(10)+ void requestAuthorizerNullQueryParamsWhenNonePresent() throws Exception {+ String response = given()+ .header("Authorization", "Bearer test")+ .when().get("/execute-api/" + apiId + "/prod/items/99")+ .then()+ .statusCode(200)+ .extract().asString();++ JsonNode payload = OBJECT_MAPPER.readTree(response);+ String receivedEventStr = payload.path("authorizer").path("receivedEvent").asText(null);+ assertNotNull(receivedEventStr);++ JsonNode event = OBJECT_MAPPER.readTree(receivedEventStr);+ assertTrue(event.path("queryStringParameters").isNull(),+ "queryStringParameters must be null when no query string is present");+ assertTrue(event.path("multiValueQueryStringParameters").isNull(),+ "multiValueQueryStringParameters must be null when no query string is present");+ }++ // ──────────────────────────── TOKEN authorizer preservation ────────────────────────────++ @Test+ @Order(20)+ void preservation_createTokenLambdas() throws Exception {+ createNodeLambda(TOKEN_AUTHORIZER_FUNCTION, """+ exports.handler = async (event) => ({+ principalId: "test-user",+ policyDocument: {+ Version: "2012-10-17",+ Statement: [{+ Action: "execute-api:Invoke",+ Effect: "Allow",+ Resource: event.methodArn+ }]+ },+ context: { receivedEvent: JSON.stringify(event) }+ });+ """);+ createNodeLambda(TOKEN_PROXY_FUNCTION, """+ exports.handler = async (event) => ({+ statusCode: 200,+ body: JSON.stringify({+ authorizer: event.requestContext && event.requestContext.authorizer+ ? event.requestContext.authorizer : null+ })+ });+ """);+ }++ @Test+ @Order(21)+ void preservation_setupTokenAuthorizerApi() {+ tokenApiId = given()+ .contentType(ContentType.JSON)+ .body("{\"name\":\"token-authorizer-preservation-api\"}")+ .when().post("/restapis")+ .then().statusCode(201)+ .extract().path("id");++ String tokenRootId = given()+ .when().get("/restapis/" + tokenApiId + "/resources")+ .then().statusCode(200)+ .extract().path("item[0].id");++ String secureResourceId = given()+ .contentType(ContentType.JSON)+ .body("{\"pathPart\":\"secure\"}")+ .when().post("/restapis/" + tokenApiId + "/resources/" + tokenRootId)+ .then().statusCode(201)+ .extract().path("id");++ String authUri = "arn:aws:apigateway:" + REGION + ":lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:" + TOKEN_AUTHORIZER_FUNCTION + "/invocations";+ String tokenAuthId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"token-echo-authorizer","type":"TOKEN","authorizerUri":"%s","identitySource":"method.request.header.Authorization","authorizerResultTtlInSeconds":0}+ """.formatted(authUri))+ .when().post("/restapis/" + tokenApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("id");++ given().contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(tokenAuthId))+ .when().put("/restapis/" + tokenApiId + "/resources/" + secureResourceId + "/methods/GET")+ .then().statusCode(201);++ String proxyUri = "arn:aws:apigateway:" + REGION + ":lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:" + TOKEN_PROXY_FUNCTION + "/invocations";+ given().contentType(ContentType.JSON)+ .body("""+ {"type":"AWS_PROXY","httpMethod":"POST","uri":"%s"}+ """.formatted(proxyUri))+ .when().put("/restapis/" + tokenApiId + "/resources/" + secureResourceId + "/methods/GET/integration")+ .then().statusCode(201);++ String depId = given().contentType(ContentType.JSON)+ .body("{\"description\":\"token-auth-preservation\"}")+ .when().post("/restapis/" + tokenApiId + "/deployments")+ .then().statusCode(201)+ .extract().path("id");++ given().contentType(ContentType.JSON)+ .body("""+ {"stageName":"prod","deploymentId":"%s"}+ """.formatted(depId))+ .when().post("/restapis/" + tokenApiId + "/stages")+ .then().statusCode(201);+ }++ @Test+ @Order(22)+ void preservation_tokenAuthorizerEventShapeIsExact() throws Exception {+ String response = given()+ .header("Authorization", "Bearer mytoken")+ .when().get("/execute-api/" + tokenApiId + "/prod/secure")+ .then().statusCode(200)+ .extract().asString();++ JsonNode payload = OBJECT_MAPPER.readTree(response);+ String receivedEventStr = payload.path("authorizer").path("receivedEvent").asText(null);+ assertNotNull(receivedEventStr, "TOKEN authorizer should embed receivedEvent in context");++ JsonNode event = OBJECT_MAPPER.readTree(receivedEventStr);++ assertEquals("TOKEN", event.path("type").asText(null));+ assertFalse(event.path("methodArn").isMissingNode(), "methodArn must be present");+ assertEquals("Bearer mytoken", event.path("authorizationToken").asText(null));++ // TOKEN event must NOT contain REQUEST-specific fields+ assertTrue(event.path("headers").isMissingNode() || event.path("headers").isNull(),+ "TOKEN event must NOT contain headers");+ assertTrue(event.path("queryStringParameters").isMissingNode() || event.path("queryStringParameters").isNull(),+ "TOKEN event must NOT contain queryStringParameters");+ assertTrue(event.path("requestContext").isMissingNode() || event.path("requestContext").isNull(),+ "TOKEN event must NOT contain requestContext");+ }++ // ──────────────────────────── NONE authorizer preservation ────────────────────────────++ @Test+ @Order(30)+ void preservation_setupNoneAuthorizerApi() throws Exception {+ createNodeLambda(NONE_INTEGRATION_FUNCTION, """+ exports.handler = async (event) => ({+ statusCode: 200,+ body: JSON.stringify({ invoked: true })+ });+ """);++ noneApiId = given()+ .contentType(ContentType.JSON)+ .body("{\"name\":\"none-authorizer-preservation-api\"}")+ .when().post("/restapis")+ .then().statusCode(201)+ .extract().path("id");++ String noneRootId = given()+ .when().get("/restapis/" + noneApiId + "/resources")+ .then().statusCode(200)+ .extract().path("item[0].id");++ String openResourceId = given()+ .contentType(ContentType.JSON)+ .body("{\"pathPart\":\"open\"}")+ .when().post("/restapis/" + noneApiId + "/resources/" + noneRootId)+ .then().statusCode(201)+ .extract().path("id");++ given().contentType(ContentType.JSON)+ .body("{\"authorizationType\":\"NONE\"}")+ .when().put("/restapis/" + noneApiId + "/resources/" + openResourceId + "/methods/GET")+ .then().statusCode(201);++ String integrationUri = "arn:aws:apigateway:" + REGION + ":lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:" + NONE_INTEGRATION_FUNCTION + "/invocations";+ given().contentType(ContentType.JSON)+ .body("""+ {"type":"AWS_PROXY","httpMethod":"POST","uri":"%s"}+ """.formatted(integrationUri))+ .when().put("/restapis/" + noneApiId + "/resources/" + openResourceId + "/methods/GET/integration")+ .then().statusCode(201);++ String depId = given().contentType(ContentType.JSON)+ .body("{\"description\":\"none-auth-preservation\"}")+ .when().post("/restapis/" + noneApiId + "/deployments")+ .then().statusCode(201)+ .extract().path("id");++ given().contentType(ContentType.JSON)+ .body("""+ {"stageName":"prod","deploymentId":"%s"}+ """.formatted(depId))+ .when().post("/restapis/" + noneApiId + "/stages")+ .then().statusCode(201);+ }++ @Test+ @Order(31)+ void preservation_noneAuthorizerSkipsInvocation() {+ given()+ .when().get("/execute-api/" + noneApiId + "/prod/open")+ .then()+ .statusCode(200)+ .body("invoked", org.hamcrest.Matchers.equalTo(true));+ }++ // ──────────────────────────── Allow / Deny policy ────────────────────────────++ @Test+ @Order(32)+ void preservation_requestAuthorizerAllowPolicyForwardsToIntegration() {+ given()+ .header("Authorization", "Bearer test")+ .when().get("/execute-api/" + apiId + "/prod/items/42")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(40)+ void preservation_setupDenyAuthorizerApi() throws Exception {+ createNodeLambda(DENY_AUTHORIZER_FUNCTION, """+ exports.handler = async (event) => ({+ principalId: "test-user",+ policyDocument: {+ Version: "2012-10-17",+ Statement: [{+ Action: "execute-api:Invoke",+ Effect: "Deny",+ Resource: event.methodArn+ }]+ }+ });+ """);++ denyApiId = given()+ .contentType(ContentType.JSON)+ .body("{\"name\":\"deny-authorizer-preservation-api\"}")+ .when().post("/restapis")+ .then().statusCode(201)+ .extract().path("id");++ String denyRootId = given()+ .when().get("/restapis/" + denyApiId + "/resources")+ .then().statusCode(200)+ .extract().path("item[0].id");++ String protectedResourceId = given()+ .contentType(ContentType.JSON)+ .body("{\"pathPart\":\"protected\"}")+ .when().post("/restapis/" + denyApiId + "/resources/" + denyRootId)+ .then().statusCode(201)+ .extract().path("id");++ String authUri = "arn:aws:apigateway:" + REGION + ":lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:" + DENY_AUTHORIZER_FUNCTION + "/invocations";+ String denyAuthId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"deny-authorizer","type":"REQUEST","authorizerUri":"%s","identitySource":"method.request.header.Authorization","authorizerResultTtlInSeconds":0}+ """.formatted(authUri))+ .when().post("/restapis/" + denyApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("id");++ given().contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(denyAuthId))+ .when().put("/restapis/" + denyApiId + "/resources/" + protectedResourceId + "/methods/GET")+ .then().statusCode(201);++ given().contentType(ContentType.JSON)+ .body("{\"type\":\"MOCK\",\"requestTemplates\":{\"application/json\":\"{\\\"statusCode\\\": 200}\"}}")+ .when().put("/restapis/" + denyApiId + "/resources/" + protectedResourceId + "/methods/GET/integration")+ .then().statusCode(201);++ given().contentType(ContentType.JSON)+ .body("{\"responseParameters\":{}}")+ .when().put("/restapis/" + denyApiId + "/resources/" + protectedResourceId + "/methods/GET/responses/200")+ .then().statusCode(201);++ given().contentType(ContentType.JSON)+ .body("{\"selectionPattern\":\"\",\"responseTemplates\":{\"application/json\":\"{\\\"message\\\":\\\"ok\\\"}\"}}")+ .when().put("/restapis/" + denyApiId + "/resources/" + protectedResourceId + "/methods/GET/integration/responses/200")+ .then().statusCode(201);++ String depId = given().contentType(ContentType.JSON)+ .body("{\"description\":\"deny-auth-preservation\"}")+ .when().post("/restapis/" + denyApiId + "/deployments")+ .then().statusCode(201)+ .extract().path("id");++ given().contentType(ContentType.JSON)+ .body("""+ {"stageName":"prod","deploymentId":"%s"}+ """.formatted(depId))+ .when().post("/restapis/" + denyApiId + "/stages")+ .then().statusCode(201);+ }++ @Test+ @Order(41)+ void preservation_requestAuthorizerDenyPolicyReturns403() {+ given()+ .header("Authorization", "Bearer anytoken")+ .when().get("/execute-api/" + denyApiId + "/prod/protected")+ .then()+ .statusCode(403);+ }++ // ──────────────────────────── Stage Variables ────────────────────────────++ private static String stageVarApiId;++ @Test+ @Order(50)+ void stageVariables_setupApiWithStageVars() throws Exception {+ createNodeLambda("apigw-stagevar-auth-echo", """+ exports.handler = async (event) => ({+ principalId: "user",+ policyDocument: {+ Version: "2012-10-17",+ Statement: [{ Action: "execute-api:Invoke", Effect: "Allow", Resource: event.methodArn }]+ },+ context: { receivedEvent: JSON.stringify(event) }+ });+ """);+ createNodeLambda("apigw-stagevar-proxy", """+ exports.handler = async (event) => ({+ statusCode: 200,+ body: JSON.stringify({+ stageVariables: event.stageVariables,+ authorizer: event.requestContext && event.requestContext.authorizer+ ? event.requestContext.authorizer : null+ })+ });+ """);++ stageVarApiId = given()+ .contentType(ContentType.JSON)+ .body("{\"name\":\"stage-var-test-api\"}")+ .when().post("/restapis")+ .then().statusCode(201)+ .extract().path("id");++ String svRootId = given()+ .when().get("/restapis/" + stageVarApiId + "/resources")+ .then().statusCode(200)+ .extract().path("item[0].id");++ String resourceId = given()+ .contentType(ContentType.JSON)+ .body("{\"pathPart\":\"ping\"}")+ .when().post("/restapis/" + stageVarApiId + "/resources/" + svRootId)+ .then().statusCode(201)+ .extract().path("id");++ String authUri = "arn:aws:apigateway:" + REGION + ":lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:apigw-stagevar-auth-echo/invocations";+ String svAuthId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"sv-auth","type":"REQUEST","authorizerUri":"%s","identitySource":"method.request.header.Authorization","authorizerResultTtlInSeconds":0}+ """.formatted(authUri))+ .when().post("/restapis/" + stageVarApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("id");++ given().contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(svAuthId))+ .when().put("/restapis/" + stageVarApiId + "/resources/" + resourceId + "/methods/GET")+ .then().statusCode(201);++ String proxyUri = "arn:aws:apigateway:" + REGION + ":lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:apigw-stagevar-proxy/invocations";+ given().contentType(ContentType.JSON)+ .body("""+ {"type":"AWS_PROXY","httpMethod":"POST","uri":"%s"}+ """.formatted(proxyUri))+ .when().put("/restapis/" + stageVarApiId + "/resources/" + resourceId + "/methods/GET/integration")+ .then().statusCode(201);++ String depId = given().contentType(ContentType.JSON)+ .body("{\"description\":\"sv-test\"}")+ .when().post("/restapis/" + stageVarApiId + "/deployments")+ .then().statusCode(201)+ .extract().path("id");++ // Create stage WITH variables+ given().contentType(ContentType.JSON)+ .body("""+ {"stageName":"prod","deploymentId":"%s","variables":{"env":"test","version":"v1"}}+ """.formatted(depId))+ .when().post("/restapis/" + stageVarApiId + "/stages")+ .then().statusCode(201);+ }++ @Test+ @Order(51)+ void stageVariables_authorizerEventContainsStageVars() throws Exception {+ String response = given()+ .header("Authorization", "Bearer test")+ .when().get("/execute-api/" + stageVarApiId + "/prod/ping")+ .then().statusCode(200)+ .extract().asString();++ JsonNode payload = OBJECT_MAPPER.readTree(response);++ // Proxy event stageVariables+ JsonNode proxyStageVars = payload.path("stageVariables");+ assertFalse(proxyStageVars.isNull(), "proxy event stageVariables must be non-null");+ assertEquals("test", proxyStageVars.path("env").asText(null));+ assertEquals("v1", proxyStageVars.path("version").asText(null));++ // Authorizer event stageVariables (embedded in context)+ String receivedEventStr = payload.path("authorizer").path("receivedEvent").asText(null);+ assertNotNull(receivedEventStr);+ JsonNode authEvent = OBJECT_MAPPER.readTree(receivedEventStr);+ JsonNode authStageVars = authEvent.path("stageVariables");+ assertFalse(authStageVars.isNull(), "authorizer event stageVariables must be non-null");+ assertEquals("test", authStageVars.path("env").asText(null));+ assertEquals("v1", authStageVars.path("version").asText(null));+ }++ // ──────────────────────────── API Key Resolution ────────────────────────────++ private static String apiKeyApiId;++ @Test+ @Order(60)+ void apiKey_setupApiWithUsagePlan() throws Exception {+ createNodeLambda("apigw-apikey-auth-echo", """+ exports.handler = async (event) => ({+ principalId: "user",+ policyDocument: {+ Version: "2012-10-17",+ Statement: [{ Action: "execute-api:Invoke", Effect: "Allow", Resource: event.methodArn }]+ },+ context: { receivedEvent: JSON.stringify(event) }+ });+ """);+ createNodeLambda("apigw-apikey-proxy", """+ exports.handler = async (event) => ({+ statusCode: 200,+ body: JSON.stringify({+ authorizer: event.requestContext && event.requestContext.authorizer+ ? event.requestContext.authorizer : null+ })+ });+ """);++ apiKeyApiId = given()+ .contentType(ContentType.JSON)+ .body("{\"name\":\"apikey-test-api\"}")+ .when().post("/restapis")+ .then().statusCode(201)+ .extract().path("id");++ String akRootId = given()+ .when().get("/restapis/" + apiKeyApiId + "/resources")+ .then().statusCode(200)+ .extract().path("item[0].id");++ String resourceId = given()+ .contentType(ContentType.JSON)+ .body("{\"pathPart\":\"secure\"}")+ .when().post("/restapis/" + apiKeyApiId + "/resources/" + akRootId)+ .then().statusCode(201)+ .extract().path("id");++ String authUri = "arn:aws:apigateway:" + REGION + ":lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:apigw-apikey-auth-echo/invocations";+ String akAuthId = given()+ .contentType(ContentType.JSON)+ .body("""+ {"name":"ak-auth","type":"REQUEST","authorizerUri":"%s","identitySource":"method.request.header.Authorization","authorizerResultTtlInSeconds":0}+ """.formatted(authUri))+ .when().post("/restapis/" + apiKeyApiId + "/authorizers")+ .then().statusCode(201)+ .extract().path("id");++ given().contentType(ContentType.JSON)+ .body("""+ {"authorizationType":"CUSTOM","authorizerId":"%s"}+ """.formatted(akAuthId))+ .when().put("/restapis/" + apiKeyApiId + "/resources/" + resourceId + "/methods/GET")+ .then().statusCode(201);++ String proxyUri = "arn:aws:apigateway:" + REGION + ":lambda:path/2015-03-31/functions/"+ + "arn:aws:lambda:" + REGION + ":" + ACCOUNT + ":function:apigw-apikey-proxy/invocations";+ given().contentType(ContentType.JSON)+ .body("""+ {"type":"AWS_PROXY","httpMethod":"POST","uri":"%s"}+ """.formatted(proxyUri))+ .when().put("/restapis/" + apiKeyApiId + "/resources/" + resourceId + "/methods/GET/integration")+ .then().statusCode(201);++ String depId = given().contentType(ContentType.JSON)+ .body("{\"description\":\"ak-test\"}")+ .when().post("/restapis/" + apiKeyApiId + "/deployments")+ .then().statusCode(201)+ .extract().path("id");++ given().contentType(ContentType.JSON)+ .body("""+ {"stageName":"prod","deploymentId":"%s"}+ """.formatted(depId))+ .when().post("/restapis/" + apiKeyApiId + "/stages")+ .then().statusCode(201);++ // Create API key + usage plan linked to this (apiId, stage)+ given().contentType(ContentType.JSON)+ .body("{\"name\":\"test-key\",\"value\":\"my-secret-api-key\",\"enabled\":true}")+ .when().post("/apikeys")+ .then().statusCode(201);++ String keyId = given()+ .when().get("/apikeys")+ .then().statusCode(200)+ .extract().path("item.find { it.name == 'test-key' }.id");++ String planId = given().contentType(ContentType.JSON)+ .body("""+ {"name":"test-plan","apiStages":[{"apiId":"%s","stage":"prod"}]}+ """.formatted(apiKeyApiId))+ .when().post("/usageplans")+ .then().statusCode(201)+ .extract().path("id");++ given().contentType(ContentType.JSON)+ .body("""+ {"keyId":"%s","keyType":"API_KEY"}+ """.formatted(keyId))+ .when().post("/usageplans/" + planId + "/keys")+ .then().statusCode(201);+ }++ @Test+ @Order(61)+ void apiKey_identityApiKeyPopulatedWhenHeaderMatches() throws Exception {+ String response = given()+ .header("Authorization", "Bearer test")+ .header("x-api-key", "my-secret-api-key")+ .when().get("/execute-api/" + apiKeyApiId + "/prod/secure")+ .then().statusCode(200)+ .extract().asString();++ JsonNode payload = OBJECT_MAPPER.readTree(response);+ String receivedEventStr = payload.path("authorizer").path("receivedEvent").asText(null);+ assertNotNull(receivedEventStr);+ JsonNode event = OBJECT_MAPPER.readTree(receivedEventStr);++ assertEquals("my-secret-api-key",+ event.path("requestContext").path("identity").path("apiKey").asText(null),+ "identity.apiKey must equal the matched usage plan key value");+ }++ @Test+ @Order(62)+ void apiKey_identityApiKeyNullWhenNoHeaderPresent() throws Exception {+ String response = given()+ .header("Authorization", "Bearer test")+ .when().get("/execute-api/" + apiKeyApiId + "/prod/secure")+ .then().statusCode(200)+ .extract().asString();++ JsonNode payload = OBJECT_MAPPER.readTree(response);+ String receivedEventStr = payload.path("authorizer").path("receivedEvent").asText(null);+ assertNotNull(receivedEventStr);+ JsonNode event = OBJECT_MAPPER.readTree(receivedEventStr);++ assertTrue(event.path("requestContext").path("identity").path("apiKey").isNull(),+ "identity.apiKey must be null when no x-api-key header is present");+ }++ @Test+ @Order(63)+ void apiKey_identityApiKeyNullWhenHeaderDoesNotMatchAnyPlanKey() throws Exception {+ String response = given()+ .header("Authorization", "Bearer test")+ .header("x-api-key", "wrong-key-value")+ .when().get("/execute-api/" + apiKeyApiId + "/prod/secure")+ .then().statusCode(200)+ .extract().asString();++ JsonNode payload = OBJECT_MAPPER.readTree(response);+ String receivedEventStr = payload.path("authorizer").path("receivedEvent").asText(null);+ assertNotNull(receivedEventStr);+ JsonNode event = OBJECT_MAPPER.readTree(receivedEventStr);++ assertTrue(event.path("requestContext").path("identity").path("apiKey").isNull(),+ "identity.apiKey must be null when x-api-key header does not match any plan key");+ }++ // ──────────────────────────── Cleanup ────────────────────────────++ @Test+ @Order(99)+ void cleanup() {+ if (apiId != null) given().when().delete("/restapis/" + apiId).then().statusCode(202);+ if (tokenApiId != null) given().when().delete("/restapis/" + tokenApiId).then().statusCode(202);+ if (noneApiId != null) given().when().delete("/restapis/" + noneApiId).then().statusCode(202);+ if (denyApiId != null) given().when().delete("/restapis/" + denyApiId).then().statusCode(202);+ if (stageVarApiId != null) given().when().delete("/restapis/" + stageVarApiId).then().statusCode(202);+ if (apiKeyApiId != null) given().when().delete("/restapis/" + apiKeyApiId).then().statusCode(202);+ deleteFunction(AUTHORIZER_FUNCTION);+ deleteFunction(PROXY_FUNCTION);+ deleteFunction(TOKEN_AUTHORIZER_FUNCTION);+ deleteFunction(TOKEN_PROXY_FUNCTION);+ deleteFunction(NONE_INTEGRATION_FUNCTION);+ deleteFunction(DENY_AUTHORIZER_FUNCTION);+ deleteFunction("apigw-stagevar-auth-echo");+ deleteFunction("apigw-stagevar-proxy");+ deleteFunction("apigw-apikey-auth-echo");+ deleteFunction("apigw-apikey-proxy");+ }++ // ──────────────────────────── Helpers ────────────────────────────++ private static void createNodeLambda(String functionName, String handlerSource) throws Exception {+ String zipBase64 = Base64.getEncoder().encodeToString(zipEntries(Map.of(+ "index.js", handlerSource+ )));+ given()+ .contentType(ContentType.JSON)+ .body("""+ {+ "FunctionName": "%s",+ "Runtime": "nodejs20.x",+ "Role": "%s",+ "Handler": "index.handler",+ "Timeout": 30,+ "Code": {"ZipFile": "%s"}+ }+ """.formatted(functionName, ROLE_ARN, zipBase64))+ .when().post(LAMBDA_BASE_PATH)+ .then()+ .statusCode(201);+ }++ private static byte[] zipEntries(Map<String, String> entries) throws Exception {+ ByteArrayOutputStream baos = new ByteArrayOutputStream();+ try (ZipOutputStream zos = new ZipOutputStream(baos)) {+ for (Map.Entry<String, String> entry : entries.entrySet()) {+ zos.putNextEntry(new ZipEntry(entry.getKey()));+ zos.write(entry.getValue().getBytes(StandardCharsets.UTF_8));+ zos.closeEntry();+ }+ }+ return baos.toByteArray();+ }++ private static void deleteFunction(String functionName) {+ int statusCode = given()+ .when().delete(LAMBDA_BASE_PATH + "/" + functionName)+ .then()+ .extract().statusCode();+ assertTrue(statusCode == 204 || statusCode == 404);+ }+}