@forwardimpact/libmock 0.1.2

package/src/mock/storage.js

@@ -0,0 +1,118 @@
+import { spy } from "./spy.js";
+/**
+ * Creates a mock storage instance with tracking
+ * @param {object} overrides - Method overrides
+ * @returns {object} Mock storage with data tracking
+ */
+export function createMockStorage(overrides = {}) {
+  const data = new Map();
+
+  return {
+    data,
+    exists: spy((key) => Promise.resolve(data.has(key))),
+    get: spy((key) => {
+      const value = data.get(key);
+      if (!value) return Promise.reject(new Error("Not found"));
+
+      if (key.endsWith(".json")) {
+        return Promise.resolve(value ? JSON.parse(value) : {});
+      }
+      if (key.endsWith(".jsonl")) {
+        const lines = value.split("\n").filter(Boolean);
+        return Promise.resolve(lines.map((line) => JSON.parse(line)));
+      }
+      return Promise.resolve(value);
+    }),
+    put: spy((key, value) => {
+      data.set(key, value);
+      return Promise.resolve();
+    }),
+    append: spy((key, value) => {
+      const existing = data.get(key) || "";
+      data.set(key, existing ? `${existing}\n${value}` : value);
+      return Promise.resolve();
+    }),
+    delete: spy((key) => {
+      data.delete(key);
+      return Promise.resolve();
+    }),
+    findByPrefix: spy(() => Promise.resolve([])),
+    ...overrides,
+  };
+}
+
+/**
+ * MockStorage class for OOP-style usage
+ */
+export class MockStorage {
+  /**
+   * Creates a new MockStorage instance
+   */
+  constructor() {
+    this.data = new Map();
+  }
+
+  /**
+   * Gets a value by key
+   * @param {string} key - The storage key
+   * @returns {Promise<*>} The stored value
+   */
+  async get(key) {
+    const value = this.data.get(key);
+    if (!value) throw new Error("Not found");
+
+    if (key.endsWith(".jsonl")) {
+      return value.split("\n").map((line) => JSON.parse(line));
+    }
+    return value;
+  }
+
+  /**
+   * Stores a value by key
+   * @param {string} key - The storage key
+   * @param {*} value - The value to store
+   * @returns {Promise<void>}
+   */
+  async put(key, value) {
+    this.data.set(key, value);
+  }
+
+  /**
+   * Alias for put - stores a value by key
+   * @param {string} key - The storage key
+   * @param {*} value - The value to store
+   * @returns {Promise<void>}
+   */
+  async set(key, value) {
+    this.data.set(key, value);
+  }
+
+  /**
+   * Appends a value to an existing key
+   * @param {string} key - The storage key
+   * @param {string} value - The value to append
+   * @returns {Promise<void>}
+   */
+  async append(key, value) {
+    const existing = this.data.get(key) || "";
+    this.data.set(key, existing ? `${existing}\n${value}` : value);
+  }
+
+  /**
+   * Checks if a key exists
+   * @param {string} key - The storage key
+   * @returns {Promise<boolean>} True if key exists
+   */
+  async exists(key) {
+    return this.data.has(key);
+  }
+
+  /**
+   * Deletes a value by key
+   * @param {string} key - The storage key
+   * @returns {Promise<void>}
+   */
+  async delete(key) {
+    this.data.delete(key);
+  }
+}

package/src/mock/subprocess.js

