@fragno-dev/test 1.0.1 → 2.0.0

package/src/index.ts

@@ -5,6 +5,7 @@ import type {
   KyselySqliteAdapter,
   KyselyPgliteAdapter,
   DrizzlePgliteAdapter,
+  InMemoryAdapterConfig,
 } from "./adapters";
 import type { DatabaseAdapter } from "@fragno-dev/db";
 import type { SimpleQueryInterface } from "@fragno-dev/db/query";
@@ -22,11 +23,45 @@ export type {
   KyselySqliteAdapter,
   KyselyPgliteAdapter,
   DrizzlePgliteAdapter,
+  InMemoryAdapterConfig,
   AdapterContext,
 } from "./adapters";
 
 // Re-export new builder-based database test utilities
 export { buildDatabaseFragmentsTest, DatabaseFragmentsTestBuilder } from "./db-test";
+export { drainDurableHooks } from "./durable-hooks";
+export {
+  runModelChecker,
+  defaultStateHasher,
+  defaultTraceHasher,
+  type ModelCheckerConfig,
+  type ModelCheckerBounds,
+  type ModelCheckerRunResult,
+  type ModelCheckerScheduleResult,
+  type ModelCheckerMode,
+  type ModelCheckerStep,
+  type ModelCheckerTraceEvent,
+  type ModelCheckerTrace,
+  type ModelCheckerTraceRecorder,
+  type ModelCheckerTraceHasher,
+  type ModelCheckerTraceHashMode,
+  type NormalizedMutationOperation,
+  type RawUowTransaction,
+  type RawUowTransactionBuilder,
+  type RawUowTransactionContext,
+  type RawUowMutateContext,
+  createRawUowTransaction,
+} from "./model-checker";
+
+export {
+  runModelCheckerWithActors,
+  type ModelCheckerActor,
+  type ModelCheckerInvariant,
+  type ModelCheckerInvariantContext,
+  type ModelCheckerActorsConfig,
+} from "./model-checker-actors";
+
+export { ModelCheckerAdapter, type ModelCheckerScheduler } from "./model-checker-adapter";
 
 /**
  * Base test context with common functionality across all adapters
@@ -42,7 +77,7 @@ export interface BaseTestContext {
  * Internal interface with getOrm for adapter implementations
  */
 export interface InternalTestContextMethods {
-  getOrm: <TSchema extends AnySchema>(namespace: string) => SimpleQueryInterface<TSchema>;
+  getOrm: <TSchema extends AnySchema>(namespace: string | null) => SimpleQueryInterface<TSchema>;
 }
 
 /**
@@ -51,13 +86,13 @@ export interface InternalTestContextMethods {
  */
 export function createCommonTestContextMethods(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ormMap: Map<string, SimpleQueryInterface<any>>,
+  ormMap: Map<string | null, SimpleQueryInterface<any>>,
 ): InternalTestContextMethods {
   return {
-    getOrm: <TSchema extends AnySchema>(namespace: string) => {
+    getOrm: <TSchema extends AnySchema>(namespace: string | null) => {
       const orm = ormMap.get(namespace);
       if (!orm) {
-        throw new Error(`No ORM found for namespace: ${namespace}`);
+        throw new Error(`No ORM found for namespace: ${String(namespace)}`);
       }
       return orm as SimpleQueryInterface<TSchema>;
     },

package/src/model-checker-actors.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { InMemoryAdapter } from "@fragno-dev/db";
+import { column, idColumn, schema } from "@fragno-dev/db/schema";
+import { ModelCheckerAdapter } from "./model-checker-adapter";
+import { runModelCheckerWithActors } from "./model-checker-actors";
+
+const testSchema = schema("test", (s) =>
+  s.addTable("items", (t) => t.addColumn("id", idColumn()).addColumn("name", column("string"))),
+);
+
+const createContext = async () => {
+  const adapter = new InMemoryAdapter({ idSeed: "model-checker-actors" });
+  const modelAdapter = new ModelCheckerAdapter(adapter);
+  const queryEngine = modelAdapter.createQueryEngine(testSchema, "model-checker-actors");
+
+  return {
+    adapter: modelAdapter,
+    ctx: { queryEngine },
+    queryEngine,
+    cleanup: async () => {
+      await adapter.close();
+    },
+  };
+};
+
+describe("model checker actors", () => {
+  it("exhaustively explores bounded interleavings", async () => {
+    const result = await runModelCheckerWithActors({
+      schema: testSchema,
+      mode: "bounded-exhaustive",
+      bounds: { maxSteps: 2 },
+      history: false,
+      createContext,
+      setup: async ({ queryEngine }) => {
+        await queryEngine.create("items", { name: "seed" });
+      },
+      buildActors: ({ queryEngine }) => [
+        {
+          name: "tx-a",
+          run: async () => {
+            const uow = queryEngine.createUnitOfWork("tx-a");
+            uow.find("items", (b) => b.whereIndex("primary"));
+            await uow.executeRetrieve();
+            uow.create("items", { name: "alpha" });
+            const { success } = await uow.executeMutations();
+            if (!success) {
+              throw new Error("tx-a mutation failed");
+            }
+          },
+        },
+        {
+          name: "tx-b",
+          run: async () => {
+            const uow = queryEngine.createUnitOfWork("tx-b");
+            uow.find("items", (b) => b.whereIndex("primary"));
+            await uow.executeRetrieve();
+            uow.create("items", { name: "beta" });
+            const { success } = await uow.executeMutations();
+            if (!success) {
+              throw new Error("tx-b mutation failed");
+            }
+          },
+        },
+      ],
+    });
+
+    const prefixes = new Set(
+      result.schedules.map((entry) =>
+        entry.schedule
+          .slice(0, 2)
+          .map((step) => `${step.txId}:${step.phase}`)
+          .join("|"),
+      ),
+    );
+
+    expect(prefixes.size).toBe(2);
+  });
+});