@jterrazz/test 15.1.1 → 15.2.0

package/dist/intercept.js

@@ -1,101 +1,151 @@
 import { t as ContractQueue } from "./queue.js";
-//#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");
-	}
-	return {
-		node: mswModule,
-		msw: mswHttp
-	};
-}
-let serverInstance = null;
+//#region src/integrations/msw/handlers.ts
 /**
-* Start the MSW server (once per process).
+* What a chain with zero contracts gets where the facet's scope is KNOWN but
+* not total — the node engine, which shares a process with everything else the
+* test does. Nothing was declared, so nothing is guarded and nothing has to be
+* torn down (CONVENTIONS D7, known scope).
 */
-async function ensureContractServer() {
-	if (serverInstance) return;
-	const { node } = await loadMsw();
-	serverInstance = node.setupServer();
-	serverInstance.listen({ onUnhandledRequest: "bypass" });
-}
-/** Turn a contract response into the MSW reply, body kind by body kind. */
+const NO_CONTRACTS = {
+	cleanup: () => {},
+	violation: () => null
+};
+/**
+* A contract answers the request that was made, never a copy of an earlier one.
+*
+* In a page the reply travels through a real service worker and a real HTTP
+* cache, so a second render of the same component can be served the FIRST
+* test's answer and never reach the queue at all — a contract that was
+* exhausted, or replaced, silently keeps answering. Stated as a default, so a
+* spec whose subject IS caching can still say otherwise.
+*/
+const NEVER_CACHED = { "cache-control": "no-store" };
+/** Turn a contract response into the msw reply, body kind by body kind. */
 function toMswResponse(msw, response) {
 	const { body, headers, status = 200 } = response;
+	if (response.transport === "network-error") return msw.HttpResponse.error();
 	if (body === null || body === void 0) return new msw.HttpResponse(null, {
-		headers,
+		headers: {
+			...NEVER_CACHED,
+			...headers
+		},
 		status
 	});
 	if (typeof body === "string") return new msw.HttpResponse(body, {
 		headers: {
+			...NEVER_CACHED,
 			"content-type": "text/plain; charset=utf-8",
 			...headers
 		},
 		status
 	});
 	return msw.HttpResponse.json(body, {
-		headers,
+		headers: {
+			...NEVER_CACHED,
+			...headers
+		},
 		status
 	});
 }
 /**
-* 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).
+* The handlers one chain's contracts become, plus the trailing catch-all that
+* records any request no contract accepted (CONVENTIONS D7). The caller decides
+* what to do with the recorded violation — the api chain rethrows it, the
+* component chain fails the render. An EMPTY contract list is still a guard:
+* the catch-all alone says "this subject has no network".
+*
+* `bypass` names the traffic that is not the subject's: under node there is
+* none, in a page it is everything the runner fetches to BE a page.
 */
-async function registerContracts(contracts) {
-	if (contracts.length === 0) return {
-		cleanup: () => {},
-		violation: () => null
-	};
-	await ensureContractServer();
-	const { msw } = await loadMsw();
+function buildContractHandlers(msw, contracts, bypass) {
 	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 contracts: unmatched request ${method} ${url}` }, { status: 501 });
+		return msw.HttpResponse.json({ error: `@jterrazz/test strict contracts: unmatched request ${method} ${url}` }, {
+			headers: NEVER_CACHED,
+			status: 501
+		});
 	};
 	const handlers = [];
 	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(route.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,
-				method: request.method.toUpperCase(),
-				url: request.url
-			};
+		handlers.push(handlerFn(route.url, async ({ request }) => {
+			const observed = await observe(request);
 			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));
+			if (response.delay) await new Promise((resolve) => setTimeout(resolve, response.delay));
 			return toMswResponse(msw, response);
-		});
-		handlers.push(handler);
+		}));
 	}
-	handlers.push(msw.http.all("*", ({ request }) => recordViolation(request.method, request.url)));
+	handlers.push(msw.http.all("*", ({ request }) => bypass?.(request.url) === true ? msw.passthrough() : recordViolation(request.method, request.url)));
+	return {
+		handlers,
+		violation: () => violation ?? queue.requiredError()
+	};
+}
+/** The request as the queue matches it — body parsed when it is JSON. */
+async function observe(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;
+	});
+	return {
+		body,
+		headers,
+		method: request.method.toUpperCase(),
+		url: request.url
+	};
+}
+//#endregion
+//#region src/integrations/msw/intercept.ts
+let mswModule = null;
+let mswHttp = null;
+async function loadMsw() {
+	if (mswModule === null) {
+		mswModule = await import("msw/node");
+		mswHttp = await import("msw");
+	}
+	return {
+		msw: mswHttp,
+		node: mswModule
+	};
+}
+let serverInstance = null;
+/**
+* Start the MSW server (once per process).
+*/
+async function ensureContractServer() {
+	if (serverInstance !== null) return;
+	const { node } = await loadMsw();
+	serverInstance = node.setupServer();
+	serverInstance.listen({ onUnhandledRequest: "bypass" });
+}
+/**
+* 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 registerContracts(contracts) {
+	if (contracts.length === 0) return NO_CONTRACTS;
+	await ensureContractServer();
+	const { msw } = await loadMsw();
+	const { handlers, violation } = buildContractHandlers(msw, contracts);
 	serverInstance.use(...handlers);
 	return {
 		cleanup: () => {
 			serverInstance.resetHandlers();
 		},
-		violation: () => violation ?? queue.requiredError()
+		violation
 	};
 }
 //#endregion