@logixjs/test 0.0.1

package/dist/Vitest.d.cts

@@ -0,0 +1,7 @@
+export { i as itProgram, a as itProgramResult } from './Vitest-BiBMIx3C.cjs';
+import 'effect';
+import '@logixjs/core';
+import './ExecutionResult-BRC-Jzsv.cjs';
+import './TestProgram-BLXiWhJQ.cjs';
+import '@logixjs/core/Runtime';
+import './waitUntil-CjpwZxCu.cjs';

package/dist/Vitest.d.ts

@@ -0,0 +1,7 @@
+export { i as itProgram, a as itProgramResult } from './Vitest-BXBtxem-.js';
+import 'effect';
+import '@logixjs/core';
+import './ExecutionResult-BRC-Jzsv.js';
+import './TestProgram-X35n_2Js.js';
+import '@logixjs/core/Runtime';
+import './waitUntil-CjpwZxCu.js';

package/dist/Vitest.js

@@ -0,0 +1,13 @@
+import {
+  itProgram,
+  itProgramResult
+} from "./chunk-TDYES47J.js";
+import "./chunk-CZJ37XWT.js";
+import "./chunk-DU6VSL4D.js";
+import "./chunk-RG24KSEB.js";
+import "./chunk-DKT5EFOF.js";
+import "./chunk-FOYMJMJR.js";
+export {
+  itProgram,
+  itProgramResult
+};

package/dist/chunk-42QGM623.js

@@ -0,0 +1,16 @@
+import {
+  runTest
+} from "./chunk-DKT5EFOF.js";
+import {
+  __export
+} from "./chunk-FOYMJMJR.js";
+
+// src/TestRuntime.ts
+var TestRuntime_exports = {};
+__export(TestRuntime_exports, {
+  runTest: () => runTest
+});
+
+export {
+  TestRuntime_exports
+};

package/dist/chunk-5XFEOVH5.js

@@ -0,0 +1,16 @@
+import {
+  runProgram
+} from "./chunk-CZJ37XWT.js";
+import {
+  __export
+} from "./chunk-FOYMJMJR.js";
+
+// src/TestProgram.ts
+var TestProgram_exports = {};
+__export(TestProgram_exports, {
+  runProgram: () => runProgram
+});
+
+export {
+  TestProgram_exports
+};

package/dist/chunk-CZJ37XWT.js

