@ronkovic/aad 0.3.8 → 0.4.0

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

@@ -0,0 +1,332 @@
+import { describe, test, expect } from "bun:test";
+import type { StateAggregator } from "../services/state-aggregator";
+
+/**
+ * テストケース: /api/graph エンドポイント
+ *
+ * DAG (Directed Acyclic Graph) 可視化用のタスク依存関係グラフを返す
+ * - nodes: タスクのリスト (id, status)
+ * - edges: 依存関係のリスト (from → to)
+ */
+describe("GET /api/graph - Task Dependency Graph", () => {
+  /**
+   * テストケース 1: 空のグラフ (タスクなし)
+   *
+   * 期待値:
+   * - nodes: 空配列
+   * - edges: 空配列
+   */
+  test("returns empty graph when no tasks exist", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [],
+        edges: [],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toEqual([]);
+    expect(result.edges).toEqual([]);
+  });
+
+  /**
+   * テストケース 2: 単一タスク (依存関係なし)
+   *
+   * グラフ構造:
+   *
+   *   [task-1]
+   *
+   * 期待値:
+   * - nodes: 1つのノード
+   * - edges: 空配列
+   */
+  test("returns single node with no edges for independent task", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "pending" },
+        ],
+        edges: [],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(1);
+    expect(result.nodes[0]).toEqual({ id: "task-1", status: "pending" });
+    expect(result.edges).toEqual([]);
+  });
+
+  /**
+   * テストケース 3: 線形依存 (task-1 → task-2 → task-3)
+   *
+   * グラフ構造:
+   *
+   *   [task-1] → [task-2] → [task-3]
+   *
+   * 依存関係:
+   * - task-2 depends_on task-1
+   * - task-3 depends_on task-2
+   */
+  test("returns linear dependency chain", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "running" },
+          { id: "task-3", status: "pending" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-2" },
+          { from: "task-2", to: "task-3" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(3);
+    expect(result.edges).toHaveLength(2);
+
+    // エッジの正確性を検証
+    expect(result.edges).toContainEqual({ from: "task-1", to: "task-2" });
+    expect(result.edges).toContainEqual({ from: "task-2", to: "task-3" });
+
+    // ステータスの検証
+    const task1 = result.nodes.find((n) => n.id === "task-1");
+    const task2 = result.nodes.find((n) => n.id === "task-2");
+    const task3 = result.nodes.find((n) => n.id === "task-3");
+
+    expect(task1?.status).toBe("completed");
+    expect(task2?.status).toBe("running");
+    expect(task3?.status).toBe("pending");
+  });
+
+  /**
+   * テストケース 4: 並列タスク (task-1, task-2 独立、両方が task-3 に依存される)
+   *
+   * グラフ構造:
+   *
+   *   [task-1] ─┐
+   *              ├→ [task-3]
+   *   [task-2] ─┘
+   *
+   * 依存関係:
+   * - task-3 depends_on [task-1, task-2]
+   */
+  test("returns parallel tasks converging into single task", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "completed" },
+          { id: "task-3", status: "running" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-3" },
+          { from: "task-2", to: "task-3" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(3);
+    expect(result.edges).toHaveLength(2);
+
+    // task-3 は task-1 と task-2 両方に依存
+    const edgesToTask3 = result.edges.filter((e) => e.to === "task-3");
+    expect(edgesToTask3).toHaveLength(2);
+
+    expect(edgesToTask3).toContainEqual({ from: "task-1", to: "task-3" });
+    expect(edgesToTask3).toContainEqual({ from: "task-2", to: "task-3" });
+
+    // task-1, task-2 は並列実行可能 (互いに依存しない)
+    const edgesBetween1And2 = result.edges.filter(
+      (e) =>
+        (e.from === "task-1" && e.to === "task-2") ||
+        (e.from === "task-2" && e.to === "task-1")
+    );
+    expect(edgesBetween1And2).toHaveLength(0);
+  });
+
+  /**
+   * テストケース 5: ダイヤモンド依存 (task-1 → task-2,3 → task-4)
+   *
+   * グラフ構造:
+   *
+   *          [task-1]
+   *           ↙   ↘
+   *    [task-2]   [task-3]
+   *           ↘   ↙
+   *          [task-4]
+   *
+   * 依存関係:
+   * - task-2 depends_on task-1
+   * - task-3 depends_on task-1
+   * - task-4 depends_on [task-2, task-3]
+   */
+  test("returns diamond dependency graph", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "running" },
+          { id: "task-3", status: "running" },
+          { id: "task-4", status: "pending" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-2" },
+          { from: "task-1", to: "task-3" },
+          { from: "task-2", to: "task-4" },
+          { from: "task-3", to: "task-4" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(4);
+    expect(result.edges).toHaveLength(4);
+
+    // task-1 は task-2, task-3 に分岐
+    const edgesFromTask1 = result.edges.filter((e) => e.from === "task-1");
+    expect(edgesFromTask1).toHaveLength(2);
+    expect(edgesFromTask1).toContainEqual({ from: "task-1", to: "task-2" });
+    expect(edgesFromTask1).toContainEqual({ from: "task-1", to: "task-3" });
+
+    // task-4 は task-2, task-3 からマージ
+    const edgesToTask4 = result.edges.filter((e) => e.to === "task-4");
+    expect(edgesToTask4).toHaveLength(2);
+    expect(edgesToTask4).toContainEqual({ from: "task-2", to: "task-4" });
+    expect(edgesToTask4).toContainEqual({ from: "task-3", to: "task-4" });
+
+    // ステータス検証: task-1完了、task-2/3実行中、task-4保留
+    expect(result.nodes.find((n) => n.id === "task-1")?.status).toBe("completed");
+    expect(result.nodes.find((n) => n.id === "task-2")?.status).toBe("running");
+    expect(result.nodes.find((n) => n.id === "task-3")?.status).toBe("running");
+    expect(result.nodes.find((n) => n.id === "task-4")?.status).toBe("pending");
+  });
+
+  /**
+   * テストケース 6: 複雑なグラフ (多段階並列依存)
+   *
+   * グラフ構造:
+   *
+   *   [task-1] → [task-2] ─┐
+   *                         ├→ [task-5]
+   *   [task-3] → [task-4] ─┘
+   *
+   * 依存関係:
+   * - task-2 depends_on task-1
+   * - task-4 depends_on task-3
+   * - task-5 depends_on [task-2, task-4]
+   */
+  test("returns complex multi-level parallel graph", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "completed" },
+          { id: "task-3", status: "completed" },
+          { id: "task-4", status: "running" },
+          { id: "task-5", status: "pending" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-2" },
+          { from: "task-3", to: "task-4" },
+          { from: "task-2", to: "task-5" },
+          { from: "task-4", to: "task-5" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(5);
+    expect(result.edges).toHaveLength(4);
+
+    // task-1, task-3 は並列実行可能な起点
+    const rootTasks = result.nodes.filter(
+      (node) => !result.edges.some((edge) => edge.to === node.id)
+    );
+    expect(rootTasks).toHaveLength(2);
+    expect(rootTasks.map((t) => t.id).sort()).toEqual(["task-1", "task-3"]);
+
+    // task-5 は最終的な合流点
+    const edgesToTask5 = result.edges.filter((e) => e.to === "task-5");
+    expect(edgesToTask5).toHaveLength(2);
+  });
+
+  /**
+   * テストケース 7: タスクステータスのバリエーション検証
+   *
+   * 全ステータス (pending, running, completed, failed) を含むグラフ
+   */
+  test("returns graph with all task status types", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "running" },
+          { id: "task-3", status: "pending" },
+          { id: "task-4", status: "failed" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-2" },
+          { from: "task-1", to: "task-4" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    expect(result.nodes).toHaveLength(4);
+
+    const statuses = result.nodes.map((n) => n.status).sort();
+    expect(statuses).toEqual(["completed", "failed", "pending", "running"]);
+
+    // 各ステータスのノードが存在することを確認
+    expect(result.nodes.some((n) => n.status === "completed")).toBe(true);
+    expect(result.nodes.some((n) => n.status === "running")).toBe(true);
+    expect(result.nodes.some((n) => n.status === "pending")).toBe(true);
+    expect(result.nodes.some((n) => n.status === "failed")).toBe(true);
+  });
+
+  /**
+   * テストケース 8: グラフ構造の整合性検証
+   *
+   * - 全エッジの from/to が nodes に存在することを確認
+   * - 自己参照エッジがないことを確認
+   */
+  test("validates graph structure integrity", async () => {
+    const mockAggregator: StateAggregator = {
+      getGraph: async () => ({
+        nodes: [
+          { id: "task-1", status: "completed" },
+          { id: "task-2", status: "running" },
+          { id: "task-3", status: "pending" },
+        ],
+        edges: [
+          { from: "task-1", to: "task-2" },
+          { from: "task-2", to: "task-3" },
+        ],
+      }),
+    } as any;
+
+    const result = await mockAggregator.getGraph();
+
+    const nodeIds = new Set(result.nodes.map((n) => n.id));
+
+    // 全エッジの from/to が nodes に存在
+    for (const edge of result.edges) {
+      expect(nodeIds.has(edge.from)).toBe(true);
+      expect(nodeIds.has(edge.to)).toBe(true);
+    }
+
+    // 自己参照エッジがない
+    const selfReferentialEdges = result.edges.filter((e) => e.from === e.to);
+    expect(selfReferentialEdges).toHaveLength(0);
+  });
+});