@logixjs/test 0.0.1

package/dist/TestProgram.cjs

@@ -0,0 +1,220 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/TestProgram.ts
+var TestProgram_exports = {};
+__export(TestProgram_exports, {
+  runProgram: () => runProgram
+});
+module.exports = __toCommonJS(TestProgram_exports);
+
+// src/internal/api/TestProgram.ts
+var import_effect3 = require("effect");
+var Logix = __toESM(require("@logixjs/core"), 1);
+
+// src/internal/api/ExecutionResult.ts
+var make = (state, actions, trace) => ({
+  state,
+  actions,
+  trace
+});
+
+// src/internal/utils/assertions.ts
+var import_effect = require("effect");
+var assertState = (actual, predicate, message) => {
+  return import_effect.Effect.suspend(() => {
+    if (predicate(actual)) {
+      return import_effect.Effect.void;
+    }
+    return import_effect.Effect.fail(new Error(message || `State assertion failed. Actual: ${JSON.stringify(actual)}`));
+  });
+};
+var assertSignal = (actual, expectedType, expectedPayload) => {
+  return import_effect.Effect.suspend(() => {
+    const candidate = actual;
+    if (candidate && typeof candidate === "object" && typeof candidate._tag === "string" && candidate._tag === expectedType) {
+      if (expectedPayload !== void 0) {
+        if (import_effect.Equal.equals(candidate.payload, expectedPayload)) {
+          return import_effect.Effect.void;
+        }
+        return import_effect.Effect.fail(
+          new Error(
+            `Signal payload mismatch. Expected: ${JSON.stringify(expectedPayload)}, Actual: ${JSON.stringify(
+              candidate.payload
+            )}`
+          )
+        );
+      }
+      return import_effect.Effect.void;
+    }
+    return import_effect.Effect.fail(
+      new Error(`Signal assertion failed. Expected type: ${expectedType}, Actual: ${JSON.stringify(actual)}`)
+    );
+  });
+};
+
+// src/internal/utils/waitUntil.ts
+var import_effect2 = require("effect");
+var waitUntil = (check, options = {}) => import_effect2.Effect.gen(function* () {
+  const maxAttempts = options.maxAttempts ?? 20;
+  const step = options.step ?? "10 millis";
+  let lastError;
+  for (let i = 0; i < maxAttempts; i++) {
+    const result = yield* check.pipe(import_effect2.Effect.exit);
+    if (result._tag === "Success") {
+      return result.value;
+    }
+    lastError = result.cause;
+    yield* import_effect2.TestClock.adjust(step);
+    yield* import_effect2.Effect.yieldNow();
+  }
+  return yield* import_effect2.Effect.fail(lastError);
+});
+
+// src/internal/api/TestProgram.ts
+var defaultOptions = (options) => {
+  const base = options ?? {};
+  const userLayer = base.layer ?? import_effect3.Layer.empty;
+  const layer = import_effect3.Layer.mergeAll(import_effect3.TestContext.TestContext, userLayer);
+  return {
+    ...base,
+    layer,
+    handleSignals: base.handleSignals ?? false
+  };
+};
+var makeTestApi = (ctx, actionsRef) => {
+  const assertStateEffect = (predicate, options) => import_effect3.Effect.gen(function* () {
+    const check = import_effect3.Effect.flatMap(ctx.module.getState, (s) => assertState(s, predicate));
+    yield* waitUntil(check, options);
+  });
+  const assertSignalEffect = (expectedType, expectedPayload, options) => import_effect3.Effect.gen(function* () {
+    const check = import_effect3.Effect.flatMap(
+      import_effect3.Ref.get(actionsRef),
+      (actions) => import_effect3.Effect.sync(() => {
+        for (const actual of import_effect3.Chunk.toReadonlyArray(actions)) {
+          const exit = import_effect3.Effect.runSyncExit(assertSignal(actual, expectedType, expectedPayload));
+          if (exit._tag === "Success") {
+            return;
+          }
+        }
+        throw new Error(
+          `Signal assertion failed: expected type=${expectedType}, payload=${JSON.stringify(expectedPayload)}`
+        );
+      })
+    );
+    yield* waitUntil(check, options);
+  });
+  return {
+    ctx,
+    dispatch: ctx.module.dispatch,
+    advance: (duration) => import_effect3.TestClock.adjust(duration).pipe(import_effect3.Effect.asVoid),
+    assert: {
+      state: assertStateEffect,
+      signal: assertSignalEffect
+    }
+  };
+};
+var startTraceCollectors = (ctx, traceRef, actionsRef) => import_effect3.Effect.gen(function* () {
+  yield* import_effect3.Stream.runForEach(
+    ctx.module.actions$,
+    (action) => import_effect3.Effect.gen(function* () {
+      const timestamp = yield* import_effect3.Clock.currentTimeMillis;
+      const event = { _tag: "Action", action, timestamp };
+      yield* import_effect3.Ref.update(traceRef, import_effect3.Chunk.append(event));
+      yield* import_effect3.Ref.update(actionsRef, import_effect3.Chunk.append(action));
+    })
+  ).pipe(import_effect3.Effect.forkScoped, import_effect3.Scope.extend(ctx.scope));
+  yield* import_effect3.Stream.runForEach(
+    ctx.module.changes((s) => s),
+    (state) => import_effect3.Effect.gen(function* () {
+      const timestamp = yield* import_effect3.Clock.currentTimeMillis;
+      const event = { _tag: "State", state, timestamp };
+      yield* import_effect3.Ref.update(traceRef, import_effect3.Chunk.append(event));
+    })
+  ).pipe(import_effect3.Effect.forkScoped, import_effect3.Scope.extend(ctx.scope));
+  yield* import_effect3.TestClock.adjust(1);
+  yield* import_effect3.Effect.yieldNow();
+});
+var runProgram = (program, body, options) => import_effect3.Effect.gen(function* () {
+  const traceRef = yield* import_effect3.Ref.make(import_effect3.Chunk.empty());
+  const actionsRef = yield* import_effect3.Ref.make(import_effect3.Chunk.empty());
+  const debugSink = {
+    record: (event) => {
+      if (event.type !== "lifecycle:error") {
+        return import_effect3.Effect.void;
+      }
+      return import_effect3.Effect.gen(function* () {
+        const timestamp = yield* import_effect3.Clock.currentTimeMillis;
+        const traceEvent = {
+          _tag: "Error",
+          cause: event.cause,
+          timestamp
+        };
+        yield* import_effect3.Ref.update(traceRef, import_effect3.Chunk.append(traceEvent));
+      }).pipe(import_effect3.Effect.asVoid);
+    }
+  };
+  const resolved = defaultOptions(options);
+  const ctx = yield* import_effect3.Effect.locally(Logix.Debug.internal.currentDebugSinks, [debugSink])(
+    Logix.Runtime.openProgram(program, resolved)
+  );
+  yield* import_effect3.Effect.tryPromise({
+    try: () => ctx.runtime.runPromise(startTraceCollectors(ctx, traceRef, actionsRef)),
+    catch: (e) => e
+  }).pipe(import_effect3.Effect.orDie);
+  const api = makeTestApi(ctx, actionsRef);
+  yield* import_effect3.Effect.tryPromise({
+    try: () => ctx.runtime.runPromise(body(api).pipe(import_effect3.Scope.extend(ctx.scope))),
+    catch: (e) => e
+  }).pipe(import_effect3.Effect.orDie);
+  yield* import_effect3.Effect.tryPromise({
+    try: () => ctx.runtime.runPromise(
+      import_effect3.Effect.gen(function* () {
+        yield* import_effect3.TestClock.adjust(1);
+        yield* import_effect3.Effect.yieldNow();
+      })
+    ),
+    catch: (e) => e
+  }).pipe(import_effect3.Effect.orDie);
+  const finalState = yield* import_effect3.Effect.tryPromise({
+    try: () => ctx.runtime.runPromise(ctx.module.getState),
+    catch: (e) => e
+  }).pipe(import_effect3.Effect.orDie);
+  const actionsChunk = yield* import_effect3.Ref.get(actionsRef);
+  const traceChunk = yield* import_effect3.Ref.get(traceRef);
+  return make(
+    finalState,
+    import_effect3.Chunk.toReadonlyArray(actionsChunk),
+    import_effect3.Chunk.toReadonlyArray(traceChunk)
+  );
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runProgram
+});

