@avi770/testteam 1.2.0 → 3.0.0

package/agents/28-navigation-routing-tester.ts

@@ -0,0 +1,425 @@
+import type { Browser, BrowserContext, 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 navigation operations. */
+const NAV_TIMEOUT_MS = 3_000;
+
+export class NavigationRoutingTesterAgent extends BaseAgent {
+  readonly agentId = 28;
+  readonly agentName = 'Navigation & Routing Tester';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.modules || this.config.modules.length === 0) {
+      throw new Error(
+        'NavigationRoutingTesterAgent 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: 'navigation-routing-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();
+
+      let loggedIn = false;
+      if (credentials) {
+        try {
+          await login(page, credentials, loginUrl);
+          loggedIn = true;
+        } catch (loginError) {
+          findings.push({
+            id: `${this.agentId}-login-failed`,
+            type: 'infra-issue',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: 'navigation-routing-tester',
+            description: `Login failed — continuing anonymously: ${loginError instanceof Error ? loginError.message.split('\n')[0] : String(loginError)}`,
+          });
+        }
+      }
+
+      // Test 1: Sidebar navigation
+      const sidebarFindings = await this.testSidebarNavigation(page);
+      findings.push(...sidebarFindings);
+
+      // Test 2: 404 handling
+      const notFoundFindings = await this.test404Handling(page);
+      findings.push(...notFoundFindings);
+
+      // Test 3: Protected routes (only if we have credentials and successfully logged in)
+      if (credentials && loggedIn) {
+        const protectedFindings = await this.testProtectedRoutes(browser);
+        findings.push(...protectedFindings);
+      }
+
+      // Test 4: Link integrity
+      const linkFindings = await this.testLinkIntegrity(page);
+      findings.push(...linkFindings);
+
+      // Test 5: Back/forward navigation
+      const historyFindings = await this.testBackForward(page);
+      findings.push(...historyFindings);
+
+      await page.close().catch(() => undefined);
+    } catch (playwrightError) {
+      findings.push({
+        id: `${this.agentId}-playwright-failure`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'navigation-routing-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 1: For each module with sidebarIcon: true, click its sidebar link
+   * and verify the URL changes and content loads.
+   */
+  private async testSidebarNavigation(page: Page): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const sidebarModules = this.config.modules.filter((m) => m.sidebarIcon);
+
+    for (const mod of sidebarModules) {
+      const expectedUrl = mod.route.startsWith('http')
+        ? mod.route
+        : `${this.baseUrl}${mod.route}`;
+
+      try {
+        await Promise.race([
+          page.goto(expectedUrl, { waitUntil: 'domcontentloaded' }),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Navigation timeout')), NAV_TIMEOUT_MS),
+          ),
+        ]);
+
+        // Check the page has content (not blank)
+        const bodyText = await page.locator('body').innerText().catch(() => '');
+        if (bodyText.trim().length === 0) {
+          findings.push({
+            id: `${this.agentId}-sidebar-blank-${mod.id}`,
+            type: 'test-bug',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: mod.id,
+            description: `Sidebar navigation to module ${mod.id} (${mod.route}) resulted in a blank page`,
+          });
+        }
+      } catch (navError) {
+        findings.push({
+          id: `${this.agentId}-sidebar-nav-failed-${mod.id}`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: mod.id,
+          description: `Sidebar navigation to module ${mod.id} failed: ${navError instanceof Error ? navError.message.split('\n')[0] : String(navError)}`,
+        });
+      }
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test 2: Navigate to a fake route and verify 404 handling.
+   */
+  private async test404Handling(page: Page): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const fakeRoute = `${this.baseUrl}/this-page-does-not-exist-12345`;
+
+    try {
+      await Promise.race([
+        page.goto(fakeRoute, { waitUntil: 'domcontentloaded' }),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Navigation timeout')), NAV_TIMEOUT_MS),
+        ),
+      ]);
+
+      // Check if the page shows a 404 indicator or redirect
+      const bodyText = await page.locator('body').innerText().catch(() => '');
+      const url = page.url();
+      const has404Indicator =
+        bodyText.toLowerCase().includes('404') ||
+        bodyText.toLowerCase().includes('not found') ||
+        bodyText.toLowerCase().includes('page not found') ||
+        url.includes('/login') || // Redirected to login = acceptable
+        url !== fakeRoute; // Redirected somewhere = acceptable
+
+      if (!has404Indicator && bodyText.trim().length === 0) {
+        findings.push({
+          id: `${this.agentId}-404-blank`,
+          type: 'test-bug',
+          severity: 'high',
+          agentId: this.agentId,
+          module: 'routing',
+          description:
+            'App shows a blank page for non-existent routes instead of a 404 page or redirect',
+        });
+      } else if (!has404Indicator) {
+        findings.push({
+          id: `${this.agentId}-404-no-handler`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'routing',
+          description:
+            'Non-existent route did not show a clear 404 indicator or redirect — page may silently render without error handling',
+        });
+      }
+    } catch (navError) {
+      findings.push({
+        id: `${this.agentId}-404-nav-error`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'routing',
+        description: `404 test navigation failed: ${navError instanceof Error ? navError.message.split('\n')[0] : String(navError)}`,
+      });
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test 3: Open a new incognito context (no auth) and navigate to protected routes.
+   * Should redirect to login; if the page renders without auth, that is critical.
+   */
+  private async testProtectedRoutes(browser: Browser): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    let incognitoContext: BrowserContext | null = null;
+    try {
+      incognitoContext = await browser.newContext();
+      const incognitoPage = await incognitoContext.newPage();
+
+      for (const mod of this.config.modules) {
+        const fullUrl = mod.route.startsWith('http')
+          ? mod.route
+          : `${this.baseUrl}${mod.route}`;
+
+        try {
+          await Promise.race([
+            incognitoPage.goto(fullUrl, { waitUntil: 'domcontentloaded' }),
+            new Promise((_, reject) =>
+              setTimeout(() => reject(new Error('Navigation timeout')), NAV_TIMEOUT_MS),
+            ),
+          ]);
+
+          const currentUrl = incognitoPage.url();
+          const redirectedToLogin =
+            currentUrl.includes('/login') ||
+            currentUrl.includes('/auth') ||
+            currentUrl.includes('/signin');
+
+          if (!redirectedToLogin) {
+            // Check if the page actually has meaningful content (not just a shell)
+            const bodyText = await incognitoPage.locator('body').innerText().catch(() => '');
+            if (bodyText.trim().length > 0) {
+              findings.push({
+                id: `${this.agentId}-unprotected-${mod.id}`,
+                type: 'code-bug-security',
+                severity: 'critical',
+                agentId: this.agentId,
+                module: mod.id,
+                description: `Module ${mod.id} accessible without authentication — no redirect to login page`,
+              });
+            }
+          }
+        } catch {
+          // Navigation error for this module — skip
+        }
+      }
+
+      await incognitoPage.close().catch(() => undefined);
+    } catch {
+      // Incognito context creation failure — non-critical
+    } finally {
+      if (incognitoContext) await incognitoContext.close().catch(() => undefined);
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test 4: On each module page, find internal links and verify they load.
+   */
+  private async testLinkIntegrity(page: Page): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const testedUrls = new Set<string>();
+
+    for (const mod of this.config.modules) {
+      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')), NAV_TIMEOUT_MS),
+          ),
+        ]);
+
+        // Find all internal links
+        const links = await page.locator('a[href^="/"]').evaluateAll((elements) =>
+          elements.map((el) => el.getAttribute('href')).filter(Boolean),
+        ).catch(() => [] as string[]);
+
+        for (const href of links) {
+          if (!href || testedUrls.has(href)) continue;
+          testedUrls.add(href);
+
+          const linkUrl = `${this.baseUrl}${href}`;
+          try {
+            await Promise.race([
+              page.goto(linkUrl, { waitUntil: 'domcontentloaded' }),
+              new Promise((_, reject) =>
+                setTimeout(() => reject(new Error('Navigation timeout')), NAV_TIMEOUT_MS),
+              ),
+            ]);
+
+            const bodyText = await page.locator('body').innerText().catch(() => '');
+            if (bodyText.trim().length === 0) {
+              findings.push({
+                id: `${this.agentId}-broken-link-${mod.id}-${href.replace(/\//g, '-')}`,
+                type: 'test-bug',
+                severity: 'medium',
+                agentId: this.agentId,
+                module: mod.id,
+                description: `Link ${href} on module ${mod.id} leads to a blank page`,
+              });
+            }
+          } catch {
+            findings.push({
+              id: `${this.agentId}-link-error-${mod.id}-${href.replace(/\//g, '-')}`,
+              type: 'test-bug',
+              severity: 'medium',
+              agentId: this.agentId,
+              module: mod.id,
+              description: `Link ${href} on module ${mod.id} failed to load`,
+            });
+          }
+        }
+      } catch {
+        // Navigation to module failed — already covered by sidebar test
+      }
+    }
+
+    return findings;
+  }
+
+  /**
+   * Test 5: Navigate between two modules, test back/forward browser history.
+   */
+  private async testBackForward(page: Page): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    if (this.config.modules.length < 2) {
+      return findings;
+    }
+
+    const mod1 = this.config.modules[0];
+    const mod2 = this.config.modules[1];
+
+    const url1 = mod1.route.startsWith('http')
+      ? mod1.route
+      : `${this.baseUrl}${mod1.route}`;
+    const url2 = mod2.route.startsWith('http')
+      ? mod2.route
+      : `${this.baseUrl}${mod2.route}`;
+
+    try {
+      // Navigate to module 1
+      await Promise.race([
+        page.goto(url1, { waitUntil: 'domcontentloaded' }),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Navigation timeout')), NAV_TIMEOUT_MS),
+        ),
+      ]);
+
+      // Navigate to module 2
+      await Promise.race([
+        page.goto(url2, { waitUntil: 'domcontentloaded' }),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Navigation timeout')), NAV_TIMEOUT_MS),
+        ),
+      ]);
+
+      // Press back
+      await page.goBack({ timeout: NAV_TIMEOUT_MS });
+      const afterBack = page.url();
+      const expectedUrl1 = new URL(url1).pathname;
+      if (!afterBack.includes(expectedUrl1)) {
+        findings.push({
+          id: `${this.agentId}-back-nav-failed`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'routing',
+          description: `Back navigation did not return to ${mod1.id} (${mod1.route}) — got ${afterBack}`,
+        });
+      }
+
+      // Press forward
+      await page.goForward({ timeout: NAV_TIMEOUT_MS });
+      const afterForward = page.url();
+      const expectedUrl2 = new URL(url2).pathname;
+      if (!afterForward.includes(expectedUrl2)) {
+        findings.push({
+          id: `${this.agentId}-forward-nav-failed`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'routing',
+          description: `Forward navigation did not return to ${mod2.id} (${mod2.route}) — got ${afterForward}`,
+        });
+      }
+    } catch (historyError) {
+      findings.push({
+        id: `${this.agentId}-history-nav-error`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'routing',
+        description: `Back/forward navigation test failed: ${historyError instanceof Error ? historyError.message.split('\n')[0] : String(historyError)}`,
+      });
+    }
+
+    return findings;
+  }
+}