@avi770/testteam 1.2.0 → 2.0.0

package/agents/__tests__/27-search-filter-tester.test.ts

@@ -0,0 +1,311 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config helpers
+// ---------------------------------------------------------------------------
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    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: 'tasks', route: '/tasks', sidebarIcon: true },
+    ],
+    environments: {
+      alpha: { baseUrl: 'http://localhost:3000', 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' },
+    agentClassification: { blocking: [], advisory: [27] },
+    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>(),
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Mock fetch
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// Mock helpers
+// ---------------------------------------------------------------------------
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock Playwright
+// ---------------------------------------------------------------------------
+
+interface MockLocator {
+  count: ReturnType<typeof vi.fn>;
+  first: ReturnType<typeof vi.fn>;
+  nth: ReturnType<typeof vi.fn>;
+  click: ReturnType<typeof vi.fn>;
+  fill: ReturnType<typeof vi.fn>;
+  evaluate: ReturnType<typeof vi.fn>;
+  selectOption: ReturnType<typeof vi.fn>;
+  locator: ReturnType<typeof vi.fn>;
+  getAttribute: ReturnType<typeof vi.fn>;
+}
+
+function makeMockLocator(countVal = 0): MockLocator {
+  const locator: MockLocator = {
+    count: vi.fn().mockResolvedValue(countVal),
+    first: vi.fn(),
+    nth: vi.fn(),
+    click: vi.fn().mockResolvedValue(undefined),
+    fill: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue('div'),
+    selectOption: vi.fn().mockResolvedValue(undefined),
+    locator: vi.fn().mockReturnValue({ count: vi.fn().mockResolvedValue(0), nth: vi.fn(), getAttribute: vi.fn() }),
+    getAttribute: vi.fn().mockResolvedValue(null),
+  };
+  locator.first.mockReturnValue(locator);
+  locator.nth.mockReturnValue(locator);
+  return locator;
+}
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  goto: ReturnType<typeof vi.fn>;
+  locator: ReturnType<typeof vi.fn>;
+  waitForTimeout: ReturnType<typeof vi.fn>;
+}
+
+function makeMockPage(): MockPage {
+  const defaultLocator = makeMockLocator(0);
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    locator: vi.fn().mockReturnValue(defaultLocator),
+    waitForTimeout: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+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 { SearchFilterTesterAgent } = await import('../27-search-filter-tester');
+
+function createAgent(
+  config: ValidatedConfig = makeConfig(),
+  phase: Phase = 'beta',
+): InstanceType<typeof SearchFilterTesterAgent> {
+  return new SearchFilterTesterAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('SearchFilterTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+
+    currentMockPage = makeMockPage();
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  // Identity
+  it('has agentId 27 and correct agentName', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(27);
+    expect(agent.agentName).toBe('Search & Filter Tester');
+  });
+
+  // preFlight
+  it('throws when modules array is empty', async () => {
+    const config = makeConfig({ modules: [] });
+    const agent = createAgent(config);
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings[0].description).toContain('module');
+  });
+
+  it('resolves environment in preFlight', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.findings.every(f => !f.description.includes('preFlight'))).toBe(true);
+  });
+
+  // No search or filter found
+  it('produces low finding when no search or filter UI found', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const noSearchFilter = result.findings.filter(f => f.description.includes('No search or filter'));
+    expect(noSearchFilter.length).toBeGreaterThan(0);
+    expect(noSearchFilter[0].severity).toBe('low');
+  });
+
+  // Search found and tested
+  it('tests search functionality when search input exists', async () => {
+    const searchLocator = makeMockLocator(1);
+    const noResultsLocator = makeMockLocator(0);
+
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel.includes('search') || sel.includes('find') || sel.includes('searchbox'))
+        return searchLocator;
+      if (sel.includes('no results') || sel.includes('empty'))
+        return noResultsLocator;
+      return makeMockLocator(0);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    // Search fill should have been called
+    expect(searchLocator.fill).toHaveBeenCalled();
+  });
+
+  // Search not filtering
+  it('produces medium finding when gibberish search still shows items', async () => {
+    const searchLocator = makeMockLocator(1);
+    const listLocator = makeMockLocator(5); // 5 list items still showing
+    const noResultsLocator = makeMockLocator(0);
+
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel.includes('search') || sel.includes('find') || sel.includes('searchbox'))
+        return searchLocator;
+      if (sel.includes('no results') || sel.includes('not found') || sel.includes('empty'))
+        return noResultsLocator;
+      if (sel.includes('tr,') || sel.includes('list-item') || sel.includes('card'))
+        return listLocator;
+      return makeMockLocator(0);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const searchFinding = result.findings.find(f => f.description.includes('Search may not be filtering'));
+    expect(searchFinding).toBeDefined();
+    expect(searchFinding!.severity).toBe('medium');
+  });
+
+  // Filter found
+  it('reports filter controls when found', async () => {
+    const filterLocator = makeMockLocator(2);
+    filterLocator.evaluate.mockResolvedValue('select');
+    const optionLocator = makeMockLocator(3);
+    optionLocator.nth = vi.fn().mockReturnValue({ getAttribute: vi.fn().mockResolvedValue('val1') });
+    filterLocator.locator.mockReturnValue(optionLocator);
+
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel.includes('select') || sel.includes('combobox') || sel.includes('Filter') || sel.includes('filter'))
+        return filterLocator;
+      return makeMockLocator(0);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const filterFinding = result.findings.find(f => f.description.includes('filter control'));
+    expect(filterFinding).toBeDefined();
+  });
+
+  // Login failure
+  it('produces medium finding and continues when login fails', async () => {
+    loginMock.mockRejectedValue(new Error('Invalid credentials'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const loginFinding = result.findings.find(f => f.id.includes('login-failed'));
+    expect(loginFinding).toBeDefined();
+    expect(loginFinding!.severity).toBe('medium');
+  });
+
+  // No credentials
+  it('produces medium finding when no credentials configured', async () => {
+    const config = makeConfig({
+      auth: { loginUrl: 'http://localhost/login', credentials: {} },
+    });
+    const agent = createAgent(config);
+    const result = await agent.run();
+
+    const noCredsFinding = result.findings.find(f => f.id.includes('no-credentials'));
+    expect(noCredsFinding).toBeDefined();
+  });
+
+  // Playwright crash
+  it('produces medium finding when Playwright crashes', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Browser crashed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const pwFinding = result.findings.find(f => f.id.includes('playwright-failure'));
+    expect(pwFinding).toBeDefined();
+    expect(pwFinding!.severity).toBe('medium');
+  });
+
+  // Navigation failure
+  it('produces medium finding when module navigation fails', async () => {
+    currentMockPage.goto.mockRejectedValue(new Error('Navigation failed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const navFinding = result.findings.find(f => f.id.includes('nav-failed'));
+    expect(navFinding).toBeDefined();
+    expect(navFinding!.severity).toBe('medium');
+  });
+
+  // Browser closed in finally
+  it('closes browser even when an error occurs', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Launch error'));
+
+    const agent = createAgent();
+    await agent.run();
+
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+});

package/agents/__tests__/28-navigation-routing-tester.test.ts

@@ -0,0 +1,328 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config helpers
+// ---------------------------------------------------------------------------
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    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: 'tasks', route: '/tasks', sidebarIcon: true },
+      { id: 'settings', route: '/settings', sidebarIcon: false },
+    ],
+    environments: {
+      alpha: { baseUrl: 'http://localhost:3000', 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' },
+    agentClassification: { blocking: [], advisory: [28] },
+    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>(),
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Mock fetch
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// Mock helpers
+// ---------------------------------------------------------------------------
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock Playwright
+// ---------------------------------------------------------------------------
+
+interface MockLocator {
+  count: ReturnType<typeof vi.fn>;
+  innerText: ReturnType<typeof vi.fn>;
+  evaluateAll: ReturnType<typeof vi.fn>;
+}
+
+function makeMockLocator(countVal = 0, text = 'Content'): MockLocator {
+  return {
+    count: vi.fn().mockResolvedValue(countVal),
+    innerText: vi.fn().mockResolvedValue(text),
+    evaluateAll: vi.fn().mockResolvedValue([]),
+  };
+}
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  goto: ReturnType<typeof vi.fn>;
+  url: ReturnType<typeof vi.fn>;
+  locator: ReturnType<typeof vi.fn>;
+  goBack: ReturnType<typeof vi.fn>;
+  goForward: ReturnType<typeof vi.fn>;
+}
+
+function makeMockPage(urlOverride?: string): MockPage {
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    url: vi.fn().mockReturnValue(urlOverride ?? 'http://localhost:3000/dashboard'),
+    locator: vi.fn().mockReturnValue(makeMockLocator(0, 'Page Content')),
+    goBack: vi.fn().mockResolvedValue(undefined),
+    goForward: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+let currentMockPage: MockPage;
+let mockBrowser: {
+  newPage: ReturnType<typeof vi.fn>;
+  close: ReturnType<typeof vi.fn>;
+  newContext: ReturnType<typeof vi.fn>;
+};
+
+function makeMockIncognitoPage(url?: string): MockPage {
+  return makeMockPage(url ?? 'http://localhost:3000/login');
+}
+
+vi.mock('playwright', async () => ({
+  chromium: {
+    launch: vi.fn().mockImplementation(async () => mockBrowser),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks are hoisted
+// ---------------------------------------------------------------------------
+
+const { NavigationRoutingTesterAgent } = await import('../28-navigation-routing-tester');
+
+function createAgent(
+  config: ValidatedConfig = makeConfig(),
+  phase: Phase = 'beta',
+): InstanceType<typeof NavigationRoutingTesterAgent> {
+  return new NavigationRoutingTesterAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('NavigationRoutingTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+
+    currentMockPage = makeMockPage();
+
+    const incognitoPage = makeMockIncognitoPage();
+    const incognitoContext = {
+      newPage: vi.fn().mockResolvedValue(incognitoPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+      newContext: vi.fn().mockResolvedValue(incognitoContext),
+    };
+  });
+
+  // Identity
+  it('has agentId 28 and correct agentName', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(28);
+    expect(agent.agentName).toBe('Navigation & Routing Tester');
+  });
+
+  // preFlight
+  it('throws when modules array is empty', async () => {
+    const config = makeConfig({ modules: [] });
+    const agent = createAgent(config);
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings[0].description).toContain('module');
+  });
+
+  // Sidebar navigation — happy path
+  it('navigates to each sidebar module without findings on success', async () => {
+    currentMockPage.locator.mockReturnValue(makeMockLocator(0, 'Page Content'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    // Should not produce sidebar blank page findings
+    const sidebarBlank = result.findings.filter(f => f.id.includes('sidebar-blank'));
+    expect(sidebarBlank.length).toBe(0);
+  });
+
+  // Sidebar navigation — blank page
+  it('produces medium finding when sidebar navigation results in blank page', async () => {
+    currentMockPage.locator.mockReturnValue(makeMockLocator(0, ''));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const blankFindings = result.findings.filter(f => f.id.includes('sidebar-blank'));
+    expect(blankFindings.length).toBeGreaterThan(0);
+    expect(blankFindings[0].severity).toBe('medium');
+  });
+
+  // 404 handling — app shows 404 page
+  it('produces no finding when app properly handles 404 routes', async () => {
+    currentMockPage.locator.mockReturnValue(makeMockLocator(0, 'Page not found'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const notFoundFindings = result.findings.filter(f => f.id.includes('404'));
+    expect(notFoundFindings.length).toBe(0);
+  });
+
+  // 404 handling — blank page
+  it('produces high finding when 404 route shows blank page', async () => {
+    // URL stays on fake route, body is empty
+    currentMockPage.url.mockReturnValue('http://localhost:3000/this-page-does-not-exist-12345');
+    currentMockPage.locator.mockReturnValue(makeMockLocator(0, ''));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const blankFindings = result.findings.filter(f => f.id === '28-404-blank');
+    expect(blankFindings.length).toBe(1);
+    expect(blankFindings[0].severity).toBe('high');
+  });
+
+  // Protected routes — redirects to login (good)
+  it('produces no critical finding when protected routes redirect to login', async () => {
+    // Incognito page URL returns /login — correct behavior
+    const incognitoPage = makeMockIncognitoPage('http://localhost:3000/login');
+    const incognitoContext = {
+      newPage: vi.fn().mockResolvedValue(incognitoPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+    mockBrowser.newContext.mockResolvedValue(incognitoContext);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const unprotectedFindings = result.findings.filter(f => f.id.includes('unprotected'));
+    expect(unprotectedFindings.length).toBe(0);
+  });
+
+  // Protected routes — accessible without auth (critical)
+  it('produces critical finding when module is accessible without authentication', async () => {
+    // Incognito page stays on original URL with content
+    const incognitoPage = makeMockPage('http://localhost:3000/dashboard');
+    incognitoPage.locator.mockReturnValue(makeMockLocator(0, 'Sensitive data visible'));
+    const incognitoContext = {
+      newPage: vi.fn().mockResolvedValue(incognitoPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+    mockBrowser.newContext.mockResolvedValue(incognitoContext);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const unprotectedFindings = result.findings.filter(f => f.id.includes('unprotected'));
+    expect(unprotectedFindings.length).toBeGreaterThan(0);
+    expect(unprotectedFindings[0].severity).toBe('critical');
+  });
+
+  // Link integrity — all links work
+  it('produces no findings when all internal links load correctly', async () => {
+    currentMockPage.locator.mockReturnValue(makeMockLocator(0, 'Page Content'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const brokenLinkFindings = result.findings.filter(f => f.id.includes('broken-link'));
+    expect(brokenLinkFindings.length).toBe(0);
+  });
+
+  // Back/forward navigation — success
+  it('produces no findings when back/forward works correctly', async () => {
+    let callCount = 0;
+    currentMockPage.url.mockImplementation(() => {
+      callCount++;
+      // After goBack, return first module URL; after goForward, return second
+      if (callCount <= 2) return 'http://localhost:3000/dashboard';
+      return 'http://localhost:3000/tasks';
+    });
+
+    currentMockPage.locator.mockReturnValue(makeMockLocator(0, 'Page Content'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const historyFindings = result.findings.filter(f =>
+      f.id.includes('back-nav') || f.id.includes('forward-nav'),
+    );
+    expect(historyFindings.length).toBe(0);
+  });
+
+  // Login failure — graceful degradation
+  it('produces medium finding and continues when login fails', async () => {
+    loginMock.mockRejectedValue(new Error('Invalid credentials'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const loginFinding = result.findings.find(f => f.id.includes('login-failed'));
+    expect(loginFinding).toBeDefined();
+    expect(loginFinding!.severity).toBe('medium');
+  });
+
+  // Playwright crash
+  it('produces medium finding when Playwright crashes', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Browser crashed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const pwFinding = result.findings.find(f => f.id.includes('playwright-failure'));
+    expect(pwFinding).toBeDefined();
+    expect(pwFinding!.severity).toBe('medium');
+  });
+
+  // Browser closed in finally
+  it('closes browser even when an error occurs', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Launch error'));
+
+    const agent = createAgent();
+    await agent.run();
+
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+});