@avi770/testteam 1.2.0 → 2.0.0

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

@@ -0,0 +1,350 @@
+import type { Browser, Page } from 'playwright';
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+import { resolveEnvironment } from '../helpers/env-resolver';
+import { login } from '../helpers/navigation';
+
+/** Timeout (ms) for individual responsive interaction tests. */
+const OP_TIMEOUT_MS = 3_000;
+
+/** Breakpoints to test: mobile, tablet, desktop. */
+const BREAKPOINTS = [
+  { name: 'mobile', width: 375, height: 812 },
+  { name: 'tablet', width: 768, height: 1024 },
+  { name: 'desktop', width: 1280, height: 800 },
+] as const;
+
+/** Selectors for hamburger/menu toggle buttons. */
+const HAMBURGER_SELECTORS = [
+  'button[aria-label*="menu" i]',
+  '.hamburger',
+  '[data-testid*="menu-toggle"]',
+  'button:has(.ri-menu-line)',
+] as const;
+
+/** WCAG minimum touch target size in pixels. */
+const MIN_TOUCH_TARGET_PX = 44;
+
+export class ResponsiveInteractionTesterAgent extends BaseAgent {
+  readonly agentId = 29;
+  readonly agentName = 'Responsive Interaction Tester';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.modules || this.config.modules.length === 0) {
+      throw new Error(
+        'ResponsiveInteractionTesterAgent requires at least one module in config.modules',
+      );
+    }
+
+    const { env } = await resolveEnvironment(this.config, this.phase);
+    this.baseUrl = env.baseUrl;
+  }
+
+  protected async execute(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const rawLoginUrl = this.config.auth.loginUrl ?? '/login';
+    const loginUrl = rawLoginUrl.startsWith('http') ? rawLoginUrl : `${this.baseUrl}${rawLoginUrl}`;
+    const credentials =
+      this.config.auth.credentials?.['admin'] ??
+      Object.values(this.config.auth.credentials ?? {})[0];
+
+    if (!credentials) {
+      findings.push({
+        id: `${this.agentId}-no-credentials`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'responsive-interaction-tester',
+        description: 'No credentials configured — continuing without authentication',
+      });
+    }
+
+    const { chromium } = await import('playwright');
+
+    let browser: Browser | null = null;
+
+    try {
+      browser = await chromium.launch({ headless: true });
+      const page = await browser.newPage();
+
+      // Login at desktop size first
+      if (credentials) {
+        try {
+          await login(page, credentials, loginUrl);
+        } catch (loginError) {
+          findings.push({
+            id: `${this.agentId}-login-failed`,
+            type: 'infra-issue',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: 'responsive-interaction-tester',
+            description: `Login failed — continuing anonymously: ${loginError instanceof Error ? loginError.message.split('\n')[0] : String(loginError)}`,
+          });
+        }
+      }
+
+      // Test first 3 modules to limit scope
+      const modulesToTest = this.config.modules.slice(0, 3);
+
+      for (const bp of BREAKPOINTS) {
+        await page.setViewportSize({ width: bp.width, height: bp.height });
+
+        for (const mod of modulesToTest) {
+          const fullUrl = mod.route.startsWith('http')
+            ? mod.route
+            : `${this.baseUrl}${mod.route}`;
+
+          try {
+            await Promise.race([
+              page.goto(fullUrl, { waitUntil: 'domcontentloaded' }),
+              new Promise((_, reject) =>
+                setTimeout(() => reject(new Error('Navigation timeout')), OP_TIMEOUT_MS),
+              ),
+            ]);
+          } catch {
+            continue; // Skip module if navigation fails
+          }
+
+          // Hamburger menu test (mobile/tablet only)
+          if (bp.name !== 'desktop') {
+            const hamburgerFindings = await this.testHamburgerMenu(page, bp.name, mod.id);
+            findings.push(...hamburgerFindings);
+          }
+
+          // Touch target test
+          const touchFindings = await this.testTouchTargets(page, bp.name, bp.width, mod.id);
+          findings.push(...touchFindings);
+
+          // Modal test
+          const modalFindings = await this.testModalOverflow(page, bp.name, bp.width, mod.id);
+          findings.push(...modalFindings);
+
+          // Horizontal scroll test
+          const scrollFindings = await this.testHorizontalScroll(page, bp.name, mod.id);
+          findings.push(...scrollFindings);
+        }
+      }
+
+      await page.close().catch(() => undefined);
+    } catch (playwrightError) {
+      findings.push({
+        id: `${this.agentId}-playwright-failure`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'responsive-interaction-tester',
+        description: `Playwright execution failed: ${playwrightError instanceof Error ? playwrightError.message.split('\n')[0] : String(playwrightError)}`,
+      });
+    } finally {
+      if (browser) await browser.close().catch(() => undefined);
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test hamburger menu: find toggle button, click it, verify nav panel opens.
+   */
+  private async testHamburgerMenu(
+    page: Page,
+    breakpoint: string,
+    moduleId: string,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const selector = HAMBURGER_SELECTORS.join(', ');
+
+    try {
+      const hamburgerCount = await Promise.race([
+        page.locator(selector).count(),
+        new Promise<number>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as number;
+
+      if (hamburgerCount > 0) {
+        await Promise.race([
+          page.locator(selector).first().click(),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+          ),
+        ]);
+
+        // Check if a navigation panel opened
+        const navPanel = await page
+          .locator('nav, [role="navigation"], [class*="sidebar"], [class*="drawer"]')
+          .count();
+
+        if (navPanel === 0) {
+          findings.push({
+            id: `${this.agentId}-hamburger-no-nav-${breakpoint}-${moduleId}`,
+            type: 'test-bug',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: moduleId,
+            description: `Hamburger menu click did not open a navigation panel at ${breakpoint} in module ${moduleId}`,
+          });
+        }
+      }
+    } catch {
+      // Timeout — non-critical
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test touch targets: find clickable elements with dimensions < 44px.
+   */
+  private async testTouchTargets(
+    page: Page,
+    breakpoint: string,
+    viewportWidth: number,
+    moduleId: string,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      const smallTargets = await Promise.race([
+        page.evaluate((minSize: number) => {
+          const clickable = document.querySelectorAll('a, button, [role="button"], input, select');
+          const tooSmall: string[] = [];
+          for (const el of clickable) {
+            const rect = el.getBoundingClientRect();
+            if (rect.width > 0 && rect.height > 0) {
+              if (rect.width < minSize || rect.height < minSize) {
+                const tag = el.tagName.toLowerCase();
+                const id = el.id ? `#${el.id}` : '';
+                const cls = el.className
+                  ? `.${String(el.className).split(' ')[0]}`
+                  : '';
+                tooSmall.push(`${tag}${id}${cls} (${Math.round(rect.width)}x${Math.round(rect.height)})`);
+              }
+            }
+          }
+          return tooSmall.slice(0, 5); // Limit to first 5
+        }, MIN_TOUCH_TARGET_PX),
+        new Promise<string[]>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as string[];
+
+      if (smallTargets.length > 0) {
+        findings.push({
+          id: `${this.agentId}-touch-target-${breakpoint}-${moduleId}`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `Touch target too small at ${viewportWidth}px in module ${moduleId}: ${smallTargets.join(', ')}`,
+        });
+      }
+    } catch {
+      // Timeout — non-critical
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test modal overflow: look for a modal trigger, click it, check width.
+   */
+  private async testModalOverflow(
+    page: Page,
+    breakpoint: string,
+    viewportWidth: number,
+    moduleId: string,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      const modalTrigger = page.locator(
+        '[data-testid*="modal"], button:has-text("Open"), button:has-text("Details")',
+      );
+
+      const triggerCount = await Promise.race([
+        modalTrigger.count(),
+        new Promise<number>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as number;
+
+      if (triggerCount > 0) {
+        await modalTrigger.first().click().catch(() => undefined);
+        await page.waitForTimeout(500);
+
+        const modalOverflow = await page
+          .evaluate((vw: number) => {
+            const modals = document.querySelectorAll(
+              '[role="dialog"], .modal, [class*="modal"], [data-testid*="modal"]',
+            );
+            for (const modal of modals) {
+              const rect = modal.getBoundingClientRect();
+              if (rect.width > vw) {
+                return true;
+              }
+            }
+            return false;
+          }, viewportWidth)
+          .catch(() => false);
+
+        if (modalOverflow) {
+          findings.push({
+            id: `${this.agentId}-modal-overflow-${breakpoint}-${moduleId}`,
+            type: 'test-bug',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: moduleId,
+            description: `Modal overflows at ${viewportWidth}px in module ${moduleId}`,
+          });
+        }
+
+        // Close modal (press Escape)
+        await page.keyboard.press('Escape').catch(() => undefined);
+      }
+    } catch {
+      // Timeout — non-critical
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test horizontal scrolling: check if scrollWidth > clientWidth.
+   */
+  private async testHorizontalScroll(
+    page: Page,
+    breakpoint: string,
+    moduleId: string,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      const hasHorizontalScroll = await Promise.race([
+        page.evaluate(
+          () =>
+            document.documentElement.scrollWidth > document.documentElement.clientWidth,
+        ),
+        new Promise<boolean>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as boolean;
+
+      if (hasHorizontalScroll) {
+        findings.push({
+          id: `${this.agentId}-horizontal-scroll-${breakpoint}-${moduleId}`,
+          type: 'test-bug',
+          severity: 'high',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `Horizontal scroll detected at ${breakpoint} in module ${moduleId}`,
+        });
+      }
+    } catch {
+      // Timeout — non-critical
+    }
+
+    return findings;
+  }
+}

package/agents/30-multi-user-scenario-tester.ts

@@ -0,0 +1,319 @@
+import type { Browser, BrowserContext } from 'playwright';
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+import { resolveEnvironment } from '../helpers/env-resolver';
+import { login } from '../helpers/navigation';
+
+/** Timeout (ms) for individual multi-user operations. */
+const OP_TIMEOUT_MS = 5_000;
+
+export class MultiUserScenarioTesterAgent extends BaseAgent {
+  readonly agentId = 30;
+  readonly agentName = 'Multi-User Scenario Tester';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    const { env } = await resolveEnvironment(this.config, this.phase);
+    this.baseUrl = env.baseUrl;
+
+    // Check that we have at least some credentials
+    const credEntries = Object.values(this.config.auth.credentials ?? {});
+    if (credEntries.length === 0) {
+      throw new Error(
+        'MultiUserScenarioTesterAgent requires at least one credential set in config.auth.credentials',
+      );
+    }
+  }
+
+  protected async execute(): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    const rawLoginUrl = this.config.auth.loginUrl ?? '/login';
+    const loginUrl = rawLoginUrl.startsWith('http') ? rawLoginUrl : `${this.baseUrl}${rawLoginUrl}`;
+
+    const credEntries = Object.values(this.config.auth.credentials ?? {});
+    const creds1 = credEntries[0];
+    const creds2 = credEntries.length > 1 ? credEntries[1] : credEntries[0];
+
+    const { chromium } = await import('playwright');
+
+    let browser: Browser | null = null;
+    let context1: BrowserContext | null = null;
+    let context2: BrowserContext | null = null;
+
+    try {
+      browser = await chromium.launch({ headless: true });
+      context1 = await browser.newContext();
+      context2 = await browser.newContext();
+
+      const page1 = await context1.newPage();
+      const page2 = await context2.newPage();
+
+      // Login user 1
+      let user1LoggedIn = false;
+      try {
+        await login(page1, creds1, loginUrl);
+        user1LoggedIn = true;
+      } catch (loginError) {
+        findings.push({
+          id: `${this.agentId}-user1-login-failed`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'multi-user',
+          description: `User 1 login failed: ${loginError instanceof Error ? loginError.message.split('\n')[0] : String(loginError)}`,
+        });
+      }
+
+      // Login user 2
+      let user2LoggedIn = false;
+      try {
+        await login(page2, creds2, loginUrl);
+        user2LoggedIn = true;
+      } catch (loginError) {
+        findings.push({
+          id: `${this.agentId}-user2-login-failed`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'multi-user',
+          description: `User 2 login failed: ${loginError instanceof Error ? loginError.message.split('\n')[0] : String(loginError)}`,
+        });
+      }
+
+      // If either login failed, return early
+      if (!user1LoggedIn || !user2LoggedIn) {
+        findings.push({
+          id: `${this.agentId}-login-incomplete`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'multi-user',
+          description: 'One or both users failed to log in — skipping multi-user tests',
+        });
+        await page1.close().catch(() => undefined);
+        await page2.close().catch(() => undefined);
+        return findings;
+      }
+
+      const firstModule = this.config.modules?.[0];
+      const secondModule = this.config.modules?.[1];
+
+      if (!firstModule) {
+        findings.push({
+          id: `${this.agentId}-no-modules`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'multi-user',
+          description: 'No modules configured — skipping multi-user tests',
+        });
+        await page1.close().catch(() => undefined);
+        await page2.close().catch(() => undefined);
+        return findings;
+      }
+
+      const mod1Url = firstModule.route.startsWith('http')
+        ? firstModule.route
+        : `${this.baseUrl}${firstModule.route}`;
+
+      // Test 1: Concurrent sessions
+      const concurrentFindings = await this.testConcurrentSessions(page1, page2, mod1Url);
+      findings.push(...concurrentFindings);
+
+      // Test 2: Same page access
+      const samePageFindings = await this.testSamePageAccess(page1, page2, mod1Url, firstModule.id);
+      findings.push(...samePageFindings);
+
+      // Test 3: Independent navigation (requires 2 modules)
+      if (secondModule) {
+        const mod2Url = secondModule.route.startsWith('http')
+          ? secondModule.route
+          : `${this.baseUrl}${secondModule.route}`;
+        const independentFindings = await this.testIndependentNavigation(
+          page1,
+          page2,
+          mod1Url,
+          mod2Url,
+          firstModule.id,
+          secondModule.id,
+        );
+        findings.push(...independentFindings);
+      }
+
+      await page1.close().catch(() => undefined);
+      await page2.close().catch(() => undefined);
+    } catch (playwrightError) {
+      findings.push({
+        id: `${this.agentId}-playwright-failure`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'multi-user',
+        description: `Playwright execution failed: ${playwrightError instanceof Error ? playwrightError.message.split('\n')[0] : String(playwrightError)}`,
+      });
+    } finally {
+      if (context1) await context1.close().catch(() => undefined);
+      if (context2) await context2.close().catch(() => undefined);
+      if (browser) await browser.close().catch(() => undefined);
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test 1: Both users navigate to the same module.
+   * Neither should be logged out (session conflict).
+   */
+  private async testConcurrentSessions(
+    page1: import('playwright').Page,
+    page2: import('playwright').Page,
+    moduleUrl: string,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      await Promise.race([
+        Promise.all([
+          page1.goto(moduleUrl, { waitUntil: 'domcontentloaded' }),
+          page2.goto(moduleUrl, { waitUntil: 'domcontentloaded' }),
+        ]),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]);
+
+      const url1 = page1.url();
+      const url2 = page2.url();
+
+      const user1Redirected =
+        url1.includes('/login') || url1.includes('/signin') || url1.includes('/auth');
+      const user2Redirected =
+        url2.includes('/login') || url2.includes('/signin') || url2.includes('/auth');
+
+      if (user1Redirected || user2Redirected) {
+        findings.push({
+          id: `${this.agentId}-concurrent-session-conflict`,
+          type: 'test-bug',
+          severity: 'high',
+          agentId: this.agentId,
+          module: 'multi-user',
+          description: `Concurrent sessions not supported — user${user1Redirected ? '1' : '2'} was redirected to login`,
+        });
+      }
+    } catch (error) {
+      findings.push({
+        id: `${this.agentId}-concurrent-error`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'multi-user',
+        description: `Concurrent session test failed: ${error instanceof Error ? error.message.split('\n')[0] : String(error)}`,
+      });
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test 2: Both users on the same page — check both render content.
+   */
+  private async testSamePageAccess(
+    page1: import('playwright').Page,
+    page2: import('playwright').Page,
+    moduleUrl: string,
+    moduleId: string,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      const body1 = await Promise.race([
+        page1.locator('body').innerText(),
+        new Promise<string>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as string;
+
+      const body2 = await Promise.race([
+        page2.locator('body').innerText(),
+        new Promise<string>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as string;
+
+      if (body1.trim().length === 0 || body2.trim().length === 0) {
+        findings.push({
+          id: `${this.agentId}-same-page-blank`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `Same page access test: one or both users see a blank page for module ${moduleId}`,
+        });
+      }
+    } catch {
+      // Timeout — non-critical
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test 3: User1 navigates to module A, User2 to module B.
+   * Verify each is on the correct page.
+   */
+  private async testIndependentNavigation(
+    page1: import('playwright').Page,
+    page2: import('playwright').Page,
+    mod1Url: string,
+    mod2Url: string,
+    mod1Id: string,
+    mod2Id: string,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      await Promise.race([
+        Promise.all([
+          page1.goto(mod1Url, { waitUntil: 'domcontentloaded' }),
+          page2.goto(mod2Url, { waitUntil: 'domcontentloaded' }),
+        ]),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]);
+
+      const url1 = page1.url();
+      const url2 = page2.url();
+
+      // Extract path from URLs for comparison
+      const path1 = new URL(url1).pathname;
+      const path2 = new URL(url2).pathname;
+      const expectedPath1 = new URL(mod1Url).pathname;
+      const expectedPath2 = new URL(mod2Url).pathname;
+
+      // Check if sessions cross-contaminated
+      if (path1 === path2 && expectedPath1 !== expectedPath2) {
+        findings.push({
+          id: `${this.agentId}-session-isolation-failure`,
+          type: 'code-bug-security',
+          severity: 'critical',
+          agentId: this.agentId,
+          module: 'multi-user',
+          description: `Session isolation failure — both users ended up on the same path (${path1}) despite navigating to different modules`,
+        });
+      }
+    } catch (navError) {
+      findings.push({
+        id: `${this.agentId}-independent-nav-error`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'multi-user',
+        description: `Independent navigation test failed: ${navError instanceof Error ? navError.message.split('\n')[0] : String(navError)}`,
+      });
+    }
+
+    return findings;
+  }
+}