@avi770/testteam 1.2.0 → 2.0.0

package/agents/48-lighthouse-auditor.ts

@@ -0,0 +1,213 @@
+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';
+
+const NAV_TIMEOUT_MS = 10_000;
+
+export class LighthouseAuditorAgent extends BaseAgent {
+  readonly agentId = 48;
+  readonly agentName = 'Lighthouse Auditor';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.modules || this.config.modules.length === 0) {
+      throw new Error('LighthouseAuditorAgent 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];
+
+    const { chromium } = await import('playwright');
+    let browser: Browser | null = null;
+
+    try {
+      browser = await chromium.launch({ headless: true });
+      const page = await browser.newPage();
+
+      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: 'lighthouse-auditor',
+            description: `Login failed — continuing anonymously: ${loginError instanceof Error ? loginError.message.split('\n')[0] : String(loginError)}`,
+          });
+        }
+      }
+
+      for (const mod of this.config.modules) {
+        const moduleFindings = await this.auditModule(page, mod.id, mod.route);
+        findings.push(...moduleFindings);
+      }
+
+      await page.close().catch(() => undefined);
+    } catch (playwrightError) {
+      findings.push({
+        id: `${this.agentId}-playwright-failure`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'lighthouse-auditor',
+        description: `Playwright execution failed: ${playwrightError instanceof Error ? playwrightError.message.split('\n')[0] : String(playwrightError)}`,
+      });
+    } finally {
+      if (browser) await browser.close().catch(() => undefined);
+    }
+
+    return findings;
+  }
+
+  private async auditModule(
+    page: Page,
+    moduleId: string,
+    moduleRoute: string,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const fullUrl = moduleRoute.startsWith('http')
+      ? moduleRoute
+      : `${this.baseUrl}${moduleRoute}`;
+
+    try {
+      await Promise.race([
+        page.goto(fullUrl, { waitUntil: 'domcontentloaded' }),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Navigation timeout')), NAV_TIMEOUT_MS),
+        ),
+      ]);
+    } catch {
+      findings.push({
+        id: `${this.agentId}-nav-failed-${moduleId}`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: moduleId,
+        description: `Failed to navigate to module ${moduleId} at ${moduleRoute}`,
+      });
+      return findings;
+    }
+
+    // Measure performance timing
+    try {
+      const metrics = await page.evaluate(() => {
+        const timing = performance.timing;
+        const navigationStart = timing.navigationStart;
+        const entries = performance.getEntriesByType('paint') as PerformancePaintTiming[];
+        const fcp = entries.find(e => e.name === 'first-contentful-paint');
+
+        return {
+          domContentLoaded: timing.domContentLoadedEventEnd - navigationStart,
+          loadComplete: timing.loadEventEnd - navigationStart,
+          fcp: fcp?.startTime ?? null,
+        };
+      });
+
+      const fcpThreshold = this.config.thresholds?.lighthouse?.performance
+        ? (100 - this.config.thresholds.lighthouse.performance) * 50 + 1000
+        : 2500;
+
+      if (metrics.fcp !== null && metrics.fcp > fcpThreshold) {
+        findings.push({
+          id: `${this.agentId}-slow-fcp-${moduleId}`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `Module ${moduleId} First Contentful Paint is ${metrics.fcp.toFixed(0)}ms (threshold: ${fcpThreshold}ms)`,
+        });
+      }
+
+      if (metrics.domContentLoaded > 3000) {
+        findings.push({
+          id: `${this.agentId}-slow-dcl-${moduleId}`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `Module ${moduleId} DOMContentLoaded took ${metrics.domContentLoaded}ms`,
+        });
+      }
+
+      this.addEvidence({
+        type: 'log',
+        path: `perf-${moduleId}`,
+        description: `Module ${moduleId}: FCP=${metrics.fcp?.toFixed(0) ?? 'N/A'}ms, DCL=${metrics.domContentLoaded}ms, Load=${metrics.loadComplete}ms`,
+      });
+    } catch {
+      // Performance metrics unavailable
+    }
+
+    // Check <meta name="viewport">
+    try {
+      const hasViewport = await page.evaluate(() => {
+        return document.querySelector('meta[name="viewport"]') !== null;
+      });
+      if (!hasViewport) {
+        findings.push({
+          id: `${this.agentId}-no-viewport-${moduleId}`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `Module ${moduleId} is missing <meta name="viewport">`,
+        });
+      }
+    } catch {
+      // Could not evaluate viewport
+    }
+
+    // Check <html lang>
+    try {
+      const hasLang = await page.evaluate(() => {
+        return document.documentElement.hasAttribute('lang');
+      });
+      if (!hasLang) {
+        findings.push({
+          id: `${this.agentId}-no-lang-${moduleId}`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `Module ${moduleId} is missing lang attribute on <html>`,
+        });
+      }
+    } catch {
+      // Could not evaluate lang
+    }
+
+    // Check <meta charset>
+    try {
+      const hasCharset = await page.evaluate(() => {
+        return document.querySelector('meta[charset]') !== null ||
+          document.querySelector('meta[http-equiv="Content-Type"]') !== null;
+      });
+      if (!hasCharset) {
+        findings.push({
+          id: `${this.agentId}-no-charset-${moduleId}`,
+          type: 'test-bug',
+          severity: 'low',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `Module ${moduleId} is missing <meta charset>`,
+        });
+      }
+    } catch {
+      // Could not evaluate charset
+    }
+
+    return findings;
+  }
+}

