@avi770/testteam 1.2.0 → 2.0.0

package/agents/__tests__/67-wcag-aaa-tester.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    schemaVersion: 1, name: 'test',
+    auth: { loginUrl: 'http://localhost/login', credentials: { admin: { email: 'a@t.com', password: 's' } } },
+    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,
+  };
+}
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+function makeMockPage() {
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue(0),
+    locator: vi.fn().mockReturnValue({ count: vi.fn().mockResolvedValue(0) }),
+    keyboard: { press: vi.fn().mockResolvedValue(undefined) },
+    on: vi.fn(),
+  };
+}
+
+let currentMockPage: ReturnType<typeof makeMockPage>;
+let mockBrowser: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', async () => ({
+  chromium: { launch: vi.fn().mockImplementation(async () => mockBrowser) },
+}));
+
+const { WcagAaaTesterAgent } = await import('../67-wcag-aaa-tester');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new WcagAaaTesterAgent(config, phase, '/tmp/test-run');
+}
+
+describe('WcagAaaTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+    currentMockPage = makeMockPage();
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  it('has agentId 67 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(67);
+    expect(agent.agentName).toBe('WCAG AAA Tester');
+  });
+
+  it('throws when modules empty', async () => {
+    const agent = createAgent(makeConfig({ modules: [] }));
+    const result = await agent.run();
+    expect(result.status).toBe('failed');
+  });
+
+  it('reports low contrast elements', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) return 5; // low contrast count
+      if (callCount === 2) return false; // no overflow
+      if (callCount === 3) return 3; // focusable count
+      return true; // focus indicator
+    });
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('low-contrast'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('medium');
+  });
+
+  it('reports text resize overflow', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) return 0; // no low contrast
+      if (callCount === 2) return true; // has overflow
+      if (callCount === 3) return 3; // focusable
+      return true;
+    });
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('text-resize-overflow'));
+    expect(finding).toBeDefined();
+  });
+
+  it('reports no focusable elements', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) return 0; // no low contrast
+      if (callCount === 2) return false; // no overflow
+      if (callCount === 3) return 0; // no focusable elements
+      return false;
+    });
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-focusable'));
+    expect(finding).toBeDefined();
+  });
+
+  it('reports no focus indicator', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) return 0;
+      if (callCount === 2) return false;
+      if (callCount === 3) return 5; // has focusable
+      return false; // no focus indicator
+    });
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-focus-indicator'));
+    expect(finding).toBeDefined();
+  });
+
+  it('no findings when all checks pass', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) return 0;
+      if (callCount === 2) return false;
+      if (callCount === 3) return 5;
+      return true;
+    });
+    const agent = createAgent();
+    const result = await agent.run();
+    const issues = result.findings.filter(f => f.severity === 'medium' || f.severity === 'high');
+    expect(issues.length).toBe(0);
+  });
+
+  it('handles login failure', async () => {
+    loginMock.mockRejectedValue(new Error('Login failed'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('login-failed'));
+    expect(finding).toBeDefined();
+  });
+
+  it('handles playwright crash', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('playwright-failure'));
+    expect(finding).toBeDefined();
+  });
+
+  it('closes browser in finally', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Crash'));
+    const agent = createAgent();
+    await agent.run();
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  it('uses keyboard.press for tab navigation', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 3) return 3;
+      return callCount === 4 ? true : 0;
+    });
+    const agent = createAgent();
+    await agent.run();
+    expect(currentMockPage.keyboard.press).toHaveBeenCalledWith('Tab');
+  });
+});

package/agents/__tests__/68-dead-code-detector.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    schemaVersion: 1, name: 'test',
+    projectRoot: '/fake/project',
+    auth: { loginUrl: '/login', credentials: { admin: { email: 'a@t.com', password: 's' } } },
+    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,
+  };
+}
+
+const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+vi.stubGlobal('fetch', fetchMock);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: vi.fn().mockResolvedValue(undefined),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+const existsSyncMock = vi.fn();
+const readFileSyncMock = vi.fn();
+const readdirSyncMock = vi.fn();
+
+vi.mock('node:fs', () => ({
+  existsSync: (...args: unknown[]) => existsSyncMock(...args),
+  readFileSync: (...args: unknown[]) => readFileSyncMock(...args),
+  readdirSync: (...args: unknown[]) => readdirSyncMock(...args),
+}));
+
+const { DeadCodeDetectorAgent } = await import('../68-dead-code-detector');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new DeadCodeDetectorAgent(config, phase, '/tmp/test-run');
+}
+
+describe('DeadCodeDetectorAgent', () => {
+  beforeEach(() => {
+    existsSyncMock.mockReset().mockReturnValue(true);
+    readFileSyncMock.mockReset();
+    readdirSyncMock.mockReset();
+  });
+
+  it('has agentId 68 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(68);
+    expect(agent.agentName).toBe('Dead Code Detector');
+  });
+
+  it('reports no src dir', async () => {
+    existsSyncMock.mockReturnValue(false);
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-src-dir'));
+    expect(finding).toBeDefined();
+  });
+
+  it('detects unused exports', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'utils.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('export function unusedHelper() { return 1; }');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('unused-export'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('low');
+  });
+
+  it('does not flag used exports', async () => {
+    readdirSyncMock
+      .mockReturnValueOnce([
+        { name: 'utils.ts', isFile: () => true, isDirectory: () => false },
+        { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+      ]);
+    readFileSyncMock
+      .mockReturnValueOnce('export function myHelper() { return 1; }')
+      .mockReturnValueOnce('import { myHelper } from "./utils";\nmyHelper();');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.description.includes('myHelper'));
+    expect(finding).toBeUndefined();
+  });
+
+  it('skips test files', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.test.ts', isFile: () => true, isDirectory: () => false },
+      { name: 'app.spec.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+
+  it('skips d.ts files', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'types.d.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+
+  it('handles named exports', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('const foo = 1;\nexport { foo };');
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+
+  it('limits findings to 10', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'many.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    const manyExports = Array.from({ length: 15 }, (_, i) => `export function unusedFn${i}() {}`).join('\n');
+    readFileSyncMock.mockReturnValue(manyExports);
+    const agent = createAgent();
+    const result = await agent.run();
+    const exportFindings = result.findings.filter(f => f.id.match(/unused-export-\d+/));
+    expect(exportFindings.length).toBe(10);
+    const summary = result.findings.find(f => f.id.includes('unused-export-summary'));
+    expect(summary).toBeDefined();
+  });
+
+  it('adds evidence with scan stats', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('const x = 1;');
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.evidence.length).toBeGreaterThan(0);
+  });
+
+  it('recurses into subdirectories', async () => {
+    readdirSyncMock
+      .mockReturnValueOnce([
+        { name: 'sub', isFile: () => false, isDirectory: () => true },
+      ])
+      .mockReturnValueOnce([
+        { name: 'helper.ts', isFile: () => true, isDirectory: () => false },
+      ]);
+    readFileSyncMock.mockReturnValue('const x = 1;');
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+
+  it('skips common exports like default', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('export function main() {}');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.description.includes('"main"'));
+    expect(finding).toBeUndefined();
+  });
+});

