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

package/dist/vitest.d.ts

@@ -0,0 +1,74 @@
+import { a as propertyTest, o as testPaths } from "./propertyTest-BHnBV8ax.js";
+import { ActorLogic } from "@systemfsoftware/xstate";
+import { TestAPI } from "vitest";
+type Source = ActorLogic<any, any, any>;
+/**
+ * A Vitest-compatible `it` or `test`: `(name, fn, timeout?) => void`.
+ *
+ * @experimental
+ */
+export type ModelTestBase = (name: string, fn: (context: any) => Promise<void>, timeout?: number) => unknown;
+/**
+ * What an expected failure must look like. See `it.model.fails`.
+ *
+ * @experimental
+ */
+export interface ModelTestFailureExpectation {
+  /** A substring of, or a pattern matching, the failure message. */
+  readonly message?: string | RegExp;
+}
+/** @experimental */
+export interface ModelTestFunction {
+  /**
+   * Registers a test that runs `propertyTest(source, options)`. Failures are
+   * saved under the test file and name, and replayed first on the next run.
+   * On failure, the coverage report is printed.
+   */
+  <TSource extends Source>(name: string, source: TSource, options: Parameters<typeof propertyTest<TSource>>[1], timeout?: number): void;
+  /**
+   * Registers a test that passes only when `propertyTest(source, options)`
+   * fails, and its message matches `expected.message`.
+   */
+  fails<TSource extends Source>(name: string, source: TSource, options: Parameters<typeof propertyTest<TSource>>[1], expected?: ModelTestFailureExpectation): void;
+}
+/** @experimental */
+export interface PathsTestFunction {
+  /** Registers a test that runs `testPaths(source, options)`. */
+  <TSource extends Source>(name: string, source: TSource, options?: Parameters<typeof testPaths<TSource>>[1], timeout?: number): void;
+}
+/**
+ * The members `withModelTests()` adds to `it` or `test`.
+ *
+ * @experimental
+ */
+export interface ModelTestAPI {
+  readonly model: ModelTestFunction;
+  readonly paths: PathsTestFunction;
+}
+/**
+ * Adds `model` and `paths` to a Vitest `it` or `test`:
+ *
+ * ```ts
+ * import { it as vitestIt } from 'vitest';
+ * import { withModelTests } from '@systemfsoftware/xstate-test/vitest';
+ *
+ * const it = withModelTests(vitestIt);
+ * it.model('the cart matches the model', cartMachine, { sut });
+ * ```
+ *
+ * @experimental
+ */
+export declare function withModelTests<TBase extends ModelTestBase>(base: TBase): TBase & ModelTestAPI;
+/**
+ * Vitest's global `it`, with `it.model` and `it.paths`.
+ *
+ * @experimental
+ */
+export declare const it: TestAPI & ModelTestAPI;
+/**
+ * Vitest's global `test`, with `test.model` and `test.paths`.
+ *
+ * @experimental
+ */
+export declare const test: TestAPI & ModelTestAPI;
+export {};

package/dist/vitest.mjs

