Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/api-client-ts/src/generated-client-extra.test.ts
T
2026-07-08 16:15:37 +02:00

159 lines
6.2 KiB
TypeScript

// @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<string>): ReadableStream<Uint8Array> {
let index = 0;
return new ReadableStream<Uint8Array>({
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);
});
});