@jterrazz/test 7.1.0 → 9.0.0

package/dist/intercept.js

@@ -1,310 +1,149 @@
-//#region src/builder/common/intercept/adapters/anthropic.ts
-const ANTHROPIC_MESSAGES_URL = "https://api.anthropic.com/v1/messages";
-function matchesFilter(body, filter) {
-	if (filter.model) {
-		const model = body?.model;
-		if (typeof filter.model === "string" && model !== filter.model) return false;
-		if (filter.model instanceof RegExp && !filter.model.test(model ?? "")) return false;
+//#region src/integrations/msw/intercept.ts
+let mswModule = null;
+let mswHttp = null;
+async function loadMsw() {
+	if (!mswModule) {
+		mswModule = await import("msw/node");
+		mswHttp = await import("msw");
 	}
-	if (filter.system) {
-		const system = typeof body?.system === "string" ? body.system : "";
-		if (typeof filter.system === "string" && !system.includes(filter.system)) return false;
-		if (filter.system instanceof RegExp && !filter.system.test(system)) return false;
-	}
-	if (filter.user) {
-		const userMsg = body?.messages?.find((m) => m.role === "user")?.content ?? "";
-		const text = typeof userMsg === "string" ? userMsg : JSON.stringify(userMsg);
-		if (typeof filter.user === "string" && !text.includes(filter.user)) return false;
-		if (filter.user instanceof RegExp && !filter.user.test(text)) return false;
-	}
-	if (filter.tools) {
-		const names = body?.tools?.map((t) => t.name).filter(Boolean) ?? [];
-		if (!filter.tools.every((t) => names.includes(t))) return false;
-	}
-	return true;
-}
-function buildReply(data) {
 	return {
-		status: 200,
-		body: {
-			id: "msg-test",
-			type: "message",
-			role: "assistant",
-			content: [{
-				type: "text",
-				text: typeof data === "string" ? data : JSON.stringify(data)
-			}],
-			model: "claude-sonnet-4-20250514",
-			stop_reason: "end_turn",
-			usage: {
-				input_tokens: 10,
-				output_tokens: 10
-			}
-		}
+		node: mswModule,
+		msw: mswHttp
 	};
 }
+let serverInstance = null;
 /**
-* Anthropic API intercept helpers.
+* Start the MSW server (once per process).
 */
-const anthropic = {
-	request(filter) {
-		return {
-			adapter: "anthropic",
-			method: "POST",
-			url: ANTHROPIC_MESSAGES_URL,
-			match: filter ? (body) => matchesFilter(body, filter) : void 0,
-			wrap: buildReply
-		};
-	},
-	reply: buildReply,
-	error(status, message) {
-		return {
-			status,
-			body: {
-				type: "error",
-				error: {
-					type: status === 429 ? "rate_limit_error" : "api_error",
-					message: message ?? `Anthropic error (${status})`
-				}
-			}
-		};
-	},
-	timeout() {
-		return {
-			status: 200,
-			body: {},
-			delay: 3e4
-		};
-	},
-	messages(filter) {
-		return anthropic.request(filter);
-	},
-	response: buildReply
-};
-//#endregion
-//#region src/builder/common/intercept/adapters/http.ts
-function wrapJson(data) {
-	return {
-		status: 200,
-		body: data
-	};
+async function ensureInterceptServer() {
+	if (serverInstance) return;
+	const { node } = await loadMsw();
+	serverInstance = node.setupServer();
+	serverInstance.listen({ onUnhandledRequest: "bypass" });
+}
+function describeTrigger(entry) {
+	return `${entry.trigger.method === "*" ? "ANY" : entry.trigger.method} ${String(entry.trigger.url)}`;
 }
 /**
-* Generic HTTP intercept helpers for any URL.
-*
-* @example
-*   .intercept(http.get('https://api.example.com/data'), 'http/response.json')
+* Pure FIFO queue over the chain's intercept entries. Each observed request
+* consumes the first unconsumed entry whose URL, method, and optional body
+* matcher accept it. Exported for unit tests — MSW never reaches this class.
 */
-const http = {
-	get(url) {
-		return {
-			adapter: "http",
-			method: "GET",
-			url,
-			wrap: wrapJson
-		};
-	},
-	post(url) {
-		return {
-			adapter: "http",
-			method: "POST",
-			url,
-			wrap: wrapJson
-		};
-	},
-	put(url) {
-		return {
-			adapter: "http",
-			method: "PUT",
-			url,
-			wrap: wrapJson
-		};
-	},
-	delete(url) {
-		return {
-			adapter: "http",
-			method: "DELETE",
-			url,
-			wrap: wrapJson
-		};
-	},
-	any(url) {
-		return {
-			adapter: "http",
-			method: "*",
-			url,
-			wrap: wrapJson
-		};
-	},
-	json(data, status = 200) {
-		return {
-			status,
-			body: data
-		};
-	},
-	error(status, message) {
-		return {
-			status,
-			body: { error: message ?? `HTTP ${status}` }
-		};
-	}
-};
-//#endregion
-//#region src/builder/common/intercept/adapters/openai.ts
-const OPENAI_CHAT_URL = "https://api.openai.com/v1/chat/completions";
-const OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses";
-function matchesChatFilter(body, filter) {
-	if (filter.model) {
-		const model = body?.model;
-		if (typeof filter.model === "string" && model !== filter.model) return false;
-		if (filter.model instanceof RegExp && !filter.model.test(model ?? "")) return false;
-	}
-	if (filter.system) {
-		const msg = body?.messages?.find((m) => m.role === "system")?.content ?? "";
-		if (typeof filter.system === "string" && !msg.includes(filter.system)) return false;
-		if (filter.system instanceof RegExp && !filter.system.test(msg)) return false;
-	}
-	if (filter.user) {
-		const msg = body?.messages?.find((m) => m.role === "user")?.content ?? "";
-		if (typeof filter.user === "string" && !msg.includes(filter.user)) return false;
-		if (filter.user instanceof RegExp && !filter.user.test(msg)) return false;
-	}
-	if (filter.tools) {
-		const names = body?.tools?.map((t) => t.function?.name).filter(Boolean) ?? [];
-		if (!filter.tools.every((t) => names.includes(t))) return false;
+var InterceptQueue = class {
+	consumed;
+	entries;
+	constructor(entries) {
+		this.entries = entries;
+		this.consumed = entries.map(() => false);
 	}
-	if (filter.temperature !== void 0 && body?.temperature !== filter.temperature) return false;
-	return true;
-}
-function matchesResponsesFilter(body, filter) {
-	if (filter.model) {
-		const model = body?.model;
-		if (typeof filter.model === "string" && model !== filter.model) return false;
-		if (filter.model instanceof RegExp && !filter.model.test(model ?? "")) return false;
+	/**
+	* Unique trigger URLs, preserving RegExp/string identity for MSW routing.
+	* Deduped by string form — two RegExp objects with the same source are
+	* one trigger (and get one handler).
+	*/
+	get urls() {
+		const urls = /* @__PURE__ */ new Map();
+		for (const entry of this.entries) {
+			const key = String(entry.trigger.url);
+			if (!urls.has(key)) urls.set(key, entry.trigger.url);
+		}
+		return [...urls.values()];
 	}
-	if (filter.system) {
-		const instructions = body?.instructions ?? "";
-		const systemInput = body?.input?.find?.((m) => m.role === "system")?.content ?? "";
-		const text = instructions || systemInput;
-		if (typeof filter.system === "string" && !text.includes(filter.system)) return false;
-		if (filter.system instanceof RegExp && !filter.system.test(text)) return false;
+	/** Methods declared for a given trigger URL. */
+	methodsFor(url) {
+		const methods = /* @__PURE__ */ new Set();
+		for (const entry of this.entries) if (sameUrl(entry.trigger.url, url)) methods.add(entry.trigger.method);
+		return [...methods];
 	}
-	if (filter.user) {
-		const msgs = (body?.input ?? []).filter((m) => m.role === "user").map((m) => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join(" ");
-		if (typeof filter.user === "string" && !msgs.includes(filter.user)) return false;
-		if (filter.user instanceof RegExp && !filter.user.test(msgs)) return false;
+	/**
+	* Consume and return the first unconsumed entry registered for
+	* `handlerUrl`/`method` that accepts the request, or null when the queue
+	* for that trigger is exhausted (or no matcher accepts).
+	*/
+	take(handlerUrl, method, request) {
+		for (let i = 0; i < this.entries.length; i++) {
+			if (this.consumed[i]) continue;
+			const entry = this.entries[i];
+			if (!sameUrl(entry.trigger.url, handlerUrl)) continue;
+			if (entry.trigger.method !== method && entry.trigger.method !== "*") continue;
+			if (entry.trigger.match && !entry.trigger.match(request)) continue;
+			this.consumed[i] = true;
+			return entry;
+		}
+		return null;
 	}
-	if (filter.tools) {
-		const names = body?.tools?.map((t) => t.name ?? t.function?.name).filter(Boolean) ?? [];
-		if (!filter.tools.every((t) => names.includes(t))) return false;
+	/**
+	* Build the strict-intercept failure for a request that matched no
+	* registered intercept (CONVENTIONS D7): method + URL of the offending
+	* request, plus every registered trigger and its consumption state.
+	*/
+	unmatchedError(method, url) {
+		const triggers = this.entries.length === 0 ? "  (no intercepts registered)" : this.entries.map((entry, i) => `  - ${describeTrigger(entry)}${this.consumed[i] ? " (already consumed)" : ""}`).join("\n");
+		return /* @__PURE__ */ new Error(`Unmatched outgoing HTTP request during spec: ${method} ${url}\nRegistered intercepts:\n${triggers}\nEvery outgoing request of a chain that declares intercepts must match one — add an .intercept() for it (or one more if its queue is exhausted).`);
 	}
-	return true;
+};
+function sameUrl(a, b) {
+	return a === b || String(a) === String(b);
 }
-function buildChatReply(data) {
-	const content = typeof data === "string" ? data : JSON.stringify(data);
-	return {
-		status: 200,
-		body: {
-			id: "chatcmpl-test",
-			object: "chat.completion",
-			created: Math.floor(Date.now() / 1e3),
-			model: "gpt-4o-test",
-			choices: [{
-				index: 0,
-				message: {
-					role: "assistant",
-					content
-				},
-				finish_reason: "stop"
-			}],
-			usage: {
-				prompt_tokens: 10,
-				completion_tokens: 10,
-				total_tokens: 20
-			}
-		}
+/**
+* Register intercept entries as MSW handlers for one chain. A trailing
+* catch-all handler records any request that no entry accepted — the
+* builder rethrows it as the spec failure (rejecting the action promise,
+* never an unhandled rejection).
+*/
+async function registerIntercepts(entries) {
+	if (entries.length === 0) return {
+		cleanup: () => {},
+		violation: () => null
 	};
-}
-function buildResponsesReply(data) {
-	const text = typeof data === "string" ? data : JSON.stringify(data);
-	return {
-		status: 200,
-		body: {
-			id: "resp-test",
-			object: "response",
-			created_at: Math.floor(Date.now() / 1e3),
-			model: "gpt-4o-test",
-			output: [{
-				type: "message",
-				id: "msg-test",
-				role: "assistant",
-				content: [{
-					type: "output_text",
-					text,
-					annotations: []
-				}]
-			}],
-			usage: {
-				input_tokens: 10,
-				output_tokens: 10,
-				total_tokens: 20
+	await ensureInterceptServer();
+	const { msw } = await loadMsw();
+	const queue = new InterceptQueue(entries);
+	let violation = null;
+	const recordViolation = (method, url) => {
+		violation ??= queue.unmatchedError(method, url);
+		return msw.HttpResponse.json({ error: `@jterrazz/test strict intercepts: unmatched request ${method} ${url}` }, { status: 501 });
+	};
+	const handlers = [];
+	for (const url of queue.urls) for (const method of queue.methodsFor(url)) {
+		const handlerFn = method === "*" ? msw.http.all : msw.http[method.toLowerCase()];
+		if (!handlerFn) continue;
+		const handler = handlerFn(url, async ({ request }) => {
+			let body = null;
+			const rawText = await request.clone().text();
+			if (rawText) try {
+				body = JSON.parse(rawText);
+			} catch {
+				body = rawText;
 			}
-		}
+			const headers = {};
+			request.headers.forEach((value, key) => {
+				headers[key.toLowerCase()] = value;
+			});
+			const observed = {
+				body,
+				headers,
+				url: request.url
+			};
+			const entry = queue.take(url, request.method, observed);
+			if (!entry) return recordViolation(request.method, request.url);
+			const response = typeof entry.response === "function" ? entry.response(observed) : entry.response;
+			if (response.delay) await new Promise((r) => setTimeout(r, response.delay));
+			return msw.HttpResponse.json(response.body, {
+				status: response.status ?? 200,
+				headers: response.headers
+			});
+		});
+		handlers.push(handler);
+	}
+	handlers.push(msw.http.all("*", ({ request }) => recordViolation(request.method, request.url)));
+	serverInstance.use(...handlers);
+	return {
+		cleanup: () => {
+			serverInstance.resetHandlers();
+		},
+		violation: () => violation
 	};
 }
-/**
-* OpenAI API intercept helpers.
-*/
-const openai = {
-	request(filter) {
-		return {
-			adapter: "openai",
-			method: "POST",
-			url: OPENAI_CHAT_URL,
-			match: filter ? (body) => matchesChatFilter(body, filter) : void 0,
-			wrap: buildChatReply
-		};
-	},
-	agent(filter, url) {
-		return {
-			adapter: "openai",
-			method: "POST",
-			url: url ?? OPENAI_RESPONSES_URL,
-			match: filter ? (body) => matchesResponsesFilter(body, filter) : void 0,
-			wrap: buildResponsesReply
-		};
-	},
-	reply: buildChatReply,
-	error(status, message) {
-		return {
-			status,
-			body: { error: {
-				message: message ?? `OpenAI error (${status})`,
-				type: status === 429 ? "rate_limit_error" : "api_error",
-				code: status === 429 ? "rate_limit_exceeded" : null
-			} }
-		};
-	},
-	malformed(content) {
-		return buildChatReply(content);
-	},
-	timeout() {
-		return {
-			status: 200,
-			body: {},
-			delay: 3e4
-		};
-	},
-	chat(filter) {
-		return openai.request(filter);
-	},
-	response: buildChatReply,
-	responses(filter, url) {
-		return openai.agent(filter, url);
-	},
-	responsesResponse: buildResponsesReply
-};
 //#endregion
-export { anthropic, http, openai };
-
-//# sourceMappingURL=intercept.js.map
+export { registerIntercepts };

package/dist/match.js

@@ -0,0 +1,153 @@
+//#region src/core/matching/match.ts
+/** Every kind usable as a `{{token}}` in fixture files (all but ref/regex). */
+const TOKEN_KINDS = [
+	"any",
+	"base64",
+	"date",
+	"duration",
+	"email",
+	"float",
+	"hex",
+	"int",
+	"ip",
+	"iso8601",
+	"number",
+	"path",
+	"port",
+	"semver",
+	"sha",
+	"string",
+	"time",
+	"ulid",
+	"url",
+	"uuid",
+	"workdir"
+];
+/**
+* A dynamic-value matcher. Created via the {@link match} factories — never
+* constructed directly by user code.
+*/
+var Matcher = class {
+	kind;
+	/** For kind 'ref': the capture to assert inequality against. */
+	notRef;
+	/** For kind 'ref': the capture name. */
+	refName;
+	/** For kind 'regex': the pattern the actual value must match. */
+	regex;
+	constructor(kind, options = {}) {
+		this.kind = kind;
+		this.notRef = options.notRef;
+		this.refName = options.refName;
+		this.regex = options.regex;
+	}
+	/** Placeholder-style rendering used in failure diffs and serialization. */
+	toString() {
+		switch (this.kind) {
+			case "ref": return this.notRef ? `{{ref#${this.refName}!${this.notRef}}}` : `{{ref#${this.refName}}}`;
+			case "regex": return `{{regex:${this.regex?.source}}}`;
+			default: return this.refName ? `{{${this.kind}#${this.refName}}}` : `{{${this.kind}}}`;
+		}
+	}
+	toJSON() {
+		return this.toString();
+	}
+};
+const typed = (kind) => () => new Matcher(kind);
+/**
+* Dynamic-value matchers for structural comparisons — the code-side mirror of
+* the `{{token}}` fixture grammar (CONVENTIONS D4).
+*
+* @example
+*   await expect(result.table('users', { database: 'db' })).toMatchRows({
+*       columns: ['id', 'name'],
+*       rows: [[match.uuid(), 'Alice']],
+*   });
+*/
+const match = {
+	/** Matches anything. */
+	any: typed("any"),
+	/** Matches a base64 string. */
+	base64: typed("base64"),
+	/** Matches a calendar date (`YYYY-MM-DD`). */
+	date: typed("date"),
+	/** Matches a human duration (`12ms`, `1.5s`, `2m`, `3h`). */
+	duration: typed("duration"),
+	/** Matches an email address. */
+	email: typed("email"),
+	/**
+	* Matches a float. In JSON contexts any finite number passes (JSON does
+	* not distinguish `42` from `42.0`); in text contexts the decimal part
+	* is required (`4.2`, never `42`).
+	*/
+	float: typed("float"),
+	/** Matches a hexadecimal string. */
+	hex: typed("hex"),
+	/** Matches an integer (or an integer string in text contexts). */
+	int: typed("int"),
+	/** Matches an IPv4 address. */
+	ip: typed("ip"),
+	/** Matches an ISO-8601 timestamp string. */
+	iso8601: typed("iso8601"),
+	/** Matches a number (or a numeric string in text contexts). */
+	number: typed("number"),
+	/** Matches a filesystem path (`/...` or `./...`). */
+	path: typed("path"),
+	/** Matches a TCP/UDP port number (0-65535). */
+	port: typed("port"),
+	/**
+	* Capture-and-compare. The first occurrence of `ref(name)` captures the
+	* actual value; every later occurrence must strictly equal the capture.
+	* `{ not: other }` additionally asserts inequality with the capture named
+	* `other`. Scope: the current spec execution (reset per chain).
+	*/
+	ref: (name, options) => new Matcher("ref", {
+		notRef: options?.not,
+		refName: name
+	}),
+	/** Matches a string against the given regular expression. */
+	regex: (regex) => new Matcher("regex", { regex }),
+	/** Matches a semantic version (`1.2.3`, `2.0.0-rc.1`). */
+	semver: typed("semver"),
+	/** Matches a git SHA (7-64 hex chars). */
+	sha: typed("sha"),
+	/** Matches any string. */
+	string: typed("string"),
+	/** Matches a wall-clock time (`HH:MM` or `HH:MM:SS`). */
+	time: typed("time"),
+	/** Matches a ULID. */
+	ulid: typed("ulid"),
+	/** Matches an http(s) URL. */
+	url: typed("url"),
+	/** Matches a UUID string. */
+	uuid: typed("uuid"),
+	/** Matches the exact working directory of the current spec. */
+	workdir: typed("workdir")
+};
+/**
+* Named captures recorded by `match.ref()` / `{{type#ref}}` placeholders.
+* One scope lives on each spec result — every assertion chained off the same
+* result shares it, and a new chain starts fresh.
+*/
+var CaptureScope = class {
+	values = /* @__PURE__ */ new Map();
+	/**
+	* The exact working directory of the current spec, when the framework
+	* knows it (cli mode). Drives the `{{workdir}}` token / `match.workdir()`.
+	*/
+	workdir;
+	constructor(workdir) {
+		this.workdir = workdir;
+	}
+	get(name) {
+		return this.values.get(name);
+	}
+	has(name) {
+		return this.values.has(name);
+	}
+	set(name, value) {
+		this.values.set(name, value);
+	}
+};
+//#endregion
+export { match as i, Matcher as n, TOKEN_KINDS as r, CaptureScope as t };