@avi770/testteam 1.2.0

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

@@ -0,0 +1,402 @@
+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

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