@avi770/testteam 3.0.0 → 3.2.0

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

@@ -1,366 +0,0 @@
-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');
-    });
-  });
-});