@ronkovic/aad 0.3.0

package/src/__tests__/e2e/resume-e2e.test.ts

@@ -0,0 +1,200 @@
+/**
+ * E2E Resume Test — FS-based stores with real EventBus
+ */
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { EventBus } from "@aad/shared/events";
+import { createStores, type Stores } from "@aad/persistence/index";
+import { resumeRun } from "@aad/cli/commands/resume";
+import {
+  createRunId,
+  createTaskId,
+  type Task,
+  type RunState,
+} from "@aad/shared/types";
+import type { App } from "@aad/cli/app";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mock } from "bun:test";
+
+function createMockLogger() {
+  const noop = () => {};
+  return {
+    info: noop, warn: noop, error: noop, debug: noop, trace: noop, fatal: noop,
+    child: () => createMockLogger(),
+  } as any;
+}
+
+describe("E2E Resume", () => {
+  let tmpDir: string;
+  let stores: Stores;
+  let eventBus: EventBus;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "aad-resume-e2e-"));
+    stores = createStores("fs", { basePath: tmpDir, logger: createMockLogger() });
+    eventBus = new EventBus();
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  function createApp(overrides?: Partial<App>): App {
+    return {
+      config: {
+        workers: { num: 2, max: 4 },
+        models: {},
+        timeouts: { claude: 1200, test: 600, staleTask: 10 }, // 10s timeout for tests
+        retry: { maxRetries: 2 },
+        debug: false,
+        adaptiveEffort: false,
+        teams: { splitter: false, reviewer: false },
+        memorySync: false,
+        dashboard: { enabled: false, port: 7333, host: "localhost" },
+      },
+      eventBus,
+      logger: createMockLogger(),
+      stores,
+      dispatcher: {
+        initialize: mock(async () => {}),
+        start: mock(() => {}),
+      } as any,
+      processManager: {
+        initializePool: mock(async () => {}),
+      } as any,
+      planningService: {} as any,
+      providerRegistry: {} as any,
+      worktreeManager: {} as any,
+      branchManager: {} as any,
+      mergeService: {} as any,
+      shutdown: mock(async () => {}),
+      ...overrides,
+    } as App;
+  }
+
+  test("resumes with FS-persisted tasks, resets running to pending, completes on event", async () => {
+    const runId = createRunId("e2e-run-1");
+
+    // Write run state
+    const runState: RunState = {
+      runId,
+      parentBranch: "main",
+      totalTasks: 2,
+      pending: 0,
+      running: 1,
+      completed: 1,
+      failed: 0,
+      startTime: new Date().toISOString(),
+    };
+    await stores.runStore.save(runState);
+
+    // Write tasks
+    const tasks: Task[] = [
+      {
+        taskId: createTaskId("task-e2e-run-1-1"),
+        title: "Completed task",
+        description: "Already done",
+        filesToModify: [],
+        dependsOn: [],
+        priority: 1,
+        status: "completed",
+        retryCount: 0,
+      },
+      {
+        taskId: createTaskId("task-e2e-run-1-2"),
+        title: "Running task",
+        description: "Was interrupted",
+        filesToModify: ["src/foo.ts"],
+        dependsOn: [],
+        priority: 2,
+        status: "running",
+        retryCount: 0,
+      },
+    ];
+    for (const t of tasks) {
+      await stores.taskStore.save(t);
+    }
+
+    const app = createApp();
+
+    // Emit completion after short delay
+    setTimeout(() => {
+      eventBus.emit({ type: "run:completed", runId });
+    }, 2000);
+
+    await resumeRun(app, "e2e-run-1");
+
+    // Verify running task was reset
+    const saved = await stores.taskStore.get(createTaskId("task-e2e-run-1-2"));
+    expect(saved?.status).toBe("pending");
+    expect(saved?.workerId).toBeUndefined();
+
+    expect(app.dispatcher.initialize).toHaveBeenCalled();
+    expect(app.dispatcher.start).toHaveBeenCalled();
+    expect(app.shutdown).toHaveBeenCalled();
+  });
+
+  test("early returns when all tasks already completed (FS store)", async () => {
+    const runId = createRunId("e2e-run-2");
+
+    await stores.runStore.save({
+      runId,
+      parentBranch: "main",
+      totalTasks: 1,
+      pending: 0,
+      running: 0,
+      completed: 1,
+      failed: 0,
+      startTime: new Date().toISOString(),
+    });
+
+    await stores.taskStore.save({
+      taskId: createTaskId("task-e2e-run-2-1"),
+      title: "Done task",
+      description: "Already completed",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "completed",
+      retryCount: 0,
+    });
+
+    const app = createApp();
+    await resumeRun(app, "e2e-run-2");
+
+    expect(app.dispatcher.start).not.toHaveBeenCalled();
+    expect(app.shutdown).toHaveBeenCalled();
+  });
+
+  test("times out when no completion event arrives (FS store)", async () => {
+    const runId = createRunId("e2e-run-3");
+
+    await stores.runStore.save({
+      runId,
+      parentBranch: "main",
+      totalTasks: 1,
+      pending: 1,
+      running: 0,
+      completed: 0,
+      failed: 0,
+      startTime: new Date().toISOString(),
+    });
+
+    await stores.taskStore.save({
+      taskId: createTaskId("task-e2e-run-3-1"),
+      title: "Pending task",
+      description: "Waiting",
+      filesToModify: [],
+      dependsOn: [],
+      priority: 1,
+      status: "pending",
+      retryCount: 0,
+    });
+
+    const app = createApp();
+    app.config.timeouts.staleTask = 1; // 1s for this test
+
+    await expect(resumeRun(app, "e2e-run-3")).rejects.toThrow("Resume timed out");
+  });
+});

