@avi770/testteam 1.2.0 → 3.0.0

package/agents/__tests__/29-responsive-interaction-tester.test.ts

@@ -0,0 +1,297 @@
+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: 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: [29] },
+    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>;
+}
+
+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),
+  };
+  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>;
+  setViewportSize: ReturnType<typeof vi.fn>;
+  evaluate: ReturnType<typeof vi.fn>;
+  waitForTimeout: ReturnType<typeof vi.fn>;
+  keyboard: { press: 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),
+    setViewportSize: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue(false),
+    waitForTimeout: vi.fn().mockResolvedValue(undefined),
+    keyboard: { press: 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 { ResponsiveInteractionTesterAgent } = await import('../29-responsive-interaction-tester');
+
+function createAgent(
+  config: ValidatedConfig = makeConfig(),
+  phase: Phase = 'beta',
+): InstanceType<typeof ResponsiveInteractionTesterAgent> {
+  return new ResponsiveInteractionTesterAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('ResponsiveInteractionTesterAgent', () => {
+  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 29 and correct agentName', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(29);
+    expect(agent.agentName).toBe('Responsive Interaction 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);
+  });
+
+  // Viewport is set for each breakpoint
+  it('sets viewport size for mobile, tablet, and desktop', async () => {
+    const agent = createAgent();
+    await agent.run();
+
+    expect(currentMockPage.setViewportSize).toHaveBeenCalledWith({ width: 375, height: 812 });
+    expect(currentMockPage.setViewportSize).toHaveBeenCalledWith({ width: 768, height: 1024 });
+    expect(currentMockPage.setViewportSize).toHaveBeenCalledWith({ width: 1280, height: 800 });
+  });
+
+  // Touch target detection
+  it('produces medium finding when touch targets are too small', async () => {
+    currentMockPage.evaluate.mockImplementation((fn: unknown) => {
+      // Return small touch targets for the touch target test
+      if (typeof fn === 'function') {
+        return Promise.resolve(['button.small (20x20)', 'a.link (30x15)']);
+      }
+      return Promise.resolve(false);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const touchFinding = result.findings.find(f => f.description.includes('Touch target too small'));
+    expect(touchFinding).toBeDefined();
+    expect(touchFinding!.severity).toBe('medium');
+  });
+
+  // Horizontal scroll detection
+  it('produces high finding when horizontal scroll detected', async () => {
+    // Return true for horizontal scroll check
+    currentMockPage.evaluate.mockResolvedValue(true);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const scrollFinding = result.findings.find(f => f.description.includes('Horizontal scroll'));
+    expect(scrollFinding).toBeDefined();
+    expect(scrollFinding!.severity).toBe('high');
+  });
+
+  // No horizontal scroll
+  it('produces no scroll finding when no horizontal overflow', async () => {
+    currentMockPage.evaluate.mockResolvedValue(false);
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const scrollFinding = result.findings.find(f => f.description.includes('Horizontal scroll'));
+    expect(scrollFinding).toBeUndefined();
+  });
+
+  // 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');
+  });
+
+  // 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();
+  });
+
+  // Tests only first 3 modules
+  it('limits testing to first 3 modules', async () => {
+    const config = makeConfig({
+      modules: [
+        { id: 'mod1', route: '/mod1', sidebarIcon: true },
+        { id: 'mod2', route: '/mod2', sidebarIcon: true },
+        { id: 'mod3', route: '/mod3', sidebarIcon: true },
+        { id: 'mod4', route: '/mod4', sidebarIcon: true },
+        { id: 'mod5', route: '/mod5', sidebarIcon: true },
+      ],
+    });
+
+    const agent = createAgent(config);
+    await agent.run();
+
+    // 3 breakpoints * 3 modules = 9 module navigations
+    // Should NOT navigate to mod4 or mod5
+    const gotoArgs = currentMockPage.goto.mock.calls.map((c: unknown[]) => c[0] as string);
+    expect(gotoArgs.filter((u: string) => u.includes('mod4'))).toHaveLength(0);
+    expect(gotoArgs.filter((u: string) => u.includes('mod5'))).toHaveLength(0);
+  });
+});

