@avi770/testteam 1.2.0

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

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