package/agents/49-i18n-tester.ts

@@ -0,0 +1,198 @@
+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';
+
+/** Pattern that detects raw i18n keys like home.title, nav.dashboard.items */
+const I18N_KEY_PATTERN = /\b[a-z][a-zA-Z0-9]*\.[a-z][a-zA-Z0-9]*\.[a-z][a-zA-Z0-9]*/;
+
+/** Selectors for language switcher UI elements. */
+const LANG_SWITCHER_SELECTORS = [
+  '[data-testid*="lang"]',
+  '[data-testid*="locale"]',
+  '[data-testid*="language"]',
+  'select[name*="lang"]',
+  'select[name*="locale"]',
+  'button:has-text("English")',
+  'button:has-text("EN")',
+  '[aria-label*="language"]',
+  '[aria-label*="locale"]',
+] as const;
+
+/** RTL locales to check. */
+const RTL_LOCALES = ['ar', 'he', 'fa', 'ur'] as const;
+
+export class I18nTesterAgent extends BaseAgent {
+  readonly agentId = 49;
+  readonly agentName = 'i18n Tester';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.modules || this.config.modules.length === 0) {
+      throw new Error('I18nTesterAgent 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];
+
+    const { chromium } = await import('playwright');
+
+    let browser: Browser | null = null;
+
+    try {
+      browser = await chromium.launch({ headless: true });
+      const page = await browser.newPage();
+
+      if (credentials) {
+        try {
+          await login(page, credentials, loginUrl);
+        } catch {
+          findings.push({
+            id: `${this.agentId}-login-failed`,
+            type: 'infra-issue',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: 'i18n-tester',
+            description: 'Login failed — continuing anonymously',
+          });
+        }
+      }
+
+      // Check for language switcher
+      const langSwitcherFound = await this.findLanguageSwitcher(page);
+
+      if (!langSwitcherFound) {
+        findings.push({
+          id: `${this.agentId}-no-lang-switcher`,
+          type: 'test-bug',
+          severity: 'low',
+          agentId: this.agentId,
+          module: 'i18n-tester',
+          description: 'No language switcher UI element found',
+        });
+      }
+
+      // Check pages for untranslated strings
+      for (const mod of this.config.modules) {
+        const moduleFindings = await this.checkModule(page, mod.id, mod.route);
+        findings.push(...moduleFindings);
+      }
+
+      // Check RTL layout if language switcher found
+      if (langSwitcherFound) {
+        const rtlFindings = await this.checkRtlLayout(page);
+        findings.push(...rtlFindings);
+      }
+
+      await page.close().catch(() => undefined);
+    } catch (playwrightError) {
+      findings.push({
+        id: `${this.agentId}-playwright-failure`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'i18n-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;
+  }
+
+  private async findLanguageSwitcher(page: Page): Promise<boolean> {
+    const selector = LANG_SWITCHER_SELECTORS.join(', ');
+    try {
+      const count = await page.locator(selector).count();
+      return count > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  private async checkModule(
+    page: Page,
+    moduleId: string,
+    moduleRoute: string,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const fullUrl = moduleRoute.startsWith('http')
+      ? moduleRoute
+      : `${this.baseUrl}${moduleRoute}`;
+
+    try {
+      await page.goto(fullUrl, { waitUntil: 'domcontentloaded', timeout: 10_000 });
+    } catch {
+      findings.push({
+        id: `${this.agentId}-nav-failed-${moduleId}`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: moduleId,
+        description: `Failed to navigate to module ${moduleId} at ${moduleRoute}`,
+      });
+      return findings;
+    }
+
+    // Check for untranslated i18n keys
+    try {
+      const bodyText = await page.evaluate(() => document.body.innerText);
+      const lines = bodyText.split('\n');
+      for (const line of lines) {
+        if (I18N_KEY_PATTERN.test(line.trim()) && !line.includes(' ')) {
+          findings.push({
+            id: `${this.agentId}-untranslated-${moduleId}`,
+            type: 'test-bug',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: moduleId,
+            description: `Possible untranslated i18n key found: "${line.trim().substring(0, 80)}"`,
+          });
+          break; // Report one per module
+        }
+      }
+    } catch {
+      // evaluate failed — non-critical
+    }
+
+    return findings;
+  }
+
+  private async checkRtlLayout(page: Page): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    try {
+      const dir = await page.evaluate(() => document.dir || document.documentElement.dir);
+      const lang = await page.evaluate(() => document.documentElement.lang);
+
+      const isRtlLocale = RTL_LOCALES.some(locale => lang?.startsWith(locale));
+
+      if (isRtlLocale && dir !== 'rtl') {
+        findings.push({
+          id: `${this.agentId}-rtl-missing`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'i18n-tester',
+          description: `RTL locale "${lang}" detected but document.dir is "${dir ?? 'not set'}" instead of "rtl"`,
+        });
+      }
+    } catch {
+      // evaluate failed — non-critical
+    }
+
+    return findings;
+  }
+}

package/agents/50-timezone-tester.ts

@@ -0,0 +1,173 @@
+import type { Browser } from 'playwright';
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+import { resolveEnvironment } from '../helpers/env-resolver';
+import { login } from '../helpers/navigation';
+
+/** Timezones to test across. */
+const TEST_TIMEZONES = ['UTC', 'America/New_York', 'Australia/Sydney'] as const;
+
+/** Selectors that commonly hold date values. */
+const DATE_SELECTORS = 'time, [datetime], .date, [data-date], [data-testid*="date"]';
+
+export class TimezoneTesterAgent extends BaseAgent {
+  readonly agentId = 50;
+  readonly agentName = 'Timezone Tester';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.modules || this.config.modules.length === 0) {
+      throw new Error('TimezoneTesterAgent 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];
+
+    const { chromium } = await import('playwright');
+
+    let browser: Browser | null = null;
+
+    try {
+      browser = await chromium.launch({ headless: true });
+
+      const firstModule = this.config.modules[0];
+      const fullUrl = firstModule.route.startsWith('http')
+        ? firstModule.route
+        : `${this.baseUrl}${firstModule.route}`;
+
+      const datesByTimezone: Record<string, string[]> = {};
+
+      for (const tz of TEST_TIMEZONES) {
+        const context = await browser.newContext({ timezoneId: tz });
+        const page = await context.newPage();
+
+        if (credentials) {
+          try {
+            await login(page, credentials, loginUrl);
+          } catch {
+            // Continue without auth
+          }
+        }
+
+        try {
+          await page.goto(fullUrl, { waitUntil: 'domcontentloaded', timeout: 10_000 });
+        } catch {
+          findings.push({
+            id: `${this.agentId}-nav-failed-${tz}`,
+            type: 'test-bug',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: firstModule.id,
+            description: `Failed to navigate to ${firstModule.id} with timezone ${tz}`,
+          });
+          await context.close().catch(() => undefined);
+          continue;
+        }
+
+        // Read date elements
+        try {
+          const dates = await page.evaluate((selector: string) => {
+            const elements = document.querySelectorAll(selector);
+            return Array.from(elements).map(el => el.textContent?.trim() ?? '');
+          }, DATE_SELECTORS);
+
+          datesByTimezone[tz] = dates.filter(d => d.length > 0);
+        } catch {
+          datesByTimezone[tz] = [];
+        }
+
+        await page.close().catch(() => undefined);
+        await context.close().catch(() => undefined);
+      }
+
+      // Check format consistency across timezones
+      const timezoneKeys = Object.keys(datesByTimezone);
+      if (timezoneKeys.length >= 2) {
+        const firstTzDates = datesByTimezone[timezoneKeys[0]];
+        const otherTzKeys = timezoneKeys.slice(1);
+
+        for (const otherTz of otherTzKeys) {
+          const otherDates = datesByTimezone[otherTz];
+          if (firstTzDates.length !== otherDates.length) {
+            findings.push({
+              id: `${this.agentId}-date-count-mismatch-${otherTz}`,
+              type: 'test-bug',
+              severity: 'low',
+              agentId: this.agentId,
+              module: firstModule.id,
+              description: `Date element count differs between ${timezoneKeys[0]} (${firstTzDates.length}) and ${otherTz} (${otherDates.length})`,
+            });
+          }
+
+          // Check for day-level differences (off-by-one)
+          const minLen = Math.min(firstTzDates.length, otherDates.length);
+          for (let i = 0; i < minLen; i++) {
+            const dayDiff = this.detectDayDifference(firstTzDates[i], otherDates[i]);
+            if (dayDiff) {
+              findings.push({
+                id: `${this.agentId}-off-by-one-${otherTz}-${i}`,
+                type: 'test-bug',
+                severity: 'medium',
+                agentId: this.agentId,
+                module: firstModule.id,
+                description: `Potential off-by-one date: "${firstTzDates[i]}" (${timezoneKeys[0]}) vs "${otherDates[i]}" (${otherTz})`,
+              });
+            }
+          }
+        }
+
+        if (timezoneKeys.every(tz => datesByTimezone[tz].length === 0)) {
+          findings.push({
+            id: `${this.agentId}-no-dates-found`,
+            type: 'test-bug',
+            severity: 'low',
+            agentId: this.agentId,
+            module: firstModule.id,
+            description: 'No date elements found on the page to test timezone behavior',
+          });
+        }
+      }
+    } catch (playwrightError) {
+      findings.push({
+        id: `${this.agentId}-playwright-failure`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'timezone-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;
+  }
+
+  private detectDayDifference(dateA: string, dateB: string): boolean {
+    if (dateA === dateB) return false;
+
+    // Extract day numbers from both strings
+    const dayPatternA = dateA.match(/\b(\d{1,2})\b/g);
+    const dayPatternB = dateB.match(/\b(\d{1,2})\b/g);
+
+    if (!dayPatternA || !dayPatternB) return false;
+
+    // If any day number differs by exactly 1, it could be an off-by-one
+    for (let i = 0; i < Math.min(dayPatternA.length, dayPatternB.length); i++) {
+      const diff = Math.abs(parseInt(dayPatternA[i], 10) - parseInt(dayPatternB[i], 10));
+      if (diff === 1) return true;
+    }
+
+    return false;
+  }
+}