agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/test/pr-monitor.spec.ts

@@ -0,0 +1,385 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  PrMonitorService,
+  createGhRunner
+} from '../src/application/services/pr-monitor-service.js';
+import type { GhRunner, PrInfo } from '../src/application/services/pr-monitor-service.js';
+import { TOOLS } from '../src/core/constants.js';
+
+function makeGhRunner(stdout: string, exitCode = 0): GhRunner {
+  return async () => ({ stdout, exitCode });
+}
+
+function makeToolCaller(frontMatter: Record<string, unknown> = { version: 1, status: 'building' }) {
+  return {
+    callTool: vi.fn(async (_role: string, toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 1, ...frontMatter } } };
+      }
+      return { ok: true, data: {} };
+    })
+  };
+}
+
+const PR_JSON = JSON.stringify({
+  number: 42,
+  url: 'https://github.com/org/repo/pull/42',
+  statusCheckRollup: [{ state: 'SUCCESS' }, { state: 'SUCCESS' }],
+  reviewDecision: 'APPROVED',
+  mergeable: 'MERGEABLE',
+  reviewThreads: []
+});
+
+const FAILING_CI_JSON = JSON.stringify({
+  number: 43,
+  url: 'https://github.com/org/repo/pull/43',
+  statusCheckRollup: [{ state: 'SUCCESS' }, { state: 'FAILURE' }],
+  reviewDecision: null,
+  mergeable: 'MERGEABLE',
+  reviewThreads: []
+});
+
+const APPROVED_PR: PrInfo = {
+  number: 1,
+  url: 'https://github.com/org/repo/pull/1',
+  ci_status: 'passing',
+  review_decision: 'approved',
+  merge_ready: true,
+  pending_review_threads: 0,
+  has_conflicts: false,
+  merge_score: 0
+};
+
+describe('PrMonitorService', () => {
+  it('GIVEN gh not available WHEN detectPr called THEN returns null gracefully', async () => {
+    const service = new PrMonitorService({
+      toolCaller: makeToolCaller() as never,
+      ghRunner: makeGhRunner('', 127)
+    });
+
+    const result = await service.detectPr('my-feature', 'feature/my-feature');
+
+    expect(result).toBeNull();
+  });
+
+  it('GIVEN_primary_branch_lookup_misses_WHEN_detectPr_called_THEN_falls_back_to_feature_id_branch', async () => {
+    const ghRunner = vi.fn()
+      .mockResolvedValueOnce({ stdout: '', exitCode: 1 })
+      .mockResolvedValueOnce({ stdout: PR_JSON, exitCode: 0 });
+    const service = new PrMonitorService({
+      toolCaller: makeToolCaller() as never,
+      ghRunner
+    });
+
+    const result = await service.detectPr('my-feature', 'mismatched-branch');
+
+    expect(result?.number).toBe(42);
+    expect(ghRunner).toHaveBeenNthCalledWith(
+      2,
+      expect.arrayContaining(['--head', 'my-feature'])
+    );
+  });
+
+  it('GIVEN PR found with all CI passing WHEN detectPr called THEN ci_status=passing', async () => {
+    const service = new PrMonitorService({
+      toolCaller: makeToolCaller() as never,
+      ghRunner: makeGhRunner(PR_JSON)
+    });
+
+    const result = await service.detectPr('my-feature', 'feature/my-feature');
+
+    expect(result).not.toBeNull();
+    expect(result.ci_status).toBe('passing');
+    expect(result.number).toBe(42);
+  });
+
+  it('GIVEN PR found with failed CI WHEN detectPr called THEN ci_status=failing', async () => {
+    const service = new PrMonitorService({
+      toolCaller: makeToolCaller() as never,
+      ghRunner: makeGhRunner(FAILING_CI_JSON)
+    });
+
+    const result = await service.detectPr('my-feature', 'feature/my-feature');
+
+    expect(result).not.toBeNull();
+    expect(result.ci_status).toBe('failing');
+  });
+
+  it('GIVEN PR approved WHEN computeMergeScore called THEN score >= 80', () => {
+    const service = new PrMonitorService({
+      toolCaller: makeToolCaller() as never,
+      ghRunner: makeGhRunner('')
+    });
+
+    const score = service.computeMergeScore(APPROVED_PR);
+
+    expect(score).toBeGreaterThanOrEqual(80);
+  });
+
+  it('GIVEN PR has changes_requested WHEN handleChangesRequested called THEN feature log updated', async () => {
+    const reviewJson = JSON.stringify({
+      reviews: [{ body: 'Please fix the tests', state: 'CHANGES_REQUESTED' }]
+    });
+    const ghRunner = vi.fn().mockResolvedValue({ stdout: reviewJson, exitCode: 0 });
+    const toolCaller = makeToolCaller();
+    const service = new PrMonitorService({
+      toolCaller: toolCaller as never,
+      ghRunner,
+      reactionsPolicy: {
+        changes_requested: { enabled: true, action: 'send_review_context_to_agent', escalate_after: 2 }
+      }
+    });
+
+    const prInfo: PrInfo = {
+      number: 42,
+      url: 'https://github.com/org/repo/pull/42',
+      ci_status: 'passing',
+      review_decision: 'changes_requested',
+      merge_ready: false,
+      pending_review_threads: 0,
+      has_conflicts: false,
+      merge_score: 40
+    };
+
+    await service.handleChangesRequested('my-feature', prInfo);
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_LOG_APPEND,
+      expect.objectContaining({ feature_id: 'my-feature' })
+    );
+  });
+
+  it('GIVEN changes_requested reaction disabled WHEN handleChangesRequested called THEN log not updated', async () => {
+    const toolCaller = makeToolCaller();
+    const service = new PrMonitorService({
+      toolCaller: toolCaller as never,
+      ghRunner: makeGhRunner(''),
+      reactionsPolicy: {
+        changes_requested: { enabled: false, action: 'send_review_context_to_agent', escalate_after: 2 }
+      }
+    });
+
+    const prInfo: PrInfo = {
+      number: 42,
+      url: 'https://github.com/org/repo/pull/42',
+      ci_status: 'passing',
+      review_decision: 'changes_requested',
+      merge_ready: false,
+      pending_review_threads: 0,
+      has_conflicts: false,
+      merge_score: 40
+    };
+
+    await service.handleChangesRequested('my-feature', prInfo);
+
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_LOG_APPEND,
+      expect.anything()
+    );
+  });
+
+  it('GIVEN PR with conflicts WHEN computeMergeScore called THEN score penalized', () => {
+    const service = new PrMonitorService({
+      toolCaller: makeToolCaller() as never,
+      ghRunner: makeGhRunner('')
+    });
+
+    const prWithConflict: PrInfo = { ...APPROVED_PR, has_conflicts: true, merge_ready: false };
+    const prWithoutConflict: PrInfo = { ...APPROVED_PR, has_conflicts: false };
+
+    const scoreWithConflict = service.computeMergeScore(prWithConflict);
+    const scoreWithoutConflict = service.computeMergeScore(prWithoutConflict);
+
+    expect(scoreWithConflict).toBeLessThan(scoreWithoutConflict);
+  });
+
+  it('GIVEN checkAndUpdate called WHEN PR found THEN storePrState called with correct data', async () => {
+    const toolCaller = makeToolCaller();
+    const service = new PrMonitorService({
+      toolCaller: toolCaller as never,
+      ghRunner: makeGhRunner(PR_JSON)
+    });
+
+    const result = await service.checkAndUpdate('my-feature', 'feature/my-feature');
+
+    expect(result).not.toBeNull();
+    expect(result.number).toBe(42);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: 'my-feature',
+        patch: expect.objectContaining({
+          front_matter: expect.objectContaining({
+            pr: expect.objectContaining({
+              number: 42,
+              url: 'https://github.com/org/repo/pull/42'
+            })
+          })
+        })
+      })
+    );
+  });
+
+  it('GIVEN createGhRunner with injected fn WHEN called THEN uses provided function', async () => {
+    const mockFn = vi.fn().mockResolvedValue({ stdout: PR_JSON, exitCode: 0 });
+    const runner = createGhRunner(mockFn);
+
+    const result = await runner(['pr', 'view', '--head', 'main']);
+
+    expect(mockFn).toHaveBeenCalledWith(['pr', 'view', '--head', 'main']);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe(PR_JSON);
+  });
+
+  it('GIVEN checkAndUpdate called WHEN PR not found THEN returns null', async () => {
+    const toolCaller = makeToolCaller();
+    const service = new PrMonitorService({
+      toolCaller: toolCaller as never,
+      ghRunner: makeGhRunner('', 1)
+    });
+
+    const result = await service.checkAndUpdate('no-pr-feature', 'feature/no-pr-feature');
+
+    expect(result).toBeNull();
+    expect(toolCaller.callTool).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_PR_with_changes_requested_WHEN_checkAndUpdate_called_THEN_handleChangesRequested_invoked', async () => {
+    const CHANGES_REQUESTED_JSON = JSON.stringify({
+      number: 55,
+      url: 'https://github.com/org/repo/pull/55',
+      statusCheckRollup: [{ state: 'SUCCESS' }],
+      reviewDecision: 'CHANGES_REQUESTED',
+      mergeable: 'MERGEABLE',
+      reviewThreads: []
+    });
+    const reviewJson = JSON.stringify({ reviews: [{ body: 'Fix typo', state: 'CHANGES_REQUESTED' }] });
+    const ghRunner = vi.fn()
+      .mockResolvedValueOnce({ stdout: CHANGES_REQUESTED_JSON, exitCode: 0 })  // detectPr
+      .mockResolvedValueOnce({ stdout: reviewJson, exitCode: 0 });               // handleChangesRequested
+    const toolCaller = makeToolCaller();
+    const notifier = { notify: vi.fn(async () => {}) };
+    const service = new PrMonitorService({
+      toolCaller: toolCaller as never,
+      ghRunner,
+      reactionsPolicy: {
+        changes_requested: { enabled: true, action: 'send_review_context_to_agent', escalate_after: 2 }
+      },
+      notifier: notifier as never
+    });
+
+    const result = await service.checkAndUpdate('my-feature', 'feature/my-feature');
+
+    expect(result).not.toBeNull();
+    expect(result?.review_decision).toBe('changes_requested');
+    expect(notifier.notify).toHaveBeenCalledWith('changes_requested', expect.objectContaining({ feature_id: 'my-feature' }));
+  });
+
+  it('GIVEN_invalid_JSON_in_reviews_response_WHEN_handleChangesRequested_called_THEN_logs_empty_review_body', async () => {
+    const ghRunner = vi.fn().mockResolvedValue({ stdout: 'not-valid-json{{{', exitCode: 0 });
+    const toolCaller = makeToolCaller();
+    const service = new PrMonitorService({
+      toolCaller: toolCaller as never,
+      ghRunner,
+      reactionsPolicy: {
+        changes_requested: { enabled: true, action: 'send_review_context_to_agent', escalate_after: 2 }
+      }
+    });
+
+    const prInfo: PrInfo = {
+      number: 42,
+      url: 'https://github.com/org/repo/pull/42',
+      ci_status: 'passing',
+      review_decision: 'changes_requested',
+      merge_ready: false,
+      pending_review_threads: 0,
+      has_conflicts: false,
+      merge_score: 40
+    };
+
+    await expect(service.handleChangesRequested('my-feature', prInfo)).resolves.toBeUndefined();
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_LOG_APPEND,
+      expect.objectContaining({ note: expect.stringContaining('PR #42 changes requested') })
+    );
+  });
+});
+
+describe('PrMonitorService branch coverage', () => {
+  it('GIVEN_detectPr_returns_parsed_number_zero_WHEN_called_THEN_returns_null', async () => {
+    const service = new PrMonitorService({
+      toolCaller: makeToolCaller() as never,
+      ghRunner: makeGhRunner(JSON.stringify({ number: 0, url: '', statusCheckRollup: null, reviewDecision: null, mergeable: 'UNKNOWN', reviewThreads: null }))
+    });
+    const result = await service.detectPr('f1', 'branch');
+    expect(result).toBeNull();
+  });
+
+  it('GIVEN_invalid_JSON_WHEN_detectPr_called_THEN_returns_null', async () => {
+    const service = new PrMonitorService({
+      toolCaller: makeToolCaller() as never,
+      ghRunner: makeGhRunner('not-json')
+    });
+    const result = await service.detectPr('f1', 'branch');
+    expect(result).toBeNull();
+  });
+
+  it('GIVEN_REVIEW_REQUIRED_review_decision_WHEN_detectPr_called_THEN_review_decision_is_pending', async () => {
+    const service = new PrMonitorService({
+      toolCaller: makeToolCaller() as never,
+      ghRunner: makeGhRunner(JSON.stringify({
+        number: 5, url: 'https://example.com/pr/5',
+        statusCheckRollup: [{ state: 'PENDING' }],
+        reviewDecision: 'REVIEW_REQUIRED',
+        mergeable: 'MERGEABLE',
+        reviewThreads: [{ isResolved: false }, { isResolved: true }]
+      }))
+    });
+    const result = await service.detectPr('f1', 'branch');
+    expect(result?.review_decision).toBe('pending');
+    expect(result?.ci_status).toBe('pending');
+    expect(result?.pending_review_threads).toBe(1);
+  });
+
+  it('GIVEN_unknown_review_decision_WHEN_detectPr_called_THEN_review_decision_is_none', async () => {
+    const service = new PrMonitorService({
+      toolCaller: makeToolCaller() as never,
+      ghRunner: makeGhRunner(JSON.stringify({
+        number: 6, url: 'https://example.com/pr/6',
+        statusCheckRollup: null,
+        reviewDecision: 'UNKNOWN_DECISION',
+        mergeable: 'CONFLICTING',
+        reviewThreads: null
+      }))
+    });
+    const result = await service.detectPr('f1', 'branch');
+    expect(result?.review_decision).toBe('none');
+    expect(result?.has_conflicts).toBe(true);
+    expect(result?.pending_review_threads).toBe(0);
+  });
+
+  it('GIVEN_action_not_send_review_context_WHEN_handleChangesRequested_called_THEN_no_op', async () => {
+    const toolCaller = makeToolCaller();
+    const service = new PrMonitorService({
+      toolCaller: toolCaller as never,
+      reactionsPolicy: { changes_requested: { enabled: true, action: 'other_action', escalate_after: 0 } }
+    });
+    await service.handleChangesRequested('f1', APPROVED_PR);
+    expect(toolCaller.callTool).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_no_notifier_WHEN_handleChangesRequested_called_with_changes_requested_THEN_no_notifier_call', async () => {
+    const toolCaller = makeToolCaller();
+    const service = new PrMonitorService({
+      toolCaller: toolCaller as never,
+      reactionsPolicy: { changes_requested: { enabled: true, action: 'send_review_context_to_agent', escalate_after: 0 } },
+      ghRunner: makeGhRunner(JSON.stringify({ reviews: [{ body: 'review content', state: 'CHANGES_REQUESTED' }] }))
+    });
+    await service.handleChangesRequested('f1', { ...APPROVED_PR, number: 10 });
+    expect(toolCaller.callTool).toHaveBeenCalledWith('orchestrator', TOOLS.FEATURE_LOG_APPEND, expect.anything());
+  });
+});