@avi770/testteam 1.2.0

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

@@ -0,0 +1,586 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { WorkflowConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config helpers
+// ---------------------------------------------------------------------------
+
+function makeWorkflow(name: string, steps: WorkflowConfig['steps'] = []): WorkflowConfig {
+  return { name, steps };
+}
+
+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: [
+      makeWorkflow('onboarding', [
+        { action: 'navigate', target: '/onboarding' },
+        { action: 'click', target: '[data-testid="next"]' },
+        { action: 'verify', target: '[data-testid="step-2"]', contains: 'Step 2' },
+      ]),
+    ],
+    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: [] },
+    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);
+const waitForSectionLoadMock = vi.fn().mockResolvedValue(undefined);
+const captureScreenshotMock = vi.fn().mockResolvedValue('/tmp/test-run/screenshot.png');
+const fillFormMock = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: (...args: unknown[]) => loginMock(...args),
+  waitForSectionLoad: (...args: unknown[]) => waitForSectionLoadMock(...args),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../../helpers/screenshot', () => ({
+  captureScreenshot: (...args: unknown[]) => captureScreenshotMock(...args),
+}));
+
+vi.mock('../../helpers/form-filler', () => ({
+  fillForm: (...args: unknown[]) => fillFormMock(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock Playwright
+// ---------------------------------------------------------------------------
+
+interface MockElement {
+  textContent: ReturnType<typeof vi.fn>;
+}
+
+interface MockPage {
+  close: ReturnType<typeof vi.fn>;
+  goto: ReturnType<typeof vi.fn>;
+  click: ReturnType<typeof vi.fn>;
+  waitForSelector: ReturnType<typeof vi.fn>;
+  setViewportSize: ReturnType<typeof vi.fn>;
+  _resolveWaitForSelector: (selector: string, resolvedText: string) => void;
+}
+
+function makeMockPage(overrides: Partial<MockPage> = {}): MockPage {
+  const waitForSelectorMap = new Map<string, string>();
+
+  const page: MockPage = {
+    close: vi.fn().mockResolvedValue(undefined),
+    goto: vi.fn().mockResolvedValue(undefined),
+    click: vi.fn().mockResolvedValue(undefined),
+    waitForSelector: vi.fn().mockImplementation(async (selector: string) => {
+      const text = waitForSelectorMap.get(selector) ?? '';
+      const element: MockElement = {
+        textContent: vi.fn().mockResolvedValue(text),
+      };
+      return element;
+    }),
+    setViewportSize: vi.fn().mockResolvedValue(undefined),
+    _resolveWaitForSelector(selector: string, text: string) {
+      waitForSelectorMap.set(selector, text);
+    },
+    ...overrides,
+  };
+
+  return page;
+}
+
+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 { WorkflowCompletionTesterAgent } = await import('../20-workflow-completion-tester');
+
+function createAgent(
+  config: ValidatedConfig = makeConfig(),
+  phase: Phase = 'uat',
+): InstanceType<typeof WorkflowCompletionTesterAgent> {
+  return new WorkflowCompletionTesterAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('WorkflowCompletionTesterAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    loginMock.mockReset().mockResolvedValue(undefined);
+    waitForSectionLoadMock.mockReset().mockResolvedValue(undefined);
+    captureScreenshotMock.mockReset().mockResolvedValue('/tmp/test-run/screenshot.png');
+    fillFormMock.mockReset().mockResolvedValue(undefined);
+
+    currentMockPage = makeMockPage();
+    mockBrowser = {
+      newPage: vi.fn().mockResolvedValue(currentMockPage),
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  // -------------------------------------------------------------------------
+  // Identity
+  // -------------------------------------------------------------------------
+
+  it('has agentId 20 and agentName "Workflow Completion Tester"', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(20);
+    expect(agent.agentName).toBe('Workflow Completion Tester');
+  });
+
+  // -------------------------------------------------------------------------
+  // preFlight()
+  // -------------------------------------------------------------------------
+
+  describe('preFlight()', () => {
+    it('throws when workflows array is empty', async () => {
+      const config = makeConfig({ workflows: [] });
+      const agent = createAgent(config);
+      const result = await agent.run();
+
+      expect(result.status).toBe('failed');
+      expect(result.findings[0].description).toContain('workflow');
+    });
+
+    it('resolves gracefully when base URL is not reachable (fallback)', async () => {
+      fetchMock.mockRejectedValue(new Error('ECONNREFUSED'));
+      currentMockPage._resolveWaitForSelector('[data-testid="step-2"]', 'Step 2');
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // With resolveEnvironment the agent no longer throws on unreachable URLs.
+      // preFlight succeeds; execute proceeds with the fallback environment.
+      expect(result.findings.some((f) => f.description.includes('not reachable'))).toBe(false);
+    });
+
+    it('passes when workflows are configured and base URL is reachable', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings.some(f => f.description.includes('workflow'))).toBe(false);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Successful workflow execution
+  // -------------------------------------------------------------------------
+
+  describe('execute() — successful workflow', () => {
+    it('returns no findings when all workflow steps succeed', async () => {
+      // Set expected text for verify step
+      currentMockPage._resolveWaitForSelector('[data-testid="step-2"]', 'Step 2 content');
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings).toHaveLength(0);
+    });
+
+    it('calls page.goto for navigate steps', async () => {
+      currentMockPage._resolveWaitForSelector('[data-testid="step-2"]', 'Step 2');
+
+      const agent = createAgent();
+      await agent.run();
+
+      expect(currentMockPage.goto).toHaveBeenCalledWith('http://localhost:3000/onboarding');
+    });
+
+    it('calls page.click for click steps', async () => {
+      currentMockPage._resolveWaitForSelector('[data-testid="step-2"]', 'Step 2');
+
+      const agent = createAgent();
+      await agent.run();
+
+      expect(currentMockPage.click).toHaveBeenCalledWith('[data-testid="next"]');
+    });
+
+    it('takes a screenshot at each step as evidence', async () => {
+      currentMockPage._resolveWaitForSelector('[data-testid="step-2"]', 'Step 2');
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      // 3 steps in onboarding workflow → 3 screenshots
+      const screenshotEvidence = result.evidence.filter(e => e.type === 'screenshot');
+      expect(screenshotEvidence.length).toBeGreaterThanOrEqual(3);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Failed step creates finding with workflow name
+  // -------------------------------------------------------------------------
+
+  describe('execute() — failed step', () => {
+    it('creates a finding with the workflow name when a step fails', async () => {
+      // click step throws
+      currentMockPage.click.mockRejectedValue(new Error('Element not found'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const workflowFinding = result.findings.find(
+        f => f.module.includes('onboarding'),
+      );
+      expect(workflowFinding).toBeDefined();
+      expect(workflowFinding!.description).toContain('onboarding');
+    });
+
+    it('creates a finding that includes the step index', async () => {
+      currentMockPage.click.mockRejectedValue(new Error('Selector timeout'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings[0];
+      // Step index 1 is the click step (0-indexed)
+      expect(finding.description).toContain('step 1');
+    });
+
+    it('captures a failure screenshot when a step fails', async () => {
+      currentMockPage.click.mockRejectedValue(new Error('Click failed'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings[0];
+      expect(finding.screenshot).toBeDefined();
+    });
+
+    it('stops processing the workflow after the first failed step', async () => {
+      // Navigate (step 0) succeeds; click (step 1) fails
+      currentMockPage.click.mockRejectedValue(new Error('Click failed'));
+
+      const agent = createAgent();
+      await agent.run();
+
+      // waitForSelector for verify (step 2) should NOT have been called
+      const verifyCall = (currentMockPage.waitForSelector.mock.calls as Array<unknown[]>).find(
+        (c) => c[0] === '[data-testid="step-2"]',
+      );
+      expect(verifyCall).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // verify action checks text content
+  // -------------------------------------------------------------------------
+
+  describe('execute() — verify action', () => {
+    it('creates no finding when element contains expected text', async () => {
+      currentMockPage._resolveWaitForSelector('[data-testid="step-2"]', 'Step 2 content here');
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings).toHaveLength(0);
+    });
+
+    it('creates a finding when element does not contain expected text', async () => {
+      // waitForSelector returns element but textContent does not match
+      currentMockPage._resolveWaitForSelector('[data-testid="step-2"]', 'Wrong content');
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const verifyFinding = result.findings.find(
+        f => f.description.includes('does not contain'),
+      );
+      expect(verifyFinding).toBeDefined();
+    });
+
+    it('creates a finding that mentions the expected text when mismatch', async () => {
+      currentMockPage._resolveWaitForSelector('[data-testid="step-2"]', 'Something else');
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings[0].description).toContain('Step 2');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // fill-form action
+  // -------------------------------------------------------------------------
+
+  describe('execute() — fill-form action', () => {
+    it('calls fillForm helper for fill-form steps', async () => {
+      const config = makeConfig({
+        workflows: [
+          {
+            name: 'create-invoice',
+            steps: [
+              { action: 'fill-form', target: 'form[data-form="invoice"]', data: 'test-data' },
+            ],
+          },
+        ],
+      });
+
+      const agent = createAgent(config);
+      await agent.run();
+
+      expect(fillFormMock).toHaveBeenCalledWith(
+        currentMockPage,
+        'form[data-form="invoice"]',
+        { data: 'test-data' },
+      );
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // wait action
+  // -------------------------------------------------------------------------
+
+  describe('execute() — wait action', () => {
+    it('calls waitForSelector for wait steps', async () => {
+      const config = makeConfig({
+        workflows: [
+          {
+            name: 'loading-test',
+            steps: [
+              { action: 'wait', target: '[data-testid="spinner-gone"]', timeout: 3000 },
+            ],
+          },
+        ],
+      });
+
+      const agent = createAgent(config);
+      await agent.run();
+
+      expect(currentMockPage.waitForSelector).toHaveBeenCalledWith(
+        '[data-testid="spinner-gone"]',
+        { timeout: 3000 },
+      );
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Multiple workflows
+  // -------------------------------------------------------------------------
+
+  describe('execute() — multiple workflows', () => {
+    it('runs all workflows and accumulates findings', async () => {
+      const config = makeConfig({
+        workflows: [
+          {
+            name: 'workflow-a',
+            steps: [{ action: 'navigate', target: '/a' }],
+          },
+          {
+            name: 'workflow-b',
+            steps: [{ action: 'click', target: '[broken]' }],
+          },
+        ],
+      });
+
+      // navigate succeeds; click fails
+      currentMockPage.click.mockRejectedValue(new Error('Not found'));
+
+      const agent = createAgent(config);
+      const result = await agent.run();
+
+      // workflow-a passes, workflow-b fails
+      const wfBFinding = result.findings.find(f => f.module.includes('workflow-b'));
+      expect(wfBFinding).toBeDefined();
+      // workflow-a should NOT produce a finding
+      const wfAFinding = result.findings.find(f => f.module.includes('workflow-a'));
+      expect(wfAFinding).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // No credentials
+  // -------------------------------------------------------------------------
+
+  describe('execute() — no credentials', () => {
+    it('creates a critical finding when no credentials are configured', async () => {
+      const config = makeConfig({
+        auth: { loginUrl: 'http://localhost/login', credentials: {} },
+      });
+      const agent = createAgent(config);
+      const result = await agent.run();
+
+      const finding = result.findings.find(f => f.id.includes('no-credentials'));
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('critical');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Login failure
+  // -------------------------------------------------------------------------
+
+  describe('execute() — login failure', () => {
+    it('creates a medium finding and skips workflows 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');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Playwright crash
+  // -------------------------------------------------------------------------
+
+  describe('execute() — playwright crash', () => {
+    it('creates a medium finding when browser launch throws', async () => {
+      mockBrowser.newPage.mockRejectedValue(new Error('Browser not found'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const playwrightFinding = result.findings.find(f => f.id.includes('playwright-failure'));
+      expect(playwrightFinding).toBeDefined();
+      expect(playwrightFinding!.severity).toBe('medium');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Navigate with absolute URL
+  // -------------------------------------------------------------------------
+
+  describe('execute() — navigate with http URL', () => {
+    it('uses absolute URL directly when target starts with http', async () => {
+      const config = makeConfig({
+        workflows: [
+          {
+            name: 'external-nav',
+            steps: [{ action: 'navigate', target: 'http://external.com/page' }],
+          },
+        ],
+      });
+
+      const agent = createAgent(config);
+      await agent.run();
+
+      expect(currentMockPage.goto).toHaveBeenCalledWith('http://external.com/page');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Click step with verify selector
+  // -------------------------------------------------------------------------
+
+  describe('execute() — click with verify', () => {
+    it('waits for verify selector after click', async () => {
+      const config = makeConfig({
+        workflows: [
+          {
+            name: 'verify-after-click',
+            steps: [
+              { action: 'click', target: '[data-testid="btn"]', verify: '[data-testid="result"]', timeout: 3000 },
+            ],
+          },
+        ],
+      });
+      currentMockPage._resolveWaitForSelector('[data-testid="result"]', 'Done');
+
+      const agent = createAgent(config);
+      await agent.run();
+
+      expect(currentMockPage.waitForSelector).toHaveBeenCalledWith(
+        '[data-testid="result"]',
+        { timeout: 3000 },
+      );
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // fill-form without data
+  // -------------------------------------------------------------------------
+
+  describe('execute() — fill-form without data', () => {
+    it('calls fillForm with undefined data when step has no data', async () => {
+      const config = makeConfig({
+        workflows: [
+          {
+            name: 'empty-form',
+            steps: [{ action: 'fill-form', target: 'form' }],
+          },
+        ],
+      });
+
+      const agent = createAgent(config);
+      await agent.run();
+
+      expect(fillFormMock).toHaveBeenCalledWith(currentMockPage, 'form', undefined);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Screenshot capture failure during success path
+  // -------------------------------------------------------------------------
+
+  describe('execute() — screenshot failure on success', () => {
+    it('does not add screenshot evidence when captureScreenshot fails', async () => {
+      captureScreenshotMock.mockResolvedValue('');
+
+      const config = makeConfig({
+        workflows: [
+          {
+            name: 'screenshot-fail',
+            steps: [{ action: 'navigate', target: '/page' }],
+          },
+        ],
+      });
+
+      const agent = createAgent(config);
+      const result = await agent.run();
+
+      // With empty string path, evidence should not be added (or be empty)
+      expect(result.findings).toHaveLength(0);
+    });
+  });
+});