@ronkovic/aad 0.3.0

package/src/modules/task-queue/__tests__/dispatcher.test.ts

@@ -0,0 +1,824 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { createTaskId, createWorkerId, createRunId, type TaskPlan, type Worker } from "@aad/shared/types";
+import { EventBus } from "@aad/shared/events";
+import { createStores } from "../../persistence";
+import { Dispatcher } from "../dispatcher";
+import { pino } from "pino";
+
+describe("Dispatcher", () => {
+  let dispatcher: Dispatcher;
+  let eventBus: EventBus;
+
+  beforeEach(() => {
+    const stores = createStores("memory");
+    eventBus = new EventBus();
+    const logger = pino({ level: "silent" });
+
+    dispatcher = new Dispatcher({
+      taskStore: stores.taskStore,
+      workerStore: stores.workerStore,
+      runStore: stores.runStore,
+      eventBus,
+      config: {
+        maxRetries: 2,
+        staleTaskCheckInterval: 60000,
+        staleTaskThreshold: 300000,
+      },
+      logger,
+    });
+  });
+
+  afterEach(() => {
+    dispatcher.stop();
+  });
+
+  describe("initialize", () => {
+    test("initializes with task plan", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "pending",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      let eventEmitted = false;
+      eventBus.on("queue:initialized", () => {
+        eventEmitted = true;
+      });
+
+      await dispatcher.initialize(taskPlan);
+
+      expect(eventEmitted).toBe(true);
+
+      const progress = dispatcher.getProgress();
+      expect(progress.total).toBe(1);
+      expect(progress.pending).toBe(1);
+    });
+
+    test("throws if already initialized", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      await expect(dispatcher.initialize(taskPlan)).rejects.toThrow("already initialized");
+    });
+  });
+
+  describe("dispatchNext", () => {
+    test("dispatches ready task to idle worker", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "pending",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      // Add idle worker
+      const worker: Worker = {
+        workerId: createWorkerId("worker-1"),
+        status: "idle",
+        currentTask: null,
+      };
+      await dispatcher["deps"].workerStore.save(worker);
+
+      let dispatchedTaskId: string | undefined;
+      eventBus.on("task:dispatched", (event) => {
+        if (event.type === "task:dispatched") {
+          dispatchedTaskId = event.taskId as string;
+        }
+      });
+
+      const dispatched = await dispatcher.dispatchNext();
+
+      expect(dispatched).toBe(true);
+      expect(dispatchedTaskId).toBe("task-1");
+    });
+
+    test("returns false when no idle workers", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "pending",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      const dispatched = await dispatcher.dispatchNext();
+
+      expect(dispatched).toBe(false);
+    });
+
+    test("returns false when no ready tasks", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "running",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      const worker: Worker = {
+        workerId: createWorkerId("worker-1"),
+        status: "idle",
+        currentTask: null,
+      };
+      await dispatcher["deps"].workerStore.save(worker);
+
+      const dispatched = await dispatcher.dispatchNext();
+
+      expect(dispatched).toBe(false);
+    });
+
+    test("dispatches highest priority task first", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "pending",
+            retryCount: 0,
+          },
+          {
+            taskId: createTaskId("task-2"),
+            title: "Task 2",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 3,
+            status: "pending",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      const worker: Worker = {
+        workerId: createWorkerId("worker-1"),
+        status: "idle",
+        currentTask: null,
+      };
+      await dispatcher["deps"].workerStore.save(worker);
+
+      let dispatchedTaskId: string | undefined;
+      eventBus.on("task:dispatched", (event) => {
+        if (event.type === "task:dispatched") {
+          dispatchedTaskId = event.taskId as string;
+        }
+      });
+
+      await dispatcher.dispatchNext();
+
+      expect(dispatchedTaskId).toBe("task-2"); // Higher priority
+    });
+  });
+
+  describe("handleTaskCompleted", () => {
+    test("marks task as completed and updates progress", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "running",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      let progressUpdated = false;
+      eventBus.on("progress:updated", () => {
+        progressUpdated = true;
+      });
+
+      await dispatcher.handleTaskCompleted(createTaskId("task-1"));
+
+      expect(progressUpdated).toBe(true);
+
+      const progress = dispatcher.getProgress();
+      expect(progress.completed).toBe(1);
+      expect(progress.running).toBe(0);
+    });
+
+    test("emits run:completed when all tasks are completed", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "running",
+            retryCount: 0,
+          },
+          {
+            taskId: createTaskId("task-2"),
+            title: "Task 2",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 2,
+            status: "completed",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      let runCompletedEmitted = false;
+      let capturedRunId: string | undefined;
+      eventBus.on("run:completed", (event) => {
+        if (event.type === "run:completed") {
+          runCompletedEmitted = true;
+          capturedRunId = event.runId as string;
+        }
+      });
+
+      await dispatcher.handleTaskCompleted(createTaskId("task-1"));
+
+      expect(runCompletedEmitted).toBe(true);
+      expect(capturedRunId).toBe("run-123");
+    });
+
+    test("emits run:completed when some tasks failed and rest completed", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-456"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "running",
+            retryCount: 0,
+          },
+          {
+            taskId: createTaskId("task-2"),
+            title: "Task 2",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 2,
+            status: "running",
+            retryCount: 2, // Will fail permanently
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      let runCompletedEmitted = false;
+      eventBus.on("run:completed", (event) => {
+        if (event.type === "run:completed") {
+          runCompletedEmitted = true;
+        }
+      });
+
+      // First task fails permanently
+      await dispatcher.handleTaskFailed(createTaskId("task-2"), "Permanent failure");
+
+      expect(runCompletedEmitted).toBe(false); // Not yet
+
+      // Second task completes
+      await dispatcher.handleTaskCompleted(createTaskId("task-1"));
+
+      expect(runCompletedEmitted).toBe(true);
+    });
+
+    test("does not emit run:completed when task plan is empty", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-empty"),
+        parentBranch: "main",
+        tasks: [],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      let runCompletedEmitted = false;
+      eventBus.on("run:completed", () => {
+        runCompletedEmitted = true;
+      });
+
+      // Simulate progress check
+      const progress = dispatcher.getProgress();
+      expect(progress.total).toBe(0);
+
+      // No tasks to complete, so run:completed should not be emitted
+      expect(runCompletedEmitted).toBe(false);
+    });
+  });
+
+  describe("handleTaskFailed", () => {
+    test("retries failed task if under max retries", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "running",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      let retryEventEmitted = false;
+      eventBus.on("task:retry", () => {
+        retryEventEmitted = true;
+      });
+
+      await dispatcher.handleTaskFailed(createTaskId("task-1"), "Test error");
+
+      expect(retryEventEmitted).toBe(true);
+
+      const progress = dispatcher.getProgress();
+      expect(progress.pending).toBe(1); // Back to pending
+      expect(progress.failed).toBe(0);
+    });
+
+    test("marks task as permanently failed after max retries", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "running",
+            retryCount: 2, // At max retries
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      await dispatcher.handleTaskFailed(createTaskId("task-1"), "Test error");
+
+      const progress = dispatcher.getProgress();
+      expect(progress.failed).toBe(1);
+      expect(progress.pending).toBe(0);
+    });
+  });
+
+  describe("getProgress", () => {
+    test("returns accurate progress state", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "pending",
+            retryCount: 0,
+          },
+          {
+            taskId: createTaskId("task-2"),
+            title: "Task 2",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 2,
+            status: "running",
+            retryCount: 0,
+          },
+          {
+            taskId: createTaskId("task-3"),
+            title: "Task 3",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 3,
+            status: "completed",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      const progress = dispatcher.getProgress();
+
+      expect(progress.total).toBe(3);
+      expect(progress.pending).toBe(1);
+      expect(progress.running).toBe(1);
+      expect(progress.completed).toBe(1);
+      expect(progress.failed).toBe(0);
+    });
+  });
+
+  describe("start", () => {
+    test("triggers initial dispatchNext on start", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "pending",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      const worker: Worker = {
+        workerId: createWorkerId("worker-1"),
+        status: "idle",
+        currentTask: null,
+      };
+      await dispatcher["deps"].workerStore.save(worker);
+
+      let dispatchedTaskId: string | undefined;
+      eventBus.on("task:dispatched", (event) => {
+        if (event.type === "task:dispatched") {
+          dispatchedTaskId = event.taskId as string;
+        }
+      });
+
+      dispatcher.start();
+
+      // Wait for microtask/setTimeout to resolve
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      expect(dispatchedTaskId).toBe("task-1");
+    });
+
+    test("dispatches multiple tasks to multiple workers simultaneously", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "pending",
+            retryCount: 0,
+          },
+          {
+            taskId: createTaskId("task-2"),
+            title: "Task 2",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 2,
+            status: "pending",
+            retryCount: 0,
+          },
+          {
+            taskId: createTaskId("task-3"),
+            title: "Task 3",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 3,
+            status: "pending",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      const worker1: Worker = {
+        workerId: createWorkerId("worker-1"),
+        status: "idle",
+        currentTask: null,
+      };
+      const worker2: Worker = {
+        workerId: createWorkerId("worker-2"),
+        status: "idle",
+        currentTask: null,
+      };
+      await dispatcher["deps"].workerStore.save(worker1);
+      await dispatcher["deps"].workerStore.save(worker2);
+
+      const dispatchedTasks: string[] = [];
+      eventBus.on("task:dispatched", (event) => {
+        if (event.type === "task:dispatched") {
+          dispatchedTasks.push(event.taskId as string);
+        }
+      });
+
+      await dispatcher.dispatchNext();
+
+      expect(dispatchedTasks.length).toBe(2);
+      // Priority order: task-3 (p=3), task-2 (p=2)
+      expect(dispatchedTasks).toContain("task-3");
+      expect(dispatchedTasks).toContain("task-2");
+    });
+
+    test("dispatches only available tasks when workers exceed tasks", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-123"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-1"),
+            title: "Task 1",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "pending",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      const worker1: Worker = {
+        workerId: createWorkerId("worker-1"),
+        status: "idle",
+        currentTask: null,
+      };
+      const worker2: Worker = {
+        workerId: createWorkerId("worker-2"),
+        status: "idle",
+        currentTask: null,
+      };
+      const worker3: Worker = {
+        workerId: createWorkerId("worker-3"),
+        status: "idle",
+        currentTask: null,
+      };
+      await dispatcher["deps"].workerStore.save(worker1);
+      await dispatcher["deps"].workerStore.save(worker2);
+      await dispatcher["deps"].workerStore.save(worker3);
+
+      const dispatchedTasks: string[] = [];
+      eventBus.on("task:dispatched", (event) => {
+        if (event.type === "task:dispatched") {
+          dispatchedTasks.push(event.taskId as string);
+        }
+      });
+
+      await dispatcher.dispatchNext();
+
+      expect(dispatchedTasks.length).toBe(1);
+      expect(dispatchedTasks[0]).toBe("task-1");
+    });
+
+    test("throws if start() called before initialize", () => {
+      expect(() => dispatcher.start()).toThrow("not initialized");
+    });
+
+    test("stop clears stale check interval", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-stop"),
+        parentBranch: "main",
+        tasks: [],
+      };
+
+      await dispatcher.initialize(taskPlan);
+      dispatcher.start();
+      dispatcher.stop();
+      // Should not throw when called again
+      dispatcher.stop();
+    });
+  });
+
+  describe("edge cases", () => {
+    test("handleTaskCompleted ignores unknown task", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-unknown"),
+        parentBranch: "main",
+        tasks: [],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      // Should not throw
+      await dispatcher.handleTaskCompleted(createTaskId("nonexistent"));
+    });
+
+    test("handleTaskFailed ignores unknown task", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-unknown2"),
+        parentBranch: "main",
+        tasks: [],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      // Should not throw
+      await dispatcher.handleTaskFailed(createTaskId("nonexistent"), "error");
+    });
+
+    test("emits queue:empty when all tasks are non-pending and no ready tasks", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-empty-q"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-done"),
+            title: "Done",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "completed",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      let queueEmptyEmitted = false;
+      eventBus.on("queue:empty", () => {
+        queueEmptyEmitted = true;
+      });
+
+      const worker: Worker = {
+        workerId: createWorkerId("worker-1"),
+        status: "idle",
+        currentTask: null,
+      };
+      await dispatcher["deps"].workerStore.save(worker);
+
+      const dispatched = await dispatcher.dispatchNext();
+
+      expect(dispatched).toBe(false);
+      expect(queueEmptyEmitted).toBe(true);
+    });
+
+    test("cascadeFailDependents fails dependent tasks recursively", async () => {
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-cascade"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-root"),
+            title: "Root",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "running",
+            retryCount: 2, // Will fail permanently
+          },
+          {
+            taskId: createTaskId("task-child"),
+            title: "Child",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [createTaskId("task-root")],
+            priority: 2,
+            status: "pending",
+            retryCount: 0,
+          },
+          {
+            taskId: createTaskId("task-grandchild"),
+            title: "Grandchild",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [createTaskId("task-child")],
+            priority: 3,
+            status: "pending",
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      await dispatcher.handleTaskFailed(createTaskId("task-root"), "Root failed");
+
+      const progress = dispatcher.getProgress();
+      expect(progress.failed).toBe(3); // root + child + grandchild
+    });
+
+    test("stale task detection emits task:stale event", async () => {
+      const pastTime = new Date(Date.now() - 600000).toISOString(); // 10 minutes ago
+
+      const taskPlan: TaskPlan = {
+        runId: createRunId("run-stale"),
+        parentBranch: "main",
+        tasks: [
+          {
+            taskId: createTaskId("task-stale"),
+            title: "Stale",
+            description: "Task",
+            filesToModify: [],
+            dependsOn: [],
+            priority: 1,
+            status: "running",
+            startTime: pastTime,
+            retryCount: 0,
+          },
+        ],
+      };
+
+      await dispatcher.initialize(taskPlan);
+
+      let staleEmitted = false;
+      eventBus.on("task:stale", (event) => {
+        if (event.type === "task:stale") {
+          staleEmitted = true;
+        }
+      });
+
+      // Manually call detectStaleTasks
+      dispatcher["detectStaleTasks"]();
+
+      expect(staleEmitted).toBe(true);
+    });
+  });
+});