@avi770/testteam 1.2.0

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

@@ -0,0 +1,578 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+
+// ---------------------------------------------------------------------------
+// Stub config with UAT credentials
+// ---------------------------------------------------------------------------
+
+const stubConfig: ValidatedConfig = {
+  schemaVersion: 1,
+  name: 'test',
+  auth: {
+    loginUrl: 'http://localhost/login',
+    credentials: {
+      admin: { email: 'admin@test.com', password: 'secret' },
+      uat: { email: 'uat@test.com', password: 'uat-secret' },
+    },
+  },
+  modules: [
+    { id: 'dashboard', route: '/dashboard', sidebarIcon: true },
+    { id: 'invoices', route: '/invoices', sidebarIcon: true },
+  ],
+  environments: {
+    alpha: { baseUrl: 'http://localhost:3000', seed: false },
+    uat: { baseUrl: 'http://uat.localhost:3000', seed: false },
+  },
+  portals: [],
+  breakpoints: [1280],
+  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
+// ---------------------------------------------------------------------------
+
+const spawnMock = vi.fn();
+vi.mock('child_process', () => ({
+  execFile: (...args: unknown[]) => spawnMock(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock path (used for video/snapshot paths — let it pass through)
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Mock fetch (preFlight isUrlReachable + ApiClient)
+// ---------------------------------------------------------------------------
+
+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 ApiClient
+// ---------------------------------------------------------------------------
+
+const apiClientGetMock = vi.fn();
+const apiClientPutMock = vi.fn();
+const createAuthenticatedMock = vi.fn();
+
+vi.mock('../../helpers/api-client', () => ({
+  ApiClient: class MockApiClient {
+    static createAuthenticated(...args: unknown[]) {
+      return createAuthenticatedMock(...args);
+    }
+    get(...args: unknown[]) {
+      return apiClientGetMock(...args);
+    }
+    put(...args: unknown[]) {
+      return apiClientPutMock(...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>;
+  goto: 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),
+    goto: 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 createUatAgent(
+  configOverride: Partial<ValidatedConfig> = {},
+): InstanceType<typeof BrowserCrawlerAgent> {
+  return new BrowserCrawlerAgent(
+    { ...stubConfig, ...configOverride },
+    'uat',
+    '/tmp/test-run',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('BrowserCrawlerAgent — UAT 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);
+    apiClientGetMock.mockReset().mockResolvedValue({ status: 200, body: [] });
+    apiClientPutMock.mockReset().mockResolvedValue({ status: 200, body: {} });
+    createAuthenticatedMock.mockReset().mockResolvedValue({
+      get: apiClientGetMock,
+      put: apiClientPutMock,
+    });
+
+    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 });
+  });
+
+  // -------------------------------------------------------------------------
+  // Basic sanity
+  // -------------------------------------------------------------------------
+
+  it('does not throw "not implemented" for UAT phase', async () => {
+    const agent = createUatAgent();
+    const result = await agent.run();
+
+    expect(result.findings.some(f => f.description.includes('not implemented'))).toBe(false);
+  });
+
+  it('returns passed status when no errors occur and no destructive elements', async () => {
+    const agent = createUatAgent();
+    const result = await agent.run();
+
+    expect(result.status).toBe('passed');
+  });
+
+  // -------------------------------------------------------------------------
+  // UAT credentials
+  // -------------------------------------------------------------------------
+
+  it('uses UAT credentials (uat entry) when available', async () => {
+    const agent = createUatAgent();
+    await agent.run();
+
+    // login is called with UAT credentials
+    expect(loginMock).toHaveBeenCalledWith(
+      currentMockPage,
+      { email: 'uat@test.com', password: 'uat-secret' },
+      expect.any(String),
+    );
+  });
+
+  it('falls back to admin credentials when uat entry is absent', async () => {
+    const configNoUat: Partial<ValidatedConfig> = {
+      auth: {
+        loginUrl: 'http://localhost/login',
+        credentials: {
+          admin: { email: 'admin@test.com', password: 'secret' },
+        },
+      },
+    };
+    const agent = createUatAgent(configNoUat);
+    await agent.run();
+
+    expect(loginMock).toHaveBeenCalledWith(
+      currentMockPage,
+      { email: 'admin@test.com', password: 'secret' },
+      expect.any(String),
+    );
+  });
+
+  // -------------------------------------------------------------------------
+  // Video evidence
+  // -------------------------------------------------------------------------
+
+  it('records a video evidence item', async () => {
+    const agent = createUatAgent();
+    const result = await agent.run();
+
+    const videoEvidence = result.evidence.filter(e => e.type === 'video');
+    expect(videoEvidence.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // -------------------------------------------------------------------------
+  // Edge cases
+  // -------------------------------------------------------------------------
+
+  it('calls fillForm with boundary inputs (empty, unicode, emoji, max-length)', async () => {
+    const agent = createUatAgent();
+    await agent.run();
+
+    const callValues = fillFormMock.mock.calls.map((c: unknown[]) => c[2]) as Array<Record<string, string> | undefined>;
+    expect(callValues).toContainEqual({ value: '' });
+    expect(callValues).toContainEqual({ value: '日本語テキスト' });
+    expect(callValues).toContainEqual({ value: '🎉🔥💡' });
+    expect(callValues.some((v) => v && typeof v === 'object' && 'value' in v && (v as Record<string, string>).value.length >= 1_000)).toBe(true);
+  });
+
+  // -------------------------------------------------------------------------
+  // Destructive snapshot / restore pattern
+  // -------------------------------------------------------------------------
+
+  it('takes a snapshot via API before executing a destructive action', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="delete-btn"]',
+        type: 'button',
+        text: 'Delete',
+        isDestructive: true,
+      },
+    ]);
+
+    const agent = createUatAgent();
+    await agent.run();
+
+    // apiClientGet should have been called with the module resource path
+    expect(apiClientGetMock).toHaveBeenCalledWith(expect.stringMatching(/^\/api\//));
+  });
+
+  it('adds a snapshot evidence item before destructive action', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="delete-btn"]',
+        type: 'button',
+        text: 'Delete',
+        isDestructive: true,
+      },
+    ]);
+
+    const agent = createUatAgent();
+    const result = await agent.run();
+
+    const snapshotEvidence = result.evidence.filter(e => e.type === 'snapshot');
+    expect(snapshotEvidence.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('restores entity via API after destructive action', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="delete-btn"]',
+        type: 'button',
+        text: 'Delete',
+        isDestructive: true,
+      },
+    ]);
+    apiClientGetMock.mockResolvedValue({ status: 200, body: { id: 'entity-1' } });
+
+    const agent = createUatAgent();
+    await agent.run();
+
+    expect(apiClientPutMock).toHaveBeenCalledWith(
+      expect.stringMatching(/restore/),
+      expect.objectContaining({ snapshot: expect.anything() }),
+    );
+  });
+
+  // -------------------------------------------------------------------------
+  // Restore failure → critical finding + stop destructive tests
+  // -------------------------------------------------------------------------
+
+  it('creates a critical finding when restore fails', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="delete-btn"]',
+        type: 'button',
+        text: 'Delete',
+        isDestructive: true,
+      },
+    ]);
+    apiClientGetMock.mockResolvedValue({ status: 200, body: { id: 'entity-1' } });
+    apiClientPutMock.mockRejectedValue(new Error('Restore endpoint unavailable'));
+
+    const agent = createUatAgent();
+    const result = await agent.run();
+
+    const criticalFinding = result.findings.find(
+      f => f.severity === 'critical' && f.description.includes('Restore failed'),
+    );
+    expect(criticalFinding).toBeDefined();
+  });
+
+  it('stops destructive tests after a restore failure', async () => {
+    const modules = [
+      { id: 'dashboard', route: '/dashboard', sidebarIcon: true },
+      { id: 'invoices', route: '/invoices', sidebarIcon: true },
+    ];
+
+    // Both modules have destructive elements
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="delete-btn"]',
+        type: 'button',
+        text: 'Delete',
+        isDestructive: true,
+      },
+    ]);
+    apiClientGetMock.mockResolvedValue({ status: 200, body: { id: 'entity-1' } });
+    // Restore always fails
+    apiClientPutMock.mockRejectedValue(new Error('Restore endpoint unavailable'));
+
+    const agent = createUatAgent({ modules });
+    await agent.run();
+
+    // After the first module's restore fails, stopDestructive=true;
+    // apiClientGet should be called only once for destructive pass (first module only)
+    const destructiveGetCalls = apiClientGetMock.mock.calls.filter(
+      (c: unknown[]) => typeof c[0] === 'string' && (c[0] as string).startsWith('/api/'),
+    );
+    expect(destructiveGetCalls.length).toBe(1);
+  });
+
+  // -------------------------------------------------------------------------
+  // Missing env / credentials
+  // -------------------------------------------------------------------------
+
+  it('creates critical finding when no environment is configured', async () => {
+    const agent = createUatAgent({ environments: {} });
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings.some(f => f.severity === 'critical')).toBe(true);
+  });
+
+  it('creates critical finding when no credentials are configured', async () => {
+    const agent = createUatAgent({
+      auth: { loginUrl: 'http://localhost/login', credentials: {} },
+    });
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings.some(f => f.severity === 'critical')).toBe(true);
+  });
+
+  // -------------------------------------------------------------------------
+  // UAT: login failure produces finding with fallback severity
+  // -------------------------------------------------------------------------
+
+  it('creates a login failure finding when login throws', async () => {
+    loginMock.mockRejectedValue(new Error('Auth service down'));
+
+    const agent = createUatAgent();
+    const result = await agent.run();
+
+    const loginFinding = result.findings.find(f => f.id === '5-uat-login-failed');
+    expect(loginFinding).toBeDefined();
+    expect(loginFinding!.description).toContain('Auth service down');
+  });
+
+  // -------------------------------------------------------------------------
+  // UAT: edge-case console errors
+  // -------------------------------------------------------------------------
+
+  it('creates a finding for console errors during edge-case pass', async () => {
+    navigateToSectionMock.mockImplementation(
+      async (_page: unknown, moduleId: string) => {
+        if (moduleId === 'dashboard') {
+          currentMockPage.emitConsole('error', 'TypeError: Cannot read properties of null');
+        }
+      },
+    );
+
+    const agent = createUatAgent();
+    const result = await agent.run();
+
+    const edgeFinding = result.findings.find(f =>
+      f.id.includes('uat-edge') && f.consoleError !== undefined,
+    );
+    expect(edgeFinding).toBeDefined();
+    expect(edgeFinding!.severity).toBe('medium');
+  });
+
+  // -------------------------------------------------------------------------
+  // UAT: edge-case navigation failure is silently skipped
+  // -------------------------------------------------------------------------
+
+  it('skips modules where navigation fails during edge-case pass', async () => {
+    // Only fail edge-case navigation by failing the second time navigation is called per module
+    let navCallCount = 0;
+    navigateToSectionMock.mockImplementation(async () => {
+      navCallCount++;
+      // Fail on every call to force edge-case skip path
+      if (navCallCount > 2) throw new Error('Nav fail');
+    });
+
+    const agent = createUatAgent();
+    const result = await agent.run();
+
+    // Should still complete without crashing
+    expect(result.status).toBe('passed');
+  });
+
+  // -------------------------------------------------------------------------
+  // UAT: destructive action error creates a test-bug finding
+  // -------------------------------------------------------------------------
+
+  it('creates a test-bug finding when destructive action throws', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="archive-btn"]',
+        type: 'button',
+        text: 'Archive',
+        isDestructive: true,
+      },
+    ]);
+    openModalMock.mockRejectedValue(new Error('Button detached'));
+    apiClientGetMock.mockResolvedValue({ status: 200, body: { id: 'e1' } });
+
+    const agent = createUatAgent();
+    const result = await agent.run();
+
+    const actionFinding = result.findings.find(f =>
+      f.type === 'test-bug' && f.description.includes('Button detached'),
+    );
+    expect(actionFinding).toBeDefined();
+    expect(actionFinding!.severity).toBe('medium');
+  });
+
+  // -------------------------------------------------------------------------
+  // UAT: destructive action with link element type
+  // -------------------------------------------------------------------------
+
+  it('handles link-type destructive elements via openModal', async () => {
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: 'a[data-testid="delete-link"]',
+        type: 'link',
+        text: 'Delete',
+        isDestructive: true,
+      },
+    ]);
+    openModalMock.mockResolvedValue(true);
+    apiClientGetMock.mockResolvedValue({ status: 200, body: { id: 'e1' } });
+
+    const agent = createUatAgent();
+    await agent.run();
+
+    expect(openModalMock).toHaveBeenCalled();
+    expect(closeModalMock).toHaveBeenCalledWith(currentMockPage, 'escape');
+  });
+
+  // -------------------------------------------------------------------------
+  // UAT: no apiClient available — snapshot is null
+  // -------------------------------------------------------------------------
+
+  it('handles null apiClient gracefully for destructive pass', async () => {
+    createAuthenticatedMock.mockRejectedValue(new Error('No API'));
+    discoverInteractiveElementsMock.mockResolvedValue([
+      {
+        selector: '[data-testid="del"]',
+        type: 'button',
+        text: 'Del',
+        isDestructive: true,
+      },
+    ]);
+
+    const agent = createUatAgent();
+    const result = await agent.run();
+
+    // Should not crash, and should not attempt restore (no apiClient)
+    expect(apiClientPutMock).not.toHaveBeenCalled();
+    expect(result.status).toBe('passed');
+  });
+});