@@ -0,0 +1,139 @@
+import { C as consoleLineLogger, O as testCoverageToJSON, n as propertyTest, r as testPaths, w as formatTestCoverage } from "./propertyTest-5bO0RsUu.mjs";
+import * as Effect from "effect/Effect";
+import * as Cause from "effect/Cause";
+import * as Logger from "effect/Logger";
+// src/vitest.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));
+function getTestKey(context) {
+	const names = [context.task.name];
+	for (let suite = context.task.suite; suite; suite = suite.suite) if (suite.name.length > 0) names.unshift(suite.name);
+	return [context.task.file?.name, ...names].filter(Boolean).join(" > ");
+}
+/**
+* Keys the failure database by the test, unless `failures` is `false`, a
+* custom store, or sets its own `key`.
+*/
+function withTestFailures(options, context) {
+	const failures = options.failures;
+	if (failures === false) return options;
+	if (failures !== void 0 && typeof failures === "object" && ("load" in failures || failures.key !== void 0)) return options;
+	return {
+		...options,
+		failures: {
+			...typeof failures === "object" ? failures : {},
+			key: getTestKey(context)
+		}
+	};
+}
+/** The test timeout for a campaign bounded by `until: { timeMs }`. */
+function getTimeout(options, timeout) {
+	if (timeout !== void 0) return timeout;
+	const until = options?.until;
+	return typeof until === "object" && typeof until.timeMs === "number" ? until.timeMs + 5e3 : void 0;
+}
+function getCoverage(error) {
+	return error?.coverage;
+}
+function attachCoverage(context, coverage) {
+	if (coverage !== void 0) context.task.meta["xstateTestCoverage"] = testCoverageToJSON(coverage);
+}
+function getMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function matchesExpectation(error, expected) {
+	const pattern = expected?.message;
+	if (pattern === void 0) return true;
+	const message = getMessage(error);
+	return typeof pattern === "string" ? message.includes(pattern) : pattern.test(message);
+}
+/**
+* Adds `model` and `paths` to a Vitest `it` or `test`:
+*
+* ```ts
+* import { it as vitestIt } from 'vitest';
+* import { withModelTests } from '@systemfsoftware/xstate-test/vitest';
+*
+* const it = withModelTests(vitestIt);
+* it.model('the cart matches the model', cartMachine, { sut });
+* ```
+*
+* @experimental
+*/
+function withModelTests(base) {
+	return withModelAPI(() => base);
+}
+/**
+* A callable that forwards everything to the base `it`, plus `model` and
+* `paths`. The base is not modified.
+*/
+function withModelAPI(resolve) {
+	const api = createModelTestAPI(resolve);
+	return new Proxy(function() {}, {
+		apply: (_target, thisArg, args) => Reflect.apply(resolve(), thisArg, args),
+		get: (_target, property) => property === "model" || property === "paths" ? api[property] : Reflect.get(resolve(), property)
+	});
+}
+function createModelTestAPI(getBase) {
+	const run = (context, campaign) => Effect.runPromise(Effect.onError(Effect.gen(function* () {
+		const { coverage } = yield* awaited(campaign());
+		attachCoverage(context, coverage);
+	}), (cause) => {
+		const coverage = getCoverage(Cause.squash(cause));
+		attachCoverage(context, coverage);
+		if (coverage !== void 0) Effect.runSync(Effect.log(formatTestCoverage(coverage)).pipe(Effect.provide(Logger.layer([consoleLineLogger]))));
+		return Effect.void;
+	}));
+	const model = ((name, source, options, timeout) => {
+		getBase()(name, (context) => run(context, () => propertyTest(source, withTestFailures(options, context))), getTimeout(options, timeout));
+	});
+	model.fails = (name, source, options, expected) => {
+		getBase()(name, (context) => Effect.runPromise(Effect.gen(function* () {
+			const outcome = yield* Effect.catchCause(Effect.gen(function* () {
+				const { coverage } = yield* awaited(propertyTest(source, withTestFailures(options, context)));
+				attachCoverage(context, coverage);
+				return { failed: false };
+			}), (cause) => {
+				const error = Cause.squash(cause);
+				attachCoverage(context, getCoverage(error));
+				return Effect.succeed({
+					failed: true,
+					error
+				});
+			});
+			if (!outcome.failed) throw new Error(`Expected "${name}" to fail, but the campaign passed.`);
+			if (!matchesExpectation(outcome.error, expected)) throw new Error(`Expected "${name}" to fail with a message matching ${String(expected.message)}, but it failed with:\n${getMessage(outcome.error)}`, { cause: outcome.error });
+		})), getTimeout(options, void 0));
+	};
+	const paths = (name, source, options, timeout) => {
+		getBase()(name, (context) => run(context, () => testPaths(source, withTestFailures(options ?? {}, context))), getTimeout(options, timeout));
+	};
+	return {
+		model,
+		paths
+	};
+}
+/** A global `it` or `test`, resolved when it is first used. */
+function fromGlobal(name) {
+	return withModelAPI(() => {
+		const base = globalThis[name];
+		if (typeof base !== "function") throw new Error(`\`${name}\` from @xstate/test/vitest uses Vitest's global \`${name}\`, which is not defined. Set \`test.globals: true\` in the Vitest config, or wrap Vitest's own: \`withModelTests(${name})\`.`);
+		return base;
+	});
+}
+/**
+* Vitest's global `it`, with `it.model` and `it.paths`.
+*
+* @experimental
+*/
+const it = fromGlobal("it");
+/**
+* Vitest's global `test`, with `test.model` and `test.paths`.
+*
+* @experimental
+*/
+const test = fromGlobal("test");
+export { it, test, withModelTests };

