@avi770/testteam 1.2.0

package/agents/__tests__/04-unit-runner.test.ts

@@ -0,0 +1,320 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub ValidatedConfig
+// ---------------------------------------------------------------------------
+
+const stubConfig = {
+  schemaVersion: 1,
+  name: 'test',
+  auth: { loginUrl: 'http://localhost' },
+  modules: [{ id: 'mod', route: '/mod', sidebarIcon: true }],
+  environments: {},
+  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' as const },
+  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>(),
+} satisfies ValidatedConfig;
+
+// ---------------------------------------------------------------------------
+// Mock child_process — intercept the module used by the agent
+// ---------------------------------------------------------------------------
+
+const spawnMock = vi.fn();
+
+vi.mock('child_process', () => ({
+  execFile: (...args: unknown[]) => spawnMock(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Vitest JSON report builders
+// ---------------------------------------------------------------------------
+
+interface AssertionResult {
+  status: 'passed' | 'failed';
+  fullName: string;
+  failureMessages: string[];
+}
+
+interface VitestTestResult {
+  testFilePath: string;
+  status: 'passed' | 'failed';
+  assertionResults: AssertionResult[];
+}
+
+interface VitestJsonReport {
+  numPassedTests: number;
+  numFailedTests: number;
+  testResults: VitestTestResult[];
+}
+
+function buildReport(
+  passedCount: number,
+  failedTests: Array<{ fullName: string; failureMessages: string[] }> = [],
+): VitestJsonReport {
+  const assertions: AssertionResult[] = [
+    ...Array.from({ length: passedCount }, (_, i) => ({
+      status: 'passed' as const,
+      fullName: `passing test ${i + 1}`,
+      failureMessages: [],
+    })),
+    ...failedTests.map((t) => ({
+      status: 'failed' as const,
+      fullName: t.fullName,
+      failureMessages: t.failureMessages,
+    })),
+  ];
+
+  return {
+    numPassedTests: passedCount,
+    numFailedTests: failedTests.length,
+    testResults: [
+      {
+        testFilePath: '/project/src/__tests__/example.test.ts',
+        status: failedTests.length > 0 ? 'failed' : 'passed',
+        assertionResults: assertions,
+      },
+    ],
+  };
+}
+
+/** Configure the mock to succeed with a specific stdout for ALL calls */
+function mockSucceedsWith(stdout: string): void {
+  spawnMock.mockImplementation(
+    (_file: string, _args: string[], _opts: unknown, cb: (err: Error | null, stdout: string, stderr: string) => void) => {
+      cb(null, stdout, '');
+    },
+  );
+}
+
+/** Configure preFlight call to return a version string, then subsequent calls use provided stdout */
+function mockVersionThenReport(reportStdout: string): void {
+  let callCount = 0;
+  spawnMock.mockImplementation(
+    (_file: string, _args: string[], _opts: unknown, cb: (err: Error | null, stdout: string, stderr: string) => void) => {
+      callCount++;
+      if (callCount === 1) {
+        // preFlight: vitest --version
+        cb(null, '2.0.0\n', '');
+      } else {
+        cb(null, reportStdout, '');
+      }
+    },
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks are declared
+// ---------------------------------------------------------------------------
+
+const { UnitRunnerAgent } = await import('../04-unit-runner');
+
+function createAgent(phase: Phase = 'alpha'): InstanceType<typeof UnitRunnerAgent> {
+  return new UnitRunnerAgent(stubConfig, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('UnitRunnerAgent', () => {
+  beforeEach(() => {
+    spawnMock.mockReset();
+  });
+
+  it('has agentId 4 and agentName "Unit Runner"', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(4);
+    expect(agent.agentName).toBe('Unit Runner');
+  });
+
+  // -------------------------------------------------------------------------
+  // preFlight()
+  // -------------------------------------------------------------------------
+
+  describe('preFlight()', () => {
+    it('passes when vitest --version returns output', async () => {
+      mockSucceedsWith('2.0.0\n');
+      const agent = createAgent();
+      const result = await agent.run();
+      // No critical infra error from preFlight
+      expect(result.findings.some((f) => f.description.includes('vitest is not available'))).toBe(false);
+    });
+
+    it('fails when vitest --version returns empty stdout', async () => {
+      spawnMock.mockImplementation(
+        (_file: string, _args: string[], _opts: unknown, cb: (err: Error | null, stdout: string, stderr: string) => void) => {
+          cb(null, '', '');
+        },
+      );
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('failed');
+      expect(result.findings[0].description).toContain('vitest is not available');
+    });
+
+    it('fails when process spawn rejects (vitest not installed)', async () => {
+      spawnMock.mockImplementation(
+        (_file: string, _args: string[], _opts: unknown, cb: (err: Error | null, stdout: string, stderr: string) => void) => {
+          cb(new Error('command not found: npx'), '', '');
+        },
+      );
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('failed');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — all passing
+  // -------------------------------------------------------------------------
+
+  describe('execute() — all tests passing', () => {
+    it('returns no test-bug findings when all suites pass', async () => {
+      const passingJson = JSON.stringify(buildReport(10));
+      mockVersionThenReport(passingJson);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const testBugFindings = result.findings.filter((f) => f.type === 'test-bug');
+      expect(testBugFindings).toHaveLength(0);
+    });
+
+    it('returns passed AgentResult status when all tests pass', async () => {
+      const passingJson = JSON.stringify(buildReport(5));
+      mockVersionThenReport(passingJson);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('passed');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — failing tests
+  // -------------------------------------------------------------------------
+
+  describe('execute() — failing tests', () => {
+    it('creates one high-severity test-bug finding per failed assertion per suite', async () => {
+      const failingJson = JSON.stringify(
+        buildReport(3, [
+          { fullName: 'Dashboard renders correctly', failureMessages: ['Expected true to be false'] },
+          { fullName: 'Invoice total calculates', failureMessages: ['Expected 100 to equal 200'] },
+        ]),
+      );
+      mockVersionThenReport(failingJson);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // 3 suites × 2 failures per suite = 6 test-bug findings
+      const testBugFindings = result.findings.filter((f) => f.type === 'test-bug');
+      expect(testBugFindings).toHaveLength(6);
+      expect(testBugFindings[0].severity).toBe('high');
+    });
+
+    it('includes the failed test name in the finding description', async () => {
+      const failingJson = JSON.stringify(
+        buildReport(0, [{ fullName: 'My specific test name', failureMessages: ['boom'] }]),
+      );
+      mockVersionThenReport(failingJson);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const testBugFindings = result.findings.filter((f) => f.type === 'test-bug');
+      expect(testBugFindings[0].description).toContain('My specific test name');
+    });
+
+    it('sets the stackTrace from failure messages', async () => {
+      const failingJson = JSON.stringify(
+        buildReport(0, [{ fullName: 'Test with error', failureMessages: ['AssertionError: expected 1 to equal 2'] }]),
+      );
+      mockVersionThenReport(failingJson);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const testBugFindings = result.findings.filter((f) => f.type === 'test-bug');
+      expect(testBugFindings[0].stackTrace).toContain('AssertionError');
+    });
+
+    it('returns failed AgentResult status when test-bug findings exist', async () => {
+      const failingJson = JSON.stringify(
+        buildReport(0, [{ fullName: 'Failing test', failureMessages: ['Error'] }]),
+      );
+      mockVersionThenReport(failingJson);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('failed');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — evidence
+  // -------------------------------------------------------------------------
+
+  describe('execute() — evidence', () => {
+    it('adds a log evidence item for each suite', async () => {
+      const passingJson = JSON.stringify(buildReport(3));
+      mockVersionThenReport(passingJson);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // 3 suite configs → 3 evidence items
+      expect(result.evidence.length).toBeGreaterThanOrEqual(3);
+      expect(result.evidence[0].type).toBe('log');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — malformed / missing output
+  // -------------------------------------------------------------------------
+
+  describe('execute() — malformed or missing JSON output', () => {
+    it('creates an infra-issue finding when stdout contains no JSON', async () => {
+      spawnMock.mockImplementation(
+        (_file: string, args: string[], _opts: unknown, cb: (err: Error | null, stdout: string, stderr: string) => void) => {
+          if ((args as string[]).includes('--version')) {
+            cb(null, '2.0.0\n', '');
+          } else {
+            cb(null, 'not valid json at all', 'some stderr');
+          }
+        },
+      );
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const infraFindings = result.findings.filter(
+        (f) => f.type === 'infra-issue' && f.id.includes('no-output'),
+      );
+      expect(infraFindings.length).toBeGreaterThan(0);
+    });
+  });
+});