@ronkovic/aad 0.3.0

package/src/shared/__tests__/events.test.ts

@@ -0,0 +1,496 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { EventBus, type AADEvent } from "../events";
+import { createTaskId, createWorkerId, createRunId } from "../types";
+
+describe("EventBus", () => {
+  let eventBus: EventBus;
+
+  beforeEach(() => {
+    eventBus = new EventBus();
+  });
+
+  test("emits and receives task:dispatched event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("task:dispatched", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "task:dispatched",
+      taskId: createTaskId("t1"),
+      workerId: createWorkerId("w1"),
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives task:completed event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("task:completed", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "task:completed",
+      taskId: createTaskId("t1"),
+      result: {
+        taskId: createTaskId("t1"),
+        status: "completed",
+        duration: 1000,
+      },
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives task:failed event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("task:failed", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "task:failed",
+      taskId: createTaskId("t1"),
+      error: "Timeout",
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives worker:idle event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("worker:idle", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "worker:idle",
+      workerId: createWorkerId("w1"),
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives progress:updated event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("progress:updated", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "progress:updated",
+      state: {
+        total: 10,
+        pending: 5,
+        running: 3,
+        completed: 2,
+        failed: 0,
+      },
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives run:completed event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("run:completed", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "run:completed",
+      runId: createRunId("r1"),
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives log:entry event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("log:entry", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "log:entry",
+      entry: {
+        level: "info",
+        service: "test",
+        message: "Test log",
+        timestamp: Date.now(),
+      },
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("supports multiple listeners for same event type", () => {
+    const received: AADEvent[] = [];
+
+    eventBus.on("worker:idle", (event) => {
+      received.push(event);
+    });
+
+    eventBus.on("worker:idle", (event) => {
+      received.push(event);
+    });
+
+    const event: AADEvent = {
+      type: "worker:idle",
+      workerId: createWorkerId("w1"),
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toHaveLength(2);
+    expect(received[0]).toEqual(event);
+    expect(received[1]).toEqual(event);
+  });
+
+  test("off() removes listener", () => {
+    let count = 0;
+    const listener = () => {
+      count++;
+    };
+
+    eventBus.on("worker:idle", listener);
+
+    const event: AADEvent = {
+      type: "worker:idle",
+      workerId: createWorkerId("w1"),
+    };
+
+    eventBus.emit(event);
+    expect(count).toBe(1);
+
+    eventBus.off("worker:idle", listener);
+    eventBus.emit(event);
+    expect(count).toBe(1);
+  });
+
+  test("listener exception does not affect other listeners", () => {
+    let received: AADEvent | undefined;
+
+    eventBus.on("worker:idle", () => {
+      throw new Error("Listener error");
+    });
+
+    eventBus.on("worker:idle", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "worker:idle",
+      workerId: createWorkerId("w1"),
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits wildcard * for all events", () => {
+    const received: AADEvent[] = [];
+
+    eventBus.on("*", (event) => {
+      received.push(event);
+    });
+
+    const event1: AADEvent = {
+      type: "worker:idle",
+      workerId: createWorkerId("w1"),
+    };
+    const event2: AADEvent = {
+      type: "task:dispatched",
+      taskId: createTaskId("t1"),
+      workerId: createWorkerId("w1"),
+    };
+
+    eventBus.emit(event1);
+    eventBus.emit(event2);
+
+    expect(received).toHaveLength(2);
+    expect(received[0]).toEqual(event1);
+    expect(received[1]).toEqual(event2);
+  });
+
+  test("emits and receives task:stale event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("task:stale", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "task:stale",
+      taskId: createTaskId("t1"),
+      elapsed: 120000,
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives task:retry event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("task:retry", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "task:retry",
+      taskId: createTaskId("t1"),
+      retryCount: 2,
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives worker:started event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("worker:started", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "worker:started",
+      workerId: createWorkerId("w1"),
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives worker:stopped event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("worker:stopped", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "worker:stopped",
+      workerId: createWorkerId("w1"),
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives worker:busy event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("worker:busy", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "worker:busy",
+      workerId: createWorkerId("w1"),
+      taskId: createTaskId("t1"),
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives queue:initialized event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("queue:initialized", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "queue:initialized",
+      totalTasks: 10,
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives queue:empty event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("queue:empty", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "queue:empty",
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives planning:started event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("planning:started", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "planning:started",
+      requirementsPath: "/path/to/req.md",
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives planning:completed event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("planning:completed", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "planning:completed",
+      taskCount: 5,
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives planning:failed event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("planning:failed", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "planning:failed",
+      error: "Invalid task plan",
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives execution:started event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("execution:started", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "execution:started",
+      taskId: createTaskId("t1"),
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives execution:completed event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("execution:completed", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "execution:completed",
+      taskId: createTaskId("t1"),
+      duration: 5000,
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives execution:phase:started event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("execution:phase:started", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "execution:phase:started",
+      taskId: createTaskId("t1"),
+      phase: "red",
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives execution:phase:completed event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("execution:phase:completed", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "execution:phase:completed",
+      taskId: createTaskId("t1"),
+      phase: "green",
+      duration: 2000,
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives execution:phase:failed event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("execution:phase:failed", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "execution:phase:failed",
+      taskId: createTaskId("t1"),
+      phase: "verify",
+      error: "Tests failed",
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+
+  test("emits and receives execution:merge:conflict event", () => {
+    let received: AADEvent | undefined;
+    eventBus.on("execution:merge:conflict", (event) => {
+      received = event;
+    });
+
+    const event: AADEvent = {
+      type: "execution:merge:conflict",
+      taskId: createTaskId("t1"),
+      conflictedFiles: ["src/file1.ts", "src/file2.ts"],
+    };
+
+    eventBus.emit(event);
+
+    expect(received).toEqual(event);
+  });
+});