192 lines
7.3 KiB
TypeScript
192 lines
7.3 KiB
TypeScript
// @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<Request, Response, unknown, { tag: string }>();
|
|
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<string> = [];
|
|
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<string, unknown>), 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({});
|
|
});
|
|
});
|