@avi770/testteam 3.0.0 → 3.2.0

package/agents/51-error-recovery-tester.ts

@@ -1,155 +0,0 @@
-import type { Browser, Page, Route } from 'playwright';
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-import { resolveEnvironment } from '../helpers/env-resolver';
-import { login } from '../helpers/navigation';
-
-/** How long to stay offline (ms). */
-const OFFLINE_DURATION_MS = 3_000;
-
-export class ErrorRecoveryTesterAgent extends BaseAgent {
-  readonly agentId = 51;
-  readonly agentName = 'Error Recovery Tester';
-  private baseUrl = '';
-
-  protected async preFlight(): Promise<void> {
-    if (!this.config.modules || this.config.modules.length === 0) {
-      throw new Error('ErrorRecoveryTesterAgent 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: 'error-recovery-tester',
-            description: 'Login failed — continuing anonymously',
-          });
-        }
-      }
-
-      const firstModule = this.config.modules[0];
-      const fullUrl = firstModule.route.startsWith('http')
-        ? firstModule.route
-        : `${this.baseUrl}${firstModule.route}`;
-
-      try {
-        await page.goto(fullUrl, { waitUntil: 'domcontentloaded', timeout: 10_000 });
-      } catch {
-        findings.push({
-          id: `${this.agentId}-nav-failed`,
-          type: 'test-bug',
-          severity: 'medium',
-          agentId: this.agentId,
-          module: firstModule.id,
-          description: `Failed to navigate to ${firstModule.id}`,
-        });
-        await page.close().catch(() => undefined);
-        return findings;
-      }
-
-      // Go offline
-      const abortHandler = (route: Route) => route.abort();
-      await page.route('**/*', abortHandler);
-
-      // Wait while offline
-      await new Promise(resolve => setTimeout(resolve, OFFLINE_DURATION_MS));
-
-      // Go back online
-      await page.unroute('**/*', abortHandler);
-
-      // Wait for recovery
-      await new Promise(resolve => setTimeout(resolve, 2_000));
-
-      // Check if app recovered
-      const recoveryFindings = await this.checkRecovery(page, firstModule.id);
-      findings.push(...recoveryFindings);
-
-      await page.close().catch(() => undefined);
-    } catch (playwrightError) {
-      findings.push({
-        id: `${this.agentId}-playwright-failure`,
-        type: 'infra-issue',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: 'error-recovery-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 checkRecovery(page: Page, moduleId: string): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    try {
-      const bodyContent = await page.evaluate(() => document.body.innerText?.trim() ?? '');
-
-      if (bodyContent.length === 0) {
-        findings.push({
-          id: `${this.agentId}-blank-screen-${moduleId}`,
-          type: 'test-bug',
-          severity: 'high',
-          agentId: this.agentId,
-          module: moduleId,
-          description: 'App shows blank screen after network recovery — no error recovery UI detected',
-        });
-        return findings;
-      }
-
-      // Check for recovery indicators
-      const hasRetryButton = await page.locator('button:has-text("Retry"), button:has-text("Reload"), button:has-text("Try Again")').count();
-      const hasErrorMessage = await page.locator('[role="alert"], .error, .offline').count();
-
-      if (hasRetryButton > 0 || hasErrorMessage > 0) {
-        findings.push({
-          id: `${this.agentId}-recovery-ui-${moduleId}`,
-          type: 'test-bug',
-          severity: 'low',
-          agentId: this.agentId,
-          module: moduleId,
-          description: 'App shows recovery/error UI after network restoration — manual reload may be needed',
-        });
-      }
-    } catch {
-      findings.push({
-        id: `${this.agentId}-recovery-check-failed-${moduleId}`,
-        type: 'test-bug',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: moduleId,
-        description: 'Failed to check recovery state after network restoration',
-      });
-    }
-
-    return findings;
-  }
-}

package/agents/52-offline-mode-tester.ts

