@avi770/testteam 1.2.0

package/core/__tests__/ci-output.test.ts

@@ -0,0 +1,430 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  detectCIEnvironment,
+  determineExitCode,
+  generateGitHubSummary,
+  generateAzureTags,
+  writeCISummary,
+  EXIT_CODE,
+} from '../ci-output';
+import type { CIOutputIO } from '../ci-output';
+import type { RunState, PhaseGateResult, AgentResult } from '../types';
+
+/** Helper to build a minimal AgentResult. */
+function makeAgentResult(
+  overrides: Partial<AgentResult> & { agentId: number; status: AgentResult['status'] },
+): AgentResult {
+  return {
+    agentName: `Agent ${overrides.agentId}`,
+    phase: 'alpha',
+    startedAt: '2026-01-01T00:00:00Z',
+    completedAt: '2026-01-01T00:01:00Z',
+    durationMs: 60_000,
+    findings: [],
+    evidence: [],
+    summary: 'Test result',
+    ...overrides,
+  };
+}
+
+/** Helper to build a minimal PhaseGateResult. */
+function makeGate(overrides: Partial<PhaseGateResult> = {}): PhaseGateResult {
+  return {
+    phase: 'alpha',
+    passed: true,
+    blockingResults: [],
+    advisoryResults: [],
+    failedBlockingAgents: [],
+    timestamp: '2026-01-01T00:01:00Z',
+    ...overrides,
+  };
+}
+
+/** Helper to build a minimal RunState. */
+function makeRunState(overrides: Partial<RunState> = {}): RunState {
+  return {
+    runId: 'run-test-123',
+    startedAt: '2026-01-01T00:00:00Z',
+    currentPhase: 'alpha',
+    phaseAttempt: 1,
+    agentResults: new Map(),
+    gateResults: [],
+    totalCost: 0,
+    ...overrides,
+  };
+}
+
+describe('detectCIEnvironment', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    // Clear all CI env vars
+    delete process.env['GITHUB_ACTIONS'];
+    delete process.env['TF_BUILD'];
+    delete process.env['GITLAB_CI'];
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('detects GitHub Actions', () => {
+    process.env['GITHUB_ACTIONS'] = 'true';
+    expect(detectCIEnvironment()).toBe('github');
+  });
+
+  it('detects Azure Pipelines', () => {
+    process.env['TF_BUILD'] = 'True';
+    expect(detectCIEnvironment()).toBe('azure');
+  });
+
+  it('detects GitLab CI', () => {
+    process.env['GITLAB_CI'] = 'true';
+    expect(detectCIEnvironment()).toBe('gitlab');
+  });
+
+  it('returns none when no CI environment is detected', () => {
+    expect(detectCIEnvironment()).toBe('none');
+  });
+
+  it('prioritises GitHub when multiple CI env vars are set', () => {
+    process.env['GITHUB_ACTIONS'] = 'true';
+    process.env['TF_BUILD'] = 'True';
+    expect(detectCIEnvironment()).toBe('github');
+  });
+});
+
+describe('determineExitCode', () => {
+  it('returns SUCCESS (0) when all gates pass and no advisory failures', () => {
+    const gates = [makeGate({ passed: true, advisoryResults: [] })];
+    expect(determineExitCode(gates)).toBe(EXIT_CODE.SUCCESS);
+  });
+
+  it('returns BLOCKING_FAILURE (1) when blocking agents failed', () => {
+    const gates = [
+      makeGate({
+        passed: false,
+        failedBlockingAgents: [1, 2],
+      }),
+    ];
+    expect(determineExitCode(gates)).toBe(EXIT_CODE.BLOCKING_FAILURE);
+  });
+
+  it('returns ADVISORY_WARNINGS (2) when only advisory agents failed', () => {
+    const advisoryResult = makeAgentResult({ agentId: 7, status: 'failed' });
+    const gates = [
+      makeGate({
+        passed: true,
+        advisoryResults: [advisoryResult],
+      }),
+    ];
+    expect(determineExitCode(gates)).toBe(EXIT_CODE.ADVISORY_WARNINGS);
+  });
+
+  it('returns BLOCKING_FAILURE (1) when both blocking and advisory fail', () => {
+    const advisoryResult = makeAgentResult({ agentId: 7, status: 'failed' });
+    const gates = [
+      makeGate({
+        passed: false,
+        failedBlockingAgents: [1],
+        advisoryResults: [advisoryResult],
+      }),
+    ];
+    expect(determineExitCode(gates)).toBe(EXIT_CODE.BLOCKING_FAILURE);
+  });
+
+  it('returns SUCCESS (0) when advisory agents pass', () => {
+    const advisoryResult = makeAgentResult({ agentId: 7, status: 'passed' });
+    const gates = [
+      makeGate({
+        passed: true,
+        advisoryResults: [advisoryResult],
+      }),
+    ];
+    expect(determineExitCode(gates)).toBe(EXIT_CODE.SUCCESS);
+  });
+
+  it('handles multiple phases — fails if any phase has blocking failure', () => {
+    const gates = [
+      makeGate({ phase: 'alpha', passed: true }),
+      makeGate({ phase: 'beta', passed: false, failedBlockingAgents: [5] }),
+    ];
+    expect(determineExitCode(gates)).toBe(EXIT_CODE.BLOCKING_FAILURE);
+  });
+
+  it('returns SUCCESS (0) for empty gate results', () => {
+    expect(determineExitCode([])).toBe(EXIT_CODE.SUCCESS);
+  });
+});
+
+describe('generateGitHubSummary', () => {
+  it('generates markdown with overall passed status', () => {
+    const state = makeRunState({
+      gateResults: [makeGate({ passed: true })],
+    });
+    const md = generateGitHubSummary(state);
+
+    expect(md).toContain('## TestTeam');
+    expect(md).toContain('All Gates Passed');
+    expect(md).toContain('run-test-123');
+  });
+
+  it('generates markdown with blocking failure status', () => {
+    const state = makeRunState({
+      gateResults: [
+        makeGate({
+          passed: false,
+          failedBlockingAgents: [1, 3],
+          blockingResults: [
+            makeAgentResult({ agentId: 1, status: 'failed' }),
+            makeAgentResult({ agentId: 3, status: 'failed' }),
+          ],
+        }),
+      ],
+    });
+    const md = generateGitHubSummary(state);
+
+    expect(md).toContain('Blocking Failures');
+    expect(md).toContain('Failed blocking agents');
+    expect(md).toContain('1, 3');
+  });
+
+  it('generates markdown with advisory warnings status', () => {
+    const advisoryResult = makeAgentResult({ agentId: 7, status: 'failed' });
+    const state = makeRunState({
+      gateResults: [
+        makeGate({
+          passed: true,
+          advisoryResults: [advisoryResult],
+        }),
+      ],
+    });
+    const md = generateGitHubSummary(state);
+
+    expect(md).toContain('Advisory Warnings');
+  });
+
+  it('includes findings summary when findings exist', () => {
+    const agentResult = makeAgentResult({
+      agentId: 1,
+      status: 'passed',
+      findings: [
+        {
+          id: 'f1',
+          type: 'code-bug-logic',
+          severity: 'high',
+          agentId: 1,
+          module: 'auth',
+          description: 'Logic error in auth module',
+        },
+        {
+          id: 'f2',
+          type: 'code-bug-cosmetic',
+          severity: 'low',
+          agentId: 1,
+          module: 'ui',
+          description: 'Cosmetic issue',
+        },
+      ],
+    });
+
+    const agentMap = new Map<number, AgentResult>();
+    agentMap.set(1, agentResult);
+
+    const state = makeRunState({
+      agentResults: agentMap,
+      gateResults: [makeGate()],
+    });
+
+    const md = generateGitHubSummary(state);
+
+    expect(md).toContain('Findings Summary');
+    expect(md).toContain('high');
+    expect(md).toContain('low');
+  });
+
+  it('includes agent results table with duration', () => {
+    const result = makeAgentResult({
+      agentId: 1,
+      agentName: 'Smoke Tester',
+      status: 'passed',
+      durationMs: 5_000,
+    });
+
+    const state = makeRunState({
+      gateResults: [
+        makeGate({
+          blockingResults: [result],
+        }),
+      ],
+    });
+
+    const md = generateGitHubSummary(state);
+
+    expect(md).toContain('Smoke Tester');
+    expect(md).toContain('5s');
+  });
+});
+
+describe('generateAzureTags', () => {
+  it('returns passed tag when all gates pass', () => {
+    const state = makeRunState({
+      gateResults: [makeGate({ passed: true })],
+    });
+    const tags = generateAzureTags(state);
+
+    expect(tags).toContain('testteam:passed');
+    expect(tags).toContain('testteam:phase:alpha');
+    expect(tags).toContain('testteam:phase:alpha:passed');
+  });
+
+  it('returns failed tag when blocking agents fail', () => {
+    const state = makeRunState({
+      gateResults: [
+        makeGate({ passed: false, failedBlockingAgents: [1] }),
+      ],
+    });
+    const tags = generateAzureTags(state);
+
+    expect(tags).toContain('testteam:failed');
+    expect(tags).toContain('testteam:phase:alpha:failed');
+  });
+
+  it('returns warnings tag for advisory-only failures', () => {
+    const advisoryResult = makeAgentResult({ agentId: 7, status: 'failed' });
+    const state = makeRunState({
+      gateResults: [
+        makeGate({ passed: true, advisoryResults: [advisoryResult] }),
+      ],
+    });
+    const tags = generateAzureTags(state);
+
+    expect(tags).toContain('testteam:warnings');
+  });
+
+  it('includes severity tags from findings', () => {
+    const agentResult = makeAgentResult({
+      agentId: 1,
+      status: 'passed',
+      findings: [
+        {
+          id: 'f1',
+          type: 'code-bug-security',
+          severity: 'critical',
+          agentId: 1,
+          module: 'auth',
+          description: 'Security vulnerability',
+        },
+      ],
+    });
+
+    const agentMap = new Map<number, AgentResult>();
+    agentMap.set(1, agentResult);
+
+    const state = makeRunState({
+      agentResults: agentMap,
+      gateResults: [makeGate()],
+    });
+    const tags = generateAzureTags(state);
+
+    expect(tags).toContain('testteam:severity:critical');
+  });
+
+  it('includes tags for multiple phases', () => {
+    const state = makeRunState({
+      gateResults: [
+        makeGate({ phase: 'alpha', passed: true }),
+        makeGate({ phase: 'beta', passed: true }),
+      ],
+    });
+    const tags = generateAzureTags(state);
+
+    expect(tags).toContain('testteam:phase:alpha');
+    expect(tags).toContain('testteam:phase:beta');
+  });
+});
+
+describe('writeCISummary', () => {
+  const originalEnv = process.env;
+
+  function mockIO(): CIOutputIO & {
+    appendFileCalls: Array<{ path: string; data: string }>;
+    writeFileCalls: Array<{ path: string; data: string }>;
+    logCalls: string[];
+  } {
+    const appendFileCalls: Array<{ path: string; data: string }> = [];
+    const writeFileCalls: Array<{ path: string; data: string }> = [];
+    const logCalls: string[] = [];
+    return {
+      appendFile: (filePath: string, data: string) => appendFileCalls.push({ path: filePath, data }),
+      writeFile: (filePath: string, data: string) => writeFileCalls.push({ path: filePath, data }),
+      log: (message: string) => logCalls.push(message),
+      appendFileCalls,
+      writeFileCalls,
+      logCalls,
+    };
+  }
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    delete process.env['GITHUB_ACTIONS'];
+    delete process.env['TF_BUILD'];
+    delete process.env['GITLAB_CI'];
+    delete process.env['GITHUB_STEP_SUMMARY'];
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('writes markdown to GITHUB_STEP_SUMMARY in GitHub Actions', () => {
+    process.env['GITHUB_ACTIONS'] = 'true';
+    process.env['GITHUB_STEP_SUMMARY'] = '/tmp/test-summary.md';
+
+    const io = mockIO();
+    const state = makeRunState({ gateResults: [makeGate()] });
+
+    writeCISummary(state, io);
+
+    expect(io.appendFileCalls).toHaveLength(1);
+    expect(io.appendFileCalls[0].path).toBe('/tmp/test-summary.md');
+    expect(io.appendFileCalls[0].data).toContain('TestTeam');
+  });
+
+  it('writes tags to console in Azure Pipelines', () => {
+    process.env['TF_BUILD'] = 'True';
+
+    const io = mockIO();
+    const state = makeRunState({ gateResults: [makeGate()] });
+
+    writeCISummary(state, io);
+
+    const vsoCalls = io.logCalls.filter(msg => msg.includes('##vso[build.addbuildtag]'));
+    expect(vsoCalls.length).toBeGreaterThan(0);
+  });
+
+  it('writes summary file in GitLab CI', () => {
+    process.env['GITLAB_CI'] = 'true';
+
+    const io = mockIO();
+    const state = makeRunState({ gateResults: [makeGate()] });
+
+    writeCISummary(state, io);
+
+    expect(io.writeFileCalls).toHaveLength(1);
+    expect(io.writeFileCalls[0].path).toBe('.run/testteam-summary.md');
+    expect(io.writeFileCalls[0].data).toContain('TestTeam');
+  });
+
+  it('does nothing when not in CI', () => {
+    const io = mockIO();
+    const state = makeRunState({ gateResults: [makeGate()] });
+
+    writeCISummary(state, io);
+
+    expect(io.appendFileCalls).toHaveLength(0);
+    expect(io.writeFileCalls).toHaveLength(0);
+    expect(io.logCalls).toHaveLength(0);
+  });
+});