@avi770/testteam 1.2.0 → 3.0.0

package/agents/27-search-filter-tester.ts

@@ -0,0 +1,326 @@
+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 search/filter operations. */
+const OP_TIMEOUT_MS = 5_000;
+
+/** Selectors for search inputs. */
+const SEARCH_SELECTORS = [
+  'input[type="search"]',
+  'input[placeholder*="search" i]',
+  'input[placeholder*="find" i]',
+  '[data-testid*="search"]',
+  '[role="searchbox"]',
+] as const;
+
+/** Selectors for filter controls. */
+const FILTER_SELECTORS = [
+  'select',
+  '[role="combobox"]',
+  'button:has-text("Filter")',
+  '[data-testid*="filter"]',
+] as const;
+
+export class SearchFilterTesterAgent extends BaseAgent {
+  readonly agentId = 27;
+  readonly agentName = 'Search & Filter Tester';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.modules || this.config.modules.length === 0) {
+      throw new Error('SearchFilterTesterAgent 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: 'search-filter-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();
+
+      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: 'search-filter-tester',
+            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.testModuleSearchFilter(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: 'search-filter-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 testModuleSearchFilter(
+    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')), OP_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;
+    }
+
+    // Find search inputs
+    const searchSelector = SEARCH_SELECTORS.join(', ');
+    let searchCount = 0;
+    try {
+      searchCount = await Promise.race([
+        page.locator(searchSelector).count(),
+        new Promise<number>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as number;
+    } catch {
+      // Timeout discovering search inputs
+    }
+
+    if (searchCount > 0) {
+      const searchFindings = await this.testSearch(page, moduleId);
+      findings.push(...searchFindings);
+    }
+
+    // Find filters
+    const filterSelector = FILTER_SELECTORS.join(', ');
+    let filterCount = 0;
+    try {
+      filterCount = await Promise.race([
+        page.locator(filterSelector).count(),
+        new Promise<number>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as number;
+    } catch {
+      // Timeout discovering filters
+    }
+
+    if (filterCount > 0) {
+      const filterFindings = await this.testFilter(page, moduleId, filterCount);
+      findings.push(...filterFindings);
+    }
+
+    if (searchCount === 0 && filterCount === 0) {
+      findings.push({
+        id: `${this.agentId}-no-search-filter-${moduleId}`,
+        type: 'test-bug',
+        severity: 'low',
+        agentId: this.agentId,
+        module: moduleId,
+        description: `No search or filter UI found in module ${moduleId}`,
+      });
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test search functionality: type query, check results change,
+   * clear, check restore, type gibberish, check empty state.
+   */
+  private async testSearch(page: Page, moduleId: string): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const searchSelector = SEARCH_SELECTORS.join(', ');
+    const searchInput = page.locator(searchSelector).first();
+
+    try {
+      // Type "test" and wait for results
+      await Promise.race([
+        searchInput.fill('test'),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]);
+
+      await page.waitForTimeout(1000);
+
+      // Clear search
+      await Promise.race([
+        searchInput.fill(''),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]);
+
+      await page.waitForTimeout(1000);
+
+      // Type gibberish
+      await Promise.race([
+        searchInput.fill('zzz999xxx'),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]);
+
+      await page.waitForTimeout(1000);
+
+      // Check if results area shows content (meaning search may not be filtering)
+      const noResultsIndicators = await page
+        .locator(
+          ':text("no results"), :text("not found"), :text("no matches"), [data-testid*="empty"], .empty-state',
+        )
+        .count()
+        .catch(() => 0);
+
+      // Check if list items still exist
+      const listItems = await page
+        .locator('tr, [class*="list-item"], [class*="card"], li')
+        .count()
+        .catch(() => 0);
+
+      if (noResultsIndicators === 0 && listItems > 0) {
+        findings.push({
+          id: `${this.agentId}-search-not-filtering-${moduleId}`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: moduleId,
+          description: 'Search may not be filtering — gibberish query still shows list items',
+        });
+      }
+
+      // Clear search for next tests
+      await searchInput.fill('').catch(() => undefined);
+    } catch (searchError) {
+      findings.push({
+        id: `${this.agentId}-search-error-${moduleId}`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: moduleId,
+        description: `Search test failed in module ${moduleId}: ${searchError instanceof Error ? searchError.message.split('\n')[0] : String(searchError)}`,
+      });
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test filter controls: click/select, verify list updates.
+   */
+  private async testFilter(
+    page: Page,
+    moduleId: string,
+    filterCount: number,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const filterSelector = FILTER_SELECTORS.join(', ');
+
+    try {
+      const firstFilter = page.locator(filterSelector).first();
+      const tagName = await firstFilter.evaluate((el) => el.tagName.toLowerCase()).catch(() => '');
+
+      if (tagName === 'select') {
+        const optionCount = await firstFilter.locator('option').count();
+        if (optionCount > 1) {
+          const value = await firstFilter.locator('option').nth(1).getAttribute('value');
+          if (value) {
+            await Promise.race([
+              firstFilter.selectOption(value),
+              new Promise((_, reject) =>
+                setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+              ),
+            ]);
+          }
+        }
+      } else {
+        await Promise.race([
+          firstFilter.click(),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+          ),
+        ]);
+      }
+
+      findings.push({
+        id: `${this.agentId}-filter-found-${moduleId}`,
+        type: 'infra-issue',
+        severity: 'info',
+        agentId: this.agentId,
+        module: moduleId,
+        description: `Found ${filterCount} filter control(s) in module ${moduleId}`,
+      });
+    } catch (filterError) {
+      findings.push({
+        id: `${this.agentId}-filter-error-${moduleId}`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: moduleId,
+        description: `Filter test failed in module ${moduleId}: ${filterError instanceof Error ? filterError.message.split('\n')[0] : String(filterError)}`,
+      });
+    }
+
+    return findings;
+  }
+}