release: WRNexusJS 0.4.0

packages/test/src/advanced.ts

@@ -0,0 +1,129 @@
+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();
+  }
+}

packages/test/src/index.ts

@@ -179,3 +179,14 @@ export async function createHarness(
     close: () => server.stop(),
   };
 }
+
+export {
+  testRequest,
+  testContext,
+  readJsonResponse,
+  expectProblem,
+  deferred,
+  waitFor,
+  MemoryCookieJar,
+} from "./advanced.ts";
+export type { TestRequestOptions, JsonResponse, Deferred, WaitForOptions } from "./advanced.ts";