@ronkovic/aad 0.3.0

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

@@ -0,0 +1,285 @@
+import { describe, test, expect } from "bun:test";
+import {
+  AadError,
+  ConfigError,
+  ClaudeProviderError,
+  TimeoutError,
+  ValidationError,
+  DashboardError,
+  PersistenceError,
+  FileLockError,
+  TaskQueueError,
+  CircularDependencyError,
+  GitWorkspaceError,
+  ProcessManagerError,
+  PlanningError,
+  TaskExecutionError,
+  PhaseError,
+  TestRunnerError,
+  MergeConflictError,
+} from "../errors";
+
+describe("AadError", () => {
+  test("creates error with code and message", () => {
+    const error = new AadError("TEST_ERROR", "Test error message");
+    expect(error.code).toBe("TEST_ERROR");
+    expect(error.message).toBe("Test error message");
+    expect(error.context).toEqual({});
+  });
+
+  test("creates error with context", () => {
+    const context = { taskId: "t1", retries: 3 };
+    const error = new AadError("TEST_ERROR", "Test error", context);
+    expect(error.context).toEqual(context);
+  });
+
+  test("is instance of Error", () => {
+    const error = new AadError("TEST_ERROR", "Test");
+    expect(error instanceof Error).toBe(true);
+  });
+
+  test("has proper stack trace", () => {
+    const error = new AadError("TEST_ERROR", "Test");
+    expect(error.stack).toBeDefined();
+    expect(error.stack).toContain("AadError");
+  });
+});
+
+describe("ConfigError", () => {
+  test("creates config error", () => {
+    const error = new ConfigError("Invalid config value");
+    expect(error.code).toBe("CONFIG_ERROR");
+    expect(error.message).toBe("Invalid config value");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const error = new ConfigError("Missing env var", { key: "AAD_WORKERS" });
+    expect(error.context).toEqual({ key: "AAD_WORKERS" });
+  });
+});
+
+describe("ClaudeProviderError", () => {
+  test("creates claude provider error", () => {
+    const error = new ClaudeProviderError("Claude call failed");
+    expect(error.code).toBe("CLAUDE_PROVIDER_ERROR");
+    expect(error.message).toBe("Claude call failed");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { phase: "tester", exitCode: 1 };
+    const error = new ClaudeProviderError("Execution failed", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("TimeoutError", () => {
+  test("creates timeout error", () => {
+    const error = new TimeoutError("Operation timed out");
+    expect(error.code).toBe("TIMEOUT_ERROR");
+    expect(error.message).toBe("Operation timed out");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { timeout: 30000, elapsed: 35000 };
+    const error = new TimeoutError("Timeout exceeded", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("ValidationError", () => {
+  test("creates validation error", () => {
+    const error = new ValidationError("Invalid input");
+    expect(error.code).toBe("VALIDATION_ERROR");
+    expect(error.message).toBe("Invalid input");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { field: "taskId", value: "" };
+    const error = new ValidationError("Field cannot be empty", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("DashboardError", () => {
+  test("creates dashboard error", () => {
+    const error = new DashboardError("Server failed to start");
+    expect(error.code).toBe("DASHBOARD_ERROR");
+    expect(error.message).toBe("Server failed to start");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { port: 3333, reason: "EADDRINUSE" };
+    const error = new DashboardError("Port already in use", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("PersistenceError", () => {
+  test("creates persistence error", () => {
+    const error = new PersistenceError("Failed to save task");
+    expect(error.code).toBe("PERSISTENCE_ERROR");
+    expect(error.message).toBe("Failed to save task");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { taskId: "task-1", path: "/tmp/task.json" };
+    const error = new PersistenceError("Write failed", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("FileLockError", () => {
+  test("creates file lock error", () => {
+    const error = new FileLockError("Lock acquisition failed");
+    expect(error.code).toBe("FILE_LOCK_ERROR");
+    expect(error.message).toBe("Lock acquisition failed");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { lockPath: "/tmp/.lock", holder: "worker-1" };
+    const error = new FileLockError("Lock held by another process", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("TaskQueueError", () => {
+  test("creates task queue error", () => {
+    const error = new TaskQueueError("Dispatch failed");
+    expect(error.code).toBe("TASK_QUEUE_ERROR");
+    expect(error.message).toBe("Dispatch failed");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { taskId: "task-1", workerId: "worker-1" };
+    const error = new TaskQueueError("No idle workers", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("CircularDependencyError", () => {
+  test("creates circular dependency error", () => {
+    const error = new CircularDependencyError("Circular dependency detected");
+    expect(error.code).toBe("CIRCULAR_DEPENDENCY_ERROR");
+    expect(error.message).toBe("Circular dependency detected");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context with cycle", () => {
+    const context = { cycle: ["task-1", "task-2", "task-3", "task-1"] };
+    const error = new CircularDependencyError("Cycle found", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("GitWorkspaceError", () => {
+  test("creates git workspace error", () => {
+    const error = new GitWorkspaceError("Worktree creation failed");
+    expect(error.code).toBe("GIT_WORKSPACE_ERROR");
+    expect(error.message).toBe("Worktree creation failed");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { branch: "task-1-branch", exitCode: 128 };
+    const error = new GitWorkspaceError("Git command failed", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("ProcessManagerError", () => {
+  test("creates process manager error", () => {
+    const error = new ProcessManagerError("Worker spawn failed");
+    expect(error.code).toBe("PROCESS_MANAGER_ERROR");
+    expect(error.message).toBe("Worker spawn failed");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { workerId: "worker-1", signal: "SIGTERM" };
+    const error = new ProcessManagerError("Process terminated", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("PlanningError", () => {
+  test("creates planning error", () => {
+    const error = new PlanningError("Task splitting failed");
+    expect(error.code).toBe("PLANNING_ERROR");
+    expect(error.message).toBe("Task splitting failed");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { requirementsPath: "/path/to/req.md" };
+    const error = new PlanningError("Invalid requirements", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("TaskExecutionError", () => {
+  test("creates task execution error", () => {
+    const error = new TaskExecutionError("Execution failed");
+    expect(error.code).toBe("TASK_EXECUTION_ERROR");
+    expect(error.message).toBe("Execution failed");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { taskId: "task-1", phase: "green" };
+    const error = new TaskExecutionError("Phase failed", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("PhaseError", () => {
+  test("creates phase error", () => {
+    const error = new PhaseError("Phase execution failed");
+    expect(error.code).toBe("PHASE_ERROR");
+    expect(error.message).toBe("Phase execution failed");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { phase: "review", taskId: "task-1" };
+    const error = new PhaseError("Review failed", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("TestRunnerError", () => {
+  test("creates test runner error", () => {
+    const error = new TestRunnerError("Tests failed");
+    expect(error.code).toBe("TEST_RUNNER_ERROR");
+    expect(error.message).toBe("Tests failed");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context", () => {
+    const context = { exitCode: 1, command: "bun test" };
+    const error = new TestRunnerError("Test execution failed", context);
+    expect(error.context).toEqual(context);
+  });
+});
+
+describe("MergeConflictError", () => {
+  test("creates merge conflict error", () => {
+    const error = new MergeConflictError("Merge conflict detected");
+    expect(error.code).toBe("MERGE_CONFLICT_ERROR");
+    expect(error.message).toBe("Merge conflict detected");
+    expect(error instanceof AadError).toBe(true);
+  });
+
+  test("includes context with files", () => {
+    const context = { conflictedFiles: ["src/file1.ts", "src/file2.ts"] };
+    const error = new MergeConflictError("Conflicts found", context);
+    expect(error.context).toEqual(context);
+  });
+});