@avi770/testteam 1.2.0

package/agents/20-workflow-completion-tester.ts

@@ -0,0 +1,203 @@
+import type { Browser, Page } from 'playwright';
+import type { Finding } from '../core/types';
+import type { ValidatedConfig } from '../core/config';
+import { BaseAgent } from './base-agent';
+import { login, waitForSectionLoad } from '../helpers/navigation';
+import { captureScreenshot } from '../helpers/screenshot';
+import { fillForm } from '../helpers/form-filler';
+import { resolveEnvironment, isUrlReachable } from '../helpers/env-resolver';
+
+export class WorkflowCompletionTesterAgent extends BaseAgent {
+  readonly agentId = 20;
+  readonly agentName = 'Workflow Completion Tester';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.workflows || this.config.workflows.length === 0) {
+      throw new Error(
+        'WorkflowCompletionTesterAgent requires at least one workflow in config.workflows',
+      );
+    }
+
+    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: 'critical',
+        agentId: this.agentId,
+        module: 'workflow-completion-tester',
+        description: 'No credentials configured — cannot log in to run workflow tests',
+      });
+      return findings;
+    }
+
+    const { chromium } = await import('playwright');
+
+    let browser: Browser | null = null;
+    let page: Page | null = null;
+
+    try {
+      browser = await chromium.launch({ headless: true });
+      page = await browser.newPage();
+
+      try {
+        await login(page, credentials, loginUrl);
+      } catch (loginError) {
+        findings.push({
+          id: `${this.agentId}-login-failed`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: 'workflow-completion-tester',
+          description: `Login failed — skipping workflow tests: ${loginError instanceof Error ? loginError.message.split('\n')[0] : String(loginError)}`,
+        });
+        return findings;
+      }
+
+      for (const workflow of this.config.workflows) {
+        const workflowFindings = await this.runWorkflow(page, workflow.name, workflow.steps);
+        findings.push(...workflowFindings);
+      }
+    } catch (playwrightError) {
+      findings.push({
+        id: `${this.agentId}-playwright-failure`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'workflow-completion-tester',
+        description: `Workflow Playwright execution failed: ${playwrightError instanceof Error ? playwrightError.message.split('\n')[0] : String(playwrightError)}`,
+      });
+    } finally {
+      if (page) await page.close().catch(() => undefined);
+      if (browser) await browser.close().catch(() => undefined);
+    }
+
+    return findings;
+  }
+
+  private async runWorkflow(
+    page: Page,
+    workflowName: string,
+    steps: ValidatedConfig['workflows'][number]['steps'],
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+
+    for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
+      const step = steps[stepIndex];
+
+      try {
+        await this.executeStep(page, step);
+      } catch (err) {
+        const description = err instanceof Error ? err.message : String(err);
+
+        const screenshotPath = await captureScreenshot(
+          page,
+          `workflow-${workflowName.replace(/\s+/g, '-')}-step${stepIndex}-failure`,
+          this.runDir,
+        ).catch(() => '');
+
+        if (screenshotPath) {
+          this.addEvidence({
+            type: 'screenshot',
+            path: screenshotPath,
+            description: `[Workflow "${workflowName}"] Failure screenshot at step ${stepIndex} (${step.action}: ${step.target})`,
+          });
+        }
+
+        findings.push({
+          id: `${this.agentId}-workflow-${workflowName.replace(/\s+/g, '-')}-step${stepIndex}`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: `workflow:${workflowName}`,
+          description: `Workflow "${workflowName}" failed at step ${stepIndex} (${step.action}: ${step.target}): ${description}`,
+          screenshot: screenshotPath || undefined,
+        });
+
+        // Stop processing this workflow on failure
+        break;
+      }
+
+      // Screenshot evidence at each step
+      const screenshotPath = await captureScreenshot(
+        page,
+        `workflow-${workflowName.replace(/\s+/g, '-')}-step${stepIndex}`,
+        this.runDir,
+      ).catch(() => '');
+
+      if (screenshotPath) {
+        this.addEvidence({
+          type: 'screenshot',
+          path: screenshotPath,
+          description: `[Workflow "${workflowName}"] Step ${stepIndex} completed (${step.action}: ${step.target})`,
+        });
+      }
+    }
+
+    return findings;
+  }
+
+  private async executeStep(
+    page: Page,
+    step: ValidatedConfig['workflows'][number]['steps'][number],
+  ): Promise<void> {
+    switch (step.action) {
+      case 'navigate': {
+        const url = step.target.startsWith('http') ? step.target : `${this.baseUrl}${step.target}`;
+        await page.goto(url);
+        await waitForSectionLoad(page);
+        break;
+      }
+
+      case 'click': {
+        await page.click(step.target);
+        if (step.verify) {
+          await page.waitForSelector(step.verify, { timeout: step.timeout ?? 5_000 });
+        }
+        break;
+      }
+
+      case 'fill-form': {
+        await fillForm(page, step.target, step.data ? { data: step.data } : undefined);
+        break;
+      }
+
+      case 'wait': {
+        await page.waitForSelector(step.target, { timeout: step.timeout ?? 5_000 });
+        break;
+      }
+
+      case 'verify': {
+        const element = await page.waitForSelector(step.target, { timeout: step.timeout ?? 5_000 });
+        if (step.contains !== undefined) {
+          const text = await element.textContent();
+          if (!text?.includes(step.contains)) {
+            throw new Error(
+              `Element "${step.target}" does not contain expected text "${step.contains}" — found: "${text ?? ''}"`,
+            );
+          }
+        }
+        break;
+      }
+
+      default: {
+        // TypeScript exhaustiveness guard
+        const _exhaustive: never = step.action;
+        throw new Error(`Unknown workflow step action: ${String(_exhaustive)}`);
+      }
+    }
+  }
+}

