@avi770/testteam 1.2.0

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

@@ -0,0 +1,412 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config with release environment
+// ---------------------------------------------------------------------------
+
+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 },
+    release: { baseUrl: 'https://app.example.com', 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
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// Mock helpers (needed for preFlight's resolveEnvironment + isUrlReachable)
+// ---------------------------------------------------------------------------
+
+vi.mock('../../helpers/navigation', () => ({
+  login: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../../helpers/screenshot', () => ({
+  captureScreenshot: vi.fn().mockResolvedValue('/tmp/test-run/screenshot.png'),
+}));
+
+vi.mock('../../helpers/element-discovery', () => ({
+  discoverInteractiveElements: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock('../../helpers/form-filler', () => ({
+  fillForm: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../../helpers/modal-handler', () => ({
+  openModal: vi.fn().mockResolvedValue(false),
+  closeModal: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../../helpers/api-client', () => ({
+  ApiClient: { createAuthenticated: vi.fn().mockResolvedValue({}) },
+}));
+
+// Mock playwright (not used in release mode but imported at module level)
+vi.mock('playwright', () => ({
+  chromium: {
+    launch: vi.fn().mockImplementation(async () => ({
+      newPage: vi.fn().mockResolvedValue({ close: vi.fn() }),
+      close: vi.fn(),
+    })),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks
+// ---------------------------------------------------------------------------
+
+const { BrowserCrawlerAgent } = await import('../05-browser-crawler');
+
+function createAgent(phase: Phase = 'release', config: ValidatedConfig = stubConfig): InstanceType<typeof BrowserCrawlerAgent> {
+  return new BrowserCrawlerAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('BrowserCrawlerAgent — release mode', () => {
+  beforeEach(() => {
+    spawnMock.mockReset();
+    fetchMock.mockReset();
+
+    // preFlight: 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: preFlight isUrlReachable (HEAD) + release mode fetch both succeed
+    fetchMock.mockImplementation(async (url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') {
+        // preFlight reachability check
+        return { ok: true, status: 200 };
+      }
+      // release mode GET requests
+      return {
+        ok: true,
+        status: 200,
+        text: async () => '<html><head><title>App</title><meta charset="utf-8"></head><body></body></html>',
+      };
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Happy path
+  // -----------------------------------------------------------------------
+
+  it('returns no findings when base URL and all module routes return 200 with valid HTML', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.status).toBe('passed');
+    expect(result.findings).toHaveLength(0);
+  });
+
+  // -----------------------------------------------------------------------
+  // No environment configured
+  // -----------------------------------------------------------------------
+
+  it('returns critical finding when no environment is configured', async () => {
+    const noEnvConfig: ValidatedConfig = {
+      ...stubConfig,
+      environments: {},
+    };
+
+    // preFlight resolveEnvironment will also fail, causing a thrown error
+    const agent = createAgent('release', noEnvConfig);
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+  });
+
+  // -----------------------------------------------------------------------
+  // Base URL returns non-ok status
+  // -----------------------------------------------------------------------
+
+  it('creates critical finding when base URL returns non-OK HTTP status', async () => {
+    fetchMock.mockImplementation(async (_url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') return { ok: true, status: 200 };
+      return { ok: false, status: 503, text: async () => '' };
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const finding = result.findings.find((f) => f.id === '5-release-base-status');
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('critical');
+    expect(finding!.description).toContain('503');
+  });
+
+  // -----------------------------------------------------------------------
+  // Base URL unreachable
+  // -----------------------------------------------------------------------
+
+  it('creates critical finding and returns early when base URL fetch throws', async () => {
+    let callCount = 0;
+    fetchMock.mockImplementation(async (_url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') return { ok: true, status: 200 };
+      callCount++;
+      if (callCount === 1) throw new Error('Network error');
+      return { ok: true, status: 200, text: async () => '<html></html>' };
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const finding = result.findings.find((f) => f.id === '5-release-base-unreachable');
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('critical');
+    expect(finding!.description).toContain('unreachable');
+    // Should return early -- no route findings
+    const routeFindings = result.findings.filter((f) => f.id.includes('release-route'));
+    expect(routeFindings).toHaveLength(0);
+  });
+
+  // -----------------------------------------------------------------------
+  // HTML markers missing
+  // -----------------------------------------------------------------------
+
+  it('creates high finding when HTML is missing all expected markers', async () => {
+    fetchMock.mockImplementation(async (_url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') return { ok: true, status: 200 };
+      return {
+        ok: true,
+        status: 200,
+        text: async () => 'just plain text with no html tags at all',
+      };
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const markerFinding = result.findings.find((f) => f.id === '5-release-base-html-markers');
+    expect(markerFinding).toBeDefined();
+    expect(markerFinding!.severity).toBe('high');
+    expect(markerFinding!.description).toContain('missing expected markers');
+  });
+
+  it('does NOT create marker finding when HTML has a <title> tag', async () => {
+    fetchMock.mockImplementation(async (_url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') return { ok: true, status: 200 };
+      return {
+        ok: true,
+        status: 200,
+        text: async () => '<title>My App</title>',
+      };
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const markerFinding = result.findings.find((f) => f.id === '5-release-base-html-markers');
+    expect(markerFinding).toBeUndefined();
+  });
+
+  it('does NOT create marker finding when HTML has a <meta charset> tag', async () => {
+    fetchMock.mockImplementation(async (_url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') return { ok: true, status: 200 };
+      return {
+        ok: true,
+        status: 200,
+        text: async () => '<meta charset="utf-8">',
+      };
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const markerFinding = result.findings.find((f) => f.id === '5-release-base-html-markers');
+    expect(markerFinding).toBeUndefined();
+  });
+
+  it('does NOT create marker finding when HTML has an <html> tag', async () => {
+    fetchMock.mockImplementation(async (_url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') return { ok: true, status: 200 };
+      return {
+        ok: true,
+        status: 200,
+        text: async () => '<html lang="en"><body>content</body></html>',
+      };
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const markerFinding = result.findings.find((f) => f.id === '5-release-base-html-markers');
+    expect(markerFinding).toBeUndefined();
+  });
+
+  // -----------------------------------------------------------------------
+  // Module route checks
+  // -----------------------------------------------------------------------
+
+  it('creates a finding for each module route that returns 4xx or 5xx', async () => {
+    let fetchCount = 0;
+    fetchMock.mockImplementation(async (_url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') return { ok: true, status: 200 };
+      fetchCount++;
+      if (fetchCount === 1) {
+        // base URL
+        return {
+          ok: true,
+          status: 200,
+          text: async () => '<html><title>App</title></html>',
+        };
+      }
+      if (fetchCount === 2) {
+        // dashboard route -- 404
+        return { ok: false, status: 404 };
+      }
+      // invoices route -- 500
+      return { ok: false, status: 500 };
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const dashboardFinding = result.findings.find((f) => f.id === '5-release-route-dashboard');
+    expect(dashboardFinding).toBeDefined();
+    expect(dashboardFinding!.severity).toBe('high'); // 4xx = high
+
+    const invoicesFinding = result.findings.find((f) => f.id === '5-release-route-invoices');
+    expect(invoicesFinding).toBeDefined();
+    expect(invoicesFinding!.severity).toBe('critical'); // 5xx = critical
+  });
+
+  it('creates a finding when a module route fetch throws', async () => {
+    let fetchCount = 0;
+    fetchMock.mockImplementation(async (_url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') return { ok: true, status: 200 };
+      fetchCount++;
+      if (fetchCount === 1) {
+        return {
+          ok: true,
+          status: 200,
+          text: async () => '<html><title>App</title></html>',
+        };
+      }
+      throw new Error('DNS resolution failed');
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const routeFindings = result.findings.filter((f) => f.id.includes('release-route'));
+    expect(routeFindings.length).toBeGreaterThanOrEqual(1);
+    expect(routeFindings[0].severity).toBe('critical');
+    expect(routeFindings[0].description).toContain('unreachable');
+  });
+
+  it('handles absolute route URLs (starting with http)', async () => {
+    const configWithAbsoluteRoutes: ValidatedConfig = {
+      ...stubConfig,
+      modules: [
+        { id: 'ext', route: 'https://external.example.com/app', sidebarIcon: true },
+      ],
+    };
+
+    fetchMock.mockImplementation(async (_url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') return { ok: true, status: 200 };
+      return {
+        ok: true,
+        status: 200,
+        text: async () => '<html><title>App</title></html>',
+      };
+    });
+
+    const agent = createAgent('release', configWithAbsoluteRoutes);
+    const result = await agent.run();
+
+    expect(result.findings).toHaveLength(0);
+  });
+
+  // -----------------------------------------------------------------------
+  // Environment fallback priority
+  // -----------------------------------------------------------------------
+
+  it('falls back through environment priority: release > uat > beta > alpha', async () => {
+    const alphaOnlyConfig: ValidatedConfig = {
+      ...stubConfig,
+      environments: {
+        alpha: { baseUrl: 'http://alpha.example.com', seed: false },
+      },
+    };
+
+    fetchMock.mockImplementation(async (_url: string | URL | Request, opts?: RequestInit) => {
+      const method = opts?.method ?? 'GET';
+      if (method === 'HEAD') return { ok: true, status: 200 };
+      return {
+        ok: true,
+        status: 200,
+        text: async () => '<html><title>App</title></html>',
+      };
+    });
+
+    const agent = createAgent('release', alphaOnlyConfig);
+    const result = await agent.run();
+
+    // Should succeed using alpha env as fallback
+    expect(result.status).toBe('passed');
+  });
+});