@avi770/testteam 1.2.0 → 2.0.0

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

@@ -0,0 +1,322 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config helpers
+// ---------------------------------------------------------------------------
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    schemaVersion: 1,
+    name: 'test',
+    auth: {
+      loginUrl: 'http://localhost/login',
+      credentials: {
+        admin: { email: 'admin@test.com', password: 'secret' },
+      },
+    },
+    modules: [
+      { id: 'dashboard', route: '/dashboard', sidebarIcon: true },
+      { id: 'tasks', route: '/tasks', sidebarIcon: true },
+    ],
+    environments: {
+      alpha: { baseUrl: 'http://localhost:3000', seed: false },
+    },
+    portals: [],
+    breakpoints: [],
+    integrations: [],
+    workers: [],
+    workflows: [],
+    accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+    tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+    costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' },
+    agentClassification: { blocking: [], advisory: [25] },
+    thresholds: {
+      unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
+      lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
+      apiResponseTime: 2000,
+      bundleSizeLimit: 500000,
+      maxConsoleErrors: 0,
+    },
+    disabledAgents: [],
+    disabledAgentSet: new Set<number>(),
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Mock fetch (preFlight URL reachability)
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// Mock helpers
+// ---------------------------------------------------------------------------
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock Playwright
+// ---------------------------------------------------------------------------
+
+interface MockLocator {
+  count: ReturnType<typeof vi.fn>;
+  first: ReturnType<typeof vi.fn>;
+  nth: ReturnType<typeof vi.fn>;
+  click: ReturnType<typeof vi.fn>;
+  fill: ReturnType<typeof vi.fn>;
+}
+
+function makeMockLocator(countVal = 0): MockLocator {
+  const locator: MockLocator = {
+    count: vi.fn().mockResolvedValue(countVal),
+    first: vi.fn(),
+    nth: vi.fn(),
+    click: vi.fn().mockResolvedValue(undefined),
+    fill: vi.fn().mockResolvedValue(undefined),
+  };
+  locator.first.mockReturnValue(locator);
+  locator.nth.mockReturnValue(locator);
+  return locator;
+}
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  goto: ReturnType<typeof vi.fn>;
+  click: ReturnType<typeof vi.fn>;
+  locator: ReturnType<typeof vi.fn>;
+  waitForSelector: ReturnType<typeof vi.fn>;
+}
+
+function makeMockPage(): MockPage {
+  const defaultLocator = makeMockLocator(0);
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    click: vi.fn().mockResolvedValue(undefined),
+    locator: vi.fn().mockReturnValue(defaultLocator),
+    waitForSelector: vi.fn().mockResolvedValue({ textContent: vi.fn().mockResolvedValue('') }),
+  };
+}
+
+let currentMockPage: MockPage;
+let mockBrowser: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', async () => ({
+  chromium: {
+    launch: vi.fn().mockImplementation(async () => mockBrowser),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks are hoisted
+// ---------------------------------------------------------------------------
+
+const { CrudFlowTesterAgent } = await import('../25-crud-flow-tester');
+
+function createAgent(
+  config: ValidatedConfig = makeConfig(),
+  phase: Phase = 'beta',
+): InstanceType<typeof CrudFlowTesterAgent> {
+  return new CrudFlowTesterAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('CrudFlowTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+
+    currentMockPage = makeMockPage();
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  // Identity
+  it('has agentId 25 and correct agentName', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(25);
+    expect(agent.agentName).toBe('CRUD Flow Tester');
+  });
+
+  // preFlight
+  it('throws when modules array is empty', async () => {
+    const config = makeConfig({ modules: [] });
+    const agent = createAgent(config);
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings[0].description).toContain('module');
+  });
+
+  it('resolves environment in preFlight', async () => {
+    const agent = createAgent();
+    const result = await agent.run();
+    // Should not have a preFlight error
+    expect(result.findings.every(f => !f.description.includes('preFlight'))).toBe(true);
+  });
+
+  // No CRUD buttons found
+  it('produces low finding when no CRUD actions found for a module', async () => {
+    // All locator().count() returns 0 by default
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const noCrudFindings = result.findings.filter(f => f.description.includes('No CRUD actions'));
+    expect(noCrudFindings.length).toBeGreaterThan(0);
+    expect(noCrudFindings[0].severity).toBe('low');
+  });
+
+  // CRUD buttons found — create flow
+  it('clicks create button when found and tests the flow', async () => {
+    const createLocator = makeMockLocator(1);
+    const formLocator = makeMockLocator(1);
+    const inputLocator = makeMockLocator(1);
+    const submitLocator = makeMockLocator(1);
+    const editLocator = makeMockLocator(0);
+    const deleteLocator = makeMockLocator(0);
+
+    inputLocator.fill = vi.fn().mockResolvedValue(undefined);
+    inputLocator.nth = vi.fn().mockReturnValue(inputLocator);
+
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel.includes('Create') || sel.includes('Add') || sel.includes('New')) return createLocator;
+      if (sel.includes('form') || sel.includes('dialog') || sel.includes('modal')) return formLocator;
+      if (sel.includes('input[type="text"]')) return inputLocator;
+      if (sel.includes('submit') || sel.includes('Save')) return submitLocator;
+      if (sel.includes('Edit')) return editLocator;
+      if (sel.includes('Delete') || sel.includes('Remove')) return deleteLocator;
+      return makeMockLocator(0);
+    });
+
+    currentMockPage.waitForSelector.mockResolvedValue({});
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    expect(createLocator.first).toHaveBeenCalled();
+  });
+
+  // Create fails
+  it('produces medium finding when create action fails', async () => {
+    const createLocator = makeMockLocator(1);
+    createLocator.first.mockReturnValue({
+      click: vi.fn().mockRejectedValue(new Error('Click failed')),
+    });
+
+    const editLocator = makeMockLocator(0);
+    const deleteLocator = makeMockLocator(0);
+
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel.includes('Create') || sel.includes('Add') || sel.includes('New')) return createLocator;
+      if (sel.includes('Edit')) return editLocator;
+      if (sel.includes('Delete') || sel.includes('Remove')) return deleteLocator;
+      return makeMockLocator(0);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const createFailed = result.findings.filter(f => f.description.includes('Create action failed'));
+    expect(createFailed.length).toBeGreaterThan(0);
+    expect(createFailed[0].severity).toBe('medium');
+  });
+
+  // Delete fails
+  it('produces medium finding when delete action fails', async () => {
+    const createLocator = makeMockLocator(0);
+    const editLocator = makeMockLocator(0);
+    const deleteLocator = makeMockLocator(1);
+    deleteLocator.first.mockReturnValue({
+      click: vi.fn().mockRejectedValue(new Error('Delete error')),
+    });
+
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel.includes('Create') || sel.includes('Add') || sel.includes('New')) return createLocator;
+      if (sel.includes('Edit')) return editLocator;
+      if (sel.includes('Delete') || sel.includes('Remove')) return deleteLocator;
+      return makeMockLocator(0);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const deleteFailed = result.findings.filter(f => f.description.includes('Delete action failed'));
+    expect(deleteFailed.length).toBeGreaterThan(0);
+    expect(deleteFailed[0].severity).toBe('medium');
+  });
+
+  // Login failure — graceful degradation
+  it('produces medium finding and continues when login fails', async () => {
+    loginMock.mockRejectedValue(new Error('Invalid credentials'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const loginFinding = result.findings.find(f => f.id.includes('login-failed'));
+    expect(loginFinding).toBeDefined();
+    expect(loginFinding!.severity).toBe('medium');
+  });
+
+  // No credentials — graceful
+  it('produces medium finding when no credentials configured', async () => {
+    const config = makeConfig({
+      auth: { loginUrl: 'http://localhost/login', credentials: {} },
+    });
+    const agent = createAgent(config);
+    const result = await agent.run();
+
+    const noCredsFinding = result.findings.find(f => f.id.includes('no-credentials'));
+    expect(noCredsFinding).toBeDefined();
+    expect(noCredsFinding!.severity).toBe('medium');
+  });
+
+  // Playwright crash — graceful
+  it('produces medium finding when Playwright crashes', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Browser crashed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const pwFinding = result.findings.find(f => f.id.includes('playwright-failure'));
+    expect(pwFinding).toBeDefined();
+    expect(pwFinding!.severity).toBe('medium');
+  });
+
+  // Navigation failure for a module
+  it('produces medium finding when module navigation fails', async () => {
+    currentMockPage.goto.mockRejectedValue(new Error('Navigation failed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const navFinding = result.findings.find(f => f.id.includes('nav-failed'));
+    expect(navFinding).toBeDefined();
+    expect(navFinding!.severity).toBe('medium');
+  });
+
+  // Browser is closed in finally block
+  it('closes browser even when an error occurs', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Launch error'));
+
+    const agent = createAgent();
+    await agent.run();
+
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+});

package/agents/__tests__/26-form-validator.test.ts

@@ -0,0 +1,345 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config helpers
+// ---------------------------------------------------------------------------
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    schemaVersion: 1,
+    name: 'test',
+    auth: {
+      loginUrl: 'http://localhost/login',
+      credentials: {
+        admin: { email: 'admin@test.com', password: 'secret' },
+      },
+    },
+    modules: [
+      { id: 'dashboard', route: '/dashboard', sidebarIcon: true },
+    ],
+    environments: {
+      alpha: { baseUrl: 'http://localhost:3000', seed: false },
+    },
+    portals: [],
+    breakpoints: [],
+    integrations: [],
+    workers: [],
+    workflows: [],
+    accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+    tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+    costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' },
+    agentClassification: { blocking: [], advisory: [26] },
+    thresholds: {
+      unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
+      lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
+      apiResponseTime: 2000,
+      bundleSizeLimit: 500000,
+      maxConsoleErrors: 0,
+    },
+    disabledAgents: [],
+    disabledAgentSet: new Set<number>(),
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Mock fetch (preFlight URL reachability)
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// Mock helpers
+// ---------------------------------------------------------------------------
+
+const loginMock = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock Playwright
+// ---------------------------------------------------------------------------
+
+interface MockLocator {
+  count: ReturnType<typeof vi.fn>;
+  first: ReturnType<typeof vi.fn>;
+  nth: ReturnType<typeof vi.fn>;
+  click: ReturnType<typeof vi.fn>;
+  fill: ReturnType<typeof vi.fn>;
+  check: ReturnType<typeof vi.fn>;
+  selectOption: ReturnType<typeof vi.fn>;
+  locator: ReturnType<typeof vi.fn>;
+  evaluate: ReturnType<typeof vi.fn>;
+  getAttribute: ReturnType<typeof vi.fn>;
+}
+
+function makeMockLocator(countVal = 0): MockLocator {
+  const locator: MockLocator = {
+    count: vi.fn().mockResolvedValue(countVal),
+    first: vi.fn(),
+    nth: vi.fn(),
+    click: vi.fn().mockResolvedValue(undefined),
+    fill: vi.fn().mockResolvedValue(undefined),
+    check: vi.fn().mockResolvedValue(undefined),
+    selectOption: vi.fn().mockResolvedValue(undefined),
+    locator: vi.fn().mockReturnValue({
+      count: vi.fn().mockResolvedValue(0),
+      nth: vi.fn().mockReturnValue({
+        getAttribute: vi.fn().mockResolvedValue(null),
+      }),
+    }),
+    evaluate: vi.fn().mockResolvedValue('input'),
+    getAttribute: vi.fn().mockResolvedValue('text'),
+  };
+  locator.first.mockReturnValue(locator);
+  locator.nth.mockReturnValue(locator);
+  return locator;
+}
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  goto: ReturnType<typeof vi.fn>;
+  locator: ReturnType<typeof vi.fn>;
+  waitForSelector: ReturnType<typeof vi.fn>;
+  waitForTimeout: ReturnType<typeof vi.fn>;
+}
+
+function makeMockPage(): MockPage {
+  const defaultLocator = makeMockLocator(0);
+  return {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    locator: vi.fn().mockReturnValue(defaultLocator),
+    waitForSelector: vi.fn().mockResolvedValue({ textContent: vi.fn().mockResolvedValue('') }),
+    waitForTimeout: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+let currentMockPage: MockPage;
+let mockBrowser: { newPage: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
+
+vi.mock('playwright', async () => ({
+  chromium: {
+    launch: vi.fn().mockImplementation(async () => mockBrowser),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks are hoisted
+// ---------------------------------------------------------------------------
+
+const { FormValidatorAgent } = await import('../26-form-validator');
+
+function createAgent(
+  config: ValidatedConfig = makeConfig(),
+  phase: Phase = 'beta',
+): InstanceType<typeof FormValidatorAgent> {
+  return new FormValidatorAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('FormValidatorAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+
+    currentMockPage = makeMockPage();
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  // Identity
+  it('has agentId 26 and correct agentName', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(26);
+    expect(agent.agentName).toBe('Form Validator');
+  });
+
+  // preFlight
+  it('throws when modules array is empty', async () => {
+    const config = makeConfig({ modules: [] });
+    const agent = createAgent(config);
+    const result = await agent.run();
+
+    expect(result.status).toBe('failed');
+    expect(result.findings[0].description).toContain('module');
+  });
+
+  // No forms found
+  it('produces low finding when no forms found in a module', async () => {
+    // form locator returns count 0
+    const formLocator = makeMockLocator(0);
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel === 'form') return formLocator;
+      return makeMockLocator(0);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const noFormFindings = result.findings.filter(f => f.description.includes('No forms found'));
+    expect(noFormFindings.length).toBeGreaterThan(0);
+    expect(noFormFindings[0].severity).toBe('low');
+  });
+
+  // Form accepts empty submission (high finding)
+  it('produces high finding when form accepts empty submission without validation', async () => {
+    const submitLocator = makeMockLocator(1);
+    const inputLocator = makeMockLocator(2);
+    const errorLocator = makeMockLocator(0); // No validation errors
+
+    const formLocator = makeMockLocator(1);
+    formLocator.nth = vi.fn().mockReturnValue(formLocator);
+    formLocator.locator.mockImplementation((sel: string) => {
+      if (sel.includes('submit') || sel.includes('Submit') || sel.includes('Save')) return submitLocator;
+      return inputLocator;
+    });
+
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel === 'form') return formLocator;
+      // error selectors checked via page.locator(errorSelector)
+      if (sel.includes('error') || sel.includes('invalid') || sel.includes('red') || sel.includes('alert')) return errorLocator;
+      return makeMockLocator(0);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const emptySubmitFinding = result.findings.filter(f =>
+      f.description.includes('accepts empty submission'),
+    );
+    expect(emptySubmitFinding.length).toBeGreaterThan(0);
+    expect(emptySubmitFinding[0].severity).toBe('high');
+  });
+
+  // Form shows validation errors on empty submit
+  it('produces no finding when form shows validation errors on empty submit', async () => {
+    const submitLocator = makeMockLocator(1);
+    const inputLocator = makeMockLocator(2);
+    const errorLocator = makeMockLocator(3); // Validation errors present
+
+    const formLocator = makeMockLocator(1);
+    formLocator.nth = vi.fn().mockReturnValue(formLocator);
+    formLocator.locator.mockImplementation((sel: string) => {
+      if (sel.includes('submit') || sel.includes('Submit') || sel.includes('Save')) return submitLocator;
+      return inputLocator;
+    });
+
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel === 'form') return formLocator;
+      // Error selectors checked via page.locator
+      if (sel.includes('error') || sel.includes('invalid') || sel.includes('red') || sel.includes('alert') || sel.includes('field-error') || sel.includes('validation')) return errorLocator;
+      return makeMockLocator(0);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const emptySubmitFinding = result.findings.filter(f =>
+      f.description.includes('accepts empty submission'),
+    );
+    expect(emptySubmitFinding.length).toBe(0);
+  });
+
+  // Login failure — graceful degradation
+  it('produces medium finding and continues when login fails', async () => {
+    loginMock.mockRejectedValue(new Error('Invalid credentials'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const loginFinding = result.findings.find(f => f.id.includes('login-failed'));
+    expect(loginFinding).toBeDefined();
+    expect(loginFinding!.severity).toBe('medium');
+  });
+
+  // No credentials
+  it('produces medium finding when no credentials configured', async () => {
+    const config = makeConfig({
+      auth: { loginUrl: 'http://localhost/login', credentials: {} },
+    });
+    const agent = createAgent(config);
+    const result = await agent.run();
+
+    const noCredsFinding = result.findings.find(f => f.id.includes('no-credentials'));
+    expect(noCredsFinding).toBeDefined();
+    expect(noCredsFinding!.severity).toBe('medium');
+  });
+
+  // Playwright crash
+  it('produces medium finding when Playwright crashes', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Browser crashed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const pwFinding = result.findings.find(f => f.id.includes('playwright-failure'));
+    expect(pwFinding).toBeDefined();
+    expect(pwFinding!.severity).toBe('medium');
+  });
+
+  // Module navigation failure
+  it('produces medium finding when module navigation fails', async () => {
+    currentMockPage.goto.mockRejectedValue(new Error('Navigation failed'));
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const navFinding = result.findings.find(f => f.id.includes('nav-failed'));
+    expect(navFinding).toBeDefined();
+    expect(navFinding!.severity).toBe('medium');
+  });
+
+  // Browser closed in finally
+  it('closes browser even when an error occurs', async () => {
+    mockBrowser.newPage.mockRejectedValue(new Error('Launch error'));
+
+    const agent = createAgent();
+    await agent.run();
+
+    expect(mockBrowser.close).toHaveBeenCalled();
+  });
+
+  // Submit button click failure
+  it('produces medium finding when submit button click throws', async () => {
+    const submitLocator = makeMockLocator(1);
+    submitLocator.first.mockReturnValue({
+      click: vi.fn().mockRejectedValue(new Error('Submit click failed')),
+    });
+
+    const inputLocator = makeMockLocator(2);
+
+    const formLocator = makeMockLocator(1);
+    formLocator.nth = vi.fn().mockReturnValue(formLocator);
+    // form.locator() returns inputs or submit button depending on selector
+    formLocator.locator.mockImplementation((sel: string) => {
+      if (sel.includes('submit') || sel.includes('Submit') || sel.includes('Save')) return submitLocator;
+      return inputLocator;
+    });
+
+    currentMockPage.locator.mockImplementation((sel: string) => {
+      if (sel === 'form') return formLocator;
+      return makeMockLocator(0);
+    });
+
+    const agent = createAgent();
+    const result = await agent.run();
+
+    const submitError = result.findings.filter(f => f.description.includes('submit test failed'));
+    expect(submitError.length).toBeGreaterThan(0);
+    expect(submitError[0].severity).toBe('medium');
+  });
+});