package/agents/21-state-session-tester.ts

@@ -0,0 +1,262 @@
+import type { Browser, BrowserContext, Page } from 'playwright';
+import type { Finding } from '../core/types';
+import { BaseAgent } from './base-agent';
+import { resolveEnvironment } from '../helpers/env-resolver';
+
+export class StateSessionTesterAgent extends BaseAgent {
+  readonly agentId = 21;
+  readonly agentName = 'State & Session Tester';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    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: 'critical',
+        agentId: this.agentId,
+        module: 'state-session',
+        description: 'No credentials configured — cannot run state/session tests',
+      });
+      return findings;
+    }
+
+    if (this.config.modules.length === 0) {
+      findings.push({
+        id: `${this.agentId}-no-modules`,
+        type: 'infra-issue',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: 'state-session',
+        description: 'No modules configured — skipping state/session tests',
+      });
+      return findings;
+    }
+
+    const { chromium } = await import('playwright');
+
+    // -----------------------------------------------------------------------
+    // Scenario 1: Deep link — open module URL directly in a fresh context
+    // -----------------------------------------------------------------------
+    {
+      let browser: Browser | null = null;
+      let context: BrowserContext | null = null;
+      let page: Page | null = null;
+      try {
+        browser = await chromium.launch({ headless: true });
+        context = await browser.newContext();
+        page = await context.newPage();
+
+        const targetModule = this.config.modules[0]!;
+        const deepLinkUrl = `${this.baseUrl}${targetModule.route}`;
+
+        // Navigate directly to a deep link without prior login
+        await page.goto(deepLinkUrl, { waitUntil: 'networkidle', timeout: 20_000 });
+
+        // After potential login redirect and re-authentication, check we eventually load the module
+        const finalUrl = page.url();
+        const isOnLogin =
+          finalUrl.includes('/login') ||
+          finalUrl.includes('/auth') ||
+          finalUrl.includes('/signin');
+
+        if (!isOnLogin) {
+          // We either loaded the module or landed somewhere unexpected without login
+          const pageContent = await page.content();
+          const moduleLoaded =
+            pageContent.includes(targetModule.id) ||
+            pageContent.includes(targetModule.route.replace('/', ''));
+
+          if (!moduleLoaded) {
+            findings.push({
+              id: `${this.agentId}-deep-link-${targetModule.id}`,
+              type: 'code-bug-logic',
+              severity: 'medium',
+              agentId: this.agentId,
+              module: targetModule.id,
+              description:
+                `Deep link scenario: navigating directly to "${deepLinkUrl}" did not load the expected module ` +
+                `or redirect to login. Final URL: ${finalUrl}`,
+              suggestedFix:
+                'Ensure unauthenticated deep links redirect to login then back to the original route.',
+            });
+          }
+        }
+        // Redirect to login on direct deep link is the correct behaviour — no finding
+      } catch (error) {
+        findings.push({
+          id: `${this.agentId}-deep-link-error`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: this.config.modules[0]?.id ?? 'unknown',
+          description: `Deep link scenario failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+      } finally {
+        if (page) await page.close().catch(() => undefined);
+        if (context) await context.close().catch(() => undefined);
+        if (browser) await browser.close().catch(() => undefined);
+      }
+    }
+
+    // -----------------------------------------------------------------------
+    // Scenario 2: Refresh persistence — navigate to a module, reload, verify
+    // -----------------------------------------------------------------------
+    {
+      let browser: Browser | null = null;
+      let context: BrowserContext | null = null;
+      let page: Page | null = null;
+      try {
+        browser = await chromium.launch({ headless: true });
+        context = await browser.newContext();
+        page = await context.newPage();
+
+        // Login first
+        await page.goto(loginUrl, { waitUntil: 'networkidle', timeout: 20_000 });
+        await page
+          .fill('input[type="email"], input[name="email"]', credentials.email)
+          .catch(() => undefined);
+        await page
+          .fill('input[type="password"], input[name="password"]', credentials.password)
+          .catch(() => undefined);
+        await page.click('button[type="submit"]').catch(() => undefined);
+        await page
+          .waitForNavigation({ waitUntil: 'networkidle', timeout: 15_000 })
+          .catch(() => undefined);
+
+        const targetModule = this.config.modules[0]!;
+        const moduleUrl = `${this.baseUrl}${targetModule.route}`;
+
+        await page.goto(moduleUrl, { waitUntil: 'networkidle', timeout: 15_000 });
+        const urlBeforeReload = page.url();
+
+        // Reload the page
+        await page.reload({ waitUntil: 'networkidle', timeout: 15_000 });
+
+        const urlAfterReload = page.url();
+        const reloadedToLogin =
+          urlAfterReload.includes('/login') ||
+          urlAfterReload.includes('/auth') ||
+          urlAfterReload.includes('/signin');
+
+        if (reloadedToLogin) {
+          findings.push({
+            id: `${this.agentId}-refresh-${targetModule.id}`,
+            type: 'code-bug-logic',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: targetModule.id,
+            description:
+              `Refresh persistence: page reload on "${urlBeforeReload}" redirected to login (${urlAfterReload}). ` +
+              'Session was not persisted across a page refresh.',
+            suggestedFix:
+              'Store the authentication token in a persistent storage (localStorage or httpOnly cookie) and restore session on reload.',
+          });
+        }
+      } catch (error) {
+        findings.push({
+          id: `${this.agentId}-refresh-error`,
+          type: 'infra-issue',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: this.config.modules[0]?.id ?? 'unknown',
+          description: `Refresh persistence scenario failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+      } finally {
+        if (page) await page.close().catch(() => undefined);
+        if (context) await context.close().catch(() => undefined);
+        if (browser) await browser.close().catch(() => undefined);
+      }
+    }
+
+    // -----------------------------------------------------------------------
+    // Scenario 3: Back/forward navigation — navigate 3 modules, go back 2
+    // -----------------------------------------------------------------------
+    if (this.config.modules.length >= 3) {
+      let browser: Browser | null = null;
+      let context: BrowserContext | null = null;
+      let page: Page | null = null;
+      try {
+        browser = await chromium.launch({ headless: true });
+        context = await browser.newContext();
+        page = await context.newPage();
+
+        // Login first
+        await page.goto(loginUrl, { waitUntil: 'networkidle', timeout: 20_000 });
+        await page
+          .fill('input[type="email"], input[name="email"]', credentials.email)
+          .catch(() => undefined);
+        await page
+          .fill('input[type="password"], input[name="password"]', credentials.password)
+          .catch(() => undefined);
+        await page.click('button[type="submit"]').catch(() => undefined);
+        await page
+          .waitForNavigation({ waitUntil: 'networkidle', timeout: 15_000 })
+          .catch(() => undefined);
+
+        const [mod1, mod2, mod3] = this.config.modules.slice(0, 3) as [
+          (typeof this.config.modules)[0],
+          (typeof this.config.modules)[0],
+          (typeof this.config.modules)[0],
+        ];
+
+        await page.goto(`${this.baseUrl}${mod1.route}`, { waitUntil: 'networkidle', timeout: 15_000 });
+        await page.goto(`${this.baseUrl}${mod2.route}`, { waitUntil: 'networkidle', timeout: 15_000 });
+        await page.goto(`${this.baseUrl}${mod3.route}`, { waitUntil: 'networkidle', timeout: 15_000 });
+
+        // Go back 2 pages — should land on mod1
+        await page.goBack({ waitUntil: 'networkidle', timeout: 10_000 });
+        await page.goBack({ waitUntil: 'networkidle', timeout: 10_000 });
+
+        const currentUrl = page.url();
+        const expectedRoute = mod1.route;
+        const landedOnCorrectModule =
+          currentUrl.includes(expectedRoute) ||
+          currentUrl.endsWith(expectedRoute.replace(/^\//, ''));
+
+        if (!landedOnCorrectModule) {
+          findings.push({
+            id: `${this.agentId}-back-forward-${mod1.id}`,
+            type: 'code-bug-logic',
+            severity: 'low',
+            agentId: this.agentId,
+            module: mod1.id,
+            description:
+              `Back/forward navigation: after navigating to modules [${mod1.id}, ${mod2.id}, ${mod3.id}] ` +
+              `and going back 2 times, expected to be on "${mod1.route}" but landed on "${currentUrl}".`,
+            suggestedFix:
+              'Ensure router history is correctly maintained across module transitions.',
+          });
+        }
+      } catch (error) {
+        findings.push({
+          id: `${this.agentId}-back-forward-error`,
+          type: 'infra-issue',
+          severity: 'low',
+          agentId: this.agentId,
+          module: 'navigation',
+          description: `Back/forward scenario failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+      } finally {
+        if (page) await page.close().catch(() => undefined);
+        if (context) await context.close().catch(() => undefined);
+        if (browser) await browser.close().catch(() => undefined);
+      }
+    }
+
+    return findings;
+  }
+}