@avi770/testteam 1.2.0

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

@@ -0,0 +1,492 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+
+// ---------------------------------------------------------------------------
+// Stub config
+// ---------------------------------------------------------------------------
+
+const stubConfig: ValidatedConfig = {
+  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: [
+    { name: 'client', queryParam: 'client' },
+  ],
+  breakpoints: [1280, 768],
+  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>(),
+};
+
+// ---------------------------------------------------------------------------
+// Mock child_process (for preFlight playwright version check)
+// ---------------------------------------------------------------------------
+
+const spawnMock = vi.fn();
+vi.mock('child_process', () => ({
+  execFile: (...args: unknown[]) => spawnMock(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock fetch (for isUrlReachable in preFlight)
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// Mock helpers
+// ---------------------------------------------------------------------------
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+const navigateToSectionMock = vi.fn().mockResolvedValue(undefined);
+const waitForSectionLoadMock = vi.fn().mockResolvedValue(undefined);
+const switchPortalMock = vi.fn().mockResolvedValue(undefined);
+const captureScreenshotMock = vi.fn().mockResolvedValue('/tmp/test-run/screenshot.png');
+const discoverInteractiveElementsMock = vi.fn().mockResolvedValue([]);
+const fillFormMock = vi.fn().mockResolvedValue(undefined);
+const openModalMock = vi.fn().mockResolvedValue(false);
+const closeModalMock = vi.fn().mockResolvedValue(true);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  navigateToSection: (...args: unknown[]) => navigateToSectionMock(...args),
+  waitForSectionLoad: (...args: unknown[]) => waitForSectionLoadMock(...args),
+  switchPortal: (...args: unknown[]) => switchPortalMock(...args),
+}));
+
+vi.mock('../../helpers/screenshot', () => ({
+  captureScreenshot: (...args: unknown[]) => captureScreenshotMock(...args),
+}));
+
+vi.mock('../../helpers/element-discovery', () => ({
+  discoverInteractiveElements: (...args: unknown[]) => discoverInteractiveElementsMock(...args),
+}));
+
+vi.mock('../../helpers/form-filler', () => ({
+  fillForm: (...args: unknown[]) => fillFormMock(...args),
+}));
+
+vi.mock('../../helpers/modal-handler', () => ({
+  openModal: (...args: unknown[]) => openModalMock(...args),
+  closeModal: (...args: unknown[]) => closeModalMock(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock Playwright
+// ---------------------------------------------------------------------------
+
+type ConsoleListener = (msg: { type(): string; text(): string }) => void;
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  on: ReturnType<typeof vi.fn>;
+  removeListener: ReturnType<typeof vi.fn>;
+  waitForTimeout: ReturnType<typeof vi.fn>;
+  setViewportSize: ReturnType<typeof vi.fn>;
+  _consoleListeners: ConsoleListener[];
+  emitConsole(type: string, text: string): void;
+}
+
+function makeMockPage(): MockPage {
+  const consoleListeners: ConsoleListener[] = [];
+
+  const page: MockPage = {
+    close: vi.fn().mockResolvedValue(undefined),
+    on: vi.fn().mockImplementation((event: string, listener: ConsoleListener) => {
+      if (event === 'console') consoleListeners.push(listener);
+    }),
+    removeListener: vi.fn().mockImplementation((event: string, listener: ConsoleListener) => {
+      if (event === 'console') {
+        const idx = consoleListeners.indexOf(listener);
+        if (idx !== -1) consoleListeners.splice(idx, 1);
+      }
+    }),
+    waitForTimeout: vi.fn().mockResolvedValue(undefined),
+    setViewportSize: vi.fn().mockResolvedValue(undefined),
+    _consoleListeners: consoleListeners,
+    emitConsole(type: string, text: string): void {
+      for (const l of consoleListeners) {
+        l({ type: () => type, text: () => text });
+      }
+    },
+  };
+
+  return page;
+}
+
+let currentMockPage: MockPage;
+let mockBrowser: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', async () => ({
+  chromium: {
+    launch: vi.fn().mockImplementation(async () => mockBrowser),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks are hoisted
+// ---------------------------------------------------------------------------
+
+const { BrowserCrawlerAgent } = await import('../05-browser-crawler');
+
+function createAgent(): InstanceType<typeof BrowserCrawlerAgent> {
+  return new BrowserCrawlerAgent(stubConfig, 'beta', '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('BrowserCrawlerAgent — Beta mode', () => {
+  beforeEach(() => {
+    spawnMock.mockReset();
+    fetchMock.mockReset();
+    loginMock.mockReset().mockResolvedValue(undefined);
+    navigateToSectionMock.mockReset().mockResolvedValue(undefined);
+    waitForSectionLoadMock.mockReset().mockResolvedValue(undefined);
+    switchPortalMock.mockReset().mockResolvedValue(undefined);
+    captureScreenshotMock.mockReset().mockResolvedValue('/tmp/test-run/screenshot.png');
+    discoverInteractiveElementsMock.mockReset().mockResolvedValue([]);
+    fillFormMock.mockReset().mockResolvedValue(undefined);
+    openModalMock.mockReset().mockResolvedValue(false);
+    closeModalMock.mockReset().mockResolvedValue(true);
+
+    currentMockPage = makeMockPage();
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+
+    spawnMock.mockImplementation(
+      (_file: string, _args: string[], _opts: unknown, cb: (err: Error | null, stdout: string, stderr: string) => void) => {
+        cb(null, '1.40.0\n', '');
+      },
+    );
+    fetchMock.mockResolvedValue({ ok: true, status: 200 });
+  });
+
+  it('enters beta mode and does not throw "not yet implemented"', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.findings.some(f => f.description.includes('not implemented'))).toBe(false);
+  });
+
+  it('calls login once per breakpoint', async () => {
+    const agent = createAgent();
+    await agent.run();
+
+    // Beta mode uses a single desktop breakpoint [1280] regardless of config
+    expect(loginMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls navigateToSection for each module × each breakpoint pass', async () => {
+    const agent = createAgent();
+    await agent.run();
+
+    // 2 breakpoints × 2 modules = 4 bookkeeper calls, plus portal calls
+    // The bookkeeper pass alone is 2 × 2 = 4
+    const navigateCalls = navigateToSectionMock.mock.calls;
+    expect(navigateCalls.length).toBeGreaterThanOrEqual(
+      stubConfig.breakpoints.length * stubConfig.modules.length,
+    );
+  });
+
+  it('calls discoverInteractiveElements for each module visited', async () => {
+    const agent = createAgent();
+    await agent.run();
+
+    expect(discoverInteractiveElementsMock).toHaveBeenCalled();
+  });
+
+  it('takes a before and after screenshot for each module', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const screenshotEvidence = result.evidence.filter(e => e.type === 'screenshot');
+    // 2 breakpoints × 2 portals-passes × 2 modules × 2 (before+after) = at least 8
+    expect(screenshotEvidence.length).toBeGreaterThan(0);
+  });
+
+  it('skips destructive elements and does not attempt to click them', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="delete-btn"]',
+        type: 'button',
+        text: 'Delete',
+        isDestructive: true,
+      },
+      {
+        selector: '[data-testid="save-btn"]',
+        type: 'button',
+        text: 'Save',
+        isDestructive: false,
+      },
+    ]);
+
+    const agent = createAgent();
+    await agent.run();
+
+    // openModal is called for non-destructive buttons; delete button must be skipped
+    const openModalCalls = openModalMock.mock.calls as Array<[unknown, string]>;
+    const clickedSelectors = openModalCalls.map(([, sel]) => sel);
+    expect(clickedSelectors).not.toContain('[data-testid="delete-btn"]');
+  });
+
+  it('interacts with non-destructive button elements via openModal', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="new-invoice"]',
+        type: 'button',
+        text: 'New Invoice',
+        isDestructive: false,
+      },
+    ]);
+
+    const agent = createAgent();
+    await agent.run();
+
+    expect(openModalMock).toHaveBeenCalledWith(currentMockPage, '[data-testid="new-invoice"]');
+  });
+
+  it('calls closeModal when openModal returns true (modal was opened)', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="open-modal"]',
+        type: 'button',
+        text: 'Open',
+        isDestructive: false,
+      },
+    ]);
+    openModalMock.mockResolvedValue(true);
+
+    const agent = createAgent();
+    await agent.run();
+
+    expect(closeModalMock).toHaveBeenCalled();
+  });
+
+  it('creates a console-error finding when a console error fires during interaction', async () => {
+    navigateToSectionMock.mockImplementation(
+      async (_page: unknown, moduleId: string) => {
+        if (moduleId === 'dashboard') {
+          currentMockPage.emitConsole('error', 'Uncaught ReferenceError: foo');
+        }
+      },
+    );
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const consoleFinding = result.findings.find(f => f.consoleError !== undefined);
+    expect(consoleFinding).toBeDefined();
+    expect(consoleFinding!.severity).toBe('high');
+    expect(consoleFinding!.consoleError).toBe('Uncaught ReferenceError: foo');
+  });
+
+  it('calls switchPortal for configured portal passes', async () => {
+    const agent = createAgent();
+    await agent.run();
+
+    // Beta mode uses a single desktop breakpoint, so 1 portal pass
+    expect(switchPortalMock).toHaveBeenCalledTimes(1);
+    expect(switchPortalMock).toHaveBeenCalledWith(currentMockPage, 'client');
+  });
+
+  it('returns passed status when no errors are found', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.status).toBe('passed');
+    expect(result.findings).toHaveLength(0);
+  });
+
+  it('uses default breakpoint [1280] when breakpoints array is empty', async () => {
+    const configNoBreakpoints: ValidatedConfig = {
+      ...stubConfig,
+      breakpoints: [],
+      portals: [],
+    };
+    const agent = new BrowserCrawlerAgent(configNoBreakpoints, 'beta', '/tmp/test-run');
+    await agent.run();
+
+    // Should still call login once (for the single default-breakpoint pass)
+    expect(loginMock).toHaveBeenCalledTimes(1);
+  });
+
+  // -------------------------------------------------------------------------
+  // Beta: no environment configured
+  // -------------------------------------------------------------------------
+
+  it('handles empty environments gracefully via resolveEnvironment fallback', async () => {
+    const configNoEnv: ValidatedConfig = {
+      ...stubConfig,
+      environments: {},
+    };
+    // resolveEnvironment will throw or return a fallback — preFlight catches it
+    fetchMock.mockRejectedValue(new Error('no env'));
+    const agent = new BrowserCrawlerAgent(configNoEnv, 'beta', '/tmp/test-run');
+    const result = await agent.run();
+
+    // Either fails in preFlight or returns critical finding
+    expect(result.status === 'failed' || result.findings.some(f => f.severity === 'critical')).toBe(true);
+  });
+
+  // -------------------------------------------------------------------------
+  // Beta: no credentials configured
+  // -------------------------------------------------------------------------
+
+  it('creates critical finding when no credentials are configured', async () => {
+    const configNoCreds: ValidatedConfig = {
+      ...stubConfig,
+      auth: { loginUrl: 'http://localhost/login', credentials: {} },
+    };
+    const agent = new BrowserCrawlerAgent(configNoCreds, 'beta', '/tmp/test-run');
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    const finding = result.findings.find(f => f.id === '5-beta-no-credentials');
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('critical');
+  });
+
+  // -------------------------------------------------------------------------
+  // Beta: login failure with fallback severity
+  // -------------------------------------------------------------------------
+
+  it('creates a login finding when login throws in beta mode', async () => {
+    loginMock.mockRejectedValue(new Error('Login failed'));
+    // Beta mode needs page.goto for fallback anonymous crawling
+    (currentMockPage as unknown as Record<string, unknown>).goto = vi.fn().mockResolvedValue(undefined);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    // Login failure in beta produces a finding that mentions "Login failed"
+    const loginFinding = result.findings.find(f =>
+      f.description.includes('Login failed') || f.id.includes('login-failed'),
+    );
+    expect(loginFinding).toBeDefined();
+  });
+
+  // -------------------------------------------------------------------------
+  // Beta: navigation timeout in interaction pass
+  // -------------------------------------------------------------------------
+
+  it('creates a medium finding for navigation timeout (5s)', async () => {
+    navigateToSectionMock.mockImplementation(async () => {
+      return new Promise((_resolve, reject) =>
+        setTimeout(() => reject(new Error('Navigation timed out after 5s')), 10),
+      );
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const timeoutFinding = result.findings.find(f =>
+      f.description.includes('exceeded 5s timeout'),
+    );
+    expect(timeoutFinding).toBeDefined();
+    expect(timeoutFinding!.severity).toBe('medium');
+  });
+
+  it('creates a high finding for non-timeout navigation failure', async () => {
+    navigateToSectionMock.mockRejectedValue(new Error('Element not found'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const navFinding = result.findings.find(f =>
+      f.id.includes('beta-nav') && f.severity === 'high',
+    );
+    expect(navFinding).toBeDefined();
+  });
+
+  // -------------------------------------------------------------------------
+  // Beta: input/textarea/select element interaction via fillForm
+  // -------------------------------------------------------------------------
+
+  it('calls fillForm for input elements', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: 'input[name="email"]',
+        type: 'input',
+        text: '',
+        isDestructive: false,
+      },
+    ]);
+
+    const agent = createAgent();
+    await agent.run();
+
+    expect(fillFormMock).toHaveBeenCalled();
+  });
+
+  // -------------------------------------------------------------------------
+  // Beta: modal opened then closed via waitForTimeout
+  // -------------------------------------------------------------------------
+
+  it('waits after interaction when openModal returns false (no modal)', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="tab-1"]',
+        type: 'tab',
+        text: 'Tab 1',
+        isDestructive: false,
+      },
+    ]);
+    openModalMock.mockResolvedValue(false);
+
+    const agent = createAgent();
+    await agent.run();
+
+    expect(currentMockPage.waitForTimeout).toHaveBeenCalledWith(1000);
+  });
+
+  // -------------------------------------------------------------------------
+  // Beta: limits to first 5 modules
+  // -------------------------------------------------------------------------
+
+  it('limits interaction pass to first 5 modules in beta', async () => {
+    const manyModules = Array.from({ length: 8 }, (_, i) => ({
+      id: `mod-${i}`,
+      route: `/mod-${i}`,
+      sidebarIcon: true,
+    }));
+    const configManyModules: ValidatedConfig = {
+      ...stubConfig,
+      modules: manyModules,
+      portals: [],
+    };
+    const agent = new BrowserCrawlerAgent(configManyModules, 'beta', '/tmp/test-run');
+    await agent.run();
+
+    // Beta limits to 5 modules for the interaction pass
+    // navigateToSection is called once per module in the interaction pass
+    expect(navigateToSectionMock.mock.calls.length).toBeLessThanOrEqual(5);
+  });
+});