package/agents/__tests__/30-multi-user-scenario-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' },
+        staff: { email: 'staff@test.com', password: 'secret2' },
+      },
+    },
+    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: [30] },
+    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>;
+  innerText: ReturnType<typeof vi.fn>;
+}
+
+function makeMockLocator(countVal = 0): MockLocator {
+  const locator: MockLocator = {
+    count: vi.fn().mockResolvedValue(countVal),
+    first: vi.fn(),
+    nth: vi.fn(),
+    innerText: vi.fn().mockResolvedValue('some content'),
+  };
+  locator.first.mockReturnValue(locator);
+  locator.nth.mockReturnValue(locator);
+  return locator;
+}
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  goto: ReturnType<typeof vi.fn>;
+  url: ReturnType<typeof vi.fn>;
+  locator: ReturnType<typeof vi.fn>;
+}
+
+function makeMockPage(urlValue = 'http://localhost:3000/dashboard'): MockPage {
+  const defaultLocator = makeMockLocator(0);
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    url: vi.fn().mockReturnValue(urlValue),
+    locator: vi.fn().mockReturnValue(defaultLocator),
+  };
+}
+
+let mockPage1: MockPage;
+let mockPage2: MockPage;
+let mockContext1: {
+  newPage: ReturnType<typeof vi.fn>;
+  close: ReturnType<typeof vi.fn>;
+};
+let mockContext2: {
+  newPage: ReturnType<typeof vi.fn>;
+  close: ReturnType<typeof vi.fn>;
+};
+let mockBrowser: {
+  newContext: 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 { MultiUserScenarioTesterAgent } = await import('../30-multi-user-scenario-tester');
+
+function createAgent(
+  config: ValidatedConfig = makeConfig(),
+  phase: Phase = 'beta',
+): InstanceType<typeof MultiUserScenarioTesterAgent> {
+  return new MultiUserScenarioTesterAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('MultiUserScenarioTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+
+    mockPage1 = makeMockPage('http://localhost:3000/dashboard');
+    mockPage2 = makeMockPage('http://localhost:3000/dashboard');
+    mockPage1.locator.mockReturnValue(makeMockLocator(0));
+    mockPage1.locator.mockImplementation(() => {
+      const loc = makeMockLocator(0);
+      loc.innerText.mockResolvedValue('dashboard content');
+      return loc;
+    });
+    mockPage2.locator.mockImplementation(() => {
+      const loc = makeMockLocator(0);
+      loc.innerText.mockResolvedValue('dashboard content');
+      return loc;
+    });
+
+    mockContext1 = {
+      newPage: vi.fn().mockResolvedValue(mockPage1),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+    mockContext2 = {
+      newPage: vi.fn().mockResolvedValue(mockPage2),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+
+    let contextCallCount = 0;
+    mockBrowser = {
+      newContext: vi.fn().mockImplementation(async () => {
+        contextCallCount++;
+        return contextCallCount === 1 ? mockContext1 : mockContext2;
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  // Identity
+  it('has agentId 30 and correct agentName', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(30);
+    expect(agent.agentName).toBe('Multi-User Scenario Tester');
+  });
+
+  // preFlight
+  it('throws when no credentials configured', async () => {
+    const config = makeConfig({
+      auth: { loginUrl: 'http://localhost/login', credentials: {} },
+    });
+    const agent = createAgent(config);
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings[0].description).toContain('credential');
+  });
+
+  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);
+  });
+
+  // Two browser contexts created
+  it('creates two browser contexts for multi-user testing', async () => {
+    const agent = createAgent();
+    await agent.run();
+
+    expect(mockBrowser.newContext).toHaveBeenCalledTimes(2);
+  });
+
+  // Login failure for user 1
+  it('produces medium finding when user 1 login fails', async () => {
+    loginMock.mockRejectedValueOnce(new Error('Auth failed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const loginFinding = result.findings.find(f => f.id.includes('user1-login-failed'));
+    expect(loginFinding).toBeDefined();
+    expect(loginFinding!.severity).toBe('medium');
+  });
+
+  // Login failure for user 2
+  it('produces medium finding when user 2 login fails', async () => {
+    loginMock
+      .mockResolvedValueOnce(undefined)  // user1 succeeds
+      .mockRejectedValueOnce(new Error('Auth failed'));  // user2 fails
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const loginFinding = result.findings.find(f => f.id.includes('user2-login-failed'));
+    expect(loginFinding).toBeDefined();
+  });
+
+  // Returns early when login fails
+  it('returns early with finding when login is incomplete', async () => {
+    loginMock.mockRejectedValue(new Error('Auth failed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const incompleteFinding = result.findings.find(f => f.id.includes('login-incomplete'));
+    expect(incompleteFinding).toBeDefined();
+  });
+
+  // Concurrent sessions — both stay logged in
+  it('passes when both users remain logged in concurrently', async () => {
+    mockPage1.url.mockReturnValue('http://localhost:3000/dashboard');
+    mockPage2.url.mockReturnValue('http://localhost:3000/dashboard');
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const conflictFinding = result.findings.find(f => f.id.includes('concurrent-session-conflict'));
+    expect(conflictFinding).toBeUndefined();
+  });
+
+  // Concurrent sessions — one gets redirected
+  it('produces high finding when a user gets redirected to login', async () => {
+    mockPage1.url.mockReturnValue('http://localhost:3000/login');
+    mockPage2.url.mockReturnValue('http://localhost:3000/dashboard');
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const conflictFinding = result.findings.find(f => f.id.includes('concurrent-session-conflict'));
+    expect(conflictFinding).toBeDefined();
+    expect(conflictFinding!.severity).toBe('high');
+  });
+
+  // Playwright crash
+  it('produces medium finding when Playwright crashes', async () => {
+    mockBrowser.newContext.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 and contexts closed in finally
+  it('closes contexts and browser even when an error occurs', async () => {
+    // Let contexts be created but fail on page creation for context2
+    const failContext = {
+      newPage: vi.fn().mockRejectedValue(new Error('Page error')),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+
+    let ctxCount = 0;
+    mockBrowser.newContext.mockImplementation(async () => {
+      ctxCount++;
+      return ctxCount === 1 ? mockContext1 : failContext;
+    });
+
+    const agent = createAgent();
+    await agent.run();
+
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  // Works with single credential set
+  it('works with single credential set using same creds for both users', async () => {
+    const config = makeConfig({
+      auth: {
+        loginUrl: 'http://localhost/login',
+        credentials: {
+          admin: { email: 'admin@test.com', password: 'secret' },
+        },
+      },
+    });
+
+    const agent = createAgent(config);
+    const result = await agent.run();
+
+    // login should be called twice (once per user)
+    expect(loginMock).toHaveBeenCalledTimes(2);
+  });
+});