@avi770/testteam 1.2.0

package/agents/__tests__/10-reporter.test.ts

@@ -0,0 +1,366 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { AgentResult, Finding } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config
+// ---------------------------------------------------------------------------
+
+const stubConfig: ValidatedConfig = {
+  schemaVersion: 1,
+  name: 'test',
+  auth: { loginUrl: 'http://localhost/login' },
+  modules: [{ id: 'dashboard', route: '/dashboard', sidebarIcon: true }],
+  environments: {
+    alpha: { baseUrl: 'http://localhost:3000', seed: false },
+  },
+  portals: [],
+  breakpoints: [],
+  integrations: [],
+  workers: [],
+  workflows: [],
+  accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+  tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+  costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' },
+  agentClassification: { blocking: [], advisory: [] },
+  thresholds: {
+    unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
+    lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
+    apiResponseTime: 2000,
+    bundleSizeLimit: 500000,
+    maxConsoleErrors: 0,
+  },
+  disabledAgents: [],
+  disabledAgentSet: new Set<number>(),
+};
+
+// ---------------------------------------------------------------------------
+// Mock fs/promises
+// ---------------------------------------------------------------------------
+
+const readdirMock = vi.fn();
+const readFileMock = vi.fn();
+const writeFileMock = vi.fn().mockResolvedValue(undefined);
+const mkdirMock = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('fs/promises', () => ({
+  readdir: (...args: unknown[]) => readdirMock(...args),
+  readFile: (...args: unknown[]) => readFileMock(...args),
+  writeFile: (...args: unknown[]) => writeFileMock(...args),
+  mkdir: (...args: unknown[]) => mkdirMock(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock core/evidence (readAgentResult)
+// ---------------------------------------------------------------------------
+
+const readAgentResultMock = vi.fn();
+
+vi.mock('../../core/evidence', () => ({
+  readAgentResult: (...args: unknown[]) => readAgentResultMock(...args),
+  writeFinding: vi.fn().mockResolvedValue(undefined),
+  writeAgentResult: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks
+// ---------------------------------------------------------------------------
+
+const { ReporterAgent, determineRecommendation, buildMarkdownReport } = await import('../10-reporter');
+
+function createAgent(): InstanceType<typeof ReporterAgent> {
+  return new ReporterAgent(stubConfig, 'release', '/tmp/.run/run-001');
+}
+
+function makeAgentResult(
+  agentId: number,
+  findings: Finding[] = [],
+  phase: AgentResult['phase'] = 'alpha',
+): AgentResult {
+  return {
+    agentId,
+    agentName: `Agent ${agentId}`,
+    phase,
+    status: findings.some((f) => f.severity === 'critical' || f.severity === 'high') ? 'failed' : 'passed',
+    startedAt: new Date().toISOString(),
+    completedAt: new Date().toISOString(),
+    durationMs: 100,
+    findings,
+    evidence: [],
+    summary: `Agent ${agentId}: ${findings.length} findings`,
+  };
+}
+
+function makeFinding(severity: Finding['severity'], id = 'f-001'): Finding {
+  return {
+    id,
+    type: 'code-bug-logic',
+    severity,
+    agentId: 1,
+    module: 'test-module',
+    description: `Test finding severity=${severity}`,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests — determineRecommendation()
+// ---------------------------------------------------------------------------
+
+describe('determineRecommendation()', () => {
+  it('returns "GO" when there are no findings', () => {
+    const results = [makeAgentResult(1, []), makeAgentResult(2, [])];
+    expect(determineRecommendation(results)).toBe('GO');
+  });
+
+  it('returns "GO" when all findings are medium or lower', () => {
+    const results = [
+      makeAgentResult(1, [makeFinding('medium'), makeFinding('low', 'f-002')]),
+    ];
+    expect(determineRecommendation(results)).toBe('GO');
+  });
+
+  it('returns "CONDITIONAL GO" when there are high findings but no critical', () => {
+    const results = [makeAgentResult(1, [makeFinding('high')])];
+    expect(determineRecommendation(results)).toBe('CONDITIONAL GO');
+  });
+
+  it('returns "NO-GO" when there is at least one critical finding', () => {
+    const results = [makeAgentResult(1, [makeFinding('critical')])];
+    expect(determineRecommendation(results)).toBe('NO-GO');
+  });
+
+  it('returns "NO-GO" when there are both critical and high findings', () => {
+    const results = [
+      makeAgentResult(1, [makeFinding('critical'), makeFinding('high', 'f-002')]),
+    ];
+    expect(determineRecommendation(results)).toBe('NO-GO');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests — buildMarkdownReport()
+// ---------------------------------------------------------------------------
+
+describe('buildMarkdownReport()', () => {
+  it('includes the run ID in the report', () => {
+    const report = buildMarkdownReport([], 'run-abc-123', 'GO');
+    expect(report).toContain('run-abc-123');
+  });
+
+  it('includes the recommendation', () => {
+    const report = buildMarkdownReport([], 'run-001', 'NO-GO');
+    expect(report).toContain('NO-GO');
+  });
+
+  it('includes per-phase summaries', () => {
+    const results = [makeAgentResult(1, [], 'alpha'), makeAgentResult(5, [], 'beta')];
+    const report = buildMarkdownReport(results, 'run-001', 'GO');
+    expect(report).toContain('ALPHA');
+    expect(report).toContain('BETA');
+  });
+
+  it('lists findings under correct severity headings', () => {
+    const findings = [makeFinding('high'), makeFinding('medium', 'f-002')];
+    const results = [makeAgentResult(1, findings, 'alpha')];
+    const report = buildMarkdownReport(results, 'run-001', 'CONDITIONAL GO');
+    expect(report).toContain('HIGH');
+    expect(report).toContain('MEDIUM');
+  });
+
+  it('shows "no findings" message when all agents pass cleanly', () => {
+    const report = buildMarkdownReport([], 'run-001', 'GO');
+    expect(report).toContain('No findings');
+  });
+
+  it('includes specialist summary lines', () => {
+    const coverage = makeAgentResult(4, [], 'alpha');
+    coverage.summary = 'Unit Runner: All checks passed';
+    const security = makeAgentResult(7, [], 'beta');
+    security.summary = 'Security Scout: All checks passed';
+    const report = buildMarkdownReport([coverage, security], 'run-001', 'GO');
+    expect(report).toContain('Coverage (Agent 4)');
+    expect(report).toContain('Security (Agent 7)');
+  });
+
+  it('shows "not run" for agents with no results', () => {
+    const report = buildMarkdownReport([], 'run-001', 'GO');
+    expect(report).toContain('not run');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests — ReporterAgent
+// ---------------------------------------------------------------------------
+
+describe('ReporterAgent', () => {
+  beforeEach(() => {
+    readdirMock.mockReset();
+    readFileMock.mockReset();
+    writeFileMock.mockReset().mockResolvedValue(undefined);
+    mkdirMock.mockReset().mockResolvedValue(undefined);
+    readAgentResultMock.mockReset().mockResolvedValue(null);
+  });
+
+  it('has agentId 10 and agentName "Reporter"', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(10);
+    expect(agent.agentName).toBe('Reporter');
+  });
+
+  // -------------------------------------------------------------------------
+  // preFlight
+  // -------------------------------------------------------------------------
+
+  describe('preFlight()', () => {
+    it('gracefully handles missing agent-results directory', async () => {
+      const enoentError = Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+      readdirMock.mockRejectedValue(enoentError);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // Should NOT fail — returns a low-severity informational finding instead
+      expect(result.status).toBe('passed');
+      expect(result.findings).toHaveLength(1);
+      expect(result.findings[0].description).toContain('No agent results to report');
+      expect(result.findings[0].severity).toBe('low');
+    });
+
+    it('gracefully handles empty agent-results directory', async () => {
+      readdirMock.mockResolvedValue([]);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // Should NOT fail — returns a low-severity informational finding instead
+      expect(result.status).toBe('passed');
+      expect(result.findings).toHaveLength(1);
+      expect(result.findings[0].description).toContain('No agent results to report');
+      expect(result.findings[0].severity).toBe('low');
+    });
+
+    it('passes when at least one result file exists', async () => {
+      readdirMock.mockResolvedValue(['1.json']);
+      readAgentResultMock.mockResolvedValue(makeAgentResult(1, [], 'alpha'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('passed');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — recommendation logic
+  // -------------------------------------------------------------------------
+
+  describe('execute() — GO/CONDITIONAL GO/NO-GO recommendation', () => {
+    it('writes a report with GO when all results are clean', async () => {
+      readdirMock.mockResolvedValue(['1.json']);
+      readAgentResultMock.mockImplementation(async (_runDir: string, agentId: number) => {
+        if (agentId === 1) return makeAgentResult(1, [], 'alpha');
+        return null;
+      });
+
+      const agent = createAgent();
+      await agent.run();
+
+      const [, content] = writeFileMock.mock.calls[0] as [string, string];
+      expect(content).toContain('GO');
+    });
+
+    it('writes a report with CONDITIONAL GO when high findings exist', async () => {
+      readdirMock.mockResolvedValue(['7.json']);
+      readAgentResultMock.mockImplementation(async (_runDir: string, agentId: number) => {
+        if (agentId === 7) return makeAgentResult(7, [makeFinding('high')], 'beta');
+        return null;
+      });
+
+      const agent = createAgent();
+      await agent.run();
+
+      const [, content] = writeFileMock.mock.calls[0] as [string, string];
+      expect(content).toContain('CONDITIONAL GO');
+    });
+
+    it('writes a report with NO-GO when critical findings exist', async () => {
+      readdirMock.mockResolvedValue(['7.json']);
+      readAgentResultMock.mockImplementation(async (_runDir: string, agentId: number) => {
+        if (agentId === 7) return makeAgentResult(7, [makeFinding('critical')], 'beta');
+        return null;
+      });
+
+      const agent = createAgent();
+      await agent.run();
+
+      const [, content] = writeFileMock.mock.calls[0] as [string, string];
+      expect(content).toContain('NO-GO');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — report file written
+  // -------------------------------------------------------------------------
+
+  describe('execute() — report file is written', () => {
+    it('writes report to testteam/reports/{date}-{runId}.md', async () => {
+      readdirMock.mockResolvedValue(['1.json']);
+      readAgentResultMock.mockResolvedValue(makeAgentResult(1, [], 'alpha'));
+
+      const agent = createAgent();
+      await agent.run();
+
+      expect(writeFileMock).toHaveBeenCalled();
+      const [reportPath] = writeFileMock.mock.calls[0] as [string];
+      expect(reportPath).toContain('reports');
+      expect(reportPath).toMatch(/\d{4}-\d{2}-\d{2}-run-001\.md$/);
+    });
+
+    it('returns empty findings array (Reporter creates no new findings)', async () => {
+      readdirMock.mockResolvedValue(['1.json']);
+      readAgentResultMock.mockResolvedValue(makeAgentResult(1, [], 'alpha'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings).toHaveLength(0);
+    });
+
+    it('records a report evidence item', async () => {
+      readdirMock.mockResolvedValue(['1.json']);
+      readAgentResultMock.mockResolvedValue(makeAgentResult(1, [], 'alpha'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const reportEvidence = result.evidence.find((e) => e.type === 'report');
+      expect(reportEvidence).toBeDefined();
+      expect(reportEvidence!.description).toContain('GO');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — multiple results aggregated
+  // -------------------------------------------------------------------------
+
+  describe('execute() — aggregation', () => {
+    it('aggregates results across alpha, beta, and uat phases', async () => {
+      readdirMock.mockResolvedValue(['1.json', '5.json', '13.json']);
+      readAgentResultMock.mockImplementation(async (_runDir: string, agentId: number) => {
+        if (agentId === 1) return makeAgentResult(1, [], 'alpha');
+        if (agentId === 5) return makeAgentResult(5, [], 'beta');
+        if (agentId === 13) return makeAgentResult(13, [], 'uat');
+        return null;
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('passed');
+      const [, content] = writeFileMock.mock.calls[0] as [string, string];
+      expect(content).toContain('ALPHA');
+      expect(content).toContain('BETA');
+      expect(content).toContain('UAT');
+    });
+  });
+});