@avi770/testteam 1.2.0 → 2.0.0

package/agents/__tests__/47-social-preview-tester.test.ts

@@ -0,0 +1,245 @@
+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: 'home', route: '/', 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: [47] },
+    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 MockPage {
+  close: ReturnType<typeof vi.fn>;
+  goto: ReturnType<typeof vi.fn>;
+  evaluate: ReturnType<typeof vi.fn>;
+}
+
+function makeMockPage(): MockPage {
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue(null),
+  };
+}
+
+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
+// ---------------------------------------------------------------------------
+
+const { SocialPreviewTesterAgent } = await import('../47-social-preview-tester');
+
+function createAgent(
+  config: ValidatedConfig = makeConfig(),
+  phase: Phase = 'beta',
+): InstanceType<typeof SocialPreviewTesterAgent> {
+  return new SocialPreviewTesterAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('SocialPreviewTesterAgent', () => {
+  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),
+    };
+  });
+
+  it('has agentId 47 and correct agentName', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(47);
+    expect(agent.agentName).toBe('Social Preview Tester');
+  });
+
+  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');
+  });
+
+  it('detects missing og:image', async () => {
+    currentMockPage.evaluate.mockResolvedValue(null);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const noImage = result.findings.find(f => f.id.includes('no-og-image'));
+    expect(noImage).toBeDefined();
+    expect(noImage!.severity).toBe('medium');
+  });
+
+  it('detects broken og:image URL', async () => {
+    currentMockPage.evaluate.mockImplementation((fn: unknown) => {
+      const fnStr = String(fn);
+      if (fnStr.includes('og:image')) return Promise.resolve('http://localhost:3000/broken.png');
+      return Promise.resolve(null);
+    });
+    fetchMock.mockImplementation((url: string) => {
+      if (typeof url === 'string' && url.includes('broken.png')) {
+        return Promise.resolve({ ok: false, status: 404 });
+      }
+      return Promise.resolve({ ok: true, status: 200 });
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const brokenImage = result.findings.find(f => f.id.includes('og-image-broken'));
+    expect(brokenImage).toBeDefined();
+  });
+
+  it('detects missing og:title', async () => {
+    currentMockPage.evaluate.mockResolvedValue(null);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const noTitle = result.findings.find(f => f.id.includes('no-og-title'));
+    expect(noTitle).toBeDefined();
+  });
+
+  it('detects long og:title', async () => {
+    currentMockPage.evaluate.mockImplementation((fn: unknown) => {
+      const fnStr = String(fn);
+      if (fnStr.includes('og:title')) return Promise.resolve('A'.repeat(80));
+      return Promise.resolve(null);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const longTitle = result.findings.find(f => f.id.includes('long-og-title'));
+    expect(longTitle).toBeDefined();
+  });
+
+  it('detects missing og:description', async () => {
+    currentMockPage.evaluate.mockResolvedValue(null);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const noDesc = result.findings.find(f => f.id.includes('no-og-desc'));
+    expect(noDesc).toBeDefined();
+  });
+
+  it('detects missing twitter:card', async () => {
+    currentMockPage.evaluate.mockResolvedValue(null);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const noCard = result.findings.find(f => f.id.includes('no-twitter-card'));
+    expect(noCard).toBeDefined();
+  });
+
+  it('produces medium finding when login fails', async () => {
+    loginMock.mockRejectedValue(new Error('Auth failed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const loginFinding = result.findings.find(f => f.id.includes('login-failed'));
+    expect(loginFinding).toBeDefined();
+  });
+
+  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();
+  });
+
+  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();
+  });
+
+  it('produces medium finding when 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();
+  });
+});

package/agents/__tests__/48-lighthouse-auditor.test.ts

