agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/test/bootstrap-edge-cases.spec.ts

@@ -0,0 +1,252 @@
+/**
+ * Bootstrap edge-case tests covering uncovered branches in bootstrap.ts.
+ * Separate from bootstrap.spec.ts to allow different kernel mock configurations.
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// ── hoisted mocks ─────────────────────────────────────────────────────────────
+
+const ensureLoadedMock = vi.hoisted(() => vi.fn(async () => undefined));
+const createToolingRuntimeMock = vi.hoisted(() => vi.fn(async () => ({ runtime: 'ok' })));
+const resolveToolClientMock = vi.hoisted(() => vi.fn());
+const toolCallMock = vi.hoisted(() => vi.fn(async () => ({ ok: true, data: {} })));
+
+/** Allows per-test control of getPolicySnapshot return value */
+const policySnapshotOverride = vi.hoisted(() => ({
+  value: {} as Record<string, unknown>
+}));
+
+/** Allows per-test control of whether ensureLoaded throws */
+const kernelThrowOverride = vi.hoisted(() => ({
+  value: null as Error | null
+}));
+
+vi.mock('node:readline/promises', () => ({
+  default: {
+    createInterface: vi.fn(() => ({
+      question: vi.fn(async () => ''),
+      close: vi.fn()
+    }))
+  }
+}));
+
+vi.mock('../src/core/kernel.js', () => {
+  class AopKernel {
+    private readonly repoRoot: string;
+    constructor(repoRoot: string) { this.repoRoot = repoRoot; }
+
+    async ensureLoaded() {
+      await ensureLoadedMock();
+      if (kernelThrowOverride.value) {
+        throw kernelThrowOverride.value;
+      }
+    }
+
+    getRepoRoot() { return this.repoRoot; }
+    getAgentsConfig() { return {}; }
+    getRbacPolicy() { return {}; }
+
+    getPolicySnapshot() {
+      return policySnapshotOverride.value;
+    }
+
+    setProvider() {}
+  }
+
+  return { AopKernel };
+});
+
+vi.mock('../src/mcp/runtime-factory.js', () => ({
+  createToolingRuntime: createToolingRuntimeMock,
+  resolveToolClient: resolveToolClientMock
+}));
+
+vi.mock('../src/cli/init-command-handler.js', () => ({
+  InitCommandHandler: vi.fn().mockImplementation(() => ({
+    execute: vi.fn(async () => ({ ok: true, data: { command: 'init', created: [], updated: [], skipped: [], validation_warnings: [], next_steps: [] } }))
+  }))
+}));
+
+vi.mock('../src/cli/dashboard-command-handler.js', () => ({
+  DashboardCommandHandler: vi.fn().mockImplementation(() => ({
+    execute: vi.fn(async () => ({ ok: true, data: { message: 'started', port: 3000 } }))
+  }))
+}));
+
+vi.mock('../src/cli/run-command-handler.js', () => ({
+  RunCommandHandler: vi.fn().mockImplementation(() => ({
+    execute: vi.fn(async () => ({ ok: true, data: { status: 'running' } }))
+  }))
+}));
+
+vi.mock('../src/cli/resume-command-handler.js', () => ({
+  ResumeCommandHandler: vi.fn().mockImplementation(() => ({
+    execute: vi.fn(async () => ({ ok: true, data: { resumed: false } }))
+  }))
+}));
+
+vi.mock('../src/cli/attach-command-handler.js', () => ({
+  AttachCommandHandler: vi.fn().mockImplementation(() => ({
+    execute: vi.fn(async () => ({ ok: true, data: { command: 'attach' } }))
+  }))
+}));
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+async function writeMultiProjectYaml(dir: string, content: string): Promise<void> {
+  const configDir = path.join(dir, 'agentic', 'orchestrator');
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(path.join(configDir, 'multi-project.yaml'), content, 'utf8');
+}
+
+async function writeSchemaFile(dir: string): Promise<void> {
+  const schemasDir = path.join(dir, 'agentic', 'orchestrator', 'schemas');
+  await fs.mkdir(schemasDir, { recursive: true });
+  const repoRoot = path.resolve(import.meta.dirname, '../../../');
+  const srcSchema = path.join(repoRoot, 'agentic', 'orchestrator', 'schemas', 'multi-project.schema.json');
+  const destSchema = path.join(schemasDir, 'multi-project.schema.json');
+  await fs.copyFile(srcSchema, destSchema);
+}
+
+describe('bootstrap edge-case branch coverage', () => {
+  let tmpDir: string;
+  let stdoutSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-bs-edge-'));
+    await writeSchemaFile(tmpDir);
+    resolveToolClientMock.mockReturnValue({ call: toolCallMock });
+    toolCallMock.mockResolvedValue({ ok: true, data: { features: [] } });
+    ensureLoadedMock.mockClear();
+    createToolingRuntimeMock.mockClear();
+    stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    policySnapshotOverride.value = {};
+    kernelThrowOverride.value = null;
+  });
+
+  afterEach(async () => {
+    stdoutSpy.mockRestore();
+    vi.clearAllMocks();
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('GIVEN_cwd_is_subdir_of_project_WHEN_status_THEN_selectProjectByCwd_uses_isPathWithin_subdir_branch', async () => {
+    // Covers line 33 branch 0: relative !== '' but still within parent
+    const proj1 = path.join(tmpDir, 'proj1');
+    const proj1sub = path.join(proj1, 'src');
+    await fs.mkdir(proj1sub, { recursive: true });
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n`
+    );
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    // cwd is a subdir of proj1 → isPathWithin returns true via !startsWith('..') branch
+    const code = await runCli(['status'], { cwd: proj1sub, env: process.env });
+    expect(code).toBe(0);
+  });
+
+  it('GIVEN_multi_project_no_cwd_match_and_no_default_WHEN_cwd_matches_zero_THEN_returns_null_from_selectProjectByCwd', async () => {
+    // Covers line 38 branch 0: selectProjectByCwd returns null (no match)
+    const proj1 = path.join(tmpDir, 'proj1');
+    await fs.mkdir(proj1, { recursive: true });
+    const other = path.join(tmpDir, 'other');
+    await fs.mkdir(other, { recursive: true });
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\ndefaults:\n  default_project: proj1\n`
+    );
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    // cwd is 'other' which is not within proj1 → selectProjectByCwd returns null → uses default
+    const code = await runCli(['status'], { cwd: other, env: process.env });
+    expect(code).toBe(0);
+  });
+
+  it('GIVEN_cleanup_with_policy_having_grace_period_and_auto_after_merge_WHEN_cleanup_THEN_uses_policy_values', async () => {
+    // Covers lines 291 and 292: cleanup?.grace_period_seconds non-null and auto_after_merge=true
+    policySnapshotOverride.value = {
+      cleanup: { grace_period_seconds: 120, auto_after_merge: true }
+    };
+    toolCallMock.mockResolvedValue({ ok: true, data: { cleaned: [], would_clean: [] } });
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['cleanup', '--dry-run'], { cwd: '/tmp', env: process.env });
+    expect(code).toBe(0);
+  });
+
+  it('GIVEN_kernel_throws_plain_error_without_code_WHEN_run_THEN_uses_fallback_code_and_message', async () => {
+    // Covers lines 341-342: typed.code is undefined (|| ERROR_CODES.INTERNAL_ERROR) and typed.message is undefined (|| 'Unhandled CLI error')
+    const plainError = new Error(); // no code, no message (empty string)
+    (plainError as Error & { message: string }).message = ''; // empty message
+    kernelThrowOverride.value = plainError;
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status'], { cwd: '/tmp', env: process.env });
+    expect(code).toBe(1);
+  });
+
+  it('GIVEN_multi_project_with_max_active_features_default_WHEN_run_THEN_passes_to_handler', async () => {
+    // Covers lines 334-335: multiConfig?.defaults?.max_active_features non-null
+    const proj1 = path.join(tmpDir, 'proj1');
+    await fs.mkdir(proj1, { recursive: true });
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\ndefaults:\n  max_active_features: 5\n  max_parallel_gate_runs: 2\n`
+    );
+    toolCallMock.mockResolvedValue({ ok: true, data: { status: 'running' } });
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['run', '--feature-id', 'feat_test'], { cwd: tmpDir, env: process.env });
+    expect(code).toBe(0);
+  });
+
+  it('GIVEN_dashboard_command_without_port_option_WHEN_executed_THEN_uses_project_default_port', async () => {
+    // Covers line 167: options.port ?? defaultDashboardPort (both ?? branches)
+    const proj1 = path.join(tmpDir, 'proj1');
+    await fs.mkdir(proj1, { recursive: true });
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n    dashboard_port: 4000\n`
+    );
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    // No --port option → options.port is undefined → uses defaultDashboardPort (4000)
+    const code = await runCli(['dashboard'], { cwd: proj1, env: process.env });
+    expect(code).toBe(0);
+  });
+
+  it('GIVEN_status_all_with_one_project_throwing_error_without_code_WHEN_executed_THEN_uses_fallback_code', async () => {
+    // Covers line 205: typed.code ?? ERROR_CODES.INTERNAL_ERROR when typed.code is undefined
+    const proj1 = path.join(tmpDir, 'proj1');
+    const proj2 = path.join(tmpDir, 'proj2');
+    await fs.mkdir(proj1, { recursive: true });
+    await fs.mkdir(proj2, { recursive: true });
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`
+    );
+
+    // proj2 will throw an error without .code property
+    let callCount = 0;
+    toolCallMock.mockImplementation(async () => {
+      callCount++;
+      // Second project's status call throws a plain Error
+      if (callCount > 1) {
+        throw new Error('plain error without code');
+      }
+      return { ok: true, data: { features: [] } };
+    });
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status', '--all'], { cwd: tmpDir, env: process.env });
+    expect(code).toBe(0);
+    const writes = stdoutSpy.mock.calls.flatMap((call) => {
+      try { return [JSON.parse(String(call[0]))]; } catch { return []; }
+    });
+    expect(writes.some((w) => w.ok === true)).toBe(true);
+  });
+});