package/package.json

@@ -1,10 +1,91 @@
 {
   "name": "@systemfsoftware/xstate-test",
-  "version": "0.0.0-bootstrap.0",
-  "description": "Reserved for trusted publishing from github.com/systemfsoftware/xstate.",
+  "license": "MIT",
+  "version": "2.0.0-beta.2",
+  "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/systemfsoftware/xstate.git"
+    "url": "git+https://github.com/systemfsoftware/xstate.git",
+    "directory": "packages/xstate-test"
   },
-  "license": "Apache-2.0"
-}
+  "homepage": "https://github.com/systemfsoftware/xstate/tree/main/packages/xstate-test#readme",
+  "bugs": "https://github.com/systemfsoftware/xstate/issues",
+  "description": "Model-based testing for XState machines — forked under systemfsoftware from statelyai/xstate (@xstate/test at 2146ae26).",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@systemfsoftware/xstate": "^6.0.0-beta.65",
+    "effect": "^4.1.0",
+    "fast-check": "^4",
+    "vitest": "^5",
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "effect": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@effect/tsgo": "0.64.1",
+    "@microsoft/api-extractor": "7.59.1",
+    "@playwright/test": "1.63.0",
+    "@systemfsoftware/arethetypeswrong-cli": "file:../../.deps/arethetypeswrong-cli.tgz",
+    "@systemfsoftware/tsconfig": "file:../../.deps/tsconfig.tgz",
+    "@systemfsoftware/vitest": "file:../../.deps/vitest.tgz",
+    "@systemfsoftware/xstate": "^6.0.0-beta.65",
+    "@types/node": "24.19.1",
+    "effect": "4.1.2",
+    "fast-check": "4.9.0",
+    "rimraf": "6.1.3",
+    "tsdown": "0.23.0",
+    "typescript": "7.0.2",
+    "vitest": "5.0.3",
+    "zod": "4.4.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./effect-schema": {
+      "types": "./dist/effect-schema.d.ts",
+      "default": "./dist/effect-schema.mjs"
+    },
+    "./playwright": {
+      "types": "./dist/playwright.d.ts",
+      "default": "./dist/playwright.mjs"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "default": "./dist/schema.mjs"
+    },
+    "./vitest": {
+      "types": "./dist/vitest.d.ts",
+      "default": "./dist/vitest.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsdown -l warn && pnpm api:check",
+    "typecheck": "tsc -b",
+    "test": "vitest run",
+    "lint:tsgo": "effect-tsgo diagnostics --project tsconfig.app.json --format ${TSGO_FORMAT:-text} && ../../scripts/tsgo-test-diagnostics.ts",
+    "attw": "attw --pack .",
+    "api:check": "api-extractor run && api-extractor run --config api-extractor.effect-schema.json && api-extractor run --config api-extractor.playwright.json && api-extractor run --config api-extractor.schema.json && api-extractor run --config api-extractor.vitest.json",
+    "api:update": "api-extractor run --local && api-extractor run --local --config api-extractor.effect-schema.json && api-extractor run --local --config api-extractor.playwright.json && api-extractor run --local --config api-extractor.schema.json && api-extractor run --local --config api-extractor.vitest.json"
+  }
+}