@avi770/testteam 1.2.0

package/agents/__tests__/12-ux-inspector-extended.test.ts

@@ -0,0 +1,465 @@
+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: 'clients', route: '/clients', sidebarIcon: true },
+  ],
+  environments: {
+    beta: { baseUrl: 'http://localhost:3000', seed: false },
+  },
+  portals: [],
+  breakpoints: [],
+  integrations: [],
+  workers: [],
+  workflows: [],
+  accuracy: { enabled: true, 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 node:fs/promises
+// ---------------------------------------------------------------------------
+
+const statMock = vi.fn();
+const readdirMock = vi.fn();
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs/promises')>();
+  return {
+    ...actual,
+    stat: (...args: unknown[]) => statMock(...args),
+    readdir: (...args: unknown[]) => readdirMock(...args),
+  };
+});
+
+// ---------------------------------------------------------------------------
+// Mock navigation helpers
+// ---------------------------------------------------------------------------
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+const navigateToSectionMock = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  navigateToSection: (...args: unknown[]) => navigateToSectionMock(...args),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock screenshot helper
+// ---------------------------------------------------------------------------
+
+const captureScreenshotMock = vi.fn().mockResolvedValue('/tmp/test-run/screenshot.png');
+
+vi.mock('../../helpers/screenshot', () => ({
+  captureScreenshot: (...args: unknown[]) => captureScreenshotMock(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock Playwright page
+// ---------------------------------------------------------------------------
+
+type RouteHandler = (route: { fulfill: (opts: Record<string, unknown>) => Promise<void> }) => void | Promise<void>;
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  goto: ReturnType<typeof vi.fn>;
+  reload: ReturnType<typeof vi.fn>;
+  isVisible: ReturnType<typeof vi.fn>;
+  evaluate: ReturnType<typeof vi.fn>;
+  route: ReturnType<typeof vi.fn>;
+  unroute: ReturnType<typeof vi.fn>;
+  waitForTimeout: ReturnType<typeof vi.fn>;
+  locator: ReturnType<typeof vi.fn>;
+  _routeHandlers: Map<string, RouteHandler>;
+}
+
+function makeMockPage(overrides: Partial<MockPage> = {}): MockPage {
+  const routeHandlers = new Map<string, RouteHandler>();
+
+  const page: MockPage = {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    reload: vi.fn().mockResolvedValue(undefined),
+    isVisible: vi.fn().mockResolvedValue(false),
+    evaluate: vi.fn().mockResolvedValue(false),
+    route: vi.fn().mockImplementation(async (pattern: string, handler: RouteHandler) => {
+      routeHandlers.set(pattern, handler);
+    }),
+    unroute: vi.fn().mockResolvedValue(undefined),
+    waitForTimeout: vi.fn().mockResolvedValue(undefined),
+    locator: vi.fn().mockReturnValue({
+      first: () => ({ isVisible: vi.fn().mockResolvedValue(false) }),
+    }),
+    _routeHandlers: routeHandlers,
+    ...overrides,
+  };
+
+  return page;
+}
+
+let currentMockPage: MockPage;
+let mockBrowser: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', () => ({
+  chromium: {
+    launch: vi.fn().mockImplementation(async () => mockBrowser),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks
+// ---------------------------------------------------------------------------
+
+const { UxInspectorAgent } = await import('../12-ux-inspector');
+
+function createAgent(phase: Phase = 'beta'): InstanceType<typeof UxInspectorAgent> {
+  return new UxInspectorAgent(stubConfig, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('UxInspectorAgent — extended coverage', () => {
+  beforeEach(() => {
+    statMock.mockReset().mockResolvedValue({});
+    readdirMock.mockReset().mockResolvedValue(['smoke-dashboard.png', 'smoke-clients.png']);
+    loginMock.mockReset().mockResolvedValue(undefined);
+    navigateToSectionMock.mockReset().mockResolvedValue(undefined);
+    captureScreenshotMock.mockReset().mockResolvedValue('/tmp/test-run/screenshot.png');
+
+    currentMockPage = makeMockPage();
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  // -------------------------------------------------------------------------
+  // No environment configured
+  // -------------------------------------------------------------------------
+
+  describe('no environment', () => {
+    it('returns critical finding when no environment is configured', async () => {
+      const noEnvConfig: ValidatedConfig = {
+        ...stubConfig,
+        environments: {},
+      };
+      const agent = new UxInspectorAgent(noEnvConfig, 'beta', '/tmp/test-run');
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id === '12-no-env');
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('critical');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // No credentials
+  // -------------------------------------------------------------------------
+
+  describe('no credentials', () => {
+    it('returns critical finding when no credentials configured', async () => {
+      const noCredConfig: ValidatedConfig = {
+        ...stubConfig,
+        auth: { loginUrl: '/login', credentials: {} },
+      };
+      const agent = new UxInspectorAgent(noCredConfig, 'beta', '/tmp/test-run');
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id === '12-no-credentials');
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('critical');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Loading states stuck
+  // -------------------------------------------------------------------------
+
+  describe('loading states', () => {
+    it('creates finding when a loading spinner is stuck', async () => {
+      currentMockPage.isVisible = vi.fn().mockImplementation((selector: string) => {
+        if (selector === '[data-testid="loading-spinner"]') return Promise.resolve(true);
+        return Promise.resolve(false);
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const loadingFinding = result.findings.find((f) => f.id.includes('loading-stuck'));
+      expect(loadingFinding).toBeDefined();
+      expect(loadingFinding!.type).toBe('code-bug-cosmetic');
+      expect(loadingFinding!.severity).toBe('medium');
+    });
+
+    it('creates finding when skeleton loader is stuck', async () => {
+      currentMockPage.isVisible = vi.fn().mockImplementation((selector: string) => {
+        if (selector === '.skeleton') return Promise.resolve(true);
+        return Promise.resolve(false);
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const loadingFinding = result.findings.find((f) => f.id.includes('loading-stuck'));
+      expect(loadingFinding).toBeDefined();
+    });
+
+    it('does not create finding when no loading indicators visible', async () => {
+      currentMockPage.isVisible = vi.fn().mockResolvedValue(false);
+      currentMockPage.evaluate = vi.fn().mockResolvedValue(true); // has data rows
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const loadingFindings = result.findings.filter((f) => f.id.includes('loading-stuck'));
+      // May still get error-boundary findings, but no loading-stuck
+      expect(loadingFindings).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Form validation checks
+  // -------------------------------------------------------------------------
+
+  describe('form validation', () => {
+    it('creates finding when form has required fields but no validation messages on submit', async () => {
+      currentMockPage.isVisible = vi.fn().mockImplementation((selector: string) => {
+        if (selector === 'form') return Promise.resolve(true);
+        return Promise.resolve(false);
+      });
+      currentMockPage.evaluate = vi.fn().mockImplementation((fn: unknown) => {
+        // First evaluate call: check for data rows (in checkEmptyStates)
+        // Second evaluate call: check for required fields
+        if (typeof fn === 'function') {
+          return Promise.resolve(true); // has required fields or data rows
+        }
+        return Promise.resolve(true);
+      });
+      const clickMock = vi.fn().mockResolvedValue(undefined);
+      currentMockPage.locator = vi.fn().mockReturnValue({
+        first: () => ({
+          isVisible: vi.fn().mockResolvedValue(true),
+          click: clickMock,
+        }),
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const validationFinding = result.findings.find((f) => f.id.includes('form-validation'));
+      expect(validationFinding).toBeDefined();
+      expect(validationFinding!.severity).toBe('medium');
+    });
+
+    it('does NOT create finding when form validation messages are shown', async () => {
+      currentMockPage.isVisible = vi.fn().mockImplementation((selector: string) => {
+        if (selector === 'form') return Promise.resolve(true);
+        if (selector === '[data-testid="field-error"]') return Promise.resolve(true);
+        // Error boundary selectors
+        if (selector === '[role="alert"]') return Promise.resolve(true);
+        return Promise.resolve(false);
+      });
+      currentMockPage.evaluate = vi.fn().mockResolvedValue(true);
+      currentMockPage.locator = vi.fn().mockReturnValue({
+        first: () => ({
+          isVisible: vi.fn().mockResolvedValue(true),
+          click: vi.fn().mockResolvedValue(undefined),
+        }),
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const validationFindings = result.findings.filter((f) => f.id.includes('form-validation'));
+      expect(validationFindings).toHaveLength(0);
+    });
+
+    it('skips form validation when no form is visible', async () => {
+      currentMockPage.isVisible = vi.fn().mockImplementation((selector: string) => {
+        if (selector === 'form') return Promise.resolve(false);
+        return Promise.resolve(false);
+      });
+      currentMockPage.evaluate = vi.fn().mockResolvedValue(true);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const validationFindings = result.findings.filter((f) => f.id.includes('form-validation'));
+      expect(validationFindings).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Truncated text detection
+  // -------------------------------------------------------------------------
+
+  describe('truncated text', () => {
+    it('creates finding when elements with truncated text are detected', async () => {
+      // evaluate is called multiple times:
+      //   - checkEmptyStates (once per module) — should return true (data present)
+      //   - checkTruncatedText (once per module) — should return count > 0
+      //   - possibly checkFormValidation
+      // We use a counter to know which call is which: for 2 modules, calls 1-2 are empty-state,
+      // calls 3-4 (if reached) are truncated text.
+      let evalCallCount = 0;
+      currentMockPage.evaluate = vi.fn().mockImplementation(() => {
+        evalCallCount++;
+        // Calls for checkEmptyStates (2 modules): return true (data present)
+        // Calls for checkFormValidation: also calls evaluate
+        // Calls for checkTruncatedText: return count
+        // Since evaluate is used by checkEmptyStates, checkFormValidation AND checkTruncatedText
+        // we just return 3 for all — truthy means data present, and 3 means truncated elements
+        return Promise.resolve(3);
+      });
+      currentMockPage.isVisible = vi.fn().mockImplementation((selector: string) => {
+        // Make error boundary found to avoid those findings
+        if (selector === '[role="alert"]') return Promise.resolve(true);
+        return Promise.resolve(false);
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const truncatedFinding = result.findings.find((f) => f.id.includes('truncated-text'));
+      expect(truncatedFinding).toBeDefined();
+      expect(truncatedFinding!.severity).toBe('low');
+      expect(truncatedFinding!.description).toContain('element(s)');
+    });
+
+    it('does NOT create finding when no truncated text is detected', async () => {
+      currentMockPage.evaluate = vi.fn().mockResolvedValue(0);
+      currentMockPage.isVisible = vi.fn().mockImplementation((selector: string) => {
+        if (selector === '[role="alert"]') return Promise.resolve(true);
+        return Promise.resolve(false);
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const truncatedFindings = result.findings.filter((f) => f.id.includes('truncated-text'));
+      expect(truncatedFindings).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Browser cleanup on error
+  // -------------------------------------------------------------------------
+
+  describe('browser cleanup', () => {
+    it('closes browser and page even when login throws', async () => {
+      loginMock.mockRejectedValue(new Error('Login failed'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('failed');
+      expect(currentMockPage.close).toHaveBeenCalled();
+      expect(mockBrowser.close).toHaveBeenCalled();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Screenshot evidence is captured
+  // -------------------------------------------------------------------------
+
+  describe('evidence collection', () => {
+    it('captures screenshots for loading-stuck findings', async () => {
+      currentMockPage.isVisible = vi.fn().mockImplementation((selector: string) => {
+        if (selector === '[aria-label="Loading"]') return Promise.resolve(true);
+        return Promise.resolve(false);
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const screenshotEvidence = result.evidence.filter((e) => e.type === 'screenshot');
+      expect(screenshotEvidence.length).toBeGreaterThan(0);
+    });
+
+    it('captures screenshots for error-boundary findings', async () => {
+      currentMockPage.isVisible = vi.fn().mockResolvedValue(false);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const screenshotEvidence = result.evidence.filter((e) => e.type === 'screenshot');
+      expect(screenshotEvidence.length).toBeGreaterThan(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Environment fallback
+  // -------------------------------------------------------------------------
+
+  describe('environment fallback', () => {
+    it('uses alpha environment when beta is not configured', async () => {
+      const alphaOnlyConfig: ValidatedConfig = {
+        ...stubConfig,
+        environments: {
+          alpha: { baseUrl: 'http://alpha.localhost:3000', seed: false },
+        },
+      };
+
+      const agent = new UxInspectorAgent(alphaOnlyConfig, 'beta', '/tmp/test-run');
+      const result = await agent.run();
+
+      // Should not produce a no-env finding
+      const noEnvFinding = result.findings.find((f) => f.id === '12-no-env');
+      expect(noEnvFinding).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // isVisible throws (error resilience)
+  // -------------------------------------------------------------------------
+
+  describe('error resilience', () => {
+    it('handles isVisible throwing gracefully in loading state check', async () => {
+      currentMockPage.isVisible = vi.fn().mockRejectedValue(new Error('Detached'));
+      currentMockPage.evaluate = vi.fn().mockResolvedValue(true);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // Should not crash; the checks are best-effort
+      expect(result.status).toBeDefined();
+    });
+
+    it('handles evaluate throwing gracefully in empty state check', async () => {
+      currentMockPage.evaluate = vi.fn().mockRejectedValue(new Error('Execution context was destroyed'));
+      currentMockPage.isVisible = vi.fn().mockResolvedValue(false);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBeDefined();
+    });
+  });
+});