@ronkovic/aad 0.3.0

package/src/modules/persistence/__tests__/stores.test.ts

@@ -0,0 +1,594 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { rm, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { createTaskId, createWorkerId, createRunId, type Task, type Worker, type RunState } from "@aad/shared/types";
+import { createStores } from "../index";
+import type { Stores } from "../index";
+
+// Use a unique directory per process to avoid cross-contamination in parallel runs
+const TEST_DIR = join(import.meta.dir, `.tmp-stores-test-${process.pid}`);
+
+describe("InMemory Stores", () => {
+  let stores: Stores;
+
+  beforeEach(() => {
+    stores = createStores("memory");
+  });
+
+  describe("TaskStore", () => {
+    test("saves and retrieves task", async () => {
+      const task: Task = {
+        taskId: createTaskId("task-1"),
+        title: "Test Task",
+        description: "A test task",
+        filesToModify: ["file1.ts"],
+        dependsOn: [],
+        priority: 1,
+        status: "pending",
+        retryCount: 0,
+      };
+
+      await stores.taskStore.save(task);
+      const retrieved = await stores.taskStore.get(createTaskId("task-1"));
+
+      expect(retrieved).toEqual(task);
+    });
+
+    test("getByStatus returns filtered tasks", async () => {
+      const tasks: Task[] = [
+        {
+          taskId: createTaskId("task-1"),
+          title: "Task 1",
+          description: "Pending task",
+          filesToModify: [],
+          dependsOn: [],
+          priority: 1,
+          status: "pending",
+          retryCount: 0,
+        },
+        {
+          taskId: createTaskId("task-2"),
+          title: "Task 2",
+          description: "Running task",
+          filesToModify: [],
+          dependsOn: [],
+          priority: 2,
+          status: "running",
+          retryCount: 0,
+        },
+      ];
+
+      for (const task of tasks) {
+        await stores.taskStore.save(task);
+      }
+
+      const pending = await stores.taskStore.getByStatus("pending");
+      const running = await stores.taskStore.getByStatus("running");
+
+      expect(pending).toHaveLength(1);
+      expect(running).toHaveLength(1);
+      expect(pending[0]?.taskId as string).toBe("task-1");
+      expect(running[0]?.taskId as string).toBe("task-2");
+    });
+
+    test("getAll returns all tasks", async () => {
+      const tasks: Task[] = [
+        {
+          taskId: createTaskId("task-1"),
+          title: "Task 1",
+          description: "Task 1",
+          filesToModify: [],
+          dependsOn: [],
+          priority: 1,
+          status: "pending",
+          retryCount: 0,
+        },
+        {
+          taskId: createTaskId("task-2"),
+          title: "Task 2",
+          description: "Task 2",
+          filesToModify: [],
+          dependsOn: [],
+          priority: 2,
+          status: "running",
+          retryCount: 0,
+        },
+      ];
+
+      for (const task of tasks) {
+        await stores.taskStore.save(task);
+      }
+
+      const all = await stores.taskStore.getAll();
+      expect(all).toHaveLength(2);
+    });
+
+    test("delete removes task", async () => {
+      const task: Task = {
+        taskId: createTaskId("task-1"),
+        title: "Task",
+        description: "Task",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "pending",
+        retryCount: 0,
+      };
+
+      await stores.taskStore.save(task);
+      await stores.taskStore.delete(createTaskId("task-1"));
+
+      const retrieved = await stores.taskStore.get(createTaskId("task-1"));
+      expect(retrieved).toBeNull();
+    });
+  });
+
+  describe("WorkerStore", () => {
+    test("saves and retrieves worker", async () => {
+      const worker: Worker = {
+        workerId: createWorkerId("worker-1"),
+        status: "idle",
+        currentTask: null,
+      };
+
+      await stores.workerStore.save(worker);
+      const retrieved = await stores.workerStore.get(createWorkerId("worker-1"));
+
+      expect(retrieved).toEqual(worker);
+    });
+
+    test("getIdle returns only idle workers", async () => {
+      const workers: Worker[] = [
+        {
+          workerId: createWorkerId("worker-1"),
+          status: "idle",
+          currentTask: null,
+        },
+        {
+          workerId: createWorkerId("worker-2"),
+          status: "busy",
+          currentTask: createTaskId("task-1"),
+        },
+      ];
+
+      for (const worker of workers) {
+        await stores.workerStore.save(worker);
+      }
+
+      const idle = await stores.workerStore.getIdle();
+      expect(idle).toHaveLength(1);
+      expect(idle[0]?.workerId as string).toBe("worker-1");
+    });
+
+    test("getAll returns all workers", async () => {
+      const workers: Worker[] = [
+        {
+          workerId: createWorkerId("worker-1"),
+          status: "idle",
+          currentTask: null,
+        },
+        {
+          workerId: createWorkerId("worker-2"),
+          status: "busy",
+          currentTask: createTaskId("task-1"),
+        },
+      ];
+
+      for (const worker of workers) {
+        await stores.workerStore.save(worker);
+      }
+
+      const all = await stores.workerStore.getAll();
+      expect(all).toHaveLength(2);
+    });
+
+    test("delete removes worker", async () => {
+      const worker: Worker = {
+        workerId: createWorkerId("worker-1"),
+        status: "idle",
+        currentTask: null,
+      };
+
+      await stores.workerStore.save(worker);
+      await stores.workerStore.delete(createWorkerId("worker-1"));
+
+      const retrieved = await stores.workerStore.get(createWorkerId("worker-1"));
+      expect(retrieved).toBeNull();
+    });
+  });
+
+  describe("RunStore", () => {
+    test("saves and retrieves run state", async () => {
+      const runState: RunState = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        totalTasks: 10,
+        pending: 5,
+        running: 3,
+        completed: 2,
+        failed: 0,
+        startTime: new Date().toISOString(),
+      };
+
+      await stores.runStore.save(runState);
+      const retrieved = await stores.runStore.get(createRunId("run-123"));
+
+      expect(retrieved).toEqual(runState);
+    });
+
+    test("returns null for non-existent run", async () => {
+      const retrieved = await stores.runStore.get(createRunId("non-existent"));
+      expect(retrieved).toBeNull();
+    });
+
+    test("getLatest returns most recent run by startTime", async () => {
+      const runs: RunState[] = [
+        {
+          runId: createRunId("run-1"),
+          parentBranch: "main",
+          totalTasks: 5,
+          pending: 0,
+          running: 0,
+          completed: 5,
+          failed: 0,
+          startTime: "2024-01-01T10:00:00Z",
+        },
+        {
+          runId: createRunId("run-2"),
+          parentBranch: "main",
+          totalTasks: 3,
+          pending: 0,
+          running: 0,
+          completed: 3,
+          failed: 0,
+          startTime: "2024-01-02T10:00:00Z", // Most recent
+        },
+        {
+          runId: createRunId("run-3"),
+          parentBranch: "main",
+          totalTasks: 2,
+          pending: 0,
+          running: 0,
+          completed: 2,
+          failed: 0,
+          startTime: "2024-01-01T12:00:00Z",
+        },
+      ];
+
+      for (const run of runs) {
+        await stores.runStore.save(run);
+      }
+
+      const latest = await stores.runStore.getLatest();
+      expect(latest).not.toBeNull();
+      expect(latest?.runId as string).toBe("run-2");
+    });
+
+    test("getLatest returns null when no runs exist", async () => {
+      const latest = await stores.runStore.getLatest();
+      expect(latest).toBeNull();
+    });
+  });
+});
+
+describe("FileSystem Stores", () => {
+  let stores: Stores;
+
+  beforeEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+    await mkdir(TEST_DIR, { recursive: true });
+    stores = createStores("fs", { basePath: TEST_DIR });
+  });
+
+  afterEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("FSTaskStore", () => {
+    test("saves and retrieves task", async () => {
+      const task: Task = {
+        taskId: createTaskId("task-1"),
+        title: "FS Test Task",
+        description: "A filesystem test task",
+        filesToModify: ["file1.ts", "file2.ts"],
+        dependsOn: [],
+        priority: 1,
+        status: "pending",
+        retryCount: 0,
+      };
+
+      await stores.taskStore.save(task);
+      const retrieved = await stores.taskStore.get(createTaskId("task-1"));
+
+      expect(retrieved).toEqual(task);
+    });
+
+    test("handles status changes correctly", async () => {
+      const task: Task = {
+        taskId: createTaskId("task-status-change"),
+        title: "Task",
+        description: "Task",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "pending",
+        retryCount: 0,
+      };
+
+      await stores.taskStore.save(task);
+
+      // Verify it's in pending
+      let pending = await stores.taskStore.getByStatus("pending");
+      expect(pending).toHaveLength(1);
+
+      // Change status to running
+      task.status = "running";
+      await stores.taskStore.save(task);
+
+      // Verify it moved from pending to running
+      pending = await stores.taskStore.getByStatus("pending");
+      const running = await stores.taskStore.getByStatus("running");
+
+      expect(pending).toHaveLength(0);
+      expect(running).toHaveLength(1);
+    });
+
+    test("getAll returns all tasks from all status dirs", async () => {
+      const tasks: Task[] = [
+        {
+          taskId: createTaskId("task-getall-1"),
+          title: "Task 1",
+          description: "Task 1",
+          filesToModify: [],
+          dependsOn: [],
+          priority: 1,
+          status: "pending",
+          retryCount: 0,
+        },
+        {
+          taskId: createTaskId("task-getall-2"),
+          title: "Task 2",
+          description: "Task 2",
+          filesToModify: [],
+          dependsOn: [],
+          priority: 2,
+          status: "completed",
+          retryCount: 0,
+        },
+      ];
+
+      for (const task of tasks) {
+        await stores.taskStore.save(task);
+      }
+
+      const all = await stores.taskStore.getAll();
+      expect(all).toHaveLength(2);
+    });
+  });
+
+  describe("FSWorkerStore", () => {
+    test("saves and retrieves worker", async () => {
+      const worker: Worker = {
+        workerId: createWorkerId("worker-1"),
+        status: "idle",
+        currentTask: null,
+        pid: process.pid,
+      };
+
+      await stores.workerStore.save(worker);
+      const retrieved = await stores.workerStore.get(createWorkerId("worker-1"));
+
+      expect(retrieved).toEqual(worker);
+    });
+
+    test("getIdle filters idle workers", async () => {
+      const workers: Worker[] = [
+        {
+          workerId: createWorkerId("worker-1"),
+          status: "idle",
+          currentTask: null,
+        },
+        {
+          workerId: createWorkerId("worker-2"),
+          status: "busy",
+          currentTask: createTaskId("task-1"),
+        },
+      ];
+
+      for (const worker of workers) {
+        await stores.workerStore.save(worker);
+      }
+
+      const idle = await stores.workerStore.getIdle();
+      expect(idle).toHaveLength(1);
+      expect(idle[0]?.status).toBe("idle");
+    });
+  });
+
+  describe("FSTaskStore edge cases", () => {
+    test("delete then getAll does not contain deleted task", async () => {
+      const task: Task = {
+        taskId: createTaskId("task-del-getall"),
+        title: "Task",
+        description: "Task",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "pending",
+        retryCount: 0,
+      };
+
+      await stores.taskStore.save(task);
+      await stores.taskStore.delete(createTaskId("task-del-getall"));
+
+      const all = await stores.taskStore.getAll();
+      const found = all.find((t) => (t.taskId as string) === "task-del-getall");
+      expect(found).toBeUndefined();
+    });
+
+    test("get non-existent taskId returns null", async () => {
+      const result = await stores.taskStore.get(createTaskId("does-not-exist"));
+      expect(result).toBeNull();
+    });
+
+    test("delete non-existent taskId does not throw", async () => {
+      await expect(
+        stores.taskStore.delete(createTaskId("does-not-exist"))
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  describe("FSWorkerStore edge cases", () => {
+    test("delete then getAll does not contain deleted worker", async () => {
+      const worker: Worker = {
+        workerId: createWorkerId("worker-del"),
+        status: "idle",
+        currentTask: null,
+      };
+
+      await stores.workerStore.save(worker);
+      await stores.workerStore.delete(createWorkerId("worker-del"));
+
+      const all = await stores.workerStore.getAll();
+      const found = all.find((w) => (w.workerId as string) === "worker-del");
+      expect(found).toBeUndefined();
+    });
+
+    test("get non-existent workerId returns null", async () => {
+      const result = await stores.workerStore.get(createWorkerId("does-not-exist"));
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("FSRunStore edge cases", () => {
+    test("save overwrites previous run state", async () => {
+      const run1: RunState = {
+        runId: createRunId("run-overwrite"),
+        parentBranch: "main",
+        totalTasks: 5,
+        pending: 5,
+        running: 0,
+        completed: 0,
+        failed: 0,
+        startTime: "2024-01-01T10:00:00Z",
+      };
+
+      await stores.runStore.save(run1);
+
+      const run1Updated: RunState = {
+        ...run1,
+        pending: 3,
+        running: 2,
+      };
+
+      await stores.runStore.save(run1Updated);
+      const retrieved = await stores.runStore.get(createRunId("run-overwrite"));
+
+      expect(retrieved).toEqual(run1Updated);
+      expect(retrieved?.pending).toBe(3);
+      expect(retrieved?.running).toBe(2);
+    });
+
+    test("getLatest returns last saved run (single file store)", async () => {
+      const run1: RunState = {
+        runId: createRunId("run-first"),
+        parentBranch: "main",
+        totalTasks: 5,
+        pending: 5,
+        running: 0,
+        completed: 0,
+        failed: 0,
+        startTime: "2024-01-01T10:00:00Z",
+      };
+
+      const run2: RunState = {
+        runId: createRunId("run-second"),
+        parentBranch: "main",
+        totalTasks: 3,
+        pending: 3,
+        running: 0,
+        completed: 0,
+        failed: 0,
+        startTime: "2024-01-02T10:00:00Z",
+      };
+
+      await stores.runStore.save(run1);
+      await stores.runStore.save(run2);
+
+      const latest = await stores.runStore.getLatest();
+      expect(latest).not.toBeNull();
+      expect(latest?.runId as string).toBe("run-second");
+    });
+  });
+
+  describe("FSRunStore", () => {
+    test("saves and retrieves run state", async () => {
+      const runState: RunState = {
+        runId: createRunId("run-456"),
+        parentBranch: "develop",
+        totalTasks: 20,
+        pending: 10,
+        running: 5,
+        completed: 5,
+        failed: 0,
+        startTime: new Date().toISOString(),
+      };
+
+      await stores.runStore.save(runState);
+      const retrieved = await stores.runStore.get(createRunId("run-456"));
+
+      expect(retrieved).toEqual(runState);
+    });
+
+    test("returns null for mismatched runId", async () => {
+      const runState: RunState = {
+        runId: createRunId("run-111"),
+        parentBranch: "main",
+        totalTasks: 5,
+        pending: 5,
+        running: 0,
+        completed: 0,
+        failed: 0,
+        startTime: new Date().toISOString(),
+      };
+
+      await stores.runStore.save(runState);
+      const retrieved = await stores.runStore.get(createRunId("run-999"));
+
+      expect(retrieved).toBeNull();
+    });
+
+    test("getLatest returns the saved run state", async () => {
+      const runState: RunState = {
+        runId: createRunId("run-latest"),
+        parentBranch: "main",
+        totalTasks: 8,
+        pending: 0,
+        running: 0,
+        completed: 8,
+        failed: 0,
+        startTime: "2024-01-03T10:00:00Z",
+      };
+
+      await stores.runStore.save(runState);
+      const latest = await stores.runStore.getLatest();
+
+      expect(latest).toEqual(runState);
+    });
+
+    test("getLatest returns null when no run exists", async () => {
+      // Create a completely separate directory for this test
+      const emptyTestDir = join(import.meta.dir, ".tmp-stores-test-empty");
+      await rm(emptyTestDir, { recursive: true, force: true });
+      await mkdir(emptyTestDir, { recursive: true });
+
+      try {
+        const freshStores = createStores("fs", { basePath: emptyTestDir });
+        const latest = await freshStores.runStore.getLatest();
+        expect(latest).toBeNull();
+      } finally {
+        await rm(emptyTestDir, { recursive: true, force: true });
+      }
+    });
+  });
+});