@ronkovic/aad 0.3.8 → 0.4.0

package/src/modules/dashboard/__tests__/api-timeline.test.ts

@@ -0,0 +1,461 @@
+import { describe, test, expect } from "bun:test";
+import type { StateAggregator } from "../services/state-aggregator";
+
+/**
+ * テストケース: /api/timeline エンドポイント
+ *
+ * タスクの実行タイムラインを返す
+ * - 各タスクの開始時刻、終了時刻、実行期間を可視化
+ * - Ganttチャートやタイムライン表示に使用
+ *
+ * NOTE: 現在の実装はタスク全体のタイムラインのみ。
+ * 将来的にはフェーズ別タイムライン (Red, Green, Verify, Review, Merge) に拡張予定。
+ */
+describe("GET /api/timeline - Task Execution Timeline", () => {
+  /**
+   * テストケース 1: タスクなし (空のタイムライン)
+   *
+   * 期待値:
+   * - tasks: 空配列
+   */
+  test("returns empty timeline when no tasks exist", async () => {
+    const mockAggregator: StateAggregator = {
+      getTimeline: async () => ({
+        tasks: [],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getTimeline();
+
+    expect(result.tasks).toEqual([]);
+  });
+
+  /**
+   * テストケース 2: 単一タスク (完了済み)
+   *
+   * タイムライン:
+   *   [task-1] ████████ (10:00 - 10:05)
+   *
+   * 期待値:
+   * - 開始時刻と終了時刻が設定されている
+   * - ステータスが正しく反映される
+   */
+  test("returns timeline for single completed task", async () => {
+    const startTime = "2025-02-11T10:00:00.000Z";
+    const endTime = "2025-02-11T10:05:00.000Z";
+
+    const mockAggregator: StateAggregator = {
+      getTimeline: async () => ({
+        tasks: [
+          {
+            id: "task-1",
+            status: "completed",
+            startTime,
+            endTime,
+          },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getTimeline();
+
+    expect(result.tasks).toHaveLength(1);
+    expect(result.tasks[0]).toEqual({
+      id: "task-1",
+      status: "completed",
+      startTime,
+      endTime,
+    });
+  });
+
+  /**
+   * テストケース 3: 実行中タスク (終了時刻なし)
+   *
+   * タイムライン:
+   *   [task-1] ████→ (10:00 - 進行中)
+   *
+   * 期待値:
+   * - startTime は設定されている
+   * - endTime は undefined
+   * - status は "running"
+   */
+  test("returns timeline for running task without endTime", async () => {
+    const startTime = "2025-02-11T10:00:00.000Z";
+
+    const mockAggregator: StateAggregator = {
+      getTimeline: async () => ({
+        tasks: [
+          {
+            id: "task-1",
+            status: "running",
+            startTime,
+            endTime: undefined,
+          },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getTimeline();
+
+    expect(result.tasks).toHaveLength(1);
+    expect(result.tasks[0]).toEqual({
+      id: "task-1",
+      status: "running",
+      startTime,
+      endTime: undefined,
+    });
+  });
+
+  /**
+   * テストケース 4: 保留中タスク (開始時刻・終了時刻なし)
+   *
+   * タイムライン:
+   *   [task-1] (未開始)
+   *
+   * 期待値:
+   * - startTime, endTime ともに undefined
+   * - status は "pending"
+   */
+  test("returns timeline for pending task without timestamps", async () => {
+    const mockAggregator: StateAggregator = {
+      getTimeline: async () => ({
+        tasks: [
+          {
+            id: "task-1",
+            status: "pending",
+            startTime: undefined,
+            endTime: undefined,
+          },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getTimeline();
+
+    expect(result.tasks).toHaveLength(1);
+    expect(result.tasks[0]).toEqual({
+      id: "task-1",
+      status: "pending",
+      startTime: undefined,
+      endTime: undefined,
+    });
+  });
+
+  /**
+   * テストケース 5: 並列タスク (task-1, task-2 同時実行)
+   *
+   * タイムライン:
+   *   [task-1] ████████ (10:00 - 10:05)
+   *   [task-2]   ██████ (10:01 - 10:04)
+   *
+   * 期待値:
+   * - 2つのタスクが時間的に重複
+   * - task-2 は task-1 の実行期間内に開始・終了
+   */
+  test("returns timeline for overlapping parallel tasks", async () => {
+    const task1Start = "2025-02-11T10:00:00.000Z";
+    const task1End = "2025-02-11T10:05:00.000Z";
+    const task2Start = "2025-02-11T10:01:00.000Z";
+    const task2End = "2025-02-11T10:04:00.000Z";
+
+    const mockAggregator: StateAggregator = {
+      getTimeline: async () => ({
+        tasks: [
+          {
+            id: "task-1",
+            status: "completed",
+            startTime: task1Start,
+            endTime: task1End,
+          },
+          {
+            id: "task-2",
+            status: "completed",
+            startTime: task2Start,
+            endTime: task2End,
+          },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getTimeline();
+
+    expect(result.tasks).toHaveLength(2);
+
+    // task-1 と task-2 の実行期間が重複していることを確認
+    const task1 = result.tasks.find((t) => t.id === "task-1")!;
+    const task2 = result.tasks.find((t) => t.id === "task-2")!;
+
+    expect(task1.startTime! < task2.startTime!).toBe(true);
+    expect(task2.startTime! < task1.endTime!).toBe(true);
+    expect(task2.endTime! < task1.endTime!).toBe(true);
+  });
+
+  /**
+   * テストケース 6: 順次タスク (task-1 完了後に task-2 開始)
+   *
+   * タイムライン:
+   *   [task-1] ████████ (10:00 - 10:05)
+   *   [task-2]         ████████ (10:06 - 10:10)
+   *
+   * 期待値:
+   * - task-1 の終了後に task-2 が開始
+   * - 実行期間に重複なし
+   */
+  test("returns timeline for sequential tasks", async () => {
+    const task1Start = "2025-02-11T10:00:00.000Z";
+    const task1End = "2025-02-11T10:05:00.000Z";
+    const task2Start = "2025-02-11T10:06:00.000Z";
+    const task2End = "2025-02-11T10:10:00.000Z";
+
+    const mockAggregator: StateAggregator = {
+      getTimeline: async () => ({
+        tasks: [
+          {
+            id: "task-1",
+            status: "completed",
+            startTime: task1Start,
+            endTime: task1End,
+          },
+          {
+            id: "task-2",
+            status: "completed",
+            startTime: task2Start,
+            endTime: task2End,
+          },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getTimeline();
+
+    expect(result.tasks).toHaveLength(2);
+
+    const task1 = result.tasks.find((t) => t.id === "task-1")!;
+    const task2 = result.tasks.find((t) => t.id === "task-2")!;
+
+    // task-1 の終了後に task-2 が開始
+    expect(task1.endTime! < task2.startTime!).toBe(true);
+  });
+
+  /**
+   * テストケース 7: 全ステータスタイプのタイムライン
+   *
+   * タイムライン:
+   *   [task-1] ████████ (completed)
+   *   [task-2] ████→    (running)
+   *   [task-3]          (pending)
+   *   [task-4] ██✗      (failed)
+   *
+   * 期待値:
+   * - 各ステータス (pending, running, completed, failed) が正しく反映
+   */
+  test("returns timeline with all task status types", async () => {
+    const mockAggregator: StateAggregator = {
+      getTimeline: async () => ({
+        tasks: [
+          {
+            id: "task-1",
+            status: "completed",
+            startTime: "2025-02-11T10:00:00.000Z",
+            endTime: "2025-02-11T10:05:00.000Z",
+          },
+          {
+            id: "task-2",
+            status: "running",
+            startTime: "2025-02-11T10:06:00.000Z",
+            endTime: undefined,
+          },
+          {
+            id: "task-3",
+            status: "pending",
+            startTime: undefined,
+            endTime: undefined,
+          },
+          {
+            id: "task-4",
+            status: "failed",
+            startTime: "2025-02-11T10:10:00.000Z",
+            endTime: "2025-02-11T10:12:00.000Z",
+          },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getTimeline();
+
+    expect(result.tasks).toHaveLength(4);
+
+    const statuses = result.tasks.map((t) => t.status).sort();
+    expect(statuses).toEqual(["completed", "failed", "pending", "running"]);
+
+    // completed タスク: 開始・終了時刻あり
+    const completedTask = result.tasks.find((t) => t.status === "completed")!;
+    expect(completedTask.startTime).toBeDefined();
+    expect(completedTask.endTime).toBeDefined();
+
+    // running タスク: 開始時刻あり、終了時刻なし
+    const runningTask = result.tasks.find((t) => t.status === "running")!;
+    expect(runningTask.startTime).toBeDefined();
+    expect(runningTask.endTime).toBeUndefined();
+
+    // pending タスク: 開始・終了時刻なし
+    const pendingTask = result.tasks.find((t) => t.status === "pending")!;
+    expect(pendingTask.startTime).toBeUndefined();
+    expect(pendingTask.endTime).toBeUndefined();
+
+    // failed タスク: 開始・終了時刻あり
+    const failedTask = result.tasks.find((t) => t.status === "failed")!;
+    expect(failedTask.startTime).toBeDefined();
+    expect(failedTask.endTime).toBeDefined();
+  });
+
+  /**
+   * テストケース 8: 複数タスクの複雑なタイムライン
+   *
+   * タイムライン:
+   *   [task-1] ████████           (10:00 - 10:05)
+   *   [task-2]   ██████           (10:01 - 10:04)
+   *   [task-3]         ████████   (10:06 - 10:10)
+   *   [task-4]            ██████  (10:07 - 10:09)
+   *   [task-5]                  ████→ (10:11 - 進行中)
+   *
+   * 期待値:
+   * - 並列・順次が混在したタイムライン
+   * - 各タスクのタイムスタンプが正確
+   */
+  test("returns complex timeline with mixed parallel and sequential execution", async () => {
+    const mockAggregator: StateAggregator = {
+      getTimeline: async () => ({
+        tasks: [
+          {
+            id: "task-1",
+            status: "completed",
+            startTime: "2025-02-11T10:00:00.000Z",
+            endTime: "2025-02-11T10:05:00.000Z",
+          },
+          {
+            id: "task-2",
+            status: "completed",
+            startTime: "2025-02-11T10:01:00.000Z",
+            endTime: "2025-02-11T10:04:00.000Z",
+          },
+          {
+            id: "task-3",
+            status: "completed",
+            startTime: "2025-02-11T10:06:00.000Z",
+            endTime: "2025-02-11T10:10:00.000Z",
+          },
+          {
+            id: "task-4",
+            status: "completed",
+            startTime: "2025-02-11T10:07:00.000Z",
+            endTime: "2025-02-11T10:09:00.000Z",
+          },
+          {
+            id: "task-5",
+            status: "running",
+            startTime: "2025-02-11T10:11:00.000Z",
+            endTime: undefined,
+          },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getTimeline();
+
+    expect(result.tasks).toHaveLength(5);
+
+    // 並列実行グループ1: task-1 と task-2
+    const task1 = result.tasks.find((t) => t.id === "task-1")!;
+    const task2 = result.tasks.find((t) => t.id === "task-2")!;
+    expect(task1.startTime! < task2.startTime!).toBe(true);
+    expect(task2.endTime! < task1.endTime!).toBe(true);
+
+    // 並列実行グループ2: task-3 と task-4
+    const task3 = result.tasks.find((t) => t.id === "task-3")!;
+    const task4 = result.tasks.find((t) => t.id === "task-4")!;
+    expect(task3.startTime! < task4.startTime!).toBe(true);
+    expect(task4.endTime! < task3.endTime!).toBe(true);
+
+    // 順次実行: task-5 は task-3 完了後に開始
+    const task5 = result.tasks.find((t) => t.id === "task-5")!;
+    expect(task3.endTime! < task5.startTime!).toBe(true);
+  });
+
+  /**
+   * テストケース 9: タイムスタンプのISO 8601形式検証
+   *
+   * 期待値:
+   * - startTime, endTime が有効なISO 8601形式の文字列
+   */
+  test("validates ISO 8601 timestamp format", async () => {
+    const mockAggregator: StateAggregator = {
+      getTimeline: async () => ({
+        tasks: [
+          {
+            id: "task-1",
+            status: "completed",
+            startTime: "2025-02-11T10:00:00.000Z",
+            endTime: "2025-02-11T10:05:00.000Z",
+          },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getTimeline();
+
+    const task = result.tasks[0];
+    if (!task) {
+      throw new Error("Expected at least one task in timeline");
+    }
+
+    // ISO 8601形式の検証 (Date.parse で有効な日時か確認)
+    expect(Date.parse(task.startTime!)).not.toBeNaN();
+    expect(Date.parse(task.endTime!)).not.toBeNaN();
+
+    // startTime < endTime の検証
+    expect(new Date(task.startTime!).getTime()).toBeLessThan(
+      new Date(task.endTime!).getTime()
+    );
+  });
+
+  /**
+   * テストケース 10: タスクID重複なしの検証
+   *
+   * 期待値:
+   * - タイムライン内の全タスクIDがユニーク
+   */
+  test("validates unique task IDs in timeline", async () => {
+    const mockAggregator: StateAggregator = {
+      getTimeline: async () => ({
+        tasks: [
+          {
+            id: "task-1",
+            status: "completed",
+            startTime: "2025-02-11T10:00:00.000Z",
+            endTime: "2025-02-11T10:05:00.000Z",
+          },
+          {
+            id: "task-2",
+            status: "running",
+            startTime: "2025-02-11T10:06:00.000Z",
+            endTime: undefined,
+          },
+          {
+            id: "task-3",
+            status: "pending",
+            startTime: undefined,
+            endTime: undefined,
+          },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getTimeline();
+
+    const taskIds = result.tasks.map((t) => t.id);
+    const uniqueTaskIds = new Set(taskIds);
+
+    expect(taskIds.length).toBe(uniqueTaskIds.size);
+  });
+});

package/src/modules/dashboard/routes/sse.ts

@@ -21,10 +21,11 @@ export function createSSERoutes(broadcaster: SSEBroadcaster): Hono {
       broadcaster.addClient(client);
 
       // Keep connection alive until client disconnects
-      // Use a reasonable timeout loop instead of MAX_SAFE_INTEGER
+      // Send heartbeat every 15 seconds to prevent idle timeout
       try {
         while (true) {
-          await stream.sleep(1000000); // Sleep for ~16 minutes, then loop
+          await stream.sleep(15000); // 15 seconds
+          await stream.writeSSE({ event: "heartbeat", data: "" });
         }
       } finally {
         // Cleanup on disconnect (via error or abort)

package/src/modules/dashboard/server.ts

@@ -85,6 +85,7 @@ export class DashboardServer {
         port: this.port,
         hostname: this.host,
         fetch: this.app.fetch,
+        idleTimeout: 255, // SSE long-lived connections (max: 255 seconds)
       }) as BunServer;
       this.logger?.info({ port: this.port, host: this.host }, "Dashboard server started");
     } catch (error) {

package/src/modules/dashboard/services/sse-broadcaster.ts

@@ -10,6 +10,7 @@ export class SSEBroadcaster {
   private eventBus: EventBus;
   private clients: Set<SSEClient> = new Set();
   private listener: EventListener<AADEvent> | null = null;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
   private logger?: Logger;
 
   constructor(eventBus: EventBus, logger?: Logger) {
@@ -23,9 +24,37 @@ export class SSEBroadcaster {
     };
 
     this.eventBus.on("*", this.listener);
+
+    // Independent heartbeat to keep connections alive
+    this.heartbeatTimer = setInterval(() => {
+      const failedClients: SSEClient[] = [];
+      for (const client of this.clients) {
+        try {
+          client.send(`:ping\n\n`);
+        } catch (error) {
+          this.logger?.debug({ error }, "Client failed heartbeat ping");
+          failedClients.push(client);
+        }
+      }
+      // Remove failed clients
+      for (const client of failedClients) {
+        this.clients.delete(client);
+        try {
+          client.close();
+        } catch (error) {
+          this.logger?.debug({ error }, "Failed to close dead client");
+        }
+      }
+    }, 15000); // 15 seconds
   }
 
   stop(): void {
+    // Clear heartbeat timer
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+
     if (this.listener) {
       this.eventBus.off("*", this.listener);
       this.listener = null;