@@ -0,0 +1,132 @@
+import {
+  assertSignal,
+  assertState,
+  waitUntil
+} from "./chunk-DU6VSL4D.js";
+import {
+  make
+} from "./chunk-RG24KSEB.js";
+
+// src/internal/api/TestProgram.ts
+import { Chunk, Clock, Effect, Layer, Ref, Scope, Stream, TestClock, TestContext } from "effect";
+import * as Logix from "@logixjs/core";
+var defaultOptions = (options) => {
+  const base = options ?? {};
+  const userLayer = base.layer ?? Layer.empty;
+  const layer = Layer.mergeAll(TestContext.TestContext, userLayer);
+  return {
+    ...base,
+    layer,
+    handleSignals: base.handleSignals ?? false
+  };
+};
+var makeTestApi = (ctx, actionsRef) => {
+  const assertStateEffect = (predicate, options) => Effect.gen(function* () {
+    const check = Effect.flatMap(ctx.module.getState, (s) => assertState(s, predicate));
+    yield* waitUntil(check, options);
+  });
+  const assertSignalEffect = (expectedType, expectedPayload, options) => Effect.gen(function* () {
+    const check = Effect.flatMap(
+      Ref.get(actionsRef),
+      (actions) => Effect.sync(() => {
+        for (const actual of Chunk.toReadonlyArray(actions)) {
+          const exit = 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) => TestClock.adjust(duration).pipe(Effect.asVoid),
+    assert: {
+      state: assertStateEffect,
+      signal: assertSignalEffect
+    }
+  };
+};
+var startTraceCollectors = (ctx, traceRef, actionsRef) => Effect.gen(function* () {
+  yield* Stream.runForEach(
+    ctx.module.actions$,
+    (action) => Effect.gen(function* () {
+      const timestamp = yield* Clock.currentTimeMillis;
+      const event = { _tag: "Action", action, timestamp };
+      yield* Ref.update(traceRef, Chunk.append(event));
+      yield* Ref.update(actionsRef, Chunk.append(action));
+    })
+  ).pipe(Effect.forkScoped, Scope.extend(ctx.scope));
+  yield* Stream.runForEach(
+    ctx.module.changes((s) => s),
+    (state) => Effect.gen(function* () {
+      const timestamp = yield* Clock.currentTimeMillis;
+      const event = { _tag: "State", state, timestamp };
+      yield* Ref.update(traceRef, Chunk.append(event));
+    })
+  ).pipe(Effect.forkScoped, Scope.extend(ctx.scope));
+  yield* TestClock.adjust(1);
+  yield* Effect.yieldNow();
+});
+var runProgram = (program, body, options) => Effect.gen(function* () {
+  const traceRef = yield* Ref.make(Chunk.empty());
+  const actionsRef = yield* Ref.make(Chunk.empty());
+  const debugSink = {
+    record: (event) => {
+      if (event.type !== "lifecycle:error") {
+        return Effect.void;
+      }
+      return Effect.gen(function* () {
+        const timestamp = yield* Clock.currentTimeMillis;
+        const traceEvent = {
+          _tag: "Error",
+          cause: event.cause,
+          timestamp
+        };
+        yield* Ref.update(traceRef, Chunk.append(traceEvent));
+      }).pipe(Effect.asVoid);
+    }
+  };
+  const resolved = defaultOptions(options);
+  const ctx = yield* Effect.locally(Logix.Debug.internal.currentDebugSinks, [debugSink])(
+    Logix.Runtime.openProgram(program, resolved)
+  );
+  yield* Effect.tryPromise({
+    try: () => ctx.runtime.runPromise(startTraceCollectors(ctx, traceRef, actionsRef)),
+    catch: (e) => e
+  }).pipe(Effect.orDie);
+  const api = makeTestApi(ctx, actionsRef);
+  yield* Effect.tryPromise({
+    try: () => ctx.runtime.runPromise(body(api).pipe(Scope.extend(ctx.scope))),
+    catch: (e) => e
+  }).pipe(Effect.orDie);
+  yield* Effect.tryPromise({
+    try: () => ctx.runtime.runPromise(
+      Effect.gen(function* () {
+        yield* TestClock.adjust(1);
+        yield* Effect.yieldNow();
+      })
+    ),
+    catch: (e) => e
+  }).pipe(Effect.orDie);
+  const finalState = yield* Effect.tryPromise({
+    try: () => ctx.runtime.runPromise(ctx.module.getState),
+    catch: (e) => e
+  }).pipe(Effect.orDie);
+  const actionsChunk = yield* Ref.get(actionsRef);
+  const traceChunk = yield* Ref.get(traceRef);
+  return make(
+    finalState,
+    Chunk.toReadonlyArray(actionsChunk),
+    Chunk.toReadonlyArray(traceChunk)
+  );
+});
+
+export {
+  runProgram
+};

package/dist/chunk-DKT5EFOF.js

@@ -0,0 +1,10 @@
+// src/internal/runtime/runTest.ts
+import { Effect, TestContext } from "effect";
+var runTest = (effect) => {
+  const program = Effect.scoped(effect).pipe(Effect.provide(TestContext.TestContext));
+  return Effect.runPromise(program);
+};
+
+export {
+  runTest
+};

package/dist/chunk-DU6VSL4D.js

@@ -0,0 +1,57 @@
+// src/internal/utils/assertions.ts
+import { Effect, Equal } from "effect";
+var assertState = (actual, predicate, message) => {
+  return Effect.suspend(() => {
+    if (predicate(actual)) {
+      return Effect.void;
+    }
+    return Effect.fail(new Error(message || `State assertion failed. Actual: ${JSON.stringify(actual)}`));
+  });
+};
+var assertSignal = (actual, expectedType, expectedPayload) => {
+  return Effect.suspend(() => {
+    const candidate = actual;
+    if (candidate && typeof candidate === "object" && typeof candidate._tag === "string" && candidate._tag === expectedType) {
+      if (expectedPayload !== void 0) {
+        if (Equal.equals(candidate.payload, expectedPayload)) {
+          return Effect.void;
+        }
+        return Effect.fail(
+          new Error(
+            `Signal payload mismatch. Expected: ${JSON.stringify(expectedPayload)}, Actual: ${JSON.stringify(
+              candidate.payload
+            )}`
+          )
+        );
+      }
+      return Effect.void;
+    }
+    return Effect.fail(
+      new Error(`Signal assertion failed. Expected type: ${expectedType}, Actual: ${JSON.stringify(actual)}`)
+    );
+  });
+};
+
+// src/internal/utils/waitUntil.ts
+import { Effect as Effect2, TestClock } from "effect";
+var waitUntil = (check, options = {}) => Effect2.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(Effect2.exit);
+    if (result._tag === "Success") {
+      return result.value;
+    }
+    lastError = result.cause;
+    yield* TestClock.adjust(step);
+    yield* Effect2.yieldNow();
+  }
+  return yield* Effect2.fail(lastError);
+});
+
+export {
+  assertState,
+  assertSignal,
+  waitUntil
+};

package/dist/chunk-FOYMJMJR.js

@@ -0,0 +1,38 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __commonJS,
+  __export,
+  __toESM,
+  __publicField
+};

