@ronkovic/aad 0.3.0

package/src/modules/task-execution/__tests__/executor.test.ts

@@ -0,0 +1,760 @@
+import { describe, test, expect } from "bun:test";
+import { executeTddPipeline } from "../executor";
+import type { Task, WorkspaceInfo } from "@aad/shared/types";
+import type { ClaudeProvider, ClaudeResponse } from "@aad/claude-provider";
+import type { MergeService, MergeResult } from "@aad/git-workspace";
+import type { Config } from "@aad/shared/config";
+import type { EventBus } from "@aad/shared/events";
+import { createTaskId, createRunId } from "@aad/shared/types";
+
+describe("executeTddPipeline", () => {
+  test("executes full TDD pipeline successfully", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-001"),
+      title: "Add feature",
+      description: "New feature",
+      filesToModify: ["src/feature.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const taskBranch = "task/001-add-feature";
+    const parentBranch = "main";
+    const parentWorktree = "/parent";
+    const runId = createRunId("run-001");
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return {
+          success: true,
+          message: "Merged successfully",
+        };
+      },
+    } as unknown as MergeService;
+
+    const events: string[] = [];
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit(event: any) {
+        events.push(event.type);
+      },
+    } as unknown as EventBus;
+
+    const mockSpawner = {
+      async spawn() {
+        return { exitCode: 0, stdout: "All tests passed", stderr: "" };
+      },
+    };
+
+    const result = await executeTddPipeline(
+      task,
+      workspace,
+      taskBranch,
+      parentBranch,
+      parentWorktree,
+      runId,
+      config,
+      mockProvider,
+      mockMergeService,
+      mockEventBus,
+      mockSpawner
+    );
+
+    expect(result.status).toBe("completed");
+    expect(result.taskId).toBe(task.taskId);
+    expect(result.duration).toBeGreaterThanOrEqual(0);
+
+    // Verify all phases executed
+    expect(events).toContain("execution:phase:started");
+    expect(events).toContain("execution:phase:completed");
+  });
+
+  test("handles tester-red phase failure", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-002"),
+      title: "Failing task",
+      description: "Will fail in Red phase",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const taskBranch = "task/002-failing";
+    const parentBranch = "main";
+    const parentWorktree = "/parent";
+    const runId = createRunId("run-002");
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+    };
+
+    let callCount = 0;
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        callCount++;
+        // Fail on first call (Red phase)
+        return {
+          result: "Red phase failed",
+          exitCode: 1,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 500,
+        };
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        throw new Error("Should not reach merge phase");
+      },
+    } as unknown as MergeService;
+
+    const events: string[] = [];
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit(event: any) {
+        events.push(event.type);
+      },
+    } as unknown as EventBus;
+
+    const result = await executeTddPipeline(
+      task,
+      workspace,
+      taskBranch,
+      parentBranch,
+      parentWorktree,
+      runId,
+      config,
+      mockProvider,
+      mockMergeService,
+      mockEventBus
+    );
+
+    expect(result.status).toBe("failed");
+    expect(result.error).toContain("Red phase failed");
+    expect(callCount).toBe(1); // Only Red phase called
+    expect(events).toContain("execution:phase:failed");
+  });
+
+  test("handles test verification failure", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-003"),
+      title: "Test verification fails",
+      description: "Tests fail after implementation",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const taskBranch = "task/003-test-fail";
+    const parentBranch = "main";
+    const parentWorktree = "/parent";
+    const runId = createRunId("run-003");
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        throw new Error("Should not reach merge phase");
+      },
+    } as unknown as MergeService;
+
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit() {},
+    } as unknown as EventBus;
+
+    const mockSpawner = {
+      async spawn() {
+        // Simulate test failure in verify phase
+        return {
+          exitCode: 1,
+          stdout: "Tests failed",
+          stderr: "AssertionError",
+        };
+      },
+    };
+
+    const result = await executeTddPipeline(
+      task,
+      workspace,
+      taskBranch,
+      parentBranch,
+      parentWorktree,
+      runId,
+      config,
+      mockProvider,
+      mockMergeService,
+      mockEventBus,
+      mockSpawner
+    );
+
+    expect(result.status).toBe("failed");
+    expect(result.error).toContain("Verify phase failed");
+  });
+
+  test("continues execution when review phase fails (non-fatal)", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-004"),
+      title: "Review fails",
+      description: "Review will fail but execution continues",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const taskBranch = "task/004-review-fail";
+    const parentBranch = "main";
+    const parentWorktree = "/parent";
+    const runId = createRunId("run-004");
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+    };
+
+    let phaseCount = 0;
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        phaseCount++;
+        // Fail only on Review phase (4th call)
+        if (phaseCount === 3) {
+          return {
+            result: "Review failed",
+            exitCode: 1,
+            model: "claude-sonnet-4-5",
+            effortLevel: "medium",
+            duration: 500,
+          };
+        }
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return {
+          success: true,
+          message: "Merged successfully",
+        };
+      },
+    } as unknown as MergeService;
+
+    const mockEventBus: EventBus = {
+      on() {},
+      off() {},
+      emit() {},
+    } as unknown as EventBus;
+
+    const mockSpawner = {
+      async spawn() {
+        return { exitCode: 0, stdout: "OK", stderr: "" };
+      },
+    };
+
+    const result = await executeTddPipeline(
+      task,
+      workspace,
+      taskBranch,
+      parentBranch,
+      parentWorktree,
+      runId,
+      config,
+      mockProvider,
+      mockMergeService,
+      mockEventBus,
+      mockSpawner
+    );
+
+    // Should still complete despite review failure
+    expect(result.status).toBe("completed");
+    expect(phaseCount).toBeGreaterThanOrEqual(3); // Red, Green, Review phases called
+  });
+
+  test("emits execution events", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-005"),
+      title: "Event test",
+      description: "Test events",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const taskBranch = "task/005-events";
+    const parentBranch = "main";
+    const parentWorktree = "/parent";
+    const runId = createRunId("run-005");
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return {
+          result: "OK",
+          exitCode: 0,
+          model: "claude-sonnet-4-5",
+          effortLevel: "medium",
+          duration: 1000,
+        };
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return {
+          success: true,
+        };
+      },
+    } as unknown as MergeService;
+
+    const events: Array<{ type: string; phase?: string }> = [];
+    const mockEventBus = {
+      on() {},
+      off() {},
+      emit(event: any) {
+        events.push({ type: event.type, phase: event.phase });
+      },
+    } as unknown as EventBus;
+
+    const mockSpawner = {
+      async spawn() {
+        return { exitCode: 0, stdout: "OK", stderr: "" };
+      },
+    };
+
+    await executeTddPipeline(
+      task,
+      workspace,
+      taskBranch,
+      parentBranch,
+      parentWorktree,
+      runId,
+      config,
+      mockProvider,
+      mockMergeService,
+      mockEventBus,
+      mockSpawner
+    );
+
+    const phaseStartedEvents = events.filter((e) => e.type === "execution:phase:started");
+    const phaseCompletedEvents = events.filter((e) => e.type === "execution:phase:completed");
+
+    expect(phaseStartedEvents.length).toBeGreaterThan(0);
+    expect(phaseCompletedEvents.length).toBeGreaterThan(0);
+
+    // Check that all expected phases are present
+    const phases = phaseStartedEvents.map((e) => e.phase);
+    expect(phases).toContain("red");
+    expect(phases).toContain("green");
+    expect(phases).toContain("verify");
+    expect(phases).toContain("review");
+    expect(phases).toContain("merge");
+  });
+
+  test("handles implementer-green phase failure", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-green-fail"),
+      title: "Green fails",
+      description: "Will fail in Green phase",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+    };
+
+    let callCount = 0;
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        callCount++;
+        if (callCount === 1) {
+          // Red phase succeeds
+          return { result: "OK", exitCode: 0, model: "claude-sonnet-4-5", effortLevel: "medium", duration: 1000 };
+        }
+        // Green phase fails
+        return { result: "Green failed", exitCode: 1, model: "claude-sonnet-4-5", effortLevel: "medium", duration: 500 };
+      },
+    };
+
+    const mockMergeService = { async mergeToParent() { throw new Error("Should not reach"); } } as unknown as MergeService;
+    const events: string[] = [];
+    const mockEventBus = { on() {}, off() {}, emit(event: any) { events.push(event.type); } } as unknown as EventBus;
+
+    const result = await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-gf"), config,
+      mockProvider, mockMergeService, mockEventBus
+    );
+
+    expect(result.status).toBe("failed");
+    expect(result.error).toContain("Green phase failed");
+    expect(callCount).toBe(2);
+    expect(events).toContain("execution:phase:failed");
+  });
+
+  test("handles merge phase failure", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-merge-fail"),
+      title: "Merge fails",
+      description: "Will fail in Merge phase",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return { result: "OK", exitCode: 0, model: "claude-sonnet-4-5", effortLevel: "medium", duration: 1000 };
+      },
+    };
+
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return { success: false, message: "Merge failed" };
+      },
+    } as unknown as MergeService;
+
+    const events: string[] = [];
+    const mockEventBus = { on() {}, off() {}, emit(event: any) { events.push(event.type); } } as unknown as EventBus;
+    const mockSpawner = { async spawn() { return { exitCode: 0, stdout: "OK", stderr: "" }; } };
+
+    const result = await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-mf"), config,
+      mockProvider, mockMergeService, mockEventBus, mockSpawner
+    );
+
+    expect(result.status).toBe("failed");
+    expect(result.error).toContain("Merge phase failed");
+  });
+
+  test("handles merge with conflict and emits conflict event", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-merge-conflict"),
+      title: "Merge with conflict",
+      description: "Merge has conflicts but resolves",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        return { result: "OK", exitCode: 0, model: "claude-sonnet-4-5", effortLevel: "medium", duration: 1000 };
+      },
+    };
+
+    // MergeService returns conflict but merge phase ultimately succeeds (conflicts resolved by Claude)
+    const mockMergeService = {
+      async mergeToParent(): Promise<MergeResult> {
+        return { success: false, conflicts: ["file.ts"], message: "Conflict" };
+      },
+    } as unknown as MergeService;
+
+    const events: string[] = [];
+    const mockEventBus = { on() {}, off() {}, emit(event: any) { events.push(event.type); } } as unknown as EventBus;
+    const mockSpawner = { async spawn() { return { exitCode: 0, stdout: "OK", stderr: "" }; } };
+
+    const result = await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-mc"), config,
+      mockProvider, mockMergeService, mockEventBus, mockSpawner
+    );
+
+    expect(result.status).toBe("completed");
+    expect(events).toContain("execution:merge:conflict");
+  });
+
+  test("handles non-PhaseError exceptions", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-unknown-err"),
+      title: "Unknown error",
+      description: "Will throw non-PhaseError",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        throw new Error("Network connection failed");
+      },
+    };
+
+    const mockMergeService = { async mergeToParent() { throw new Error("no"); } } as unknown as MergeService;
+    const mockEventBus = { on() {}, off() {}, emit() {} } as unknown as EventBus;
+
+    const result = await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-ue"), config,
+      mockProvider, mockMergeService, mockEventBus
+    );
+
+    expect(result.status).toBe("failed");
+    expect(result.error).toBe("Network connection failed");
+    expect(result.output).toBeUndefined();
+  });
+
+  test("handles non-Error thrown exceptions", async () => {
+    const task: Task = {
+      taskId: createTaskId("task-string-err"),
+      title: "String error",
+      description: "Will throw a string",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      retryCount: 0,
+    };
+
+    const workspace: WorkspaceInfo = {
+      path: "/workspace",
+      language: "typescript",
+      packageManager: "bun",
+      framework: "hono",
+      testFramework: "bun-test",
+    };
+
+    const config: Config = {
+      workers: { num: 2, max: 8 },
+      models: {},
+      timeouts: { claude: 1200, test: 600, staleTask: 5400 },
+      retry: { maxRetries: 2 },
+      debug: false,
+      adaptiveEffort: false,
+      teams: { splitter: false, reviewer: false },
+      memorySync: true,
+      dashboard: { enabled: true, port: 7333, host: "localhost" },
+    };
+
+    const mockProvider: ClaudeProvider = {
+      async call(): Promise<ClaudeResponse> {
+        throw "string error";
+      },
+    };
+
+    const mockMergeService = { async mergeToParent() { throw new Error("no"); } } as unknown as MergeService;
+    const mockEventBus = { on() {}, off() {}, emit() {} } as unknown as EventBus;
+
+    const result = await executeTddPipeline(
+      task, workspace, "branch", "main", "/parent", createRunId("run-se"), config,
+      mockProvider, mockMergeService, mockEventBus
+    );
+
+    expect(result.status).toBe("failed");
+    expect(result.error).toBe("Unknown error");
+  });
+});