package/dist/TestProgram.d.cts

@@ -0,0 +1,6 @@
+export { T as TestApi, a as TestProgramOptions, r as runProgram } from './TestProgram-BLXiWhJQ.cjs';
+import 'effect';
+import '@logixjs/core';
+import '@logixjs/core/Runtime';
+import './ExecutionResult-BRC-Jzsv.cjs';
+import './waitUntil-CjpwZxCu.cjs';

package/dist/TestProgram.d.ts

@@ -0,0 +1,6 @@
+export { T as TestApi, a as TestProgramOptions, r as runProgram } from './TestProgram-X35n_2Js.js';
+import 'effect';
+import '@logixjs/core';
+import '@logixjs/core/Runtime';
+import './ExecutionResult-BRC-Jzsv.js';
+import './waitUntil-CjpwZxCu.js';

package/dist/TestProgram.js

@@ -0,0 +1,10 @@
+import "./chunk-5XFEOVH5.js";
+import {
+  runProgram
+} from "./chunk-CZJ37XWT.js";
+import "./chunk-DU6VSL4D.js";
+import "./chunk-RG24KSEB.js";
+import "./chunk-FOYMJMJR.js";
+export {
+  runProgram
+};

package/dist/TestRuntime-CyYCUXdT.d.cts

@@ -0,0 +1,10 @@
+import { Effect } from 'effect';
+
+declare const runTest: <A, E, R>(effect: Effect.Effect<A, E, R>) => Promise<A>;
+
+declare const TestRuntime_runTest: typeof runTest;
+declare namespace TestRuntime {
+  export { TestRuntime_runTest as runTest };
+}
+
+export { TestRuntime as T, runTest as r };