package/dist/chunk-J5AZHNSA.js

@@ -0,0 +1,32 @@
+import {
+  expectActionSequence,
+  expectActionTag,
+  expectNoActionTag,
+  expectNoError,
+  getActionsByTag,
+  getErrors,
+  hasAction,
+  hasError,
+  make
+} from "./chunk-RG24KSEB.js";
+import {
+  __export
+} from "./chunk-FOYMJMJR.js";
+
+// src/Execution.ts
+var Execution_exports = {};
+__export(Execution_exports, {
+  expectActionSequence: () => expectActionSequence,
+  expectActionTag: () => expectActionTag,
+  expectNoActionTag: () => expectNoActionTag,
+  expectNoError: () => expectNoError,
+  getActionsByTag: () => getActionsByTag,
+  getErrors: () => getErrors,
+  hasAction: () => hasAction,
+  hasError: () => hasError,
+  make: () => make
+});
+
+export {
+  Execution_exports
+};

package/dist/chunk-RG24KSEB.js

@@ -0,0 +1,64 @@
+// src/internal/api/ExecutionResult.ts
+var make = (state, actions, trace) => ({
+  state,
+  actions,
+  trace
+});
+var hasAction = (result, predicate) => result.actions.some(predicate);
+var getActionsByTag = (result, tag) => result.actions.filter((action) => typeof action._tag === "string" && action._tag === tag);
+var hasError = (result) => result.trace.some((event) => event._tag === "Error");
+var getErrors = (result) => result.trace.filter((event) => event._tag === "Error");
+var actionTagOf = (action) => {
+  const value = action;
+  if (typeof value?._tag === "string") {
+    return value._tag;
+  }
+  if (typeof value?.type === "string") {
+    return value.type;
+  }
+  return void 0;
+};
+var expectActionTag = (result, tag, options = {}) => {
+  const actions = getActionsByTag(result, tag);
+  if (actions.length === 0) {
+    throw new Error(`Expected at least one action with tag "${tag}", but found none.`);
+  }
+  if (options.times !== void 0 && actions.length !== options.times) {
+    throw new Error(`Expected ${options.times} actions with tag "${tag}", but found ${actions.length}.`);
+  }
+};
+var expectNoActionTag = (result, tag) => {
+  const actions = getActionsByTag(result, tag);
+  if (actions.length > 0) {
+    throw new Error(`Expected no actions with tag "${tag}", but found ${actions.length}.`);
+  }
+};
+var expectActionSequence = (result, tags) => {
+  const actualTags = result.actions.map((action) => actionTagOf(action)).filter((tag) => typeof tag === "string");
+  if (actualTags.length !== tags.length) {
+    throw new Error(`Expected action tag sequence [${tags.join(", ")}], but got [${actualTags.join(", ")}].`);
+  }
+  for (let i = 0; i < tags.length; i++) {
+    if (actualTags[i] !== tags[i]) {
+      throw new Error(`Expected action tag sequence [${tags.join(", ")}], but got [${actualTags.join(", ")}].`);
+    }
+  }
+};
+var expectNoError = (result) => {
+  const errors = getErrors(result);
+  if (errors.length > 0) {
+    throw new Error(`Expected no errors, but found ${errors.length}. First error cause: ${String(errors[0]?.cause)}`);
+  }
+};
+
+export {
+  make,
+  hasAction,
+  getActionsByTag,
+  hasError,
+  getErrors,
+  expectActionTag,
+  expectNoActionTag,
+  expectActionSequence,
+  expectNoError
+};