@jterrazz/test 10.0.0 → 11.0.0

package/dist/intercept.js

@@ -1,3 +1,4 @@
+import { t as ContractQueue } from "./queue.js";
 //#region src/integrations/msw/intercept.ts
 let mswModule = null;
 let mswHttp = null;
@@ -15,100 +16,54 @@ let serverInstance = null;
 /**
 * Start the MSW server (once per process).
 */
-async function ensureInterceptServer() {
+async function ensureContractServer() {
 	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)}`;
-}
-/**
-* 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.
-*/
-var InterceptQueue = class {
-	consumed;
-	entries;
-	constructor(entries) {
-		this.entries = entries;
-		this.consumed = entries.map(() => 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()];
-	}
-	/** 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];
-	}
-	/**
-	* 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;
-	}
-	/**
-	* 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).`);
-	}
-};
-function sameUrl(a, b) {
-	return a === b || String(a) === String(b);
+/** Turn a contract response into the MSW reply, body kind by body kind. */
+function toMswResponse(msw, response) {
+	const { body, headers, status = 200 } = response;
+	if (body === null || body === void 0) return new msw.HttpResponse(null, {
+		headers,
+		status
+	});
+	if (typeof body === "string") return new msw.HttpResponse(body, {
+		headers: {
+			"content-type": "text/plain; charset=utf-8",
+			...headers
+		},
+		status
+	});
+	return msw.HttpResponse.json(body, {
+		headers,
+		status
+	});
 }
 /**
-* 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).
+* Register a chain's contracts as MSW handlers. A trailing catch-all handler
+* records any request no contract 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 {
+async function registerContracts(contracts) {
+	if (contracts.length === 0) return {
 		cleanup: () => {},
 		violation: () => null
 	};
-	await ensureInterceptServer();
+	await ensureContractServer();
 	const { msw } = await loadMsw();
-	const queue = new InterceptQueue(entries);
+	const queue = new ContractQueue(contracts);
 	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 });
+		return msw.HttpResponse.json({ error: `@jterrazz/test strict contracts: unmatched request ${method} ${url}` }, { status: 501 });
 	};
 	const handlers = [];
-	for (const url of queue.urls) for (const method of queue.methodsFor(url)) {
+	for (const route of queue.routes) for (const method of route.methods) {
 		const handlerFn = method === "*" ? msw.http.all : msw.http[method.toLowerCase()];
 		if (!handlerFn) continue;
-		const handler = handlerFn(url, async ({ request }) => {
+		const handler = handlerFn(route.url, async ({ request }) => {
 			let body = null;
 			const rawText = await request.clone().text();
 			if (rawText) try {
@@ -123,16 +78,14 @@ async function registerIntercepts(entries) {
 			const observed = {
 				body,
 				headers,
+				method: request.method.toUpperCase(),
 				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;
+			const contract = queue.take(observed);
+			if (!contract) return recordViolation(request.method, request.url);
+			const response = typeof contract.response === "function" ? contract.response(observed) : contract.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
-			});
+			return toMswResponse(msw, response);
 		});
 		handlers.push(handler);
 	}
@@ -142,8 +95,8 @@ async function registerIntercepts(entries) {
 		cleanup: () => {
 			serverInstance.resetHandlers();
 		},
-		violation: () => violation
+		violation: () => violation ?? queue.requiredError()
 	};
 }
 //#endregion
-export { registerIntercepts };
+export { registerContracts };

package/dist/match.js

@@ -1,5 +1,5 @@
 //#region src/core/matching/match.ts
-/** Every kind usable as a `{{token}}` in fixture files (all but ref/regex). */
+/** Every kind usable as a `{{token}}` in fixture files (all but ref/regex/includes). */
 const TOKEN_KINDS = [
 	"any",
 	"base64",
@@ -28,6 +28,8 @@ const TOKEN_KINDS = [
 * constructed directly by user code.
 */
 var Matcher = class {
+	/** For kind 'includes': the substring the actual value must contain. */
+	includes;
 	kind;
 	/** For kind 'ref': the capture to assert inequality against. */
 	notRef;
@@ -36,6 +38,7 @@ var Matcher = class {
 	/** For kind 'regex': the pattern the actual value must match. */
 	regex;
 	constructor(kind, options = {}) {
+		this.includes = options.includes;
 		this.kind = kind;
 		this.notRef = options.notRef;
 		this.refName = options.refName;
@@ -44,6 +47,7 @@ var Matcher = class {
 	/** Placeholder-style rendering used in failure diffs and serialization. */
 	toString() {
 		switch (this.kind) {
+			case "includes": return `{{includes:${this.includes}}}`;
 			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}}}`;
@@ -83,6 +87,13 @@ const match = {
 	float: typed("float"),
 	/** Matches a hexadecimal string. */
 	hex: typed("hex"),
+	/**
+	* Matches a string CONTAINING the given substring. Code-only, like
+	* {@link match.regex} — the `{{token}}` fixture vocabulary does not grow.
+	* The explicit escape hatch now that contract string filters
+	* (`openai.chat({ user })`) mean exact equality.
+	*/
+	includes: (substring) => new Matcher("includes", { includes: substring }),
 	/** Matches an integer (or an integer string in text contexts). */
 	int: typed("int"),
 	/** Matches an IPv4 address. */