@avi770/testteam 1.2.0 → 3.0.0

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

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,180 @@
+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

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1,151 @@
+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;
+  }
+}