@@ -1,180 +0,0 @@
-import type { Browser, Page, Route } from 'playwright';
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-import { resolveEnvironment } from '../helpers/env-resolver';
-import { login } from '../helpers/navigation';
-
-export class OfflineModeTesterAgent extends BaseAgent {
-  readonly agentId = 52;
-  readonly agentName = 'Offline Mode Tester';
-  private baseUrl = '';
-
-  protected async preFlight(): Promise<void> {
-    if (!this.config.modules || this.config.modules.length === 0) {
-      throw new Error('OfflineModeTesterAgent 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: 'offline-mode-tester',
-            description: 'Login failed — continuing anonymously',
-          });
-        }
-      }
-
-      // Load first module (content should be cached)
-      const firstModule = this.config.modules[0];
-      const firstUrl = firstModule.route.startsWith('http')
-        ? firstModule.route
-        : `${this.baseUrl}${firstModule.route}`;
-
-      try {
-        await page.goto(firstUrl, { waitUntil: 'domcontentloaded', timeout: 10_000 });
-      } catch {
-        findings.push({
-          id: `${this.agentId}-nav-failed`,
-          type: 'test-bug',
-          severity: 'medium',
-          agentId: this.agentId,
-          module: firstModule.id,
-          description: `Failed to navigate to ${firstModule.id}`,
-        });
-        await page.close().catch(() => undefined);
-        return findings;
-      }
-
-      // Check for service worker
-      const hasServiceWorker = await this.checkServiceWorker(page);
-      if (!hasServiceWorker) {
-        findings.push({
-          id: `${this.agentId}-no-service-worker`,
-          type: 'test-bug',
-          severity: 'low',
-          agentId: this.agentId,
-          module: 'offline-mode-tester',
-          description: 'No service worker controller detected — offline caching likely not available',
-        });
-      }
-
-      // Go offline
-      const abortHandler = (route: Route) => route.abort();
-      await page.route('**/*', abortHandler);
-
-      // Try navigating to second module while offline
-      if (this.config.modules.length >= 2) {
-        const secondModule = this.config.modules[1];
-        const secondUrl = secondModule.route.startsWith('http')
-          ? secondModule.route
-          : `${this.baseUrl}${secondModule.route}`;
-
-        try {
-          await page.goto(secondUrl, { waitUntil: 'domcontentloaded', timeout: 5_000 });
-        } catch {
-          // Navigation failure expected offline
-        }
-
-        // Check for offline content
-        const offlineFindings = await this.checkOfflineContent(page, secondModule.id);
-        findings.push(...offlineFindings);
-      }
-
-      // Restore online
-      await page.unroute('**/*', abortHandler);
-
-      await page.close().catch(() => undefined);
-    } catch (playwrightError) {
-      findings.push({
-        id: `${this.agentId}-playwright-failure`,
-        type: 'infra-issue',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: 'offline-mode-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 checkServiceWorker(page: Page): Promise<boolean> {
-    try {
-      return await page.evaluate(() => Boolean(navigator.serviceWorker?.controller));
-    } catch {
-      return false;
-    }
-  }
-
-  private async checkOfflineContent(page: Page, moduleId: string): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    try {
-      const bodyContent = await page.evaluate(() => document.body.innerText?.trim() ?? '');
-
-      if (bodyContent.length === 0) {
-        findings.push({
-          id: `${this.agentId}-blank-offline-${moduleId}`,
-          type: 'test-bug',
-          severity: 'medium',
-          agentId: this.agentId,
-          module: moduleId,
-          description: `Blank page when navigating to ${moduleId} while offline — no cached content or offline fallback`,
-        });
-        return findings;
-      }
-
-      // Check for explicit offline message
-      const lowerContent = bodyContent.toLowerCase();
-      if (lowerContent.includes('offline') || lowerContent.includes('no connection') || lowerContent.includes('network')) {
-        findings.push({
-          id: `${this.agentId}-offline-message-${moduleId}`,
-          type: 'test-bug',
-          severity: 'low',
-          agentId: this.agentId,
-          module: moduleId,
-          description: `Offline message displayed for ${moduleId} — app handles offline gracefully`,
-        });
-      }
-    } catch {
-      findings.push({
-        id: `${this.agentId}-offline-check-failed-${moduleId}`,
-        type: 'test-bug',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: moduleId,
-        description: `Failed to evaluate page content while offline for ${moduleId}`,
-      });
-    }
-
-    return findings;
-  }
-}

