@avi770/testteam 2.0.0 → 3.2.0

package/agents/__tests__/17-documentation-validator.test.ts

@@ -1,402 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { ValidatedConfig } from '../../core/config';
-import type { Phase } from '../../core/types';
-
-// ---------------------------------------------------------------------------
-// Stub config
-// ---------------------------------------------------------------------------
-
-function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
-  return {
-    schemaVersion: 1,
-    name: 'test',
-    auth: {
-      loginUrl: 'http://localhost/login',
-      credentials: {
-        admin: { email: 'admin@test.com', password: 'secret' },
-      },
-    },
-    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>(),
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Mock node:fs/promises — we fully control what the agent "sees" on disk
-// ---------------------------------------------------------------------------
-
-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),
-  };
-});
-
-// ---------------------------------------------------------------------------
-// Mock fetch (URL health checks)
-// ---------------------------------------------------------------------------
-
-const fetchMock = vi.fn();
-vi.stubGlobal('fetch', fetchMock);
-
-// ---------------------------------------------------------------------------
-// Dynamic import AFTER mocks are hoisted
-// ---------------------------------------------------------------------------
-
-const { DocumentationValidatorAgent } = await import('../17-documentation-validator');
-
-function createAgent(
-  config: ValidatedConfig = makeConfig(),
-  phase: Phase = 'uat',
-): InstanceType<typeof DocumentationValidatorAgent> {
-  return new DocumentationValidatorAgent(config, phase, '/tmp/test-run');
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Configure fs mock so the agent finds a README.md in project root. */
-function setupBasicFs(readmeContent: string = '# Hello', docsExists = false): void {
-  statMock.mockImplementation((p: string) => {
-    if (p.endsWith('README.md')) return Promise.resolve({ isDirectory: () => false });
-    if (p.endsWith('docs')) {
-      if (docsExists) return Promise.resolve({ isDirectory: () => true });
-      return Promise.reject(new Error('ENOENT'));
-    }
-    return Promise.reject(new Error('ENOENT'));
-  });
-
-  readdirMock.mockImplementation((dir: string) => {
-    if (!dir.toString().includes('docs')) return Promise.resolve(['README.md']);
-    return Promise.resolve([]);
-  });
-
-  readFileMock.mockImplementation((filePath: string) => {
-    if (String(filePath).endsWith('README.md')) return Promise.resolve(readmeContent);
-    return Promise.resolve('');
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('DocumentationValidatorAgent', () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-    fetchMock.mockResolvedValue({ ok: true, status: 200 });
-  });
-
-  // -------------------------------------------------------------------------
-  // Identity
-  // -------------------------------------------------------------------------
-
-  it('has agentId 17 and agentName "Documentation Validator"', () => {
-    const agent = createAgent();
-    expect(agent.agentId).toBe(17);
-    expect(agent.agentName).toBe('Documentation Validator');
-  });
-
-  // -------------------------------------------------------------------------
-  // preFlight()
-  // -------------------------------------------------------------------------
-
-  describe('preFlight()', () => {
-    it('throws when neither README.md nor docs/ directory exists', async () => {
-      statMock.mockRejectedValue(new Error('ENOENT'));
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      expect(result.status).toBe('failed');
-      expect(result.findings[0].description).toContain('README.md');
-    });
-
-    it('passes when README.md exists', async () => {
-      setupBasicFs();
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      expect(result.findings.some(f => f.description.includes('README.md'))).toBe(false);
-    });
-
-    it('passes when only docs/ directory exists (no README.md)', async () => {
-      statMock.mockImplementation((p: string) => {
-        if (p.endsWith('docs')) return Promise.resolve({ isDirectory: () => true });
-        return Promise.reject(new Error('ENOENT'));
-      });
-      readdirMock.mockResolvedValue([]);
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      expect(result.status).toBe('passed');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // URL extraction from markdown
-  // -------------------------------------------------------------------------
-
-  describe('URL extraction', () => {
-    it('extracts URLs from markdown link syntax', async () => {
-      setupBasicFs('See [docs](https://example.com/docs) for details.');
-      fetchMock.mockResolvedValue({ ok: true, status: 200 });
-
-      const agent = createAgent();
-      await agent.run();
-
-      const fetchCalls = fetchMock.mock.calls as Array<[string, unknown]>;
-      const urls = fetchCalls.map(([url]) => url);
-      expect(urls).toContain('https://example.com/docs');
-    });
-
-    it('extracts bare URLs from markdown content', async () => {
-      setupBasicFs('Visit https://bare-url.example.com/page for info.');
-      fetchMock.mockResolvedValue({ ok: true, status: 200 });
-
-      const agent = createAgent();
-      await agent.run();
-
-      const fetchCalls = fetchMock.mock.calls as Array<[string, unknown]>;
-      const urls = fetchCalls.map(([url]) => url);
-      expect(urls.some((u) => u.includes('bare-url.example.com'))).toBe(true);
-    });
-
-    it('does not duplicate URLs that appear in both link syntax and bare form', async () => {
-      setupBasicFs(
-        'See [link](https://example.com/dup) and also https://example.com/dup here.',
-      );
-      fetchMock.mockResolvedValue({ ok: true, status: 200 });
-
-      const agent = createAgent();
-      await agent.run();
-
-      const fetchCalls = fetchMock.mock.calls as Array<[string, unknown]>;
-      const dupUrls = fetchCalls.filter(
-        ([url]) => url === 'https://example.com/dup',
-      );
-      expect(dupUrls.length).toBe(1);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Broken link → finding
-  // -------------------------------------------------------------------------
-
-  describe('broken link detection', () => {
-    it('creates a finding for a 404 URL', async () => {
-      setupBasicFs('[broken](https://dead.example.com/gone)');
-      fetchMock.mockResolvedValue({ ok: false, status: 404 });
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      const brokenFinding = result.findings.find(
-        f => f.description.includes('https://dead.example.com/gone'),
-      );
-      expect(brokenFinding).toBeDefined();
-      expect(brokenFinding!.severity).toBe('low');
-    });
-
-    it('creates a finding for a 5xx URL', async () => {
-      setupBasicFs('[server-error](https://error.example.com/500)');
-      fetchMock.mockResolvedValue({ ok: false, status: 500 });
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      const brokenFinding = result.findings.find(
-        f => f.description.includes('https://error.example.com/500'),
-      );
-      expect(brokenFinding).toBeDefined();
-      expect(brokenFinding!.severity).toBe('low');
-    });
-
-    it('creates a finding for an unreachable URL (network error)', async () => {
-      setupBasicFs('[unreachable](https://unreachable.example.com/)');
-      fetchMock.mockRejectedValue(new Error('ECONNREFUSED'));
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      const brokenFinding = result.findings.find(
-        f => f.description.includes('https://unreachable.example.com/'),
-      );
-      expect(brokenFinding).toBeDefined();
-    });
-
-    it('does not create findings for valid links (200)', async () => {
-      setupBasicFs('[ok](https://ok.example.com/)');
-      fetchMock.mockResolvedValue({ ok: true, status: 200 });
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      const linkFindings = result.findings.filter(
-        f => f.description.includes('https://ok.example.com/'),
-      );
-      expect(linkFindings).toHaveLength(0);
-    });
-
-    it('does not create findings for redirect responses (301/302)', async () => {
-      setupBasicFs('[redirect](https://redirect.example.com/)');
-      fetchMock.mockResolvedValue({ ok: false, status: 301 });
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      const linkFindings = result.findings.filter(
-        f => f.description.includes('redirect.example.com'),
-      );
-      expect(linkFindings).toHaveLength(0);
-    });
-
-    it('sets finding.file to the markdown file path', async () => {
-      setupBasicFs('[broken](https://broken2.example.com/)');
-      fetchMock.mockResolvedValue({ ok: false, status: 404 });
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      const brokenFinding = result.findings.find(
-        f => f.description.includes('https://broken2.example.com/'),
-      );
-      expect(brokenFinding!.file).toBeDefined();
-      expect(brokenFinding!.file).toContain('README.md');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Bare catch-log pattern
-  // -------------------------------------------------------------------------
-
-  describe('bare catch log detection', () => {
-    it('creates a finding when src/ contains a catch block that only logs error.message', async () => {
-      setupBasicFs();
-
-      // Override stat and readdir to include a fake src/ directory
-      statMock.mockImplementation((p: string) => {
-        if (p.endsWith('README.md')) return Promise.resolve({ isDirectory: () => false });
-        if (p.endsWith('docs')) return Promise.reject(new Error('ENOENT'));
-        if (p.endsWith('src')) return Promise.resolve({ isDirectory: () => true });
-        if (p.endsWith('service.ts')) return Promise.resolve({ isDirectory: () => false });
-        return Promise.reject(new Error('ENOENT'));
-      });
-
-      readdirMock.mockImplementation((dir: string) => {
-        if (String(dir).endsWith('src')) return Promise.resolve(['service.ts']);
-        return Promise.resolve(['README.md']);
-      });
-
-      readFileMock.mockImplementation((filePath: string) => {
-        if (String(filePath).endsWith('README.md')) return Promise.resolve('# Docs');
-        if (String(filePath).endsWith('service.ts')) {
-          return Promise.resolve(`
-            async function doSomething() {
-              try {
-                await risky();
-              } catch (err) {
-                console.error(err.message);
-              }
-            }
-          `);
-        }
-        return Promise.resolve('');
-      });
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      const catchFinding = result.findings.find(
-        f => f.description.includes('catch') || f.type === 'code-bug-logic',
-      );
-      expect(catchFinding).toBeDefined();
-      expect(catchFinding!.severity).toBe('low');
-    });
-
-    it('does not create a bare-catch finding when no such pattern exists in source', async () => {
-      setupBasicFs();
-
-      statMock.mockImplementation((p: string) => {
-        if (p.endsWith('README.md')) return Promise.resolve({ isDirectory: () => false });
-        if (p.endsWith('docs')) return Promise.reject(new Error('ENOENT'));
-        if (p.endsWith('src')) return Promise.resolve({ isDirectory: () => true });
-        if (p.endsWith('clean-service.ts')) return Promise.resolve({ isDirectory: () => false });
-        return Promise.reject(new Error('ENOENT'));
-      });
-
-      readdirMock.mockImplementation((dir: string) => {
-        if (String(dir).endsWith('src')) return Promise.resolve(['clean-service.ts']);
-        return Promise.resolve(['README.md']);
-      });
-
-      readFileMock.mockImplementation((filePath: string) => {
-        if (String(filePath).endsWith('README.md')) return Promise.resolve('# Docs');
-        if (String(filePath).endsWith('clean-service.ts')) {
-          return Promise.resolve(`
-            async function doSomething() {
-              try {
-                await risky();
-              } catch (err) {
-                throw new BadRequestException('Something went wrong — please try again');
-              }
-            }
-          `);
-        }
-        return Promise.resolve('');
-      });
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      const catchFindings = result.findings.filter(f => f.type === 'code-bug-logic');
-      expect(catchFindings).toHaveLength(0);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // No findings when everything is valid
-  // -------------------------------------------------------------------------
-
-  it('returns passed status with no findings for clean docs and valid links', async () => {
-    setupBasicFs('# README\n\nThis project has no links.');
-    fetchMock.mockResolvedValue({ ok: true, status: 200 });
-
-    const agent = createAgent();
-    const result = await agent.run();
-
-    expect(result.status).toBe('passed');
-    expect(result.findings).toHaveLength(0);
-  });
-});

package/agents/__tests__/18-integration-watchdog.test.ts

@@ -1,263 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { ValidatedConfig } from '../../core/config';
-
-// ---------------------------------------------------------------------------
-// Stub config
-// ---------------------------------------------------------------------------
-
-function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
-  return {
-    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: [{ name: 'xero' }],
-    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>(),
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Mock node:fs and node:child_process
-// ---------------------------------------------------------------------------
-
-const existsSyncMock = vi.fn();
-vi.mock('node:fs', () => ({
-  existsSync: (...args: unknown[]) => existsSyncMock(...args),
-}));
-
-type ExecFileCallback = (err: Error | null, stdout: string, stderr: string) => void;
-
-const execFileMock = vi.fn();
-vi.mock('node:child_process', () => ({
-  execFile: (...args: unknown[]) => execFileMock(...args),
-}));
-
-/** Helper: make execFile resolve with success */
-function setupExecSuccess(stdout = ''): void {
-  execFileMock.mockImplementation(
-    (_file: string, _args: string[], _opts: unknown, cb: ExecFileCallback) => {
-      cb(null, stdout, '');
-    },
-  );
-}
-
-/** Helper: make execFile reject with a failure */
-function setupExecFailure(stderr: string): void {
-  const error = Object.assign(new Error('Command failed'), { stderr, stdout: '' });
-  execFileMock.mockImplementation(
-    (_file: string, _args: string[], _opts: unknown, cb: ExecFileCallback) => {
-      cb(error, '', stderr);
-    },
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Import after mocks
-// ---------------------------------------------------------------------------
-
-const { IntegrationWatchdogAgent } = await import('../18-integration-watchdog');
-
-function createAgent(config: ValidatedConfig = makeConfig()): InstanceType<typeof IntegrationWatchdogAgent> {
-  return new IntegrationWatchdogAgent(config, 'beta', '/tmp/test-run');
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('IntegrationWatchdogAgent', () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-    // Default: workers dir exists
-    existsSyncMock.mockReturnValue(true);
-    // Default: vitest runs succeed
-    setupExecSuccess('All tests passed');
-  });
-
-  it('has agentId 18 and agentName "Integration Watchdog"', () => {
-    const agent = createAgent();
-    expect(agent.agentId).toBe(18);
-    expect(agent.agentName).toBe('Integration Watchdog');
-  });
-
-  // -------------------------------------------------------------------------
-  // preFlight()
-  // -------------------------------------------------------------------------
-
-  describe('preFlight()', () => {
-    it('throws when config.integrations is empty', async () => {
-      const config = makeConfig({ integrations: [] });
-      const agent = createAgent(config);
-      const result = await agent.run();
-
-      expect(result.status).toBe('failed');
-      expect(result.findings[0].description).toContain('at least one integration');
-    });
-
-    it('throws when worker directories do not exist', async () => {
-      existsSyncMock.mockReturnValue(false);
-      const agent = createAgent();
-      const result = await agent.run();
-
-      expect(result.status).toBe('failed');
-      expect(result.findings[0].description).toContain('Worker directory not found');
-    });
-
-    it('passes when integrations are configured and worker dir exists', async () => {
-      existsSyncMock.mockReturnValue(true);
-      const agent = createAgent();
-      const result = await agent.run();
-
-      expect(result.findings.some((f) => f.description.includes('at least one integration'))).toBe(false);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // execute() — worker checks
-  // -------------------------------------------------------------------------
-
-  describe('execute() — worker source file checks', () => {
-    it('creates a medium finding when a worker source file is missing', async () => {
-      const config = makeConfig({ workers: [{ name: 'sync-xero' }] });
-
-      // workers dir exists, but worker source file and vitest config do not
-      existsSyncMock.mockImplementation((p: string) => {
-        const n = p.replace(/\\/g, '/');
-        // apps/workers dir must exist for preFlight
-        if (n.endsWith('apps/workers')) return true;
-        // Everything else (source files, vitest config) does not exist
-        return false;
-      });
-
-      const agent = createAgent(config);
-      const result = await agent.run();
-
-      const workerFinding = result.findings.find((f) => f.id.includes('worker-missing'));
-      expect(workerFinding).toBeDefined();
-      expect(workerFinding!.severity).toBe('medium');
-    });
-
-    it('creates a medium finding when a worker has no test file', async () => {
-      const config = makeConfig({ workers: [{ name: 'sync-xero' }] });
-
-      existsSyncMock.mockImplementation((p: string) => {
-        const n = p.replace(/\\/g, '/');
-        // apps/workers dir exists for preFlight
-        if (n.endsWith('apps/workers')) return true;
-        // vitest config does NOT exist — avoids running tests in execute()
-        if (n.endsWith('vitest.config.ts')) return false;
-        // worker source file exists, test files do not
-        if (n.includes('sync-xero') && !n.includes('.test.') && !n.includes('.spec.')) return true;
-        return false;
-      });
-
-      const agent = createAgent(config);
-      const result = await agent.run();
-
-      const testFinding = result.findings.find((f) => f.id.includes('worker-no-tests'));
-      expect(testFinding).toBeDefined();
-      expect(testFinding!.severity).toBe('medium');
-    });
-
-    it('creates no worker finding when source and test file both exist', async () => {
-      const config = makeConfig({ workers: [{ name: 'sync-xero' }] });
-
-      // All paths exist — source, tests, and vitest config
-      existsSyncMock.mockReturnValue(true);
-      setupExecSuccess('All tests passed');
-
-      const agent = createAgent(config);
-      const result = await agent.run();
-
-      const workerFindings = result.findings.filter(
-        (f) => f.id.includes('worker-missing') || f.id.includes('worker-no-tests'),
-      );
-      expect(workerFindings).toHaveLength(0);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // execute() — worker test runner
-  // -------------------------------------------------------------------------
-
-  describe('execute() — worker test runner', () => {
-    it('creates a high finding when worker tests fail', async () => {
-      const config = makeConfig({ workers: [{ name: 'sync-xero' }] });
-
-      existsSyncMock.mockReturnValue(true);
-      setupExecFailure('FAIL sync-xero.test.ts');
-
-      const agent = createAgent(config);
-      const result = await agent.run();
-
-      const testFailFinding = result.findings.find((f) => f.id.includes('worker-tests-failed'));
-      expect(testFailFinding).toBeDefined();
-      expect(testFailFinding!.severity).toBe('high');
-    });
-
-    it('creates no finding when all worker tests pass', async () => {
-      const config = makeConfig({ workers: [{ name: 'sync-xero' }] });
-
-      existsSyncMock.mockReturnValue(true);
-      setupExecSuccess('All tests passed');
-
-      const agent = createAgent(config);
-      const result = await agent.run();
-
-      const testFailFinding = result.findings.find((f) => f.id.includes('worker-tests-failed'));
-      expect(testFailFinding).toBeUndefined();
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // execute() — integration sandbox checks
-  // -------------------------------------------------------------------------
-
-  describe('execute() — integration sandbox checks', () => {
-    it('creates a low advisory finding when no sandbox config exists for an integration', async () => {
-      // Workers dir exists but integration sandbox config files do not
-      existsSyncMock.mockImplementation((p: string) => {
-        const n = p.replace(/\\/g, '/');
-        if (n.endsWith('apps/workers')) return true;
-        if (n.includes('xero')) return false;
-        return true;
-      });
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      const sandboxFinding = result.findings.find((f) => f.id.includes('integration-no-sandbox'));
-      expect(sandboxFinding).toBeDefined();
-      expect(sandboxFinding!.severity).toBe('low');
-    });
-
-    it('creates no sandbox finding when sandbox config exists', async () => {
-      // All paths exist — sandbox config found
-      existsSyncMock.mockReturnValue(true);
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      const sandboxFinding = result.findings.find((f) => f.id.includes('integration-no-sandbox'));
-      expect(sandboxFinding).toBeUndefined();
-    });
-  });
-});