130 lines
4.4 KiB
TypeScript
130 lines
4.4 KiB
TypeScript
import { createContext, type Context, type ProblemDetails } from "@wrnexus/core";
|
|
|
|
export interface TestRequestOptions extends Omit<RequestInit, "body"> {
|
|
body?: BodyInit | Record<string, unknown> | URLSearchParams | FormData | null;
|
|
baseUrl?: string;
|
|
}
|
|
|
|
/** Build a web-standard Request with convenient JSON/FormData handling. */
|
|
export function testRequest(path = "/", options: TestRequestOptions = {}): Request {
|
|
const base = options.baseUrl ?? "http://localhost";
|
|
const headers = new Headers(options.headers);
|
|
let body: BodyInit | null | undefined = options.body as BodyInit | null | undefined;
|
|
if (
|
|
body !== null &&
|
|
body !== undefined &&
|
|
typeof body === "object" &&
|
|
!(body instanceof URLSearchParams) &&
|
|
!(body instanceof FormData) &&
|
|
!(body instanceof Blob) &&
|
|
!(body instanceof ArrayBuffer) &&
|
|
!ArrayBuffer.isView(body) &&
|
|
!(body instanceof ReadableStream)
|
|
) {
|
|
body = JSON.stringify(body);
|
|
if (!headers.has("content-type")) headers.set("content-type", "application/json");
|
|
}
|
|
const method = options.method ?? (body == null ? "GET" : "POST");
|
|
return new Request(new URL(path, base), { ...options, method, headers, body });
|
|
}
|
|
|
|
/** Create a complete Context suitable for middleware and route unit tests. */
|
|
export function testContext(path = "/", options: TestRequestOptions = {}): Context {
|
|
const request = testRequest(path, options);
|
|
return createContext(request, new URL(request.url));
|
|
}
|
|
|
|
export interface JsonResponse<T> {
|
|
response: Response;
|
|
body: T;
|
|
}
|
|
|
|
export async function readJsonResponse<T = unknown>(response: Response): Promise<JsonResponse<T>> {
|
|
return { response, body: (await response.json()) as T };
|
|
}
|
|
|
|
export async function expectProblem(response: Response, status?: number): Promise<ProblemDetails> {
|
|
const contentType = response.headers.get("content-type") ?? "";
|
|
if (!contentType.includes("application/problem+json")) {
|
|
throw new Error(`Expected application/problem+json but received '${contentType || "none"}'.`);
|
|
}
|
|
if (status !== undefined && response.status !== status) {
|
|
throw new Error(`Expected status ${status} but received ${response.status}.`);
|
|
}
|
|
const value = (await response.json()) as ProblemDetails;
|
|
if (!value.title || !Number.isInteger(value.status)) {
|
|
throw new Error("Response body is not RFC 9457 Problem Details.");
|
|
}
|
|
return value;
|
|
}
|
|
|
|
export interface Deferred<T> {
|
|
promise: Promise<T>;
|
|
resolve(value: T | PromiseLike<T>): void;
|
|
reject(reason?: unknown): void;
|
|
}
|
|
|
|
export function deferred<T>(): Deferred<T> {
|
|
let resolve!: Deferred<T>["resolve"];
|
|
let reject!: Deferred<T>["reject"];
|
|
const promise = new Promise<T>((resolvePromise, rejectPromise) => {
|
|
resolve = resolvePromise;
|
|
reject = rejectPromise;
|
|
});
|
|
return { promise, resolve, reject };
|
|
}
|
|
|
|
export interface WaitForOptions {
|
|
timeoutMs?: number;
|
|
intervalMs?: number;
|
|
signal?: AbortSignal;
|
|
}
|
|
|
|
/** Poll a condition without depending on fake timers or a browser runtime. */
|
|
export async function waitFor(
|
|
condition: () => boolean | Promise<boolean>,
|
|
options: WaitForOptions = {},
|
|
): Promise<void> {
|
|
const timeoutMs = options.timeoutMs ?? 1_000;
|
|
const intervalMs = options.intervalMs ?? 10;
|
|
const startedAt = Date.now();
|
|
while (!(await condition())) {
|
|
if (options.signal?.aborted)
|
|
throw options.signal.reason ?? new DOMException("Aborted", "AbortError");
|
|
if (Date.now() - startedAt >= timeoutMs)
|
|
throw new Error(`waitFor timed out after ${timeoutMs}ms`);
|
|
await new Promise<void>((resolve) => setTimeout(resolve, intervalMs));
|
|
}
|
|
}
|
|
|
|
export class MemoryCookieJar {
|
|
readonly #cookies = new Map<string, string>();
|
|
|
|
apply(response: Response): void {
|
|
const value = response.headers.get("set-cookie");
|
|
if (!value) return;
|
|
for (const segment of value.split(/,(?=[^;,]+=)/)) {
|
|
const pair = segment.split(";", 1)[0]?.trim();
|
|
if (!pair) continue;
|
|
const index = pair.indexOf("=");
|
|
if (index <= 0) continue;
|
|
this.#cookies.set(pair.slice(0, index), pair.slice(index + 1));
|
|
}
|
|
}
|
|
|
|
header(): string {
|
|
return [...this.#cookies].map(([name, value]) => `${name}=${value}`).join("; ");
|
|
}
|
|
|
|
request(path: string, options: TestRequestOptions = {}): Request {
|
|
const headers = new Headers(options.headers);
|
|
const cookie = this.header();
|
|
if (cookie) headers.set("cookie", cookie);
|
|
return testRequest(path, { ...options, headers });
|
|
}
|
|
|
|
clear(): void {
|
|
this.#cookies.clear();
|
|
}
|
|
}
|