@avi770/testteam 3.0.0 → 3.2.0

package/agents/__tests__/05-browser-crawler.test.ts

@@ -1,518 +0,0 @@
-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/login',
-    credentials: { admin: { email: 'admin@test.com', password: 'secret' } },
-  },
-  modules: [
-    { id: 'dashboard', route: '/dashboard', sidebarIcon: true },
-    { id: 'invoices', route: '/invoices', 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' as const },
-  agentClassification: { blocking: [], advisory: [] },
-  thresholds: {
-    unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
-    lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
-    apiResponseTime: 2000,
-    bundleSizeLimit: 500000,
-    maxConsoleErrors: 0,
-  },
-  disabledAgents: [],
-  disabledAgentSet: new Set<number>(),
-} satisfies ValidatedConfig;
-
-// ---------------------------------------------------------------------------
-// Mock child_process
-// ---------------------------------------------------------------------------
-
-const spawnMock = vi.fn();
-
-vi.mock('child_process', () => ({
-  execFile: (...args: unknown[]) => spawnMock(...args),
-}));
-
-// ---------------------------------------------------------------------------
-// Mock fetch (used by isUrlReachable in preFlight)
-// ---------------------------------------------------------------------------
-
-const fetchMock = vi.fn();
-vi.stubGlobal('fetch', fetchMock);
-
-// ---------------------------------------------------------------------------
-// Mock helpers used by the agent
-// ---------------------------------------------------------------------------
-
-const loginMock = vi.fn().mockResolvedValue(undefined);
-const navigateToSectionMock = vi.fn().mockResolvedValue(undefined);
-const waitForSectionLoadMock = vi.fn().mockResolvedValue(undefined);
-const captureScreenshotMock = vi.fn().mockResolvedValue('/tmp/test-run/screenshot.png');
-
-vi.mock('../../helpers/navigation', () => ({
-  login: (...args: unknown[]) => loginMock(...args),
-  navigateToSection: (...args: unknown[]) => navigateToSectionMock(...args),
-  waitForSectionLoad: (...args: unknown[]) => waitForSectionLoadMock(...args),
-}));
-
-vi.mock('../../helpers/screenshot', () => ({
-  captureScreenshot: (...args: unknown[]) => captureScreenshotMock(...args),
-}));
-
-// ---------------------------------------------------------------------------
-// Mock Playwright
-// ---------------------------------------------------------------------------
-
-type ConsoleListener = (msg: { type(): string; text(): string }) => void;
-type ResponseListener = (response: { status(): number; url(): string }) => void;
-
-interface MockPage {
-  close: ReturnType<typeof vi.fn>;
-  on: ReturnType<typeof vi.fn>;
-  _consoleListeners: ConsoleListener[];
-  _responseListeners: ResponseListener[];
-  /** Helper: emit a console event to all listeners */
-  emitConsole(type: string, text: string): void;
-  /** Helper: emit a response event to all listeners */
-  emitResponse(status: number, url: string): void;
-}
-
-function makeMockPage(): MockPage {
-  const consoleListeners: ConsoleListener[] = [];
-  const responseListeners: ResponseListener[] = [];
-
-  const page: MockPage = {
-    close: vi.fn().mockResolvedValue(undefined),
-    on: vi.fn().mockImplementation((event: string, listener: ConsoleListener | ResponseListener) => {
-      if (event === 'console') consoleListeners.push(listener as ConsoleListener);
-      if (event === 'response') responseListeners.push(listener as ResponseListener);
-    }),
-    _consoleListeners: consoleListeners,
-    _responseListeners: responseListeners,
-    emitConsole(type: string, text: string): void {
-      for (const l of consoleListeners) {
-        l({ type: () => type, text: () => text });
-      }
-    },
-    emitResponse(status: number, url: string): void {
-      for (const l of responseListeners) {
-        l({ status: () => status, url: () => url });
-      }
-    },
-  };
-
-  return page;
-}
-
-let currentMockPage: MockPage;
-let mockBrowser: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
-
-vi.mock('playwright', async () => {
-  return {
-    chromium: {
-      launch: vi.fn().mockImplementation(async () => mockBrowser),
-    },
-  };
-});
-
-// ---------------------------------------------------------------------------
-// Dynamic import AFTER mocks
-// ---------------------------------------------------------------------------
-
-const { BrowserCrawlerAgent } = await import('../05-browser-crawler');
-
-function createAgent(phase: Phase = 'alpha'): InstanceType<typeof BrowserCrawlerAgent> {
-  return new BrowserCrawlerAgent(stubConfig, phase, '/tmp/test-run');
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('BrowserCrawlerAgent', () => {
-  beforeEach(() => {
-    spawnMock.mockReset();
-    fetchMock.mockReset();
-    loginMock.mockReset().mockResolvedValue(undefined);
-    navigateToSectionMock.mockReset().mockResolvedValue(undefined);
-    waitForSectionLoadMock.mockReset().mockResolvedValue(undefined);
-    captureScreenshotMock.mockReset().mockResolvedValue('/tmp/test-run/screenshot.png');
-
-    currentMockPage = makeMockPage();
-    mockBrowser = {
-      newPage: vi.fn().mockResolvedValue(currentMockPage),
-      close: vi.fn().mockResolvedValue(undefined),
-    };
-
-    // Default: playwright version check succeeds
-    spawnMock.mockImplementation(
-      (_file: string, _args: string[], _opts: unknown, cb: (err: Error | null, stdout: string, stderr: string) => void) => {
-        cb(null, '1.40.0\n', '');
-      },
-    );
-
-    // Default: base URL is reachable
-    fetchMock.mockResolvedValue({ ok: true, status: 200 });
-  });
-
-  it('has agentId 5 and agentName "Browser Crawler"', () => {
-    const agent = createAgent();
-    expect(agent.agentId).toBe(5);
-    expect(agent.agentName).toBe('Browser Crawler');
-  });
-
-  // -------------------------------------------------------------------------
-  // preFlight()
-  // -------------------------------------------------------------------------
-
-  describe('preFlight()', () => {
-    it('throws when base URL is not reachable', async () => {
-      fetchMock.mockRejectedValue(new Error('ECONNREFUSED'));
-
-      const agent = createAgent();
-      const result = await agent.run();
-
-      expect(result.status).toBe('failed');
-      expect(result.findings[0].description).toContain('not reachable');
-    });
-
-    it('passes when playwright version check and fetch both succeed', async () => {
-      const agent = createAgent();
-      const result = await agent.run();
-
-      // preFlight must not have thrown — status driven by execute()
-      expect(result.findings.some((f) => f.description.includes('not reachable'))).toBe(false);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // execute() — smoke / alpha mode
-  // -------------------------------------------------------------------------
-
-  describe('execute() (smoke / alpha mode)', () => {
-    it('calls login() once before iterating modules', async () => {
-      const agent = createAgent('alpha');
-      await agent.run();
-
-      expect(loginMock).toHaveBeenCalledTimes(1);
-      expect(loginMock).toHaveBeenCalledWith(
-        currentMockPage,
-        stubConfig.auth.credentials!['admin'],
-        stubConfig.auth.loginUrl,
-      );
-    });
-
-    it('navigates to each configured module', async () => {
-      const agent = createAgent('alpha');
-      await agent.run();
-
-      expect(navigateToSectionMock).toHaveBeenCalledTimes(stubConfig.modules.length);
-      for (const mod of stubConfig.modules) {
-        expect(navigateToSectionMock).toHaveBeenCalledWith(
-          currentMockPage,
-          mod.id,
-          stubConfig,
-        );
-      }
-    });
-
-    it('calls waitForSectionLoad for each module', async () => {
-      const agent = createAgent('alpha');
-      await agent.run();
-
-      expect(waitForSectionLoadMock).toHaveBeenCalledTimes(stubConfig.modules.length);
-    });
-
-    it('takes a screenshot for each module', async () => {
-      const agent = createAgent('alpha');
-      await agent.run();
-
-      expect(captureScreenshotMock).toHaveBeenCalledTimes(stubConfig.modules.length);
-    });
-
-    it('returns no findings when navigation succeeds and no console errors occur', async () => {
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      expect(result.findings).toHaveLength(0);
-    });
-
-    it('returns passed status when no errors are found', async () => {
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      expect(result.status).toBe('passed');
-    });
-
-    it('adds screenshot evidence items for each module', async () => {
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      const screenshotEvidence = result.evidence.filter((e) => e.type === 'screenshot');
-      expect(screenshotEvidence).toHaveLength(stubConfig.modules.length);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Console errors
-  // -------------------------------------------------------------------------
-
-  describe('console error handling', () => {
-    it('creates a high-severity finding for each console error', async () => {
-      navigateToSectionMock.mockImplementation(async (_page: unknown, moduleId: string) => {
-        if (moduleId === 'dashboard') {
-          currentMockPage.emitConsole('error', 'Uncaught TypeError: Cannot read properties of null');
-        }
-      });
-
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      const consoleFinding = result.findings.find((f) => f.consoleError !== undefined);
-      expect(consoleFinding).toBeDefined();
-      expect(consoleFinding!.severity).toBe('high');
-      expect(consoleFinding!.type).toBe('code-bug-logic');
-    });
-
-    it('includes the console error text in the finding description', async () => {
-      navigateToSectionMock.mockImplementation(async (_page: unknown, moduleId: string) => {
-        if (moduleId === 'dashboard') {
-          currentMockPage.emitConsole('error', 'ReferenceError: foo is not defined');
-        }
-      });
-
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      const consoleFinding = result.findings.find((f) => f.consoleError !== undefined);
-      expect(consoleFinding!.description).toContain('ReferenceError: foo is not defined');
-    });
-
-    it('does not create a finding for non-error console messages', async () => {
-      navigateToSectionMock.mockImplementation(async (_page: unknown, moduleId: string) => {
-        if (moduleId === 'dashboard') {
-          currentMockPage.emitConsole('log', 'App initialized');
-          currentMockPage.emitConsole('warn', 'Deprecated API');
-        }
-      });
-
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      const consoleFindings = result.findings.filter((f) => f.consoleError !== undefined);
-      expect(consoleFindings).toHaveLength(0);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Network failures
-  // -------------------------------------------------------------------------
-
-  describe('network failure handling', () => {
-    it('creates a finding for 4xx responses', async () => {
-      navigateToSectionMock.mockImplementation(async (_page: unknown, moduleId: string) => {
-        if (moduleId === 'invoices') {
-          currentMockPage.emitResponse(404, 'http://localhost:3000/api/invoices');
-        }
-      });
-
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      const networkFinding = result.findings.find(
-        (f) => f.description.includes('404') || f.description.includes('network failure'),
-      );
-      expect(networkFinding).toBeDefined();
-      expect(networkFinding!.severity).toBe('high');
-    });
-
-    it('creates a finding for 5xx responses', async () => {
-      navigateToSectionMock.mockImplementation(async (_page: unknown, moduleId: string) => {
-        if (moduleId === 'dashboard') {
-          currentMockPage.emitResponse(500, 'http://localhost:3000/api/health');
-        }
-      });
-
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      const networkFinding = result.findings.find(
-        (f) => f.description.includes('500') || f.description.includes('network failure'),
-      );
-      expect(networkFinding).toBeDefined();
-    });
-
-    it('does not create a finding for 2xx responses', async () => {
-      navigateToSectionMock.mockImplementation(async (_page: unknown, moduleId: string) => {
-        if (moduleId === 'dashboard') {
-          currentMockPage.emitResponse(200, 'http://localhost:3000/api/data');
-        }
-      });
-
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      const networkFindings = result.findings.filter((f) => f.type === 'infra-issue');
-      expect(networkFindings).toHaveLength(0);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Navigation failure
-  // -------------------------------------------------------------------------
-
-  describe('navigation failure', () => {
-    it('creates an infra-issue finding when navigation to a module throws', async () => {
-      navigateToSectionMock.mockImplementation(async (_page: unknown, moduleId: string) => {
-        if (moduleId === 'dashboard') {
-          throw new Error('Timeout waiting for page');
-        }
-      });
-
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      const navFinding = result.findings.find(
-        (f) => f.id.includes('nav-dashboard'),
-      );
-      expect(navFinding).toBeDefined();
-      expect(navFinding!.type).toBe('infra-issue');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Unsupported phase
-  // -------------------------------------------------------------------------
-
-  describe('unsupported phase', () => {
-    it('fails with error when phase is "beta" (not yet implemented)', async () => {
-      const agent = createAgent('beta');
-      const result = await agent.run();
-
-      expect(result.status).toBe('failed');
-    });
-
-    it('fails with error when phase is "uat" (not yet implemented)', async () => {
-      const agent = createAgent('uat');
-      const result = await agent.run();
-
-      expect(result.status).toBe('failed');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Smoke: no environment configured
-  // -------------------------------------------------------------------------
-
-  describe('smoke: no environment', () => {
-    it('fails when no environment is configured and URL is unreachable', async () => {
-      const noEnvConfig = { ...stubConfig, environments: {} };
-      fetchMock.mockRejectedValue(new Error('no env'));
-      const agent = new BrowserCrawlerAgent(noEnvConfig as ValidatedConfig, 'alpha', '/tmp/test-run');
-      const result = await agent.run();
-
-      // Either preFlight fails or execute produces critical finding
-      expect(
-        result.status === 'failed' ||
-        result.findings.some(f => f.severity === 'critical'),
-      ).toBe(true);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Smoke: no credentials
-  // -------------------------------------------------------------------------
-
-  describe('smoke: no credentials', () => {
-    it('creates a critical finding when no credentials are configured', async () => {
-      const noCredConfig = {
-        ...stubConfig,
-        auth: { loginUrl: 'http://localhost/login', credentials: {} },
-      };
-      const agent = new BrowserCrawlerAgent(noCredConfig as ValidatedConfig, 'alpha', '/tmp/test-run');
-      const result = await agent.run();
-
-      const finding = result.findings.find(f => f.id === '5-no-credentials');
-      expect(finding).toBeDefined();
-      expect(finding!.severity).toBe('critical');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Smoke: login failure
-  // -------------------------------------------------------------------------
-
-  describe('smoke: login failure', () => {
-    it('creates a finding when login fails and continues crawling anonymously', async () => {
-      loginMock.mockRejectedValue(new Error('Auth service down'));
-      (currentMockPage as unknown as Record<string, unknown>).goto = vi.fn().mockResolvedValue(undefined);
-
-      const agent = createAgent('alpha');
-      const result = await agent.run();
-
-      const loginFinding = result.findings.find(f => f.id === '5-login-failed');
-      expect(loginFinding).toBeDefined();
-      // In alpha, login failure severity is medium
-      expect(loginFinding!.severity).toBe('medium');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Smoke: login URL with full http prefix
-  // -------------------------------------------------------------------------
-
-  describe('smoke: absolute login URL', () => {
-    it('uses loginUrl directly when it starts with http', async () => {
-      const agent = createAgent('alpha');
-      await agent.run();
-
-      // loginUrl starts with http:// in our config, so should be used as-is
-      expect(loginMock).toHaveBeenCalledWith(
-        currentMockPage,
-        stubConfig.auth.credentials!['admin'],
-        'http://localhost/login',
-      );
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Smoke: relative login URL gets prefixed with baseUrl
-  // -------------------------------------------------------------------------
-
-  describe('smoke: relative login URL', () => {
-    it('prefixes relative loginUrl with baseUrl', async () => {
-      const relativeLoginConfig = {
-        ...stubConfig,
-        auth: {
-          loginUrl: '/login',
-          credentials: { admin: { email: 'admin@test.com', password: 'secret' } },
-        },
-      };
-      const agent = new BrowserCrawlerAgent(relativeLoginConfig as ValidatedConfig, 'alpha', '/tmp/test-run');
-      await agent.run();
-
-      expect(loginMock).toHaveBeenCalledWith(
-        currentMockPage,
-        relativeLoginConfig.auth.credentials['admin'],
-        'http://localhost:3000/login',
-      );
-    });
-  });
-});