@avi770/testteam 1.2.0

package/agents/__tests__/03-test-generator-full.test.ts

@@ -0,0 +1,321 @@
+/**
+ * 03-test-generator-full.test.ts
+ *
+ * Tests for Task 42: Agent 3 quality gate integration.
+ * Covers:
+ *  - validateCodeQuality called on generated test file content
+ *  - `any` type annotation triggers a quality-violation finding
+ *  - clean file passes quality gate (no violation findings)
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config
+// ---------------------------------------------------------------------------
+
+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 node:fs/promises
+// ---------------------------------------------------------------------------
+
+const statMock = vi.fn();
+const readdirMock = vi.fn();
+const readFileMock = vi.fn();
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs/promises')>();
+  return {
+    ...actual,
+    stat: (...args: unknown[]) => statMock(...args),
+    readdir: (...args: unknown[]) => readdirMock(...args),
+    readFile: (...args: unknown[]) => readFileMock(...args),
+  };
+});
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks
+// ---------------------------------------------------------------------------
+
+const { TestGeneratorAgent } = await import('../03-test-generator');
+
+function createAgent(phase: Phase = 'alpha'): InstanceType<typeof TestGeneratorAgent> {
+  return new TestGeneratorAgent(stubConfig, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Minimal valid generated test file with no quality violations. */
+const CLEAN_GENERATED_TEST = `
+import { describe, it, expect } from 'vitest';
+
+describe('SomeService', () => {
+  it('returns true', () => {
+    const result: boolean = true;
+    expect(result).toBe(true);
+  });
+});
+`.trim();
+
+/** Generated test file that uses \`any\` type — should trigger a quality violation. */
+const DIRTY_GENERATED_TEST_ANY = `
+import { describe, it, expect } from 'vitest';
+
+describe('SomeService', () => {
+  it('works with any typed value', () => {
+    const value: any = 'hello';
+    expect(value).toBeDefined();
+  });
+});
+`.trim();
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('TestGeneratorAgent — quality gate (Task 42)', () => {
+  beforeEach(() => {
+    statMock.mockReset();
+    readdirMock.mockReset();
+    readFileMock.mockReset();
+
+    // Default: no vitest config on disk, coverage dir throws, generated dir empty
+    statMock.mockRejectedValue(new Error('ENOENT'));
+    readdirMock.mockImplementation((dir: string) => {
+      if (dir === 'tests/generated') return Promise.resolve([]);
+      return Promise.reject(new Error('ENOENT: no such file or directory'));
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Quality gate is invoked on generated test content
+  // -------------------------------------------------------------------------
+
+  describe('quality gate invocation on generated tests', () => {
+    it('calls quality gate on each file in tests/generated/', async () => {
+      readdirMock.mockImplementation((dir: string) => {
+        if (dir === 'tests/generated') return Promise.resolve(['some-service.test.ts']);
+        return Promise.reject(new Error('ENOENT: no such file or directory'));
+      });
+      readFileMock.mockResolvedValue(CLEAN_GENERATED_TEST);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // Quality gate passed → evidence log added, no quality-violation findings
+      const qualityFindings = result.findings.filter((f) => f.id.includes('quality-violation'));
+      expect(qualityFindings).toHaveLength(0);
+
+      const passedEvidence = result.evidence.filter(
+        (e) => e.type === 'log' && e.description.includes('Quality gate passed'),
+      );
+      expect(passedEvidence).toHaveLength(1);
+    });
+
+    it('processes multiple generated test files', async () => {
+      readdirMock.mockImplementation((dir: string) => {
+        if (dir === 'tests/generated') return Promise.resolve(['service-a.test.ts', 'service-b.test.ts']);
+        return Promise.reject(new Error('ENOENT: no such file or directory'));
+      });
+      readFileMock.mockResolvedValue(CLEAN_GENERATED_TEST);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const passedEvidence = result.evidence.filter(
+        (e) => e.type === 'log' && e.description.includes('Quality gate passed'),
+      );
+      expect(passedEvidence).toHaveLength(2);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // `any` type triggers a quality violation finding
+  // -------------------------------------------------------------------------
+
+  describe('quality violation: any type', () => {
+    beforeEach(() => {
+      readdirMock.mockImplementation((dir: string) => {
+        if (dir === 'tests/generated') return Promise.resolve(['dirty-test.ts']);
+        return Promise.reject(new Error('ENOENT: no such file or directory'));
+      });
+      readFileMock.mockResolvedValue(DIRTY_GENERATED_TEST_ANY);
+    });
+
+    it('creates a quality-violation finding when generated test contains `any` type', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const qualityFindings = result.findings.filter((f) => f.id.includes('quality-violation'));
+      expect(qualityFindings.length).toBeGreaterThan(0);
+    });
+
+    it('quality violation finding has high severity (error-level rule)', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const anyViolation = result.findings.find(
+        (f) => f.id.includes('quality-violation') && f.description.includes('no-any'),
+      );
+      expect(anyViolation).toBeDefined();
+      expect(anyViolation!.severity).toBe('high');
+    });
+
+    it('quality violation finding mentions the rule name in the description', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const anyViolation = result.findings.find(
+        (f) => f.description.includes('no-any'),
+      );
+      expect(anyViolation).toBeDefined();
+      expect(anyViolation!.description).toContain('no-any');
+    });
+
+    it('quality violation finding has type code-bug-logic', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const qualityFinding = result.findings.find((f) => f.id.includes('quality-violation'));
+      expect(qualityFinding!.type).toBe('code-bug-logic');
+    });
+
+    it('quality violation finding references the generated test file', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const qualityFinding = result.findings.find((f) => f.id.includes('quality-violation'));
+      expect(qualityFinding!.file).toContain('dirty-test.ts');
+    });
+
+    it('does NOT add quality-gate-passed evidence when violations are found', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const passedEvidence = result.evidence.filter(
+        (e) => e.type === 'log' && e.description.includes('Quality gate passed'),
+      );
+      expect(passedEvidence).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Clean file passes quality gate
+  // -------------------------------------------------------------------------
+
+  describe('clean generated file passes quality gate', () => {
+    beforeEach(() => {
+      readdirMock.mockImplementation((dir: string) => {
+        if (dir === 'tests/generated') return Promise.resolve(['clean-test.ts']);
+        return Promise.reject(new Error('ENOENT: no such file or directory'));
+      });
+      readFileMock.mockResolvedValue(CLEAN_GENERATED_TEST);
+    });
+
+    it('produces no quality-violation findings for a clean generated test file', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const qualityFindings = result.findings.filter((f) => f.id.includes('quality-violation'));
+      expect(qualityFindings).toHaveLength(0);
+    });
+
+    it('adds quality-gate-passed evidence for a clean generated test file', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const passedEvidence = result.evidence.find(
+        (e) => e.type === 'log' && e.description.includes('Quality gate passed'),
+      );
+      expect(passedEvidence).toBeDefined();
+    });
+
+    it('passed evidence references the file path', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const passedEvidence = result.evidence.find(
+        (e) => e.type === 'log' && e.description.includes('Quality gate passed'),
+      );
+      expect(passedEvidence!.description).toContain('clean-test.ts');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // No generated test files — quality gate section produces no findings
+  // -------------------------------------------------------------------------
+
+  describe('when no generated tests exist', () => {
+    it('produces no quality-violation findings when tests/generated/ is empty', async () => {
+      // readdirMock already returns [] for tests/generated in beforeEach
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const qualityFindings = result.findings.filter((f) => f.id.includes('quality-violation'));
+      expect(qualityFindings).toHaveLength(0);
+    });
+
+    it('produces no quality-gate-passed evidence when tests/generated/ is empty', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const passedEvidence = result.evidence.filter(
+        (e) => e.type === 'log' && e.description.includes('Quality gate passed'),
+      );
+      expect(passedEvidence).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Only .ts/.tsx/.js files are scanned — non-test files ignored
+  // -------------------------------------------------------------------------
+
+  describe('file filtering in tests/generated/', () => {
+    it('ignores non-TypeScript/JavaScript files in tests/generated/', async () => {
+      readdirMock.mockImplementation((dir: string) => {
+        if (dir === 'tests/generated') return Promise.resolve(['readme.md', 'notes.txt', 'clean.ts']);
+        return Promise.reject(new Error('ENOENT: no such file or directory'));
+      });
+      // readFile only called for the .ts file
+      readFileMock.mockResolvedValue(CLEAN_GENERATED_TEST);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // Only clean.ts was scanned — 1 passed-evidence entry
+      const passedEvidence = result.evidence.filter(
+        (e) => e.type === 'log' && e.description.includes('Quality gate passed'),
+      );
+      expect(passedEvidence).toHaveLength(1);
+    });
+  });
+});

package/agents/__tests__/03-test-generator.test.ts

@@ -0,0 +1,318 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config
+// ---------------------------------------------------------------------------
+
+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 node:fs/promises
+// ---------------------------------------------------------------------------
+
+const statMock = vi.fn();
+const readdirMock = vi.fn();
+const readFileMock = vi.fn();
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs/promises')>();
+  return {
+    ...actual,
+    stat: (...args: unknown[]) => statMock(...args),
+    readdir: (...args: unknown[]) => readdirMock(...args),
+    readFile: (...args: unknown[]) => readFileMock(...args),
+  };
+});
+
+// ---------------------------------------------------------------------------
+// Coverage fixture helpers
+// ---------------------------------------------------------------------------
+
+interface FileCoverage {
+  lines: { pct: number };
+  functions: { pct: number };
+  branches: { pct: number };
+  statements: { pct: number };
+}
+
+type CoverageSummaryFixture = Record<string, FileCoverage>;
+
+function makeCoverageSummary(
+  files: Array<{ path: string; lines: number; functions: number; branches: number; statements: number }>,
+): CoverageSummaryFixture {
+  const summary: CoverageSummaryFixture = {
+    total: {
+      lines: { pct: 100 },
+      functions: { pct: 100 },
+      branches: { pct: 100 },
+      statements: { pct: 100 },
+    },
+  };
+  for (const f of files) {
+    summary[f.path] = {
+      lines: { pct: f.lines },
+      functions: { pct: f.functions },
+      branches: { pct: f.branches },
+      statements: { pct: f.statements },
+    };
+  }
+  return summary;
+}
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks
+// ---------------------------------------------------------------------------
+
+const { TestGeneratorAgent } = await import('../03-test-generator');
+
+function createAgent(phase: Phase = 'alpha'): InstanceType<typeof TestGeneratorAgent> {
+  return new TestGeneratorAgent(stubConfig, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('TestGeneratorAgent', () => {
+  beforeEach(() => {
+    statMock.mockReset();
+    readdirMock.mockReset();
+    readFileMock.mockReset();
+
+    // Default: no vitest config exists, no generated tests dir
+    statMock.mockRejectedValue(new Error('ENOENT'));
+    // Default: tests/generated/ is empty
+    readdirMock.mockImplementation((dir: string) => {
+      if (dir === 'tests/generated') return Promise.resolve([]);
+      return Promise.reject(new Error('ENOENT: no such file or directory'));
+    });
+  });
+
+  it('has agentId 3 and agentName "Test Generator"', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(3);
+    expect(agent.agentName).toBe('Test Generator');
+  });
+
+  // -------------------------------------------------------------------------
+  // No coverage data
+  // -------------------------------------------------------------------------
+
+  describe('when no coverage JSON files exist', () => {
+    beforeEach(() => {
+      readdirMock.mockImplementation(() => {
+        return Promise.reject(new Error('ENOENT: no such file or directory'));
+      });
+    });
+
+    it('creates a single advisory medium-severity finding', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings).toHaveLength(1);
+      expect(result.findings[0].severity).toBe('medium');
+      expect(result.findings[0].type).toBe('code-bug-logic');
+    });
+
+    it('the finding description mentions coverage analysis not available', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings[0].description).toContain('Coverage analysis not available');
+    });
+
+    it('returns passed status (medium finding does not block)', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('passed');
+    });
+  });
+
+  describe('when coverage directory exists but contains no JSON files', () => {
+    beforeEach(() => {
+      readdirMock.mockResolvedValue(['lcov.info', 'index.html']);
+    });
+
+    it('creates an advisory finding noting coverage not available', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings).toHaveLength(1);
+      expect(result.findings[0].description).toContain('Coverage analysis not available');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Coverage data present — all above threshold
+  // -------------------------------------------------------------------------
+
+  describe('when coverage data shows all files above threshold', () => {
+    beforeEach(() => {
+      readdirMock.mockResolvedValue(['coverage-summary.json']);
+      const summary = makeCoverageSummary([
+        { path: 'src/utils/format.ts', lines: 95, functions: 90, branches: 85, statements: 92 },
+        { path: 'src/services/billing.ts', lines: 88, functions: 82, branches: 80, statements: 87 },
+      ]);
+      readFileMock.mockResolvedValue(JSON.stringify(summary));
+    });
+
+    it('returns no coverage-gap findings', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const coverageFindings = result.findings.filter((f) => f.id.startsWith('3-coverage-gap'));
+      expect(coverageFindings).toHaveLength(0);
+    });
+
+    it('returns passed status when all files meet thresholds', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('passed');
+    });
+
+    it('adds report evidence for the coverage file', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.evidence.some((e) => e.type === 'report')).toBe(true);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Coverage data present — files below threshold
+  // -------------------------------------------------------------------------
+
+  describe('when coverage data shows files below threshold', () => {
+    beforeEach(() => {
+      readdirMock.mockResolvedValue(['coverage-summary.json']);
+      const summary = makeCoverageSummary([
+        // This file has all metrics below 80%
+        { path: 'src/services/payroll.ts', lines: 60, functions: 55, branches: 50, statements: 58 },
+        // This file is above threshold
+        { path: 'src/utils/helpers.ts', lines: 95, functions: 90, branches: 85, statements: 92 },
+      ]);
+      readFileMock.mockResolvedValue(JSON.stringify(summary));
+    });
+
+    it('creates a finding for the file below threshold', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const gapFindings = result.findings.filter((f) => f.id.startsWith('3-coverage-gap'));
+      expect(gapFindings).toHaveLength(1);
+    });
+
+    it('the finding has medium severity', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const gapFinding = result.findings.find((f) => f.id.startsWith('3-coverage-gap'));
+      expect(gapFinding!.severity).toBe('medium');
+    });
+
+    it('the finding has type code-bug-logic', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const gapFinding = result.findings.find((f) => f.id.startsWith('3-coverage-gap'));
+      expect(gapFinding!.type).toBe('code-bug-logic');
+    });
+
+    it('the finding description mentions the specific thresholds not met', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const gapFinding = result.findings.find((f) => f.id.startsWith('3-coverage-gap'));
+      expect(gapFinding!.description).toContain('lines');
+    });
+
+    it('the finding file property points to the uncovered file', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const gapFinding = result.findings.find((f) => f.id.startsWith('3-coverage-gap'));
+      expect(gapFinding!.file).toBe('src/services/payroll.ts');
+    });
+
+    it('does not create a finding for the file above threshold', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const gapFindings = result.findings.filter((f) => f.id.startsWith('3-coverage-gap'));
+      const helpersFinding = gapFindings.find((f) => f.file === 'src/utils/helpers.ts');
+      expect(helpersFinding).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Multiple files below threshold
+  // -------------------------------------------------------------------------
+
+  describe('when multiple files are below threshold', () => {
+    beforeEach(() => {
+      readdirMock.mockResolvedValue(['coverage-summary.json']);
+      const summary = makeCoverageSummary([
+        { path: 'src/a.ts', lines: 50, functions: 50, branches: 50, statements: 50 },
+        { path: 'src/b.ts', lines: 40, functions: 40, branches: 40, statements: 40 },
+        { path: 'src/c.ts', lines: 30, functions: 30, branches: 30, statements: 30 },
+      ]);
+      readFileMock.mockResolvedValue(JSON.stringify(summary));
+    });
+
+    it('creates one finding per uncovered file', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const gapFindings = result.findings.filter((f) => f.id.startsWith('3-coverage-gap'));
+      expect(gapFindings).toHaveLength(3);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Malformed JSON
+  // -------------------------------------------------------------------------
+
+  describe('when coverage JSON is malformed', () => {
+    beforeEach(() => {
+      readdirMock.mockResolvedValue(['coverage-summary.json']);
+      readFileMock.mockResolvedValue('not valid json {{{');
+    });
+
+    it('returns no findings (skips malformed file gracefully)', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // Malformed file produces no findings — this is silent skip behaviour
+      const gapFindings = result.findings.filter((f) => f.id.startsWith('3-coverage-gap'));
+      expect(gapFindings).toHaveLength(0);
+    });
+  });
+});