package/agents/53-graceful-degradation-tester.ts

@@ -1,156 +0,0 @@
-import type { Browser, Route } from 'playwright';
-import type { Finding } from '../core/types';
-import { BaseAgent } from './base-agent';
-import { resolveEnvironment } from '../helpers/env-resolver';
-
-export class GracefulDegradationTesterAgent extends BaseAgent {
-  readonly agentId = 53;
-  readonly agentName = 'Graceful Degradation Tester';
-  private baseUrl = '';
-
-  protected async preFlight(): Promise<void> {
-    if (!this.config.modules || this.config.modules.length === 0) {
-      throw new Error('GracefulDegradationTesterAgent 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 { 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}`;
-
-      // Test 1: Disable JavaScript — check for SSR
-      const noJsFindings = await this.testNoJavaScript(browser, fullUrl, firstModule.id);
-      findings.push(...noJsFindings);
-
-      // Test 2: Block images — check alt text
-      const noImgFindings = await this.testNoImages(browser, fullUrl, firstModule.id);
-      findings.push(...noImgFindings);
-    } catch (playwrightError) {
-      findings.push({
-        id: `${this.agentId}-playwright-failure`,
-        type: 'infra-issue',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: 'graceful-degradation-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 testNoJavaScript(
-    browser: Browser,
-    url: string,
-    moduleId: string,
-  ): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    const context = await browser.newContext({ javaScriptEnabled: false });
-    const page = await context.newPage();
-
-    try {
-      await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 10_000 });
-
-      const bodyContent = await page.evaluate(() => document.body.innerText?.trim() ?? '');
-
-      if (bodyContent.length === 0) {
-        findings.push({
-          id: `${this.agentId}-no-ssr-${moduleId}`,
-          type: 'test-bug',
-          severity: 'medium',
-          agentId: this.agentId,
-          module: moduleId,
-          description: `No content renders with JavaScript disabled — SSR/static fallback not available for ${moduleId}`,
-        });
-      }
-    } catch {
-      // Navigation may fail without JS — that itself is a finding
-      findings.push({
-        id: `${this.agentId}-no-js-nav-failed-${moduleId}`,
-        type: 'test-bug',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: moduleId,
-        description: `Page failed to load with JavaScript disabled for ${moduleId}`,
-      });
-    } finally {
-      await page.close().catch(() => undefined);
-      await context.close().catch(() => undefined);
-    }
-
-    return findings;
-  }
-
-  private async testNoImages(
-    browser: Browser,
-    url: string,
-    moduleId: string,
-  ): Promise<Finding[]> {
-    const findings: Finding[] = [];
-
-    const context = await browser.newContext();
-    const page = await context.newPage();
-
-    // Block all image requests
-    const imageBlocker = (route: Route) => route.abort();
-    await page.route('**/*.{png,jpg,jpeg,gif,webp,svg,ico}', imageBlocker);
-
-    try {
-      await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 10_000 });
-
-      // Check alt text on img elements
-      const missingAltCount = await page.evaluate(() => {
-        const images = document.querySelectorAll('img');
-        let missing = 0;
-        for (const img of images) {
-          if (!img.alt || img.alt.trim().length === 0) {
-            missing++;
-          }
-        }
-        return missing;
-      });
-
-      if (missingAltCount > 0) {
-        findings.push({
-          id: `${this.agentId}-missing-alt-${moduleId}`,
-          type: 'test-bug',
-          severity: 'medium',
-          agentId: this.agentId,
-          module: moduleId,
-          description: `${missingAltCount} image(s) missing alt text in ${moduleId}`,
-        });
-      }
-    } catch {
-      findings.push({
-        id: `${this.agentId}-img-test-failed-${moduleId}`,
-        type: 'test-bug',
-        severity: 'low',
-        agentId: this.agentId,
-        module: moduleId,
-        description: `Failed to test image degradation for ${moduleId}`,
-      });
-    } finally {
-      await page.close().catch(() => undefined);
-      await context.close().catch(() => undefined);
-    }
-
-    return findings;
-  }
-}

