Improve integration test helpers and scenario assertions

Add status code support to mock API, add error checking to helper
functions, and tighten assertions in S13, S17, S25, and S29 scenarios.

Author: andreogle

integration/helpers.ts

@@ -105,12 +105,13 @@ function post(
   });
 }
 
-async function setMockResponse(path: string, response: unknown): Promise<void> {
-  await fetch(`${MOCK_API_URL}/mock/set-response`, {
+async function setMockResponse(path: string, response: unknown, status = 200): Promise<void> {
+  const result = await fetch(`${MOCK_API_URL}/mock/set-response`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ path, response }),
+    body: JSON.stringify({ path, response, status }),
   });
+  if (!result.ok) throw new Error(`Failed to set mock response: ${String(result.status)}`);
 }
 
 interface RecordedCall {
@@ -122,11 +123,13 @@ interface RecordedCall {
 
 async function getMockCalls(): Promise<readonly RecordedCall[]> {
   const response = await fetch(`${MOCK_API_URL}/mock/calls`);
+  if (!response.ok) throw new Error(`Failed to get mock calls: ${String(response.status)}`);
   return (await response.json()) as RecordedCall[];
 }
 
 async function resetMock(): Promise<void> {
-  await fetch(`${MOCK_API_URL}/mock/reset`, { method: 'POST' });
+  const result = await fetch(`${MOCK_API_URL}/mock/reset`, { method: 'POST' });
+  if (!result.ok) throw new Error(`Failed to reset mock: ${String(result.status)}`);
 }
 
 export {

integration/mock-api.ts

@@ -61,8 +61,8 @@ function startMockApi(port = 5123): MockApiHandle {
 
       // Control endpoints
       if (url.pathname === '/mock/set-response' && request.method === 'POST') {
-        const payload = JSON.parse(body) as { path: string; response: unknown };
-        overrides.set(payload.path, payload.response); // eslint-disable-line functional/immutable-data
+        const payload = JSON.parse(body) as { path: string; response: unknown; status?: number };
+        overrides.set(payload.path, payload); // eslint-disable-line functional/immutable-data
         return Response.json({ ok: true });
       }
       if (url.pathname === '/mock/calls' && request.method === 'GET') {
@@ -79,8 +79,10 @@ function startMockApi(port = 5123): MockApiHandle {
       calls.push({ url: request.url, method: request.method, headers, body }); // eslint-disable-line functional/immutable-data
 
       // Return override if set, otherwise default
-      const override = overrides.get(url.pathname);
-      if (override !== undefined) return Response.json(override);
+      const override = overrides.get(url.pathname) as { response: unknown; status?: number } | undefined;
+      if (override !== undefined) {
+        return Response.json(override.response, { status: override.status ?? 200 });
+      }
 
       return Response.json(findDefaultResponse(url.pathname));
     },

integration/scenarios/s13-plugin-api-call.test.ts

@@ -48,8 +48,9 @@ describe('S13 — Plugin hooks — onBeforeApiCall / onAfterApiCall', () => {
     const body = (await response.json()) as { data: string };
 
     expect(response.status).toBe(200);
-    // The encoded value should reflect 99.9 * 100 = 9990, not the mock's 22.5 * 100 = 2250
-    expect(body.data).toBeDefined();
+    // 99.9 * 100 = 9990 as int256 → 0x...270e (9990 in hex)
+    // The mock returns 22.5 which would encode to 2250 (0x...08ca). The plugin overrides to 99.9.
+    expect(body.data).toContain('270e');
   });
 
   test('plugin returning undefined passes through', async () => {

integration/scenarios/s17-upstream-failure.test.ts

@@ -14,31 +14,26 @@ afterAll(() => {
 beforeEach(() => resetMock());
 
 describe('S17 — Upstream API failure handling', () => {
-  test('upstream 500 returns airnode 502', async () => {
-    await setMockResponse('/current.json', '__STATUS_500__');
-    // The mock returns JSON — but processResponse will fail because the shape is wrong
-    // Actually we need the mock to return a 500 status. Let me use the default mock
-    // which returns valid JSON — instead set a response that breaks encoding.
-    await setMockResponse('/current.json', { error: 'internal server error' });
+  test('upstream returning wrong shape returns 502', async () => {
+    await setMockResponse('/current.json', { completely: { wrong: 'shape' } });
 
     const endpointId = findEndpointId(ctx.endpointMap, 'WeatherAPI', 'currentTemp');
     const response = await post(ctx.baseUrl, endpointId, { q: 'London' });
     const body = (await response.json()) as { error: string };
 
-    // processResponse fails because $.current.temp_c doesn't exist → 502
     expect(response.status).toBe(502);
-    expect(body.error).not.toContain('temp_c'); // error details not leaked
+    expect(body.error).toBe('Internal processing error');
   });
 
-  test('upstream returning wrong shape returns 502', async () => {
-    await setMockResponse('/current.json', { completely: { wrong: 'shape' } });
+  test('upstream returning non-JSON returns 502', async () => {
+    // The mock always returns JSON, but we can set a response that the Airnode
+    // treats as an error because the encoded data fails processing
+    await setMockResponse('/current.json', 'not json', 200);
 
     const endpointId = findEndpointId(ctx.endpointMap, 'WeatherAPI', 'currentTemp');
     const response = await post(ctx.baseUrl, endpointId, { q: 'Berlin' });
-    const body = (await response.json()) as { error: string };
 
     expect(response.status).toBe(502);
-    expect(body.error).toBe('Internal processing error');
   });
 
   test('error details are not leaked to the client', async () => {
@@ -49,8 +44,8 @@ describe('S17 — Upstream API failure handling', () => {
     const body = (await response.json()) as { error: string };
 
     expect(response.status).toBe(502);
-    // Should be a generic message, not the JSONPath error or stack trace
     expect(body.error).not.toContain('$.');
     expect(body.error).not.toContain('stack');
+    expect(body.error).not.toContain('temp_c');
   });
 });

integration/scenarios/s25-concurrent-requests.test.ts

@@ -43,10 +43,10 @@ describe('S25 — Concurrent request handling', () => {
       expect(r.status).toBe(200);
     }
 
-    // The mock should have been called at most a few times (first request populates cache)
+    // At least one request must hit the API (cache was empty), but with caching
+    // enabled, not all 5 should hit the upstream — some should be served from cache
     const calls = await getMockCalls();
-    // With cache, subsequent requests shouldn't hit the API
-    // First request hits the API, rest may hit cache depending on timing
-    expect(calls.length).toBeLessThanOrEqual(5);
+    expect(calls.length).toBeGreaterThanOrEqual(1);
+    expect(calls.length).toBeLessThan(5);
   });
 });

integration/scenarios/s29-x402-payment.test.ts

@@ -12,31 +12,26 @@ afterAll(() => {
   ctx.stop();
 });
 
-describe('S29 — x402 payment auth', () => {
-  test('returns 402 with payment details when no proof header', () => {
-    // RandomAPI has no auth — we need an endpoint with x402 auth.
-    // Since the complete config doesn't have x402, we test via unit tests.
-    // This integration test verifies the pipeline returns 402 correctly
-    // by checking the response format from the unit test coverage.
-    // Full integration requires a live chain for payment verification.
-
-    // For now, verify the 402 flow works at the pipeline level
-    // by confirming that endpoints without payment proof return properly.
-    // The unit tests in auth.test.ts cover the x402 logic thoroughly.
-    expect(true).toBe(true);
+describe('S29 — Multi-method auth integration', () => {
+  test('endpoint with multi-method auth rejects unauthenticated requests', async () => {
+    // coinMarketData has auth: [nftKey, apiKey]
+    const endpointId = findEndpointId(ctx.endpointMap, 'CoinGecko', 'coinMarketData');
+    const response = await post(ctx.baseUrl, endpointId, { coinId: 'bitcoin' });
+
+    expect(response.status).toBe(401);
   });
 
-  test('multi-method: x402 + apiKey fallback works via API key', async () => {
-    // coinMarketData has auth: [nftKey, apiKey] — similar multi-method pattern
-    // This tests that multi-method auth with fallback works in integration
+  test('endpoint with multi-method auth accepts API key fallback', async () => {
     const endpointId = findEndpointId(ctx.endpointMap, 'CoinGecko', 'coinMarketData');
+    const response = await post(ctx.baseUrl, endpointId, { coinId: 'bitcoin' }, { 'X-Api-Key': 'test-client-key' });
+
+    expect(response.status).toBe(200);
+  });
 
-    // Without any auth — should fail
-    const r1 = await post(ctx.baseUrl, endpointId, { coinId: 'bitcoin' });
-    expect(r1.status).toBe(401);
+  test('unknown endpoint returns 404', async () => {
+    const fakeId = '0x0000000000000000000000000000000000000000000000000000000000000001';
+    const response = await post(ctx.baseUrl, fakeId, {});
 
-    // With API key fallback — should succeed
-    const r2 = await post(ctx.baseUrl, endpointId, { coinId: 'bitcoin' }, { 'X-Api-Key': 'test-client-key' });
-    expect(r2.status).toBe(200);
+    expect(response.status).toBe(404);
   });
 });