onbuzz 4.9.13 → 4.10.0

package/src/core/__tests__/flowCheckpointStore.test.js

@@ -1,140 +1,140 @@
-/**
- * flowCheckpointStore — disk persistence for flow run state.
- *
- * Layout per run (under baseDir):
- *   <baseDir>/<runId>/run.json        — top-level run metadata + nodeStates
- *   <baseDir>/<runId>/node-<id>.json  — per-node recorded output (atomic)
- *
- * Why per-node files: a single run.json that we rewrite after every
- * node would be fine for small flows but loses partial-write safety.
- * Per-node files are append-only-ish (one write per node completion)
- * and let us reconstruct progress even if run.json gets corrupted.
- *
- * The store is purely data — no business logic. The executor reads/
- * writes through it; resume() reads everything back to rehydrate.
- */
-
-import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
-import path from 'path';
-import os from 'os';
-import { promises as fs } from 'fs';
-import {
-  FlowCheckpointStore,
-} from '../flowCheckpointStore.js';
-
-let tmpRoot;
-beforeEach(async () => {
-  tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'flow-checkpoint-test-'));
-});
-afterEach(async () => {
-  try { await fs.rm(tmpRoot, { recursive: true, force: true }); } catch {}
-});
-
-const newStore = () => new FlowCheckpointStore({ baseDir: tmpRoot });
-
-describe('FlowCheckpointStore — round-trip', () => {
-  test('saveRun + loadRun preserves the run record', async () => {
-    const store = newStore();
-    const run = {
-      id: 'run-1', flowId: 'f-1', status: 'running',
-      startedAt: '2025-01-01T00:00:00Z',
-      nodeStates: {}, output: null,
-    };
-    await store.saveRun(run);
-    const loaded = await store.loadRun('run-1');
-    expect(loaded).toEqual(run);
-  });
-
-  test('saveNodeResult + loadNodeResult round-trips structured output', async () => {
-    const store = newStore();
-    const result = { type: 'agent', outputs: { draft: 'hello', wordCount: 5 }, success: true };
-    await store.saveNodeResult('run-1', 'node-a', result);
-    const loaded = await store.loadNodeResult('run-1', 'node-a');
-    expect(loaded).toEqual(result);
-  });
-
-  test('listNodeResults returns every node-id with a result, regardless of save order', async () => {
-    const store = newStore();
-    await store.saveNodeResult('run-1', 'node-c', { ok: 'c' });
-    await store.saveNodeResult('run-1', 'node-a', { ok: 'a' });
-    await store.saveNodeResult('run-1', 'node-b', { ok: 'b' });
-    const ids = await store.listNodeResults('run-1');
-    expect(new Set(ids)).toEqual(new Set(['node-a', 'node-b', 'node-c']));
-  });
-
-  test('loadAllNodeResults returns a {nodeId: result} map', async () => {
-    const store = newStore();
-    await store.saveNodeResult('run-1', 'a', { v: 1 });
-    await store.saveNodeResult('run-1', 'b', { v: 2 });
-    const all = await store.loadAllNodeResults('run-1');
-    expect(all).toEqual({ a: { v: 1 }, b: { v: 2 } });
-  });
-});
-
-describe('FlowCheckpointStore — defensive', () => {
-  test('loadRun returns null for unknown run', async () => {
-    const store = newStore();
-    expect(await store.loadRun('nope')).toBe(null);
-  });
-
-  test('loadNodeResult returns null for unknown node', async () => {
-    const store = newStore();
-    expect(await store.loadNodeResult('run-1', 'ghost')).toBe(null);
-  });
-
-  test('listNodeResults returns [] for unknown run', async () => {
-    const store = newStore();
-    expect(await store.listNodeResults('ghost-run')).toEqual([]);
-  });
-
-  test('saveRun creates the run directory if missing', async () => {
-    const store = newStore();
-    await store.saveRun({ id: 'r-new', nodeStates: {} });
-    const stat = await fs.stat(path.join(tmpRoot, 'r-new'));
-    expect(stat.isDirectory()).toBe(true);
-  });
-
-  test('node id with weird characters is sanitized in the filename', async () => {
-    const store = newStore();
-    await store.saveNodeResult('run-1', 'node/a:b', { v: 1 });
-    // We don't care about the on-disk name — just that round-trip works.
-    expect(await store.loadNodeResult('run-1', 'node/a:b')).toEqual({ v: 1 });
-  });
-
-  test('refuses to escape baseDir via "../"', async () => {
-    const store = newStore();
-    await expect(store.saveRun({ id: '../escape', nodeStates: {} }))
-      .rejects.toThrow();
-  });
-});
-
-describe('FlowCheckpointStore — clearRun', () => {
-  test('clearRun removes the run directory and all checkpoints', async () => {
-    const store = newStore();
-    await store.saveRun({ id: 'r1', nodeStates: {} });
-    await store.saveNodeResult('r1', 'a', { v: 1 });
-    await store.clearRun('r1');
-    expect(await store.loadRun('r1')).toBe(null);
-    expect(await store.listNodeResults('r1')).toEqual([]);
-  });
-
-  test('clearRun on unknown run is a no-op (does not throw)', async () => {
-    const store = newStore();
-    await expect(store.clearRun('nope')).resolves.not.toThrow();
-  });
-});
-
-describe('FlowCheckpointStore — atomic write', () => {
-  test('partial write (mocked failure between tmp+rename) leaves no half-file', async () => {
-    // Simulate by writing a node result, then forcing a write to fail
-    // mid-operation. We don't have direct hooks but can verify after a
-    // successful write the file is fully readable JSON.
-    const store = newStore();
-    await store.saveNodeResult('r1', 'a', { complex: { nested: [1, 2, 3] } });
-    const raw = await fs.readFile(path.join(tmpRoot, 'r1', 'node-a.json'), 'utf8').catch(() => null);
-    // File must be valid JSON if it exists
-    if (raw !== null) {
-      expect(() => JSON.parse(raw)).not.toThrow();
-    }
-  });
-});
+/**
+ * flowCheckpointStore — disk persistence for flow run state.
+ *
+ * Layout per run (under baseDir):
+ *   <baseDir>/<runId>/run.json        — top-level run metadata + nodeStates
+ *   <baseDir>/<runId>/node-<id>.json  — per-node recorded output (atomic)
+ *
+ * Why per-node files: a single run.json that we rewrite after every
+ * node would be fine for small flows but loses partial-write safety.
+ * Per-node files are append-only-ish (one write per node completion)
+ * and let us reconstruct progress even if run.json gets corrupted.
+ *
+ * The store is purely data — no business logic. The executor reads/
+ * writes through it; resume() reads everything back to rehydrate.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import path from 'path';
+import os from 'os';
+import { promises as fs } from 'fs';
+import {
+  FlowCheckpointStore,
+} from '../flowCheckpointStore.js';
+
+let tmpRoot;
+beforeEach(async () => {
+  tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'flow-checkpoint-test-'));
+});
+afterEach(async () => {
+  try { await fs.rm(tmpRoot, { recursive: true, force: true }); } catch { /* swallow */ }
+});
+
+const newStore = () => new FlowCheckpointStore({ baseDir: tmpRoot });
+
+describe('FlowCheckpointStore — round-trip', () => {
+  test('saveRun + loadRun preserves the run record', async () => {
+    const store = newStore();
+    const run = {
+      id: 'run-1', flowId: 'f-1', status: 'running',
+      startedAt: '2025-01-01T00:00:00Z',
+      nodeStates: {}, output: null,
+    };
+    await store.saveRun(run);
+    const loaded = await store.loadRun('run-1');
+    expect(loaded).toEqual(run);
+  });
+
+  test('saveNodeResult + loadNodeResult round-trips structured output', async () => {
+    const store = newStore();
+    const result = { type: 'agent', outputs: { draft: 'hello', wordCount: 5 }, success: true };
+    await store.saveNodeResult('run-1', 'node-a', result);
+    const loaded = await store.loadNodeResult('run-1', 'node-a');
+    expect(loaded).toEqual(result);
+  });
+
+  test('listNodeResults returns every node-id with a result, regardless of save order', async () => {
+    const store = newStore();
+    await store.saveNodeResult('run-1', 'node-c', { ok: 'c' });
+    await store.saveNodeResult('run-1', 'node-a', { ok: 'a' });
+    await store.saveNodeResult('run-1', 'node-b', { ok: 'b' });
+    const ids = await store.listNodeResults('run-1');
+    expect(new Set(ids)).toEqual(new Set(['node-a', 'node-b', 'node-c']));
+  });
+
+  test('loadAllNodeResults returns a {nodeId: result} map', async () => {
+    const store = newStore();
+    await store.saveNodeResult('run-1', 'a', { v: 1 });
+    await store.saveNodeResult('run-1', 'b', { v: 2 });
+    const all = await store.loadAllNodeResults('run-1');
+    expect(all).toEqual({ a: { v: 1 }, b: { v: 2 } });
+  });
+});
+
+describe('FlowCheckpointStore — defensive', () => {
+  test('loadRun returns null for unknown run', async () => {
+    const store = newStore();
+    expect(await store.loadRun('nope')).toBe(null);
+  });
+
+  test('loadNodeResult returns null for unknown node', async () => {
+    const store = newStore();
+    expect(await store.loadNodeResult('run-1', 'ghost')).toBe(null);
+  });
+
+  test('listNodeResults returns [] for unknown run', async () => {
+    const store = newStore();
+    expect(await store.listNodeResults('ghost-run')).toEqual([]);
+  });
+
+  test('saveRun creates the run directory if missing', async () => {
+    const store = newStore();
+    await store.saveRun({ id: 'r-new', nodeStates: {} });
+    const stat = await fs.stat(path.join(tmpRoot, 'r-new'));
+    expect(stat.isDirectory()).toBe(true);
+  });
+
+  test('node id with weird characters is sanitized in the filename', async () => {
+    const store = newStore();
+    await store.saveNodeResult('run-1', 'node/a:b', { v: 1 });
+    // We don't care about the on-disk name — just that round-trip works.
+    expect(await store.loadNodeResult('run-1', 'node/a:b')).toEqual({ v: 1 });
+  });
+
+  test('refuses to escape baseDir via "../"', async () => {
+    const store = newStore();
+    await expect(store.saveRun({ id: '../escape', nodeStates: {} }))
+      .rejects.toThrow();
+  });
+});
+
+describe('FlowCheckpointStore — clearRun', () => {
+  test('clearRun removes the run directory and all checkpoints', async () => {
+    const store = newStore();
+    await store.saveRun({ id: 'r1', nodeStates: {} });
+    await store.saveNodeResult('r1', 'a', { v: 1 });
+    await store.clearRun('r1');
+    expect(await store.loadRun('r1')).toBe(null);
+    expect(await store.listNodeResults('r1')).toEqual([]);
+  });
+
+  test('clearRun on unknown run is a no-op (does not throw)', async () => {
+    const store = newStore();
+    await expect(store.clearRun('nope')).resolves.not.toThrow();
+  });
+});
+
+describe('FlowCheckpointStore — atomic write', () => {
+  test('partial write (mocked failure between tmp+rename) leaves no half-file', async () => {
+    // Simulate by writing a node result, then forcing a write to fail
+    // mid-operation. We don't have direct hooks but can verify after a
+    // successful write the file is fully readable JSON.
+    const store = newStore();
+    await store.saveNodeResult('r1', 'a', { complex: { nested: [1, 2, 3] } });
+    const raw = await fs.readFile(path.join(tmpRoot, 'r1', 'node-a.json'), 'utf8').catch(() => null);
+    // File must be valid JSON if it exists
+    if (raw !== null) {
+      expect(() => JSON.parse(raw)).not.toThrow();
+    }
+  });
+});