@task-mcp/shared 1.0.19 → 1.0.21

package/src/algorithms/dependency-integrity.test.ts

@@ -1,348 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  DependencyErrorCode,
-  validateDependency,
-  findInvalidDependencies,
-  findSelfDependencies,
-  detectCircularDependencies,
-  checkDependencyIntegrity,
-} from "./dependency-integrity.js";
-import type { Task } from "../schemas/task.js";
-
-// Helper to create mock tasks
-function createTask(
-  id: string,
-  title: string = `Task ${id}`,
-  deps: Array<{ taskId: string; type: "blocked_by" | "blocks" | "related" }> = []
-): Task {
-  return {
-    id,
-    title,
-    status: "pending",
-    priority: "medium",
-    workspace: "test-workspace",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    dependencies: deps,
-  };
-}
-
-describe("validateDependency", () => {
-  test("returns valid for a valid dependency", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    const result = validateDependency({
-      taskId: "B",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(true);
-    expect(result.errorCode).toBeUndefined();
-  });
-
-  test("rejects self-dependency", () => {
-    const tasks = [createTask("A")];
-    const result = validateDependency({
-      taskId: "A",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.SELF_DEPENDENCY);
-    expect(result.errorMessage).toContain("cannot depend on itself");
-    expect(result.suggestion).toBeDefined();
-  });
-
-  test("rejects when task not found", () => {
-    const tasks = [createTask("A")];
-    const result = validateDependency({
-      taskId: "B",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.TASK_NOT_FOUND);
-    expect(result.errorMessage).toContain("Task not found");
-  });
-
-  test("rejects when blocker not found", () => {
-    const tasks = [createTask("A")];
-    const result = validateDependency({
-      taskId: "A",
-      blockedBy: "B",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.BLOCKER_NOT_FOUND);
-    expect(result.errorMessage).toContain("Blocking task not found");
-  });
-
-  test("rejects duplicate dependency", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = validateDependency({
-      taskId: "B",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.DUPLICATE_DEPENDENCY);
-    expect(result.errorMessage).toContain("already blocked by");
-  });
-
-  test("allows duplicate when checkDuplicates is false", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = validateDependency({
-      taskId: "B",
-      blockedBy: "A",
-      tasks,
-      checkDuplicates: false,
-    });
-    expect(result.valid).toBe(true);
-  });
-
-  test("rejects circular dependency", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
-      createTask("B"),
-    ];
-    // B is blocking A, so A blocking B would create a cycle
-    const result = validateDependency({
-      taskId: "B",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.CIRCULAR_DEPENDENCY);
-    expect(result.errorMessage).toContain("cycle");
-    expect(result.suggestion).toContain("depends on");
-  });
-
-  test("rejects indirect circular dependency", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
-      createTask("B", "Task B", [{ taskId: "C", type: "blocked_by" }]),
-      createTask("C"),
-    ];
-    // A <- B <- C, adding C <- A would create cycle
-    const result = validateDependency({
-      taskId: "C",
-      blockedBy: "A",
-      tasks,
-    });
-    expect(result.valid).toBe(false);
-    expect(result.errorCode).toBe(DependencyErrorCode.CIRCULAR_DEPENDENCY);
-  });
-});
-
-describe("findInvalidDependencies", () => {
-  test("returns empty array when all dependencies are valid", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = findInvalidDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-
-  test("finds orphaned dependency references", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "non-existent", type: "blocked_by" }]),
-    ];
-    const result = findInvalidDependencies(tasks);
-    expect(result.length).toBe(1);
-    expect(result[0]!.taskId).toBe("A");
-    expect(result[0]!.taskTitle).toBe("Task A");
-    expect(result[0]!.invalidDependencyId).toBe("non-existent");
-    expect(result[0]!.type).toBe("blocked_by");
-  });
-
-  test("finds multiple invalid references across tasks", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "deleted-1", type: "blocked_by" }]),
-      createTask("B", "Task B", [
-        { taskId: "A", type: "blocked_by" },
-        { taskId: "deleted-2", type: "blocks" },
-      ]),
-    ];
-    const result = findInvalidDependencies(tasks);
-    expect(result.length).toBe(2);
-    expect(result.map((r) => r.invalidDependencyId).sort()).toEqual([
-      "deleted-1",
-      "deleted-2",
-    ]);
-  });
-
-  test("returns empty array for tasks without dependencies", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    const result = findInvalidDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-});
-
-describe("findSelfDependencies", () => {
-  test("returns empty array when no self-dependencies exist", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = findSelfDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-
-  test("finds task with self-dependency", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = findSelfDependencies(tasks);
-    expect(result).toEqual(["A"]);
-  });
-
-  test("finds multiple self-dependencies", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "A", type: "blocked_by" }]),
-      createTask("B"),
-      createTask("C", "Task C", [{ taskId: "C", type: "blocks" }]),
-    ];
-    const result = findSelfDependencies(tasks);
-    expect(result.sort()).toEqual(["A", "C"]);
-  });
-});
-
-describe("detectCircularDependencies", () => {
-  test("returns empty array when no cycles exist", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-      createTask("C", "Task C", [{ taskId: "B", type: "blocked_by" }]),
-    ];
-    const result = detectCircularDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-
-  test("detects direct circular dependency (A -> B -> A)", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = detectCircularDependencies(tasks);
-    expect(result.length).toBe(1);
-    expect(result[0]!.sort()).toEqual(["A", "B"]);
-  });
-
-  test("detects longer cycle (A -> B -> C -> A)", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
-      createTask("B", "Task B", [{ taskId: "C", type: "blocked_by" }]),
-      createTask("C", "Task C", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = detectCircularDependencies(tasks);
-    expect(result.length).toBe(1);
-    expect(result[0]!.sort()).toEqual(["A", "B", "C"]);
-  });
-
-  test("ignores non-blocking dependency types for cycle detection", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "related" }]),
-      createTask("B", "Task B", [{ taskId: "A", type: "related" }]),
-    ];
-    const result = detectCircularDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-
-  test("handles tasks with missing dependency targets", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "non-existent", type: "blocked_by" }]),
-    ];
-    const result = detectCircularDependencies(tasks);
-    expect(result).toEqual([]);
-  });
-});
-
-describe("checkDependencyIntegrity", () => {
-  test("returns valid for healthy task set", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-      createTask("C", "Task C", [{ taskId: "B", type: "blocked_by" }]),
-    ];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(true);
-    expect(result.totalTasks).toBe(3);
-    expect(result.totalDependencies).toBe(2);
-    expect(result.issues.selfDependencies).toEqual([]);
-    expect(result.issues.invalidReferences).toEqual([]);
-    expect(result.issues.circularDependencies).toEqual([]);
-    expect(result.summary).toContain("All 2 dependencies");
-    expect(result.summary).toContain("valid");
-  });
-
-  test("detects self-dependency issues", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.issues.selfDependencies).toEqual(["A"]);
-    expect(result.summary).toContain("self-dependencies");
-  });
-
-  test("detects invalid reference issues", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "deleted", type: "blocked_by" }]),
-    ];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.issues.invalidReferences.length).toBe(1);
-    expect(result.summary).toContain("invalid references");
-  });
-
-  test("detects circular dependency issues", () => {
-    const tasks = [
-      createTask("A", "Task A", [{ taskId: "B", type: "blocked_by" }]),
-      createTask("B", "Task B", [{ taskId: "A", type: "blocked_by" }]),
-    ];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.issues.circularDependencies.length).toBe(1);
-    expect(result.summary).toContain("circular dependency");
-  });
-
-  test("reports multiple issue types", () => {
-    const tasks = [
-      createTask("A", "Task A", [
-        { taskId: "A", type: "blocked_by" }, // self-dependency
-        { taskId: "deleted", type: "blocked_by" }, // invalid reference
-      ]),
-      createTask("B", "Task B", [{ taskId: "C", type: "blocked_by" }]),
-      createTask("C", "Task C", [{ taskId: "B", type: "blocked_by" }]), // circular
-    ];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.issues.selfDependencies.length).toBeGreaterThan(0);
-    expect(result.issues.invalidReferences.length).toBeGreaterThan(0);
-    expect(result.issues.circularDependencies.length).toBeGreaterThan(0);
-    expect(result.summary).toContain("self-dependencies");
-    expect(result.summary).toContain("invalid references");
-    expect(result.summary).toContain("circular dependency");
-  });
-
-  test("handles empty task array", () => {
-    const result = checkDependencyIntegrity([]);
-    expect(result.valid).toBe(true);
-    expect(result.totalTasks).toBe(0);
-    expect(result.totalDependencies).toBe(0);
-  });
-
-  test("handles tasks with no dependencies", () => {
-    const tasks = [createTask("A"), createTask("B"), createTask("C")];
-    const result = checkDependencyIntegrity(tasks);
-    expect(result.valid).toBe(true);
-    expect(result.totalTasks).toBe(3);
-    expect(result.totalDependencies).toBe(0);
-  });
-});