// @vitest-environment node // The generated SDK runs server-side (Node), where Headers.append("Cookie", ...) // is RFC-6265-joined with "; ". The repo-root vitest config defaults to jsdom, whose // Headers polyfill joins Cookie with ", " and breaks the auth-cookie assertion. Pin // node here so the test matches the real runtime; keeps src/generated/ codegen-clean // (no manual edit → no SDK-codegen-drift failure). import { describe, expect, it } from "vitest"; import { getAuthToken } from "./generated/core/auth.gen.js"; import { createClient } from "./generated/client/client.gen.js"; import { buildUrl, createConfig, createInterceptors, createQuerySerializer, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from "./generated/client/utils.gen.js"; describe("generated auth helpers", () => { it("formats auth tokens by security scheme", async () => { await expect(getAuthToken({ scheme: "bearer", type: "http" }, "jwt")).resolves.toBe("Bearer jwt"); await expect(getAuthToken({ scheme: "basic", type: "http" }, "user:pass")).resolves.toBe(`Basic ${btoa("user:pass")}`); await expect(getAuthToken({ in: "query", name: "api_key", type: "apiKey" }, () => "key")).resolves.toBe("key"); await expect(getAuthToken({ type: "apiKey" }, undefined)).resolves.toBeUndefined(); }); }); describe("generated client utilities", () => { it("serializes query parameters with global and per-parameter overrides", () => { const querySerializer = createQuerySerializer({ allowReserved: true, array: { explode: false, style: "pipeDelimited" }, object: { explode: false, style: "form" }, parameters: { ids: { allowReserved: false, array: { explode: true, style: "form" } }, }, }); expect( querySerializer({ filter: { owner: "ops/team", status: "open" }, ids: ["a/b", "c"], q: "a/b", skipped: undefined, }) ).toBe("filter=owner,ops/team,status,open&ids=a%2Fb&ids=c&q=a/b"); }); it("infers response parsing from content type", () => { expect(getParseAs(null)).toBe("stream"); expect(getParseAs("application/problem+json; charset=utf-8")).toBe("json"); expect(getParseAs("multipart/form-data; boundary=x")).toBe("formData"); expect(getParseAs("image/png")).toBe("blob"); expect(getParseAs("text/csv")).toBe("text"); expect(getParseAs("")).toBe("stream"); expect(getParseAs("x-custom/value")).toBeUndefined(); }); it("sets auth in headers, query params, and cookies without overwriting existing values", async () => { const headers = new Headers({ Authorization: "Bearer existing", Cookie: "session=abc" }); const query = { api_key: "existing" }; await setAuthParams({ auth: ({ name }) => `token-for-${name ?? "default"}`, headers, query, security: [ { in: "header", name: "Authorization", scheme: "bearer", type: "http" }, { in: "query", name: "api_key", type: "apiKey" }, { in: "cookie", name: "csrf", type: "apiKey" }, { in: "header", name: "X-New-Token", type: "apiKey" }, ], }); expect(headers.get("Authorization")).toBe("Bearer existing"); expect(query.api_key).toBe("existing"); expect(headers.get("Cookie")).toBe("session=abc; csrf=token-for-csrf"); expect(headers.get("X-New-Token")).toBe("token-for-X-New-Token"); }); it("merges config and headers while honoring removals", () => { const mergedHeaders = mergeHeaders( { Accept: "application/json", "X-List": ["a", "b"], "X-Json": { ok: true } }, new Headers({ Accept: "text/plain" }), { "X-Json": null, "X-Skip": undefined } ); expect(mergedHeaders.get("Accept")).toBe("text/plain"); expect(mergedHeaders.get("X-List")).toBe("a, b"); expect(mergedHeaders.has("X-Json")).toBe(false); const config = mergeConfigs({ baseUrl: "https://api.example.test/", headers: { A: "1" } }, { headers: { B: "2" } }); const configHeaders = config.headers as Headers; expect(config.baseUrl).toBe("https://api.example.test"); expect(configHeaders.get("A")).toBe("1"); expect(configHeaders.get("B")).toBe("2"); }); it("creates default config, build URLs, and manages interceptors", () => { const config = createConfig({ baseUrl: "https://api.example.test" }); expect(config.parseAs).toBe("auto"); expect(config.headers).toEqual({ "Content-Type": "application/json" }); expect( buildUrl({ ...config, path: { id: "tool/a" }, query: { q: "drill" }, url: "/v1/tools/{id}", }) ).toBe("https://api.example.test/v1/tools/tool%2Fa?q=drill"); const interceptors = createInterceptors(); const fn = (request: Request) => request; const id = interceptors.request.use(fn); expect(interceptors.request.exists(id)).toBe(true); expect(interceptors.request.update(id, fn)).toBe(id); interceptors.request.eject(fn); expect(interceptors.request.exists(id)).toBe(false); interceptors.request.clear(); expect(interceptors.request.fns).toEqual([]); }); }); describe("generated fetch client", () => { it("builds requests, runs interceptors, validates, transforms, and returns data", async () => { const seen: Array = []; const client = createClient({ baseUrl: "https://api.example.test", fetch: async (requestInfo) => { const request = requestInfo as Request; seen.push(request.headers.get("X-Request-Interceptor") ?? ""); expect(request.method).toBe("POST"); expect(request.url).toBe("https://api.example.test/v1/tools?q=drill"); expect(await request.text()).toBe('{"name":"press"}'); return new Response('{"id":"tool_1"}', { headers: { "Content-Type": "application/json" } }); }, responseStyle: "data", }); client.interceptors.request.use((request) => { request.headers.set("X-Request-Interceptor", "ran"); return request; }); client.interceptors.response.use((response) => { response.headers.set("X-Response-Interceptor", "ran"); return response; }); const data = await client.post({ body: { name: "press" }, query: { q: "drill" }, responseTransformer: async (body) => ({ ...(body as Record), transformed: true }), responseValidator: async (body) => { expect(body).toEqual({ id: "tool_1" }); }, url: "/v1/tools", }); expect(seen).toEqual(["ran"]); expect(data).toEqual({ id: "tool_1", transformed: true }); }); it("returns structured errors when throwOnError is disabled", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response('{"error":"nope"}', { status: 400 }), throwOnError: false, }); client.interceptors.error.use((error) => ({ wrapped: error })); await expect(client.get({ url: "/v1/fail" })).resolves.toMatchObject({ error: { wrapped: { error: "nope" } }, response: { status: 400 }, }); }); it("returns typed empty responses for no-content results", async () => { const client = createClient({ baseUrl: "https://api.example.test", fetch: async () => new Response(null, { status: 204 }), responseStyle: "data", }); await expect(client.delete({ parseAs: "json", url: "/v1/tools/tool_1" })).resolves.toEqual({}); }); });