package/agents/54-websocket-tester.ts

@@ -1,151 +0,0 @@
-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';
-
-export class WebSocketTesterAgent extends BaseAgent {
-  readonly agentId = 54;
-  readonly agentName = 'WebSocket Tester';
-  private baseUrl = '';
-
-  protected async preFlight(): Promise<void> {
-    if (!this.config.modules || this.config.modules.length === 0) {
-      throw new Error('WebSocketTesterAgent 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];
-
-    // Check config for WS integrations
-    const hasWsConfig = this.config.integrations.some(
-      i => i.name.toLowerCase().includes('websocket') || i.name.toLowerCase().includes('ws') || i.name.toLowerCase().includes('socket'),
-    );
-
-    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: 'websocket-tester',
-            description: 'Login failed — continuing anonymously',
-          });
-        }
-      }
-
-      // Listen for WebSocket connections
-      const wsConnections: { url: string; error: boolean }[] = [];
-
-      page.on('websocket', ws => {
-        const entry = { url: ws.url(), error: false };
-        wsConnections.push(entry);
-
-        ws.on('socketerror', () => {
-          entry.error = true;
-        });
-
-        ws.on('close', () => {
-          // Track close events if needed
-        });
-      });
-
-      // Navigate through modules
-      for (const mod of this.config.modules) {
-        const fullUrl = mod.route.startsWith('http')
-          ? mod.route
-          : `${this.baseUrl}${mod.route}`;
-
-        try {
-          await page.goto(fullUrl, { waitUntil: 'domcontentloaded', timeout: 10_000 });
-          // Wait a moment for WS connections to establish
-          await new Promise(resolve => setTimeout(resolve, 2_000));
-        } catch {
-          // Navigation failure — non-critical for WS testing
-        }
-      }
-
-      // Report findings
-      if (wsConnections.length === 0 && hasWsConfig) {
-        findings.push({
-          id: `${this.agentId}-ws-configured-no-connection`,
-          type: 'test-bug',
-          severity: 'medium',
-          agentId: this.agentId,
-          module: 'websocket-tester',
-          description: 'WebSocket integration configured but no WS connections detected',
-        });
-      } else if (wsConnections.length === 0) {
-        findings.push({
-          id: `${this.agentId}-no-ws-connections`,
-          type: 'test-bug',
-          severity: 'low',
-          agentId: this.agentId,
-          module: 'websocket-tester',
-          description: 'No WebSocket connections detected during navigation',
-        });
-      }
-
-      // Check for failed connections
-      const failedWs = wsConnections.filter(ws => ws.error);
-      if (failedWs.length > 0) {
-        for (const ws of failedWs) {
-          findings.push({
-            id: `${this.agentId}-ws-error-${wsConnections.indexOf(ws)}`,
-            type: 'test-bug',
-            severity: 'medium',
-            agentId: this.agentId,
-            module: 'websocket-tester',
-            description: `WebSocket connection failed: ${ws.url}`,
-          });
-        }
-      }
-
-      // Report successful connections
-      const successfulWs = wsConnections.filter(ws => !ws.error);
-      if (successfulWs.length > 0) {
-        this.addEvidence({
-          type: 'log',
-          path: '',
-          description: `Detected ${successfulWs.length} successful WebSocket connection(s): ${successfulWs.map(ws => ws.url).join(', ')}`,
-        });
-      }
-
-      await page.close().catch(() => undefined);
-    } catch (playwrightError) {
-      findings.push({
-        id: `${this.agentId}-playwright-failure`,
-        type: 'infra-issue',
-        severity: 'medium',
-        agentId: this.agentId,
-        module: 'websocket-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;
-  }
-}