@avi770/testteam 1.2.0

package/agents/__tests__/13-performance-profiler.test.ts

@@ -0,0 +1,411 @@
+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: 'reports', route: '/reports', 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 fetch (used in preFlight isUrlReachable)
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// 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),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock Playwright page
+// ---------------------------------------------------------------------------
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  evaluate: ReturnType<typeof vi.fn>;
+}
+
+/** Default evaluate returns: [navEntries=[], paintEntries=[], lcpMs=0, heapSize=0] */
+function makeMockPage(evaluateResponses: unknown[] = []): MockPage {
+  let callIndex = 0;
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockImplementation(async () => {
+      const val = evaluateResponses[callIndex] ?? 0;
+      callIndex++;
+      return val;
+    }),
+  };
+}
+
+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),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Mock lighthouse (optional peer dep) — disabled by default
+// ---------------------------------------------------------------------------
+
+vi.mock('lighthouse', () => {
+  throw new Error('lighthouse not installed');
+});
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks
+// ---------------------------------------------------------------------------
+
+const { PerformanceProfilerAgent } = await import('../13-performance-profiler');
+
+function createAgent(phase: Phase = 'beta'): InstanceType<typeof PerformanceProfilerAgent> {
+  return new PerformanceProfilerAgent(stubConfig, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('PerformanceProfilerAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+    navigateToSectionMock.mockReset().mockResolvedValue(undefined);
+
+    // Default page: evaluate returns correct types per call order.
+    // Per module (2 modules): loadTime:number, paintEntries:array, lcpMs:number
+    // After all modules: heap:number
+    currentMockPage = makeMockPage([
+      // dashboard
+      0, [], 0,
+      // reports
+      0, [], 0,
+      // heap (memory check)
+      0,
+    ]);
+
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  it('has agentId 13 and agentName "Performance Profiler"', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(13);
+    expect(agent.agentName).toBe('Performance Profiler');
+  });
+
+  // -------------------------------------------------------------------------
+  // preFlight()
+  // -------------------------------------------------------------------------
+
+  describe('preFlight()', () => {
+    it('resolves gracefully when base URL is not reachable (fallback)', async () => {
+      fetchMock.mockRejectedValue(new Error('ECONNREFUSED'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // With resolveEnvironment the agent no longer throws on unreachable URLs.
+      expect(result.status).toBe('passed');
+    });
+
+    it('passes when base URL is reachable', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings.some((f) => f.description.includes('not reachable'))).toBe(false);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // execute() — LCP threshold
+  // -------------------------------------------------------------------------
+
+  describe('LCP > 2500ms creates a finding', () => {
+    it('creates a high-severity finding when LCP exceeds 2500ms', async () => {
+      let callIndex = 0;
+      currentMockPage.evaluate = vi.fn().mockImplementation(async () => {
+        // For each module: loadTime=0, paintEntries=[], lcpMs=3000
+        const responses = [
+          0,            // dashboard loadTime
+          [],           // dashboard paintEntries
+          3000,         // dashboard LCP — exceeds threshold
+          0,            // reports loadTime
+          [],           // reports paintEntries
+          3000,         // reports LCP — exceeds threshold
+          0,            // heap
+        ];
+        return responses[callIndex++] ?? 0;
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const lcpFindings = result.findings.filter((f) => f.id.includes('lcp'));
+      expect(lcpFindings.length).toBeGreaterThan(0);
+      expect(lcpFindings[0].severity).toBe('high');
+      expect(lcpFindings[0].description).toContain('3000');
+    });
+
+    it('does NOT create a finding when LCP is within threshold', async () => {
+      // All evaluate calls return 0 (lcpMs=0, well under 2500)
+      currentMockPage.evaluate = vi.fn().mockResolvedValue(0);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const lcpFindings = result.findings.filter((f) => f.id.includes('lcp'));
+      expect(lcpFindings).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // FCP threshold
+  // -------------------------------------------------------------------------
+
+  describe('FCP threshold', () => {
+    it('creates a medium-severity finding when FCP exceeds 1800ms', async () => {
+      let callIndex = 0;
+      currentMockPage.evaluate = vi.fn().mockImplementation(async () => {
+        const responses: unknown[] = [
+          0,   // dashboard loadTime
+          [{ name: 'first-contentful-paint', startTime: 2500 }], // FCP > 1800
+          0,   // dashboard LCP
+          0,   // reports loadTime
+          [{ name: 'first-contentful-paint', startTime: 2500 }],
+          0,   // reports LCP
+          0,   // heap
+        ];
+        return responses[callIndex++] ?? 0;
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const fcpFindings = result.findings.filter((f) => f.id.includes('fcp'));
+      expect(fcpFindings.length).toBeGreaterThan(0);
+      expect(fcpFindings[0].severity).toBe('medium');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Memory leak detection
+  // -------------------------------------------------------------------------
+
+  describe('memory leak detection', () => {
+    it('creates a high-severity finding when heap exceeds 100MB', async () => {
+      const OVER_100_MB = 110 * 1024 * 1024; // 110 MB
+      let callIndex = 0;
+      currentMockPage.evaluate = vi.fn().mockImplementation(async () => {
+        const responses = [
+          // dashboard
+          0, [], 0,
+          // reports
+          0, [], 0,
+          // heap check — over 100 MB
+          OVER_100_MB,
+        ];
+        return responses[callIndex++] ?? 0;
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const heapFinding = result.findings.find((f) => f.id === '13-memory-heap');
+      expect(heapFinding).toBeDefined();
+      expect(heapFinding!.severity).toBe('high');
+      expect(heapFinding!.description).toContain('memory leak');
+    });
+
+    it('does NOT flag memory when heap is within threshold', async () => {
+      const UNDER_100_MB = 50 * 1024 * 1024; // 50 MB
+      let callIndex = 0;
+      currentMockPage.evaluate = vi.fn().mockImplementation(async () => {
+        const responses = [
+          0, [], 0,
+          0, [], 0,
+          UNDER_100_MB,
+        ];
+        return responses[callIndex++] ?? 0;
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const heapFinding = result.findings.find((f) => f.id === '13-memory-heap');
+      expect(heapFinding).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Navigation failure
+  // -------------------------------------------------------------------------
+
+  describe('navigation failure', () => {
+    it('creates an infra-issue finding when module navigation throws', async () => {
+      navigateToSectionMock.mockRejectedValueOnce(new Error('Navigation timeout'));
+
+      const agent = createAgent();
+      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');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Passed with no violations
+  // -------------------------------------------------------------------------
+
+  it('returns passed status when all metrics are within thresholds', async () => {
+    // Each evaluate call must return the correct type:
+    // Per module: [loadTime: number, paintEntries: array, lcpMs: number]
+    // After all modules: [heap: number]
+    let callIdx = 0;
+    const responses: unknown[] = [
+      0,   // dashboard loadTime
+      [],  // dashboard paintEntries (array — fcpEntry will be undefined → fcpMs = 0)
+      0,   // dashboard lcpMs
+      0,   // reports loadTime
+      [],  // reports paintEntries
+      0,   // reports lcpMs
+      0,   // heap
+    ];
+
+    const freshPage: MockPage = {
+      close: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockImplementation(async () => responses[callIdx++] ?? 0),
+    };
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(freshPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.status).toBe('passed');
+  });
+
+  // -------------------------------------------------------------------------
+  // No credentials
+  // -------------------------------------------------------------------------
+
+  it('creates a critical finding when no credentials are configured', async () => {
+    const noCreds: ValidatedConfig = {
+      ...stubConfig,
+      auth: { loginUrl: 'http://localhost/login', credentials: {} },
+    };
+    const agent = new PerformanceProfilerAgent(noCreds, 'beta', '/tmp/test-run');
+    const result = await agent.run();
+
+    const finding = result.findings.find(f => f.id === '13-no-credentials');
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('critical');
+  });
+
+  // -------------------------------------------------------------------------
+  // Load time threshold exceeded
+  // -------------------------------------------------------------------------
+
+  describe('page load time threshold', () => {
+    it('creates a medium finding when loadTime exceeds 2x apiResponseTime', async () => {
+      let callIndex = 0;
+      currentMockPage.evaluate = vi.fn().mockImplementation(async () => {
+        // apiResponseTime is 2000, threshold is 4000 (2x)
+        const responses: unknown[] = [
+          5000, // dashboard loadTime — exceeds 4000
+          [],   // dashboard paintEntries
+          0,    // dashboard LCP
+          5000, // reports loadTime — exceeds 4000
+          [],   // reports paintEntries
+          0,    // reports LCP
+          0,    // heap
+        ];
+        return responses[callIndex++] ?? 0;
+      });
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const loadFindings = result.findings.filter(f => f.id.includes('load-time'));
+      expect(loadFindings.length).toBeGreaterThan(0);
+      expect(loadFindings[0].severity).toBe('medium');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Evidence logging
+  // -------------------------------------------------------------------------
+
+  it('adds log evidence for each module profiled', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const logEvidence = result.evidence.filter(e => e.type === 'log');
+    expect(logEvidence.length).toBeGreaterThanOrEqual(stubConfig.modules.length);
+  });
+
+  // -------------------------------------------------------------------------
+  // Evaluate catch paths (page.evaluate rejection)
+  // -------------------------------------------------------------------------
+
+  it('handles page.evaluate rejections gracefully', async () => {
+    currentMockPage.evaluate = vi.fn().mockRejectedValue(new Error('Page crashed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    // Should still complete without throwing
+    expect(result.status).toBe('passed');
+  });
+});