@task-mcp/shared 1.0.20 → 1.0.21

package/src/utils/hierarchy.test.ts

@@ -1,505 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  MAX_HIERARCHY_DEPTH,
-  getTaskLevel,
-  validateHierarchyDepth,
-  getAncestorIds,
-  getDescendantIds,
-  getChildTasks,
-  getRootTask,
-  buildTaskTree,
-  validateHierarchy,
-} from "./hierarchy.js";
-import type { Task } from "../schemas/task.js";
-
-// Helper to create mock tasks
-function createTask(
-  id: string,
-  parentId?: string,
-  overrides: Partial<Task> = {}
-): Task {
-  return {
-    id,
-    title: `Task ${id}`,
-    status: "pending",
-    priority: "medium",
-    workspace: "test-workspace",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    parentId,
-    ...overrides,
-  };
-}
-
-describe("MAX_HIERARCHY_DEPTH", () => {
-  test("is set to 3", () => {
-    expect(MAX_HIERARCHY_DEPTH).toBe(3);
-  });
-});
-
-describe("getTaskLevel", () => {
-  test("returns -1 for non-existent task", () => {
-    const tasks = [createTask("A")];
-    expect(getTaskLevel(tasks, "nonexistent")).toBe(-1);
-  });
-
-  test("returns 0 for root task (no parent)", () => {
-    const tasks = [createTask("A")];
-    expect(getTaskLevel(tasks, "A")).toBe(0);
-  });
-
-  test("returns 1 for direct child", () => {
-    const tasks = [createTask("A"), createTask("B", "A")];
-    expect(getTaskLevel(tasks, "B")).toBe(1);
-  });
-
-  test("returns 2 for grandchild", () => {
-    const tasks = [createTask("A"), createTask("B", "A"), createTask("C", "B")];
-    expect(getTaskLevel(tasks, "C")).toBe(2);
-  });
-
-  test("returns 3 for great-grandchild", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    expect(getTaskLevel(tasks, "D")).toBe(3);
-  });
-
-  test("handles missing parent gracefully", () => {
-    // Task B references non-existent parent "missing"
-    const tasks = [createTask("A"), createTask("B", "missing")];
-    // Should return 0 since parent lookup fails immediately
-    expect(getTaskLevel(tasks, "B")).toBe(0);
-  });
-
-  test("handles broken chain (middle parent missing)", () => {
-    // C -> B -> A, but B is missing
-    const tasks = [createTask("A"), createTask("C", "B")];
-    // C's parent "B" doesn't exist, so level stays 0
-    expect(getTaskLevel(tasks, "C")).toBe(0);
-  });
-});
-
-describe("validateHierarchyDepth", () => {
-  test("returns false for non-existent parent", () => {
-    const tasks = [createTask("A")];
-    expect(validateHierarchyDepth(tasks, "nonexistent")).toBe(false);
-  });
-
-  test("returns true when parent is at level 0", () => {
-    const tasks = [createTask("A")];
-    // Can add child at level 1
-    expect(validateHierarchyDepth(tasks, "A")).toBe(true);
-  });
-
-  test("returns true when parent is at level 1", () => {
-    const tasks = [createTask("A"), createTask("B", "A")];
-    // Can add child at level 2
-    expect(validateHierarchyDepth(tasks, "B")).toBe(true);
-  });
-
-  test("returns true when parent is at level 2", () => {
-    const tasks = [createTask("A"), createTask("B", "A"), createTask("C", "B")];
-    // Can add child at level 3 (MAX_HIERARCHY_DEPTH)
-    expect(validateHierarchyDepth(tasks, "C")).toBe(true);
-  });
-
-  test("returns false when parent is at level 3 (max depth)", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    // D is at level 3, cannot add child at level 4
-    expect(validateHierarchyDepth(tasks, "D")).toBe(false);
-  });
-});
-
-describe("getAncestorIds", () => {
-  test("returns empty array for non-existent task", () => {
-    const tasks = [createTask("A")];
-    expect(getAncestorIds(tasks, "nonexistent")).toEqual([]);
-  });
-
-  test("returns empty array for root task", () => {
-    const tasks = [createTask("A")];
-    expect(getAncestorIds(tasks, "A")).toEqual([]);
-  });
-
-  test("returns single ancestor for direct child", () => {
-    const tasks = [createTask("A"), createTask("B", "A")];
-    expect(getAncestorIds(tasks, "B")).toEqual(["A"]);
-  });
-
-  test("returns ancestors ordered from immediate parent to root", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    expect(getAncestorIds(tasks, "D")).toEqual(["C", "B", "A"]);
-  });
-
-  test("handles missing ancestor in chain", () => {
-    // C -> B -> missing
-    const tasks = [createTask("B", "missing"), createTask("C", "B")];
-    // Returns B and "missing" (the parentId), then stops when "missing" lookup fails
-    expect(getAncestorIds(tasks, "C")).toEqual(["B", "missing"]);
-  });
-});
-
-describe("getDescendantIds", () => {
-  test("returns empty array for task with no children", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    expect(getDescendantIds(tasks, "A")).toEqual([]);
-  });
-
-  test("returns direct children", () => {
-    const tasks = [createTask("A"), createTask("B", "A"), createTask("C", "A")];
-    const descendants = getDescendantIds(tasks, "A");
-    expect(descendants.sort()).toEqual(["B", "C"]);
-  });
-
-  test("returns all descendants (children and grandchildren)", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "A"),
-      createTask("D", "B"),
-      createTask("E", "B"),
-    ];
-    const descendants = getDescendantIds(tasks, "A");
-    expect(descendants.sort()).toEqual(["B", "C", "D", "E"]);
-  });
-
-  test("returns descendants in BFS order", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "A"),
-      createTask("D", "B"),
-    ];
-    const descendants = getDescendantIds(tasks, "A");
-    // BFS: first level (B, C), then second level (D)
-    // B and C come before D
-    const dIndex = descendants.indexOf("D");
-    const bIndex = descendants.indexOf("B");
-    const cIndex = descendants.indexOf("C");
-    expect(bIndex).toBeLessThan(dIndex);
-    expect(cIndex).toBeLessThan(dIndex);
-  });
-
-  test("returns empty array for non-existent task", () => {
-    const tasks = [createTask("A")];
-    expect(getDescendantIds(tasks, "nonexistent")).toEqual([]);
-  });
-});
-
-describe("getChildTasks", () => {
-  test("returns empty array for task with no children", () => {
-    const tasks = [createTask("A"), createTask("B")];
-    expect(getChildTasks(tasks, "A")).toEqual([]);
-  });
-
-  test("returns only direct children", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "A"),
-      createTask("D", "B"), // grandchild, should not be included
-    ];
-    const children = getChildTasks(tasks, "A");
-    expect(children.map((t) => t.id).sort()).toEqual(["B", "C"]);
-  });
-
-  test("returns empty array for non-existent parent", () => {
-    const tasks = [createTask("A")];
-    expect(getChildTasks(tasks, "nonexistent")).toEqual([]);
-  });
-
-  test("returns full task objects", () => {
-    const tasks = [createTask("A"), createTask("B", "A", { title: "Custom Title" })];
-    const children = getChildTasks(tasks, "A");
-    expect(children.length).toBe(1);
-    expect(children[0]!.id).toBe("B");
-    expect(children[0]!.title).toBe("Custom Title");
-  });
-});
-
-describe("getRootTask", () => {
-  test("returns null for non-existent task", () => {
-    const tasks = [createTask("A")];
-    expect(getRootTask(tasks, "nonexistent")).toBeNull();
-  });
-
-  test("returns the task itself if it has no parent", () => {
-    const tasks = [createTask("A")];
-    const root = getRootTask(tasks, "A");
-    expect(root?.id).toBe("A");
-  });
-
-  test("returns root for direct child", () => {
-    const tasks = [createTask("A"), createTask("B", "A")];
-    const root = getRootTask(tasks, "B");
-    expect(root?.id).toBe("A");
-  });
-
-  test("returns root for deeply nested task", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    const root = getRootTask(tasks, "D");
-    expect(root?.id).toBe("A");
-  });
-
-  test("handles broken chain (returns earliest found task)", () => {
-    // C -> B -> missing
-    const tasks = [createTask("B", "missing"), createTask("C", "B")];
-    const root = getRootTask(tasks, "C");
-    // B's parent "missing" doesn't exist, so B is the root
-    expect(root?.id).toBe("B");
-  });
-});
-
-describe("buildTaskTree", () => {
-  test("returns empty array for empty task list", () => {
-    expect(buildTaskTree([])).toEqual([]);
-  });
-
-  test("returns single root task as tree", () => {
-    const tasks = [createTask("A")];
-    const tree = buildTaskTree(tasks);
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children).toEqual([]);
-  });
-
-  test("builds tree with children", () => {
-    const tasks = [createTask("A"), createTask("B", "A"), createTask("C", "A")];
-    const tree = buildTaskTree(tasks);
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children.length).toBe(2);
-    expect(tree[0]!.children.map((c) => c.task.id).sort()).toEqual(["B", "C"]);
-  });
-
-  test("builds nested tree structure", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    const tree = buildTaskTree(tasks);
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.task.id).toBe("B");
-    expect(tree[0]!.children[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.children[0]!.task.id).toBe("C");
-    expect(tree[0]!.children[0]!.children[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.children[0]!.children[0]!.task.id).toBe("D");
-  });
-
-  test("returns multiple root tasks", () => {
-    const tasks = [createTask("A"), createTask("B"), createTask("C")];
-    const tree = buildTaskTree(tasks);
-    expect(tree.length).toBe(3);
-    expect(tree.map((n) => n.task.id).sort()).toEqual(["A", "B", "C"]);
-  });
-
-  test("builds tree from specific root", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("X"),
-      createTask("Y", "X"),
-    ];
-    const tree = buildTaskTree(tasks, "A");
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.task.id).toBe("B");
-  });
-
-  test("returns empty array for non-existent root", () => {
-    const tasks = [createTask("A")];
-    const tree = buildTaskTree(tasks, "nonexistent");
-    expect(tree).toEqual([]);
-  });
-
-  test("can build subtree from middle of hierarchy", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "B"),
-    ];
-    const tree = buildTaskTree(tasks, "B");
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("B");
-    expect(tree[0]!.children.length).toBe(2);
-    expect(tree[0]!.children.map((c) => c.task.id).sort()).toEqual(["C", "D"]);
-  });
-
-  test("respects maxDepth parameter", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-    ];
-    // maxDepth of 2 should include A (depth 0), B (depth 1), but stop children at C
-    const tree = buildTaskTree(tasks, "A", 2);
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.task.id).toBe("B");
-    // C should be included but with no children (depth 2 is the limit)
-    expect(tree[0]!.children[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.children[0]!.task.id).toBe("C");
-    expect(tree[0]!.children[0]!.children[0]!.children).toEqual([]);
-  });
-
-  test("handles circular references gracefully", () => {
-    // Create tasks with circular reference: A -> B -> C -> A
-    const taskA = createTask("A", "C");
-    const taskB = createTask("B", "A");
-    const taskC = createTask("C", "B");
-    const tasks = [taskA, taskB, taskC];
-
-    // Should not throw or hang - circular ref is detected
-    const tree = buildTaskTree(tasks);
-    // All tasks have parents, so no "root" tasks exist
-    expect(tree).toEqual([]);
-  });
-
-  test("handles self-referencing task", () => {
-    // Task references itself as parent
-    const selfRef = createTask("A", "A");
-    const tasks = [selfRef];
-
-    // No root tasks (A has parent), should return empty
-    const tree = buildTaskTree(tasks);
-    expect(tree).toEqual([]);
-  });
-
-  test("handles circular reference when building from specific root", () => {
-    // A -> B -> A (circular)
-    const taskA = createTask("A");
-    const taskB = createTask("B", "A");
-    // Manually create circular: make A's children include B which points back
-    // by creating a scenario where childrenMap would loop
-    const tasks = [taskA, taskB];
-    // Simulate circular by modifying childrenMap behavior won't work directly,
-    // but we can test that visited set prevents infinite recursion
-    // Let's create a more direct test case
-    const tree = buildTaskTree(tasks, "A");
-    expect(tree.length).toBe(1);
-    expect(tree[0]!.task.id).toBe("A");
-    expect(tree[0]!.children.length).toBe(1);
-    expect(tree[0]!.children[0]!.task.id).toBe("B");
-  });
-});
-
-describe("validateHierarchy", () => {
-  test("returns valid for empty task list", () => {
-    const result = validateHierarchy([]);
-    expect(result.valid).toBe(true);
-    expect(result.orphanedReferences).toEqual([]);
-    expect(result.circularReferences).toEqual([]);
-    expect(result.maxDepthExceeded).toEqual([]);
-  });
-
-  test("returns valid for healthy hierarchy", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-    ];
-    const result = validateHierarchy(tasks);
-    expect(result.valid).toBe(true);
-    expect(result.orphanedReferences).toEqual([]);
-    expect(result.circularReferences).toEqual([]);
-    expect(result.maxDepthExceeded).toEqual([]);
-  });
-
-  test("detects orphaned parent references", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "nonexistent"),
-    ];
-    const result = validateHierarchy(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.orphanedReferences).toEqual([
-      { taskId: "B", parentId: "nonexistent" },
-    ]);
-  });
-
-  test("detects multiple orphaned references", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "missing1"),
-      createTask("C", "missing2"),
-    ];
-    const result = validateHierarchy(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.orphanedReferences.length).toBe(2);
-    expect(result.orphanedReferences).toContainEqual({ taskId: "B", parentId: "missing1" });
-    expect(result.orphanedReferences).toContainEqual({ taskId: "C", parentId: "missing2" });
-  });
-
-  test("detects circular references (self-reference)", () => {
-    const tasks = [createTask("A", "A")];
-    const result = validateHierarchy(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.circularReferences).toContain("A");
-  });
-
-  test("detects circular references (A -> B -> A)", () => {
-    const taskA = createTask("A", "B");
-    const taskB = createTask("B", "A");
-    const tasks = [taskA, taskB];
-    const result = validateHierarchy(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.circularReferences.length).toBeGreaterThan(0);
-  });
-
-  test("detects max depth exceeded", () => {
-    // Create chain: A -> B -> C -> D -> E (E at level 4, exceeds MAX_HIERARCHY_DEPTH of 3)
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-      createTask("E", "D"),
-    ];
-    const result = validateHierarchy(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.maxDepthExceeded).toContainEqual({ taskId: "E", depth: 4 });
-  });
-
-  test("returns all issues when multiple problems exist", () => {
-    const tasks = [
-      createTask("A"),
-      createTask("B", "A"),
-      createTask("C", "B"),
-      createTask("D", "C"),
-      createTask("E", "D"), // Level 4, exceeds max
-      createTask("F", "nonexistent"), // Orphaned
-    ];
-    const result = validateHierarchy(tasks);
-    expect(result.valid).toBe(false);
-    expect(result.orphanedReferences.length).toBeGreaterThan(0);
-    expect(result.maxDepthExceeded.length).toBeGreaterThan(0);
-  });
-});