@@ -0,0 +1,276 @@
+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: 'home', route: '/', 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: [48] },
+    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>;
+}
+
+function makeMockLocator(countVal = 0): MockLocator {
+  return { count: vi.fn().mockResolvedValue(countVal) };
+}
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  goto: ReturnType<typeof vi.fn>;
+  evaluate: ReturnType<typeof vi.fn>;
+  locator: ReturnType<typeof vi.fn>;
+}
+
+function makeMockPage(): MockPage {
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue({
+      domContentLoaded: 500,
+      loadComplete: 800,
+      fcp: 1200,
+    }),
+    locator: vi.fn().mockReturnValue(makeMockLocator(0)),
+  };
+}
+
+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
+// ---------------------------------------------------------------------------
+
+const { LighthouseAuditorAgent } = await import('../48-lighthouse-auditor');
+
+function createAgent(
+  config: ValidatedConfig = makeConfig(),
+  phase: Phase = 'beta',
+): InstanceType<typeof LighthouseAuditorAgent> {
+  return new LighthouseAuditorAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('LighthouseAuditorAgent', () => {
+  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),
+    };
+  });
+
+  it('has agentId 48 and correct agentName', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(48);
+    expect(agent.agentName).toBe('Lighthouse Auditor');
+  });
+
+  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');
+  });
+
+  it('detects missing viewport meta tag', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(() => {
+      callCount++;
+      if (callCount === 1) return Promise.resolve({ domContentLoaded: 500, loadComplete: 800, fcp: 1200 });
+      if (callCount === 2) return Promise.resolve(false); // no viewport
+      return Promise.resolve(true);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const noViewport = result.findings.find(f => f.id.includes('no-viewport'));
+    expect(noViewport).toBeDefined();
+    expect(noViewport!.severity).toBe('medium');
+  });
+
+  it('detects missing lang attribute', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(() => {
+      callCount++;
+      if (callCount === 1) return Promise.resolve({ domContentLoaded: 500, loadComplete: 800, fcp: 1200 });
+      if (callCount === 2) return Promise.resolve(true); // viewport present
+      if (callCount === 3) return Promise.resolve(false); // no lang
+      return Promise.resolve(true);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const noLang = result.findings.find(f => f.id.includes('no-lang'));
+    expect(noLang).toBeDefined();
+  });
+
+  it('detects missing charset meta tag', async () => {
+    let callCount = 0;
+    currentMockPage.evaluate.mockImplementation(() => {
+      callCount++;
+      if (callCount === 1) return Promise.resolve({ domContentLoaded: 500, loadComplete: 800, fcp: 1200 });
+      if (callCount === 2) return Promise.resolve(true); // viewport
+      if (callCount === 3) return Promise.resolve(true); // lang
+      if (callCount === 4) return Promise.resolve(false); // no charset
+      return Promise.resolve(true);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const noCharset = result.findings.find(f => f.id.includes('no-charset'));
+    expect(noCharset).toBeDefined();
+  });
+
+  it('detects slow DOMContentLoaded', async () => {
+    currentMockPage.evaluate.mockImplementation(() => {
+      return Promise.resolve({
+        domContentLoaded: 5000,
+        loadComplete: 8000,
+        fcp: 1200,
+      });
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const slowDcl = result.findings.find(f => f.id.includes('slow-dcl'));
+    expect(slowDcl).toBeDefined();
+    expect(slowDcl!.severity).toBe('medium');
+  });
+
+  it('records performance evidence', async () => {
+    currentMockPage.evaluate.mockResolvedValue({
+      domContentLoaded: 500,
+      loadComplete: 800,
+      fcp: 1200,
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(result.evidence.some(e => e.description.includes('FCP'))).toBe(true);
+  });
+
+  it('produces medium finding when login fails', async () => {
+    loginMock.mockRejectedValue(new Error('Auth failed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const loginFinding = result.findings.find(f => f.id.includes('login-failed'));
+    expect(loginFinding).toBeDefined();
+  });
+
+  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();
+  });
+
+  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();
+  });
+
+  it('produces medium finding when 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();
+  });
+
+  it('handles performance metrics evaluation error gracefully', async () => {
+    currentMockPage.evaluate.mockRejectedValue(new Error('Evaluate failed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    // Should not crash — just skip metrics
+    expect(result.status).toBeDefined();
+  });
+});