@@ -0,0 +1,92 @@
+import { spy } from "./spy.js";
+
+function asyncIterableOf(str) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      if (str) yield str;
+    },
+  };
+}
+
+/**
+ * A captured-chunks stub for a spawned child's writable stdin. Records every
+ * `write(chunk)` on `chunks`; `end()`/`destroy()` are no-ops. Mirrors the
+ * shape `createDefaultSubprocess().spawn` exposes (the child's `node:stream`
+ * Writable) closely enough for a supervisor that pipes into it.
+ */
+function createMockStdinSink() {
+  const sink = {
+    chunks: [],
+    write(chunk) {
+      sink.chunks.push(typeof chunk === "string" ? chunk : chunk.toString());
+      return true;
+    },
+    end() {},
+    destroy() {},
+    on() {
+      return sink;
+    },
+    once() {
+      return sink;
+    },
+  };
+  return sink;
+}
+
+/**
+ * Creates a mock subprocess collaborator matching the `Runtime.subprocess`
+ * surface. `run(cmd, args, opts)` resolves to `{ stdout, stderr, exitCode }`
+ * consulting `responses[cmd]` (default: empty success); `runSync` is its
+ * synchronous sibling returning the same shape. `spawn` returns a streaming
+ * quad backed by the same responses (its result carries `stdout`/`stderr`
+ * AsyncIterables, a captured-chunks `stdin` sink, `exitCode`/`signal` Promises,
+ * a `kill(signal)` spy recording on `kills`, and `pid`). All invocations are
+ * recorded on `calls`.
+ *
+ * @param {object} [options]
+ * @param {Record<string, {stdout?: string, stderr?: string, exitCode?: number}>} [options.responses]
+ * @returns {{run: Function, runSync: Function, spawn: Function, calls: Array<{cmd: string, args: string[], opts: object}>}}
+ */
+export function createMockSubprocess({ responses = {} } = {}) {
+  const calls = [];
+  const resolve = (cmd) => ({
+    stdout: "",
+    stderr: "",
+    exitCode: 0,
+    signal: null,
+    ...(responses[cmd] ?? {}),
+  });
+
+  const run = spy(async (cmd, args = [], opts = {}) => {
+    calls.push({ cmd, args, opts });
+    return resolve(cmd);
+  });
+
+  const runSync = spy((cmd, args = [], opts = {}) => {
+    calls.push({ cmd, args, opts });
+    return resolve(cmd);
+  });
+
+  const spawn = spy((cmd, args = [], opts = {}) => {
+    calls.push({ cmd, args, opts });
+    const r = resolve(cmd);
+    const kills = [];
+    return {
+      stdout: asyncIterableOf(r.stdout),
+      stderr: asyncIterableOf(r.stderr),
+      // A captured-chunks writable; `null` only when a response explicitly
+      // sets `stdin: null` (matching a child spawned without a stdin pipe).
+      stdin: r.stdin === null ? null : createMockStdinSink(),
+      exitCode: Promise.resolve(r.exitCode),
+      // Terminating signal: `null` (clean exit) unless a response overrides it.
+      signal: Promise.resolve(r.signal ?? null),
+      kills,
+      kill: spy((signal) => {
+        kills.push(signal);
+      }),
+      pid: r.pid ?? 4321,
+    };
+  });
+
+  return { run, runSync, spawn, calls };
+}

package/src/runtime.js

@@ -0,0 +1,29 @@
+import { createMockClock } from "./mock/clock.js";
+import { createMockFs } from "./mock/fs.js";
+import { createMockProcess } from "./mock/infra.js";
+import { createMockSubprocess } from "./mock/subprocess.js";
+import { createMockFinder } from "./mock/finder.js";
+
+/**
+ * Build a frozen mock runtime bag for tests, matching the production
+ * `Runtime` typedef. Every field defaults to its canonical
+ * libmock fake and is independently overridable via `overrides`.
+ *
+ * @param {object} [overrides] - Per-field replacements.
+ * @param {object} [overrides.fs] - Async fs surface (default `createMockFs()`).
+ * @param {object} [overrides.fsSync] - Sync fs surface (defaults to `fs`).
+ * @param {object} [overrides.proc] - Process surface.
+ * @param {object} [overrides.clock] - Clock surface.
+ * @param {object} [overrides.subprocess] - Subprocess surface.
+ * @param {object} [overrides.finder] - Finder collaborator.
+ * @returns {Readonly<import('../../libutil/src/runtime.js').Runtime>}
+ */
+export function createTestRuntime(overrides = {}) {
+  const fs = overrides.fs ?? createMockFs();
+  const fsSync = overrides.fsSync ?? fs;
+  const proc = overrides.proc ?? createMockProcess();
+  const clock = overrides.clock ?? createMockClock();
+  const subprocess = overrides.subprocess ?? createMockSubprocess();
+  const finder = overrides.finder ?? createMockFinder();
+  return Object.freeze({ fs, fsSync, proc, clock, subprocess, finder });
+}