package/src/__tests__/integration/cli-smoke.test.ts

@@ -0,0 +1,175 @@
+/**
+ * CLI Smoke Tests
+ * 全CLIコマンド（run, resume, status, cleanup）の基本動作を検証
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { rm, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+const TEST_DIR = join(import.meta.dir, ".tmp-cli-smoke-test");
+const AAD_CLI = join(import.meta.dir, "../../main.ts");
+
+/** Helper: spawn CLI and collect output with timeout */
+async function runCli(
+  args: string[],
+  opts?: { cwd?: string; timeoutMs?: number }
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const cwd = opts?.cwd ?? TEST_DIR;
+  const timeoutMs = opts?.timeoutMs ?? 20_000;
+
+  const proc = Bun.spawn(["bun", AAD_CLI, ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const timer = setTimeout(() => proc.kill(), timeoutMs);
+
+  // Read stdout/stderr in parallel with proc.exited to avoid deadlock
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  clearTimeout(timer);
+  return { stdout, stderr, exitCode };
+}
+
+describe("CLI Smoke Tests", () => {
+  beforeAll(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+    await mkdir(TEST_DIR, { recursive: true });
+  });
+
+  afterAll(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("aad --help", () => {
+    test("displays help message", async () => {
+      const { stdout } = await runCli(["--help"]);
+
+      expect(stdout).toContain("Autonomous Agent Development Orchestrator");
+      expect(stdout).toContain("run");
+      expect(stdout).toContain("resume");
+      expect(stdout).toContain("status");
+      expect(stdout).toContain("cleanup");
+    }, 30_000);
+  });
+
+  describe("aad --version", () => {
+    test("displays version number", async () => {
+      const { stdout } = await runCli(["--version"]);
+
+      expect(stdout).toMatch(/\d+\.\d+\.\d+/); // Semantic version format
+    }, 30_000);
+  });
+
+  describe("aad run", () => {
+    test("shows error when requirements file is missing", async () => {
+      const { exitCode, stdout, stderr } = await runCli(["run", "nonexistent.md"]);
+
+      expect(exitCode).not.toBe(0);
+      // Error may appear in stdout or stderr depending on Commander.js version
+      const combined = stdout + stderr;
+      expect(combined.length).toBeGreaterThan(0);
+    }, 30_000);
+
+    test("accepts --workers option", async () => {
+      // Create minimal requirements file
+      const reqFile = join(TEST_DIR, "requirements.md");
+      await Bun.write(reqFile, "# Test Requirements\n\nBasic test.\n");
+
+      const { exitCode } = await runCli(
+        ["run", reqFile, "--workers", "2", "--debug"],
+        { timeoutMs: 3000 }
+      );
+
+      // Expect either success or graceful shutdown (killed by timeout)
+      expect([0, 1, 143, 137]).toContain(exitCode); // 143=SIGTERM, 137=SIGKILL
+    }, 30_000);
+  });
+
+  describe("aad status", () => {
+    test("shows error when no run ID provided and no runs exist", async () => {
+      const { exitCode, stdout, stderr } = await runCli(["status", "--no-dashboard"]);
+      const combined = stdout + stderr;
+
+      expect(exitCode).not.toBe(0);
+      expect(combined).toContain("No runs found");
+    }, 30_000);
+
+    test("shows error for non-existent run ID", async () => {
+      const { exitCode, stdout, stderr } = await runCli(["status", "fake-run-id", "--no-dashboard"]);
+      const combined = stdout + stderr;
+
+      expect(exitCode).not.toBe(0);
+      expect(combined).toContain("Run not found");
+    }, 30_000);
+  });
+
+  describe("aad resume", () => {
+    test("shows error when run ID is missing", async () => {
+      const { exitCode, stdout, stderr } = await runCli(["resume", "--no-dashboard"]);
+      const combined = stdout + stderr;
+
+      expect(exitCode).not.toBe(0);
+      expect(combined).toContain("required");
+    }, 30_000);
+
+    test("shows error for non-existent run ID", async () => {
+      const { exitCode, stdout, stderr } = await runCli(["resume", "fake-run-id", "--no-dashboard"]);
+      const combined = stdout + stderr;
+
+      expect(exitCode).not.toBe(0);
+      expect(combined).toContain("Run not found");
+    }, 30_000);
+  });
+
+  describe("aad cleanup", () => {
+    test("runs without errors when no worktrees exist", async () => {
+      const { exitCode, stdout } = await runCli(["cleanup", "--no-dashboard"]);
+
+      expect(exitCode).toBe(0);
+      expect(stdout).toContain("No AAD worktrees found");
+    }, 30_000);
+
+    test("accepts --force option", async () => {
+      const { exitCode, stdout } = await runCli(["cleanup", "--force", "--no-dashboard"]);
+
+      expect(exitCode).toBe(0);
+      expect(stdout).toContain("Cleanup complete");
+    }, 30_000);
+
+    test("accepts run ID argument", async () => {
+      const { exitCode, stdout } = await runCli(["cleanup", "test-run-id", "--no-dashboard"]);
+
+      expect(exitCode).toBe(0);
+      expect(stdout).toContain("Cleanup complete");
+    }, 30_000);
+  });
+
+  describe("aad global options", () => {
+    test("accepts --debug flag", async () => {
+      const { exitCode } = await runCli(["cleanup", "--debug", "--no-dashboard"]);
+      expect(exitCode).toBe(0);
+    }, 30_000);
+
+    test("accepts --persist option", async () => {
+      const { exitCode } = await runCli(["cleanup", "--persist", "memory", "--no-dashboard"]);
+      expect(exitCode).toBe(0);
+    }, 30_000);
+
+    test("accepts --no-dashboard flag", async () => {
+      const { exitCode } = await runCli(["cleanup", "--no-dashboard"]);
+      expect(exitCode).toBe(0);
+    }, 30_000);
+
+    test("accepts --provider option", async () => {
+      const { exitCode } = await runCli(["cleanup", "--provider", "cli", "--no-dashboard"]);
+      expect(exitCode).toBe(0);
+    }, 30_000);
+  });
+});