package/agents/__tests__/69-type-safety-auditor.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    schemaVersion: 1, name: 'test',
+    projectRoot: '/fake/project',
+    auth: { loginUrl: '/login', credentials: { admin: { email: 'a@t.com', password: 's' } } },
+    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,
+  };
+}
+
+const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+vi.stubGlobal('fetch', fetchMock);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: vi.fn().mockResolvedValue(undefined),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+const existsSyncMock = vi.fn();
+const readFileSyncMock = vi.fn();
+const readdirSyncMock = vi.fn();
+
+vi.mock('node:fs', () => ({
+  existsSync: (...args: unknown[]) => existsSyncMock(...args),
+  readFileSync: (...args: unknown[]) => readFileSyncMock(...args),
+  readdirSync: (...args: unknown[]) => readdirSyncMock(...args),
+}));
+
+const { TypeSafetyAuditorAgent } = await import('../69-type-safety-auditor');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new TypeSafetyAuditorAgent(config, phase, '/tmp/test-run');
+}
+
+describe('TypeSafetyAuditorAgent', () => {
+  beforeEach(() => {
+    existsSyncMock.mockReset().mockReturnValue(true);
+    readFileSyncMock.mockReset();
+    readdirSyncMock.mockReset();
+  });
+
+  it('has agentId 69 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(69);
+    expect(agent.agentName).toBe('Type Safety Auditor');
+  });
+
+  it('reports no src dir', async () => {
+    existsSyncMock.mockReturnValue(false);
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-src-dir'));
+    expect(finding).toBeDefined();
+  });
+
+  it('detects any type annotations', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('const x: any = 1;');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('any-type'));
+    expect(finding).toBeDefined();
+  });
+
+  it('detects @ts-ignore comments', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('// @ts-ignore\nconst x = badCode();');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('ts-ignore'));
+    expect(finding).toBeDefined();
+  });
+
+  it('detects "as any" assertions', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('const x = someValue as any;');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('as-any'));
+    expect(finding).toBeDefined();
+  });
+
+  it('detects missing return types on exported functions', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('export function doStuff() {\n  return 1;\n}');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('missing-return-type'));
+    expect(finding).toBeDefined();
+  });
+
+  it('no findings for clean code', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('export function doStuff(): number {\n  return 1;\n}');
+    const agent = createAgent();
+    const result = await agent.run();
+    const anyFindings = result.findings.filter(f => f.id.includes('any-type') || f.id.includes('ts-ignore') || f.id.includes('as-any'));
+    expect(anyFindings.length).toBe(0);
+  });
+
+  it('limits any findings to 5', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue(
+      Array(10).fill('const x: any = 1;').join('\n'),
+    );
+    const agent = createAgent();
+    const result = await agent.run();
+    const anyFindings = result.findings.filter(f => f.id.match(/any-type-\d+/));
+    expect(anyFindings.length).toBe(5);
+    const summary = result.findings.find(f => f.id.includes('any-summary'));
+    expect(summary).toBeDefined();
+  });
+
+  it('adds evidence with scan stats', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('const x = 1;');
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.evidence.length).toBeGreaterThan(0);
+  });
+
+  it('skips d.ts files', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'types.d.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+
+  it('recurses into subdirectories', async () => {
+    readdirSyncMock
+      .mockReturnValueOnce([
+        { name: 'sub', isFile: () => false, isDirectory: () => true },
+      ])
+      .mockReturnValueOnce([
+        { name: 'helper.ts', isFile: () => true, isDirectory: () => false },
+      ]);
+    readFileSyncMock.mockReturnValue('const x: any = 1;');
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('any-type'));
+    expect(finding).toBeDefined();
+  });
+});