@systemfsoftware/xstate-test 0.0.0-stage → 2.0.0-beta.2

package/dist/playwright.mjs

@@ -0,0 +1,287 @@
+import { t as ensuringFinalizerWins } from "./finalizerError-DOptAIDs.mjs";
+import { dual } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Data from "effect/Data";
+// src/playwright.ts
+/**
+* Awaits `value` as an Effect. A value and a thenable are both accepted, and a
+* rejection stays the same error object when the effect is run.
+*/
+const awaited = (value) => Effect.promise(() => Promise.resolve(value));
+/** The fixture document a failed run stores next to its artifacts. */
+const fixtureJson = (fixture) => JSON.stringify(fixture, null, 2);
+/**
+* Thrown by a session's `check()` when a page-level oracle fails.
+*
+* @experimental
+*/
+const PlaywrightOracleErrorBase = Data.TaggedError("@systemfsoftware/xstate-test/playwright/PlaywrightOracleError");
+var PlaywrightOracleError = class extends PlaywrightOracleErrorBase {
+	messages;
+	name = "PlaywrightOracleError";
+	constructor(messages) {
+		super({
+			message: `The page reported ${messages.length} error${messages.length === 1 ? "" : "s"}:\n${messages.map((message) => `  - ${message}`).join("\n")}`,
+			cause: messages
+		});
+		this.messages = messages;
+	}
+};
+const DEFAULT_ORACLES = {
+	pageError: true,
+	console: "error",
+	http: 400,
+	unhandledRejection: true
+};
+/** Marks the console messages the rejection listener writes. */
+const REJECTION_PREFIX = "[xstate-test] unhandledrejection: ";
+const REJECTION_SCRIPT = `window.addEventListener('unhandledrejection', function (event) {
+  var reason = event.reason;
+  console.error(${JSON.stringify(REJECTION_PREFIX)} + (reason && reason.message ? reason.message : String(reason)));
+});`;
+function resolveOracles(oracles) {
+	if (oracles === false) return;
+	if (oracles === void 0 || oracles === "defaults") return DEFAULT_ORACLES;
+	return {
+		pageError: oracles.pageError ?? false,
+		console: oracles.console ?? false,
+		http: oracles.http ?? false,
+		unhandledRejection: oracles.unhandledRejection ?? false
+	};
+}
+function formatStepName(event) {
+	const { type, ...payload } = event;
+	return Object.keys(payload).length !== 0 ? `${type} ${JSON.stringify(payload)}` : type;
+}
+function defaultCaseOf(event) {
+	const explicit = event.case;
+	return typeof explicit === "string" ? explicit : event.type;
+}
+/**
+* Wraps a page so every `route()` a mock installs is recorded and can be
+* removed again when another case's mock is applied or the session is disposed.
+*/
+function trackRoutes(page, installed, mockedRequests) {
+	if (typeof page.route !== "function") return page;
+	return new Proxy(page, { get(target, property, receiver) {
+		const value = Reflect.get(target, property, receiver);
+		if (typeof value !== "function") return value;
+		if (property === "route") return (url, handler, ...rest) => {
+			const args = [
+				url,
+				typeof handler === "function" ? (route, ...more) => {
+					const request = more[0] ?? route?.request?.();
+					if (request !== void 0 && request !== null && typeof request === "object") mockedRequests.add(request);
+					return handler(route, ...more);
+				} : handler,
+				...rest
+			];
+			installed.push(args);
+			return value.apply(target, args);
+		};
+		return value.bind(target);
+	} });
+}
+/** Removes every route a mock installed through {@link trackRoutes}. */
+function releaseRoutes(page, installed) {
+	return Effect.runPromise(Effect.gen(function* () {
+		const unroute = page.unroute;
+		if (typeof unroute === "function") for (const args of installed) yield* awaited(unroute.call(page, args[0], args[1]));
+		installed.length = 0;
+	}));
+}
+/**
+* Resolves the mock for a generated event case, trying `"<type>.<case>"`, then
+* `"<case>"`, then the case resolved by `caseOf`.
+*/
+function resolveMock(mocks, eventCase, fallbackCase) {
+	if (mocks === void 0) return;
+	const keys = [...eventCase !== void 0 ? [`${eventCase.type}.${eventCase.name}`, eventCase.name] : [], ...fallbackCase === void 0 ? [] : [fallbackCase]];
+	for (const key of keys) {
+		const mock = mocks[key];
+		if (mock !== void 0) return {
+			key,
+			mock
+		};
+	}
+}
+function sanitizeLabel(label) {
+	return label.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+/**
+* Creates a `TestSut` that drives a Playwright page as the system under
+* test for `propertyTest()` and `testPaths()`.
+*
+* @experimental
+*/
+const createPlaywrightSut = dual(2, function createPlaywrightSut(page, config) {
+	const caseOf = config.caseOf ?? defaultCaseOf;
+	const screenshotDir = config.screenshotDir ?? "property-screenshots";
+	const testInfo = config.testInfo;
+	const trace = config.trace ?? (testInfo !== void 0 ? "retain-on-failure" : "off");
+	const screenshots = config.screenshots ?? (testInfo !== void 0 ? "on-failure" : "off");
+	if (testInfo === void 0 && (trace !== "off" || screenshots !== "off")) throw new Error("`trace` and `screenshots` attach their files to `testInfo`; pass Playwright's `testInfo` fixture to `createPlaywrightSut()`.");
+	const oracles = resolveOracles(config.oracles);
+	let rejectionScriptInstalled = false;
+	let lastFailure;
+	let lastPassingTrace;
+	return {
+		...config.projectModel !== void 0 ? { projectModel: config.projectModel } : {},
+		...config.projectSut !== void 0 ? { projectSut: config.projectSut } : {},
+		...config.equivalent !== void 0 ? { equivalent: config.equivalent } : {},
+		create: (_context) => {
+			const collected = [];
+			const mockedRequests = /* @__PURE__ */ new WeakSet();
+			const listeners = [];
+			const installRejectionScript = oracles !== void 0 && oracles.unhandledRejection && !rejectionScriptInstalled;
+			if (installRejectionScript) rejectionScriptInstalled = true;
+			if (oracles !== void 0 && typeof page.on === "function") {
+				listeners.push(["pageerror", (error) => {
+					if (oracles.pageError) collected.push(`pageerror: ${error instanceof Error ? error.message : String(error)}`);
+				}], ["console", (message) => {
+					const text = message.text();
+					if (text.startsWith(REJECTION_PREFIX)) {
+						if (oracles.unhandledRejection) collected.push(`unhandledrejection: ${text.slice(34)}`);
+						return;
+					}
+					const type = message.type();
+					if (type === "error" && oracles.console !== false || type === "warning" && oracles.console === "warn") collected.push(`console.${type}: ${text}`);
+				}], ["response", (response) => {
+					if (oracles.http === false || response.status() < oracles.http || mockedRequests.has(response.request())) return;
+					collected.push(`HTTP ${response.status()} ${response.request().method()} ${response.url()}`);
+				}]);
+				for (const [event, listener] of listeners) page.on(event, listener);
+			}
+			const tracing = trace === "off" ? void 0 : page.context?.().tracing;
+			const startTracing = tracing?.start;
+			const session = {
+				tracingStarted: false,
+				appliedCase: void 0,
+				checkpoints: 0
+			};
+			const setupSession = () => Effect.gen(function* () {
+				if (installRejectionScript) yield* awaited(page.addInitScript?.(REJECTION_SCRIPT));
+				if (startTracing !== void 0) yield* Effect.ignoreCause(Effect.gen(function* () {
+					yield* awaited(startTracing({
+						screenshots: true,
+						snapshots: true
+					}));
+					session.tracingStarted = true;
+				}));
+				yield* awaited(config.reset?.(page));
+				return session;
+			});
+			const createSession = (setup) => {
+				const stepScreenshots = [];
+				const installedRoutes = [];
+				const mockPage = trackRoutes(page, installedRoutes, mockedRequests);
+				return {
+					send: (event, context) => Effect.runPromise(Effect.gen(function* () {
+						const resolved = resolveMock(config.mocks, context?.case, caseOf(event));
+						if (resolved !== void 0 && resolved.key !== setup.appliedCase) {
+							yield* awaited(releaseRoutes(page, installedRoutes));
+							yield* awaited(resolved.mock(mockPage));
+							setup.appliedCase = resolved.key;
+						}
+						const action = config.events[event.type];
+						if (action === void 0) throw new Error(`No Playwright action configured for event "${event.type}"`);
+						if (config.step !== void 0) {
+							yield* awaited(config.step(formatStepName(event), () => Promise.resolve(action(page, event))));
+							return;
+						}
+						yield* awaited(action(page, event));
+					})),
+					...config.read !== void 0 ? { read: () => config.read(page) } : {},
+					...config.states !== void 0 ? { states: Object.fromEntries(Object.entries(config.states).map(([key, assertion]) => [key, (snapshot) => assertion(page, snapshot)])) } : {},
+					settle: () => Effect.runPromise(Effect.gen(function* () {
+						if (config.settle !== void 0) {
+							yield* awaited(config.settle(page));
+							return;
+						}
+						yield* awaited(page.waitForLoadState?.("load"));
+						yield* Effect.callback((resume) => {
+							queueMicrotask(() => resume(Effect.void));
+						});
+					})),
+					check: () => Effect.runPromise(Effect.gen(function* () {
+						if (screenshots === "every-step") {
+							const shot = yield* awaited(page.screenshot?.());
+							if (shot !== void 0 && shot !== null) stepScreenshots.push(shot);
+						}
+						if (collected.length !== 0) throw new PlaywrightOracleError(collected.splice(0));
+					})),
+					advance: (milliseconds) => Effect.runPromise(Effect.gen(function* () {
+						if (config.advance !== void 0) return yield* awaited(config.advance(page, milliseconds));
+						yield* awaited(page.clock?.runFor?.(milliseconds));
+						return [];
+					})),
+					checkpoint: (label) => Effect.runPromise(Effect.gen(function* () {
+						const resolved = label ?? `checkpoint-${setup.checkpoints}`;
+						setup.checkpoints++;
+						if (config.checkpoint !== void 0) {
+							yield* awaited(config.checkpoint(page, resolved));
+							return;
+						}
+						yield* awaited(page.screenshot?.({ path: `${screenshotDir}/${sanitizeLabel(resolved)}.png` }));
+					})),
+					...config.stop !== void 0 ? { stop: () => config.stop(page) } : {},
+					dispose: ({ passed }) => Effect.runPromise(ensuringFinalizerWins(Effect.gen(function* () {
+						for (const [event, listener] of listeners) page.off?.(event, listener);
+						if (!passed) {
+							const screenshot = screenshots === "on-failure" ? yield* awaited(page.screenshot?.()) : void 0;
+							let tracePath;
+							if (setup.tracingStarted) {
+								tracePath = testInfo.outputPath("xstate-test-failure-trace.zip");
+								yield* awaited(tracing.stop({ path: tracePath }));
+							}
+							lastFailure = {
+								...tracePath !== void 0 ? { trace: tracePath } : {},
+								...screenshot !== void 0 && screenshot !== null ? { screenshot } : {},
+								steps: stepScreenshots.slice()
+							};
+						} else if (setup.tracingStarted) {
+							if (trace === "on") {
+								lastPassingTrace = testInfo.outputPath("xstate-test-trace.zip");
+								yield* awaited(tracing.stop({ path: lastPassingTrace }));
+							} else yield* awaited(tracing.stop());
+						}
+						yield* awaited(releaseRoutes(page, installedRoutes));
+					}), Effect.promise(() => Promise.resolve(config.dispose?.(page)))))
+				};
+			};
+			return Effect.runPromise(Effect.map(setupSession(), createSession));
+		},
+		complete: ({ passed, failure }) => Effect.runPromise(Effect.gen(function* () {
+			const artifacts = lastFailure;
+			const passingTrace = lastPassingTrace;
+			lastFailure = void 0;
+			lastPassingTrace = void 0;
+			if (testInfo === void 0) return;
+			if (passed) {
+				if (passingTrace !== void 0) yield* awaited(testInfo.attach("trace", {
+					path: passingTrace,
+					contentType: "application/zip"
+				}));
+				return;
+			}
+			const fixture = failure?.fixture;
+			if (fixture !== void 0) yield* awaited(testInfo.attach("fixture.json", {
+				body: fixtureJson(fixture),
+				contentType: "application/json"
+			}));
+			if (artifacts?.trace !== void 0) yield* awaited(testInfo.attach("trace", {
+				path: artifacts.trace,
+				contentType: "application/zip"
+			}));
+			if (artifacts?.screenshot !== void 0) yield* awaited(testInfo.attach("failure.png", {
+				body: artifacts.screenshot,
+				contentType: "image/png"
+			}));
+			for (const [index, shot] of (artifacts?.steps ?? []).entries()) yield* awaited(testInfo.attach(`step-${index}.png`, {
+				body: shot,
+				contentType: "image/png"
+			}));
+		}))
+	};
+});
+export { PlaywrightOracleError, createPlaywrightSut };