@avi770/testteam 1.2.0 → 2.0.0

package/agents/25-crud-flow-tester.ts

@@ -0,0 +1,302 @@
+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 module CRUD operations. */
+const OP_TIMEOUT_MS = 5_000;
+
+/** Selectors that indicate common CRUD action buttons. */
+const CREATE_SELECTORS = [
+  'button:has-text("Create")',
+  'button:has-text("Add")',
+  'button:has-text("New")',
+  '[data-testid*="create"]',
+  '[data-testid*="add"]',
+  '[data-testid*="new"]',
+] as const;
+
+const EDIT_SELECTORS = [
+  'button:has-text("Edit")',
+  '[data-testid*="edit"]',
+  'a:has-text("Edit")',
+] as const;
+
+const DELETE_SELECTORS = [
+  'button:has-text("Delete")',
+  '[data-testid*="delete"]',
+  'button:has-text("Remove")',
+] as const;
+
+const SUCCESS_SELECTORS = [
+  '[class*="toast"]',
+  '[role="alert"]',
+  '[data-testid*="success"]',
+  '.success',
+  '.notification',
+] as const;
+
+export class CrudFlowTesterAgent extends BaseAgent {
+  readonly agentId = 25;
+  readonly agentName = 'CRUD Flow Tester';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.modules || this.config.modules.length === 0) {
+      throw new Error('CrudFlowTesterAgent 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: 'crud-flow-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: 'crud-flow-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.testModuleCrud(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: 'crud-flow-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 testModuleCrud(
+    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;
+    }
+
+    // Discover create buttons
+    const createSelector = CREATE_SELECTORS.join(', ');
+    let hasCreateButton = false;
+
+    try {
+      const createCount = await Promise.race([
+        page.locator(createSelector).count(),
+        new Promise<number>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as number;
+
+      hasCreateButton = createCount > 0;
+    } catch {
+      // Timeout or error discovering create buttons
+    }
+
+    if (!hasCreateButton) {
+      // Check for edit/delete as well
+      const editSelector = EDIT_SELECTORS.join(', ');
+      const deleteSelector = DELETE_SELECTORS.join(', ');
+
+      let hasEditOrDelete = false;
+      try {
+        const editCount = await Promise.race([
+          page.locator(editSelector).count(),
+          new Promise<number>((_, reject) =>
+            setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+          ),
+        ]) as number;
+
+        const deleteCount = await Promise.race([
+          page.locator(deleteSelector).count(),
+          new Promise<number>((_, reject) =>
+            setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+          ),
+        ]) as number;
+
+        hasEditOrDelete = editCount > 0 || deleteCount > 0;
+      } catch {
+        // Timeout or error
+      }
+
+      if (!hasEditOrDelete) {
+        findings.push({
+          id: `${this.agentId}-no-crud-${moduleId}`,
+          type: 'test-bug',
+          severity: 'low',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `No CRUD actions found for module ${moduleId}`,
+        });
+        return findings;
+      }
+    }
+
+    // Attempt create flow
+    if (hasCreateButton) {
+      try {
+        await Promise.race([
+          page.locator(createSelector).first().click(),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+          ),
+        ]);
+
+        // Look for form or modal
+        const formCount = await page.locator('form, [role="dialog"], .modal').count();
+        if (formCount > 0) {
+          // Fill text inputs with test data
+          const inputs = page.locator('form input[type="text"], [role="dialog"] input[type="text"]');
+          const inputCount = await inputs.count();
+          for (let i = 0; i < inputCount; i++) {
+            await inputs.nth(i).fill(`Test Data ${i + 1}`).catch(() => undefined);
+          }
+
+          // Try submit
+          const submitBtn = page.locator(
+            'button[type="submit"], button:has-text("Save"), button:has-text("Submit"), button:has-text("Create")',
+          );
+          if (await submitBtn.count() > 0) {
+            await submitBtn.first().click().catch(() => undefined);
+
+            // Check for success indicator
+            const successSelector = SUCCESS_SELECTORS.join(', ');
+            try {
+              await page.waitForSelector(successSelector, { timeout: OP_TIMEOUT_MS });
+            } catch {
+              findings.push({
+                id: `${this.agentId}-create-no-feedback-${moduleId}`,
+                type: 'test-bug',
+                severity: 'medium',
+                agentId: this.agentId,
+                module: moduleId,
+                description: `Create action in module ${moduleId} did not produce a visible success/error response`,
+              });
+            }
+          }
+        }
+      } catch (createError) {
+        findings.push({
+          id: `${this.agentId}-create-failed-${moduleId}`,
+          type: 'test-bug',
+          severity: 'medium',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `Create action failed for module ${moduleId}: ${createError instanceof Error ? createError.message.split('\n')[0] : String(createError)}`,
+        });
+      }
+    }
+
+    // Check for delete buttons on the page
+    const deleteSelector = DELETE_SELECTORS.join(', ');
+    try {
+      const deleteCount = await Promise.race([
+        page.locator(deleteSelector).count(),
+        new Promise<number>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as number;
+
+      if (deleteCount > 0) {
+        try {
+          await Promise.race([
+            page.locator(deleteSelector).first().click(),
+            new Promise((_, reject) =>
+              setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+            ),
+          ]);
+
+          // Look for confirm dialog
+          const confirmBtn = page.locator(
+            'button:has-text("Confirm"), button:has-text("Yes"), button:has-text("OK")',
+          );
+          if (await confirmBtn.count() > 0) {
+            await confirmBtn.first().click().catch(() => undefined);
+          }
+        } catch (deleteError) {
+          findings.push({
+            id: `${this.agentId}-delete-failed-${moduleId}`,
+            type: 'test-bug',
+            severity: 'medium',
+            agentId: this.agentId,
+            module: moduleId,
+            description: `Delete action failed for module ${moduleId}: ${deleteError instanceof Error ? deleteError.message.split('\n')[0] : String(deleteError)}`,
+          });
+        }
+      }
+    } catch {
+      // Timeout discovering delete buttons — non-critical
+    }
+
+    return findings;
+  }
+}

package/agents/26-form-validator.ts

@@ -0,0 +1,297 @@
+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 form test operations. */
+const OP_TIMEOUT_MS = 5_000;
+
+/** Selectors that indicate validation error messages. */
+const VALIDATION_ERROR_SELECTORS = [
+  '.error',
+  '[aria-invalid="true"]',
+  '.text-red',
+  '[class*="error"]',
+  '[role="alert"]',
+  '.field-error',
+  '.validation-error',
+] as const;
+
+export class FormValidatorAgent extends BaseAgent {
+  readonly agentId = 26;
+  readonly agentName = 'Form Validator';
+  private baseUrl = '';
+
+  protected async preFlight(): Promise<void> {
+    if (!this.config.modules || this.config.modules.length === 0) {
+      throw new Error('FormValidatorAgent 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: 'form-validator',
+        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: 'form-validator',
+            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.testModuleForms(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: 'form-validator',
+        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 testModuleForms(
+    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 all forms
+    let formCount = 0;
+    try {
+      formCount = await Promise.race([
+        page.locator('form').count(),
+        new Promise<number>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as number;
+    } catch {
+      // Timeout discovering forms
+    }
+
+    if (formCount === 0) {
+      findings.push({
+        id: `${this.agentId}-no-forms-${moduleId}`,
+        type: 'test-bug',
+        severity: 'low',
+        agentId: this.agentId,
+        module: moduleId,
+        description: `No forms found in module ${moduleId}`,
+      });
+      return findings;
+    }
+
+    for (let formIdx = 0; formIdx < formCount; formIdx++) {
+      const formFindings = await this.testSingleForm(page, moduleId, formIdx);
+      findings.push(...formFindings);
+    }
+
+    return findings;
+  }
+
+  private async testSingleForm(
+    page: Page,
+    moduleId: string,
+    formIndex: number,
+  ): Promise<Finding[]> {
+    const findings: Finding[] = [];
+    const form = page.locator('form').nth(formIndex);
+
+    // Count inputs
+    let inputCount = 0;
+    try {
+      inputCount = await Promise.race([
+        form.locator('input, textarea, select').count(),
+        new Promise<number>((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]) as number;
+    } catch {
+      return findings;
+    }
+
+    if (inputCount === 0) {
+      return findings;
+    }
+
+    // Empty submit test: click submit without filling anything
+    const submitBtn = form.locator(
+      'button[type="submit"], input[type="submit"], button:has-text("Submit"), button:has-text("Save")',
+    );
+
+    let hasSubmitButton = false;
+    try {
+      hasSubmitButton = (await submitBtn.count()) > 0;
+    } catch {
+      return findings;
+    }
+
+    if (!hasSubmitButton) {
+      return findings;
+    }
+
+    try {
+      await Promise.race([
+        submitBtn.first().click(),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]);
+
+      // Wait briefly for validation errors to appear
+      await page.waitForTimeout(500);
+
+      // Check for validation errors
+      const errorSelector = VALIDATION_ERROR_SELECTORS.join(', ');
+      let errorCount = 0;
+      try {
+        errorCount = await page.locator(errorSelector).count();
+      } catch {
+        // Error counting validation indicators
+      }
+
+      if (errorCount === 0) {
+        findings.push({
+          id: `${this.agentId}-empty-submit-${moduleId}-form${formIndex}`,
+          type: 'test-bug',
+          severity: 'high',
+          agentId: this.agentId,
+          module: moduleId,
+          description: `Form ${formIndex} in module ${moduleId} accepts empty submission without validation`,
+        });
+      }
+    } catch (submitError) {
+      findings.push({
+        id: `${this.agentId}-submit-error-${moduleId}-form${formIndex}`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: moduleId,
+        description: `Form ${formIndex} submit test failed in module ${moduleId}: ${submitError instanceof Error ? submitError.message.split('\n')[0] : String(submitError)}`,
+      });
+    }
+
+    // Valid submit test: fill required inputs with test data
+    try {
+      const inputs = form.locator('input, textarea, select');
+      const count = await inputs.count();
+      for (let i = 0; i < count; i++) {
+        const input = inputs.nth(i);
+        const tagName = await input.evaluate((el) => el.tagName.toLowerCase());
+        const inputType = await input.getAttribute('type') ?? 'text';
+
+        if (tagName === 'select') {
+          // Select second option if available
+          const optionCount = await input.locator('option').count();
+          if (optionCount > 1) {
+            const value = await input.locator('option').nth(1).getAttribute('value');
+            if (value) {
+              await input.selectOption(value).catch(() => undefined);
+            }
+          }
+        } else if (inputType === 'email') {
+          await input.fill('test@example.com').catch(() => undefined);
+        } else if (inputType === 'number') {
+          await input.fill('42').catch(() => undefined);
+        } else if (inputType === 'tel') {
+          await input.fill('+1234567890').catch(() => undefined);
+        } else if (inputType === 'checkbox' || inputType === 'radio') {
+          await input.check().catch(() => undefined);
+        } else if (tagName === 'textarea' || inputType === 'text' || inputType === 'search') {
+          await input.fill('Test input data').catch(() => undefined);
+        } else if (inputType === 'password') {
+          await input.fill('TestPassword123!').catch(() => undefined);
+        }
+      }
+
+      // Submit with filled data
+      await Promise.race([
+        submitBtn.first().click(),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), OP_TIMEOUT_MS),
+        ),
+      ]);
+    } catch (validSubmitError) {
+      findings.push({
+        id: `${this.agentId}-valid-submit-error-${moduleId}-form${formIndex}`,
+        type: 'test-bug',
+        severity: 'medium',
+        agentId: this.agentId,
+        module: moduleId,
+        description: `Valid submission test failed for form ${formIndex} in module ${moduleId}: ${validSubmitError instanceof Error ? validSubmitError.message.split('\n')[0] : String(validSubmitError)}`,
+      });
+    }
+
+    return findings;
+  }
+}