package/dist/TestRuntime-CyYCUXdT.d.ts

@@ -0,0 +1,10 @@
+import { Effect } from 'effect';
+
+declare const runTest: <A, E, R>(effect: Effect.Effect<A, E, R>) => Promise<A>;
+
+declare const TestRuntime_runTest: typeof runTest;
+declare namespace TestRuntime {
+  export { TestRuntime_runTest as runTest };
+}
+
+export { TestRuntime as T, runTest as r };

package/dist/TestRuntime.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/TestRuntime.ts
+var TestRuntime_exports = {};
+__export(TestRuntime_exports, {
+  runTest: () => runTest
+});
+module.exports = __toCommonJS(TestRuntime_exports);
+
+// src/internal/runtime/runTest.ts
+var import_effect = require("effect");
+var runTest = (effect) => {
+  const program = import_effect.Effect.scoped(effect).pipe(import_effect.Effect.provide(import_effect.TestContext.TestContext));
+  return import_effect.Effect.runPromise(program);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runTest
+});

package/dist/TestRuntime.d.cts

@@ -0,0 +1,2 @@
+export { r as runTest } from './TestRuntime-CyYCUXdT.cjs';
+import 'effect';

package/dist/TestRuntime.d.ts

@@ -0,0 +1,2 @@
+export { r as runTest } from './TestRuntime-CyYCUXdT.js';
+import 'effect';

package/dist/TestRuntime.js

@@ -0,0 +1,8 @@
+import "./chunk-42QGM623.js";
+import {
+  runTest
+} from "./chunk-DKT5EFOF.js";
+import "./chunk-FOYMJMJR.js";
+export {
+  runTest
+};

