V2 checked the content type and decoded the body before looking at the status. An nginx 502 with an HTML page became CONTENT_TYPE_MISMATCH and an empty or broken 503/504 JSON body became MALFORMED_JSON: both non-retryable and shown as a contract breach. For a 5xx/408/425 status these branches, and the invalid-envelope branch, now return SERVER_FAILURE with the httpStatus, the same R-3.3 rule V3 uses. Retry follows V2's existing SERVER_FAILURE rule in retry-policy.ts, so 502/503/504 retry and 408/425/500 do not; SERVER_FAILURE was already in retryKinds, so retry-policy.ts is unchanged. The existing "non-JSON response" test used a 502 and pinned the old CONTENT_TYPE_MISMATCH classification; it now uses a 200, which still covers the non-JSON rejection and body redaction. Verified: four new http-client cases (502 HTML, 503 empty JSON, 504 broken JSON, 408 text) failed RED with CONTENT_TYPE_MISMATCH / MALFORMED_JSON and now pass with the expected fetch counts. All lane gates pass except the known removal-fixture test; test:reference-feature timed out once under load and passed on rerun. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
294 lines
8.9 KiB
TypeScript
294 lines
8.9 KiB
TypeScript
import { HttpResponse, http } from "msw";
|
|
import { setupServer } from "msw/node";
|
|
import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
|
|
|
|
import { createHttpClient } from "../../src/adapters/http/client.ts";
|
|
import { TEST_HTTP_CONTRACT } from "../helpers/http-contract-fixture.ts";
|
|
|
|
let attempts = 0;
|
|
const server = setupServer(
|
|
http.get("https://api.test/api/entities", () => {
|
|
attempts += 1;
|
|
if (attempts < 3) {
|
|
return HttpResponse.json(
|
|
{ success: false, error: { code: "TEMPORARY" } },
|
|
{ status: 503 },
|
|
);
|
|
}
|
|
return HttpResponse.json({
|
|
success: true,
|
|
data: [{ id: "resource-1", name: "Example" }],
|
|
meta: { requestId: "request-1", traceId: "trace-1" },
|
|
});
|
|
}),
|
|
);
|
|
|
|
beforeAll(() => server.listen({ onUnhandledRequest: "error" }));
|
|
afterEach(() => {
|
|
attempts = 0;
|
|
server.resetHandlers();
|
|
});
|
|
afterAll(() => server.close());
|
|
|
|
const clock = {
|
|
now: () => 0,
|
|
sleep: async () => {},
|
|
};
|
|
|
|
type HttpDependencies = Parameters<typeof createHttpClient>[0];
|
|
|
|
function testClient(options: HttpDependencies) {
|
|
return createHttpClient({ ...TEST_HTTP_CONTRACT, ...options });
|
|
}
|
|
|
|
describe("shared HTTP client", () => {
|
|
it("retries a safe request at most twice and returns validated data", async () => {
|
|
const client = testClient({
|
|
baseUrl: "https://api.test",
|
|
clock,
|
|
random: () => 0,
|
|
});
|
|
|
|
await expect(
|
|
client.execute("LIST_ENTITIES", { routeId: "TEST_ROUTE" }),
|
|
).resolves.toMatchObject({
|
|
ok: true,
|
|
value: [{ id: "resource-1", displayName: "Example" }],
|
|
meta: { requestId: "request-1" },
|
|
});
|
|
expect(attempts).toBe(3);
|
|
});
|
|
|
|
it.each(["", " ", "bad\u0000key", "x".repeat(513)])(
|
|
"rejects invalid keyed command key %j before credentials and fetch",
|
|
async (idempotencyKey) => {
|
|
let fetched = 0;
|
|
let credentialAttempts = 0;
|
|
server.use(
|
|
http.post("https://api.test/api/entities", () => {
|
|
fetched += 1;
|
|
return HttpResponse.json({ success: true, data: {} });
|
|
}),
|
|
);
|
|
const client = testClient({
|
|
baseUrl: "https://api.test",
|
|
clock,
|
|
authSession: {
|
|
getState: () => "authenticated",
|
|
subscribe: () => () => {},
|
|
beginSignIn: async () => {},
|
|
signOut: async () => {},
|
|
async credentialPatch() {
|
|
credentialAttempts += 1;
|
|
return { headers: {} };
|
|
},
|
|
recover: async () => "no-session" as const,
|
|
onUnauthenticated: () => {},
|
|
},
|
|
});
|
|
|
|
await expect(
|
|
client.execute("CREATE_ENTITY", {
|
|
body: { name: "n" },
|
|
idempotencyKey,
|
|
}),
|
|
).resolves.toMatchObject({
|
|
ok: false,
|
|
error: {
|
|
kind: "VALIDATION_REJECTED",
|
|
code: "IDEMPOTENCY_KEY_INVALID",
|
|
// The repository reports attempt counts as 1-based; the invariant
|
|
// proved below is that no physical attempt happened at all.
|
|
attemptCount: 1,
|
|
},
|
|
});
|
|
expect(fetched).toBe(0);
|
|
expect(credentialAttempts).toBe(0);
|
|
},
|
|
);
|
|
|
|
it("bounds a non-cooperative legacy credential owner by total deadline", async () => {
|
|
let fetched = 0;
|
|
let observedSignal: AbortSignal | undefined;
|
|
server.use(
|
|
http.get("https://api.test/api/entities", () => {
|
|
fetched += 1;
|
|
return HttpResponse.json({ success: true, data: [] });
|
|
}),
|
|
);
|
|
const client = testClient({
|
|
baseUrl: "https://api.test",
|
|
timeoutMs: 5,
|
|
clock: { now: () => 0, sleep: async () => {} },
|
|
authSession: {
|
|
getState: () => "authenticated",
|
|
subscribe: () => () => {},
|
|
beginSignIn: async () => {},
|
|
signOut: async () => {},
|
|
credentialPatch: (_binding, context) => {
|
|
observedSignal = context?.signal;
|
|
// Never settles on its own.
|
|
return new Promise<never>(() => {});
|
|
},
|
|
recover: async () => "no-session" as const,
|
|
onUnauthenticated: () => {},
|
|
},
|
|
});
|
|
|
|
const result = await client.execute("LIST_ENTITIES");
|
|
expect(result).toMatchObject({ ok: false });
|
|
expect(fetched).toBe(0);
|
|
expect(observedSignal).toBeDefined();
|
|
});
|
|
|
|
it("rejects a non-JSON response without exposing its body", async () => {
|
|
server.use(
|
|
http.get(
|
|
"https://api.test/api/entities",
|
|
() => new HttpResponse("<secret>raw body</secret>", { status: 200 }),
|
|
),
|
|
);
|
|
const client = testClient({ baseUrl: "https://api.test", clock });
|
|
const result = await client.execute("LIST_ENTITIES");
|
|
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { kind: "CONTENT_TYPE_MISMATCH" },
|
|
});
|
|
expect(JSON.stringify(result)).not.toContain("raw body");
|
|
});
|
|
|
|
// Q-6.3-3b. A gateway 5xx/408/425 with an HTML, empty or broken body is a
|
|
// server outage, not a contract breach: it keeps its status and the V2
|
|
// SERVER_FAILURE retry rule (502/503/504 only).
|
|
it.each([
|
|
{ status: 502, contentType: "text/html", body: "<secret>raw body</secret>", fetches: 3 },
|
|
{ status: 503, contentType: "application/json", body: "", fetches: 3 },
|
|
{ status: 504, contentType: "application/json", body: "{", fetches: 3 },
|
|
{ status: 408, contentType: "text/plain", body: "timeout", fetches: 1 },
|
|
])(
|
|
"keeps a $status gateway body as a server failure with its status",
|
|
async ({ status, contentType, body, fetches }) => {
|
|
let fetched = 0;
|
|
server.use(
|
|
http.get("https://api.test/api/entities", () => {
|
|
fetched += 1;
|
|
return new HttpResponse(body, {
|
|
status,
|
|
headers: { "Content-Type": contentType },
|
|
});
|
|
}),
|
|
);
|
|
const client = testClient({
|
|
baseUrl: "https://api.test",
|
|
clock,
|
|
random: () => 0,
|
|
});
|
|
const result = await client.execute("LIST_ENTITIES");
|
|
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { kind: "SERVER_FAILURE", httpStatus: status },
|
|
});
|
|
expect(fetched).toBe(fetches);
|
|
expect(JSON.stringify(result)).not.toContain("raw body");
|
|
},
|
|
);
|
|
|
|
it("classifies malformed JSON and invalid payloads at the boundary", async () => {
|
|
server.use(
|
|
http.get(
|
|
"https://api.test/api/entities",
|
|
() =>
|
|
new HttpResponse("{", {
|
|
headers: { "Content-Type": "application/json" },
|
|
}),
|
|
),
|
|
);
|
|
const client = testClient({ baseUrl: "https://api.test", clock });
|
|
await expect(client.execute("LIST_ENTITIES")).resolves.toMatchObject({
|
|
ok: false,
|
|
error: { kind: "MALFORMED_JSON" },
|
|
});
|
|
|
|
server.use(
|
|
http.get("https://api.test/api/entities", () =>
|
|
HttpResponse.json({
|
|
success: true,
|
|
data: [{ id: "resource-1", name: 42 }],
|
|
meta: { requestId: "request-1", traceId: "trace-1" },
|
|
}),
|
|
),
|
|
);
|
|
await expect(client.execute("LIST_ENTITIES")).resolves.toMatchObject({
|
|
ok: false,
|
|
error: { kind: "SCHEMA_MISMATCH" },
|
|
});
|
|
});
|
|
|
|
it("projects only approved 422 issue path and code metadata", async () => {
|
|
server.use(
|
|
http.post("https://api.test/api/entities", () =>
|
|
HttpResponse.json(
|
|
{
|
|
success: false,
|
|
error: {
|
|
code: "INVALID_INPUT",
|
|
message: "raw backend secret",
|
|
details: {
|
|
issues: [
|
|
{ path: "name", code: "REQUIRED", message: "raw field copy" },
|
|
{ path: 42, code: "INVALID" },
|
|
],
|
|
},
|
|
},
|
|
meta: { requestId: "request-422", traceId: "trace-422" },
|
|
},
|
|
{ status: 422 },
|
|
),
|
|
),
|
|
);
|
|
const client = testClient({ baseUrl: "https://api.test", clock });
|
|
const result = await client.execute("CREATE_ENTITY", {
|
|
routeId: "TEST_FORM",
|
|
body: { name: "Valid" },
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: {
|
|
kind: "VALIDATION_REJECTED",
|
|
validationIssues: [{ path: "name", code: "REQUIRED" }],
|
|
},
|
|
});
|
|
expect(JSON.stringify(result)).not.toContain("raw backend secret");
|
|
expect(JSON.stringify(result)).not.toContain("raw field copy");
|
|
});
|
|
|
|
it("guards mapper exceptions as a mapping contract violation", async () => {
|
|
server.use(
|
|
http.get("https://api.test/api/entities", () =>
|
|
HttpResponse.json({
|
|
success: true,
|
|
data: [{ id: "resource-1", name: "Example" }],
|
|
meta: { requestId: "request-1", traceId: "trace-1" },
|
|
}),
|
|
),
|
|
);
|
|
const client = testClient({
|
|
baseUrl: "https://api.test",
|
|
clock,
|
|
mapPayload: () => {
|
|
throw new Error("raw mapper detail");
|
|
},
|
|
});
|
|
|
|
const result = await client.execute("LIST_ENTITIES");
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { kind: "MAPPING_CONTRACT_VIOLATION" },
|
|
});
|
|
expect(JSON.stringify(result)).not.toContain("raw mapper detail");
|
|
});
|
|
});
|