// @vitest-environment node // Mirrors generated-client.test.ts: the generated fetch client runs server-side, // so we pin the node environment to match the real runtime (Headers/Response // semantics differ under jsdom). import { describe, expect, it } from "vitest"; import { createClient } from "./generated/client/client.gen.js"; const encoder = new TextEncoder(); function eventStream(chunks: Array): ReadableStream { let index = 0; return new ReadableStream({ pull(controller) { if (index < chunks.length) { controller.enqueue(encoder.encode(chunks[index])); index += 1; return; } controller.close(); }, }); } describe("generated fetch client — response parsing matrix", () => { it("parses a text/plain body via content-type auto-detection", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response("just text", { headers: { "Content-Type": "text/plain" } }), responseStyle: "data", }); await expect(client.get({ url: "/v1/text" })).resolves.toBe("just text"); }); it("parses a binary body as a Blob", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response(new Blob([new Uint8Array([1, 2, 3])]), { headers: { "Content-Type": "image/png" } }), responseStyle: "data", }); const blob = (await client.get({ url: "/v1/img" })) as unknown as Blob; expect(blob).toBeInstanceOf(Blob); expect(blob.size).toBe(3); }); it("parses an explicit arrayBuffer response", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response(new Uint8Array([7, 8]).buffer, { headers: { "Content-Type": "application/octet-stream" } }), responseStyle: "data", }); const buf = (await client.get({ parseAs: "arrayBuffer", url: "/v1/bin" })) as unknown as ArrayBuffer; expect(buf.byteLength).toBe(2); }); it("returns the raw stream when parseAs is stream", async () => { const body = eventStream(["chunk"]); const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response(body, { headers: { "Content-Type": "application/octet-stream" } }), responseStyle: "data", }); const result = await client.get({ parseAs: "stream", url: "/v1/stream" }); expect(result).toBeInstanceOf(ReadableStream); }); it("returns an empty object for a 200 JSON response with an empty body", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response("", { headers: { "Content-Type": "application/json" } }), responseStyle: "data", }); await expect(client.get({ url: "/v1/empty-json" })).resolves.toEqual({}); }); it("returns empty text for a 204 with parseAs text", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response(null, { status: 204 }), responseStyle: "data", }); await expect(client.delete({ parseAs: "text", url: "/v1/gone" })).resolves.toBe(""); }); it("treats a Content-Length:0 response as an empty result", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response("", { headers: { "Content-Length": "0", "Content-Type": "application/json" } }), responseStyle: "data", }); await expect(client.get({ url: "/v1/no-content" })).resolves.toEqual({}); }); }); describe("generated fetch client — response style fields", () => { it("wraps successful data with request and response when responseStyle is fields", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response('{"id":"x"}', { headers: { "Content-Type": "application/json" } }), responseStyle: "fields", }); const result = (await client.get({ url: "/v1/thing" })) as { data: { id: string }; response: Response; request: Request; }; expect(result.data).toEqual({ id: "x" }); expect(result.response.status).toBe(200); expect(result.request).toBeInstanceOf(Request); }); }); describe("generated fetch client — error handling", () => { it("throws the raw text error when the body is not JSON and throwOnError is set", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response("upstream exploded", { status: 502 }), throwOnError: true, }); await expect(client.get({ url: "/v1/boom" })).rejects.toBe("upstream exploded"); }); it("returns an error envelope for a non-JSON error when throwOnError is disabled", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response("nope", { status: 500 }), throwOnError: false, responseStyle: "fields", }); const result = (await client.get({ url: "/v1/boom" })) as { error: unknown; response: Response }; expect(result.error).toBe("nope"); expect(result.response.status).toBe(500); }); }); describe("generated fetch client — SSE method wiring", () => { it("opens an SSE stream and runs request interceptors through onRequest", async () => { let interceptorRan = false; const client = createClient({ baseUrl: "https://api.example.test", fetch: async (requestInfo) => { const request = requestInfo as Request; // The interceptor registered below must have stamped the header before fetch. expect(request.headers.get("X-Sse-Interceptor")).toBe("ran"); return new Response(eventStream(['data: {"n":1}\n\n']), { headers: { "Content-Type": "text/event-stream" } }); }, }); client.interceptors.request.use((request) => { interceptorRan = true; request.headers.set("X-Sse-Interceptor", "ran"); return request; }); const sse = await client.sse.get<{ n: number }>({ url: "/v1/stream" }); await expect(sse.stream.next()).resolves.toEqual({ done: false, value: { n: 1 } }); expect(interceptorRan).toBe(true); }); });