package/dist/Vitest-BXBtxem-.d.ts

@@ -0,0 +1,28 @@
+import { Effect } from 'effect';
+import * as Logix from '@logixjs/core';
+import { E as ExecutionResult } from './ExecutionResult-BRC-Jzsv.js';
+import { T as TestApi, a as TestProgramOptions } from './TestProgram-X35n_2Js.js';
+
+/**
+ * Sugar: defines a program test based on `TestProgram.runProgram`.
+ *
+ * - By default, asserts `Execution.expectNoError(result)`.
+ * - Recommended: for both single-module and multi-module tests, use the "program module" as the input,
+ *   instead of hand-rolling lifecycle/kernel assembly.
+ */
+declare const itProgram: <Sh extends Logix.AnyModuleShape>(name: string, program: Logix.ModuleImpl<any, Sh, any> | Logix.AnyModule, body: (api: TestApi<Sh>) => Effect.Effect<void, any, any>, options?: TestProgramOptions) => void;
+/**
+ * Variant: exposes `ExecutionResult`, leaving assertions to the caller.
+ *
+ * - Does not automatically call `Execution.expectNoError`.
+ * - Use this API when you expect specific diagnostics/traces.
+ */
+declare const itProgramResult: <Sh extends Logix.AnyModuleShape>(name: string, program: Logix.ModuleImpl<any, Sh, any> | Logix.AnyModule, body: (api: TestApi<Sh>) => Effect.Effect<void, any, any>, assert: (result: ExecutionResult<Sh>) => void, options?: TestProgramOptions) => void;
+
+declare const Vitest_itProgram: typeof itProgram;
+declare const Vitest_itProgramResult: typeof itProgramResult;
+declare namespace Vitest {
+  export { Vitest_itProgram as itProgram, Vitest_itProgramResult as itProgramResult };
+}
+
+export { Vitest as V, itProgramResult as a, itProgram as i };

package/dist/Vitest-BiBMIx3C.d.cts

@@ -0,0 +1,28 @@
+import { Effect } from 'effect';
+import * as Logix from '@logixjs/core';
+import { E as ExecutionResult } from './ExecutionResult-BRC-Jzsv.cjs';
+import { T as TestApi, a as TestProgramOptions } from './TestProgram-BLXiWhJQ.cjs';
+
+/**
+ * Sugar: defines a program test based on `TestProgram.runProgram`.
+ *
+ * - By default, asserts `Execution.expectNoError(result)`.
+ * - Recommended: for both single-module and multi-module tests, use the "program module" as the input,
+ *   instead of hand-rolling lifecycle/kernel assembly.
+ */
+declare const itProgram: <Sh extends Logix.AnyModuleShape>(name: string, program: Logix.ModuleImpl<any, Sh, any> | Logix.AnyModule, body: (api: TestApi<Sh>) => Effect.Effect<void, any, any>, options?: TestProgramOptions) => void;
+/**
+ * Variant: exposes `ExecutionResult`, leaving assertions to the caller.
+ *
+ * - Does not automatically call `Execution.expectNoError`.
+ * - Use this API when you expect specific diagnostics/traces.
+ */
+declare const itProgramResult: <Sh extends Logix.AnyModuleShape>(name: string, program: Logix.ModuleImpl<any, Sh, any> | Logix.AnyModule, body: (api: TestApi<Sh>) => Effect.Effect<void, any, any>, assert: (result: ExecutionResult<Sh>) => void, options?: TestProgramOptions) => void;
+
+declare const Vitest_itProgram: typeof itProgram;
+declare const Vitest_itProgramResult: typeof itProgramResult;
+declare namespace Vitest {
+  export { Vitest_itProgram as itProgram, Vitest_itProgramResult as itProgramResult };
+}
+
+export { Vitest as V, itProgramResult as a, itProgram as i };