qa360 2.2.1 → 2.2.13

package/core/src/adapters/__tests__/playwright-ui.test.ts

@@ -1,1073 +0,0 @@
-/**
- * PlaywrightUiAdapter - Real Unit Tests
- * Tests actual adapter logic without executing external tools
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { PlaywrightUiAdapter } from '../playwright-ui.js';
-
-// Mock Playwright to avoid actual browser launches
-vi.mock('@playwright/test', () => ({
-  chromium: {
-    launch: vi.fn().mockResolvedValue({
-      newContext: vi.fn().mockResolvedValue({
-        newPage: vi.fn().mockResolvedValue({
-          goto: vi.fn(),
-          screenshot: vi.fn(),
-          evaluate: vi.fn(),
-          addScriptTag: vi.fn(),
-          fill: vi.fn(),
-          click: vi.fn(),
-          waitForLoadState: vi.fn(),
-          url: vi.fn().mockReturnValue('https://example.com'),
-          close: vi.fn()
-        }),
-        close: vi.fn()
-      }),
-      close: vi.fn()
-    })
-  }
-}));
-
-describe('PlaywrightUiAdapter', () => {
-  let adapter: PlaywrightUiAdapter;
-
-  beforeEach(() => {
-    adapter = new PlaywrightUiAdapter();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  // ============================================================
-  // validateConfig - Static method tests
-  // ============================================================
-  describe('validateConfig', () => {
-    it('should validate config with valid baseUrl', () => {
-      const result = PlaywrightUiAdapter.validateConfig({
-        baseUrl: 'https://example.com'
-      });
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-
-    it('should reject config without baseUrl', () => {
-      const result = PlaywrightUiAdapter.validateConfig({} as any);
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('UI target requires baseUrl');
-    });
-
-    it('should reject config with invalid URL', () => {
-      const result = PlaywrightUiAdapter.validateConfig({
-        baseUrl: 'not-a-valid-url'
-      });
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain('UI target baseUrl must be a valid URL');
-    });
-
-    it('should validate pages array', () => {
-      const result = PlaywrightUiAdapter.validateConfig({
-        baseUrl: 'https://example.com',
-        pages: ['/home', '/about', '/contact']
-      });
-      expect(result.valid).toBe(true);
-    });
-
-    it('should validate absolute page URLs', () => {
-      const result = PlaywrightUiAdapter.validateConfig({
-        baseUrl: 'https://example.com',
-        pages: ['https://example.com/home', 'https://other.com/page']
-      });
-      expect(result.valid).toBe(true);
-    });
-
-    it('should handle empty pages array', () => {
-      const result = PlaywrightUiAdapter.validateConfig({
-        baseUrl: 'https://example.com',
-        pages: []
-      });
-      expect(result.valid).toBe(true);
-    });
-
-    it('should accept various URL formats', () => {
-      const configs = [
-        { baseUrl: 'https://example.com' },
-        { baseUrl: 'http://localhost:3000' },
-        { baseUrl: 'https://sub.domain.example.com:8080/path' }
-      ];
-      
-      configs.forEach(config => {
-        const result = PlaywrightUiAdapter.validateConfig(config);
-        expect(result.valid).toBe(true);
-      });
-    });
-  });
-
-  // ============================================================
-  // calculateSummary - Summary calculation
-  // ============================================================
-  describe('calculateSummary (via reflection)', () => {
-    const calculateSummary = (adapter: any, results: any[]) => {
-      return adapter.calculateSummary.call(adapter, results);
-    };
-
-    it('should calculate summary for all passed', () => {
-      const results = [
-        { success: true, loadTime: 1000, accessibility: { score: 90 } },
-        { success: true, loadTime: 2000, accessibility: { score: 85 } },
-        { success: true, loadTime: 1500, accessibility: { score: 95 } }
-      ];
-      const summary = calculateSummary(adapter, results);
-      
-      expect(summary.total).toBe(3);
-      expect(summary.passed).toBe(3);
-      expect(summary.failed).toBe(0);
-      expect(summary.avgLoadTime).toBe(1500);
-      expect(summary.avgA11yScore).toBe(90);
-    });
-
-    it('should calculate summary for mixed results', () => {
-      const results = [
-        { success: true, loadTime: 1000, accessibility: { score: 80 } },
-        { success: false, loadTime: 500, accessibility: { score: 40 } },
-        { success: true, loadTime: 1500, accessibility: { score: 100 } }
-      ];
-      const summary = calculateSummary(adapter, results);
-      
-      expect(summary.total).toBe(3);
-      expect(summary.passed).toBe(2);
-      expect(summary.failed).toBe(1);
-      expect(summary.avgLoadTime).toBe(1000);
-      expect(summary.avgA11yScore).toBe(73); // (80+40+100)/3 = 73.33 → 73
-    });
-
-    it('should handle results without accessibility', () => {
-      const results = [
-        { success: true, loadTime: 1000 },
-        { success: true, loadTime: 2000, accessibility: { score: 90 } }
-      ];
-      const summary = calculateSummary(adapter, results);
-      
-      expect(summary.avgA11yScore).toBe(90); // Only one score
-    });
-
-    it('should handle empty results', () => {
-      const summary = calculateSummary(adapter, []);
-      
-      expect(summary.total).toBe(0);
-      expect(summary.passed).toBe(0);
-      expect(summary.failed).toBe(0);
-      expect(summary.avgLoadTime).toBe(0);
-      expect(summary.avgA11yScore).toBe(0);
-    });
-
-    it('should round average values', () => {
-      const results = [
-        { success: true, loadTime: 1001, accessibility: { score: 91 } },
-        { success: true, loadTime: 1002, accessibility: { score: 92 } },
-        { success: true, loadTime: 1003, accessibility: { score: 93 } }
-      ];
-      const summary = calculateSummary(adapter, results);
-      
-      expect(summary.avgLoadTime).toBe(1002);
-      expect(summary.avgA11yScore).toBe(92);
-    });
-  });
-
-  // ============================================================
-  // generateJUnit - JUnit XML generation
-  // ============================================================
-  describe('generateJUnit (via reflection)', () => {
-    const generateJUnit = (adapter: any, results: any[]) => {
-      return adapter.generateJUnit.call(adapter, results);
-    };
-
-    it('should generate valid XML structure', () => {
-      const results = [
-        { page: 'https://example.com', success: true, loadTime: 1000 }
-      ];
-      const junit = generateJUnit(adapter, results);
-      
-      expect(junit).toContain('<?xml version="1.0" encoding="UTF-8"?>');
-      expect(junit).toContain('<testsuite');
-      expect(junit).toContain('name="UI Smoke Tests"');
-      expect(junit).toContain('</testsuite>');
-    });
-
-    it('should include test count and failures', () => {
-      const results = [
-        { page: '/a', success: true, loadTime: 1000 },
-        { page: '/b', success: false, loadTime: 500, error: 'Failed' },
-        { page: '/c', success: true, loadTime: 1500 }
-      ];
-      const junit = generateJUnit(adapter, results);
-      
-      expect(junit).toContain('tests="3"');
-      expect(junit).toContain('failures="1"');
-    });
-
-    it('should include testcase elements with page URL', () => {
-      const results = [
-        { page: 'https://example.com/home', success: true, loadTime: 1500 }
-      ];
-      const junit = generateJUnit(adapter, results);
-      
-      expect(junit).toContain('<testcase');
-      expect(junit).toContain('UI Test: https://example.com/home');
-      expect(junit).toContain('time="1.5"');
-    });
-
-    it('should include failure element for failed tests', () => {
-      const results = [
-        { page: '/home', success: false, loadTime: 500, error: 'Page not found' }
-      ];
-      const junit = generateJUnit(adapter, results);
-      
-      expect(junit).toContain('<failure');
-      expect(junit).toContain('Page not found');
-      expect(junit).toContain('</failure>');
-    });
-
-    it('should not include failure for passed tests', () => {
-      const results = [
-        { page: '/home', success: true, loadTime: 1000 }
-      ];
-      const junit = generateJUnit(adapter, results);
-      
-      expect(junit).not.toContain('<failure');
-    });
-
-    it('should escape XML special characters', () => {
-      const results = [
-        { page: '/test?param=1&other=2', success: false, loadTime: 100, error: 'Error with <tags> & "quotes"' }
-      ];
-      const junit = generateJUnit(adapter, results);
-      
-      expect(junit).toContain('&amp;');
-      expect(junit).toContain('&lt;');
-      expect(junit).toContain('&gt;');
-      expect(junit).toContain('&quot;');
-    });
-
-    it('should include timestamp', () => {
-      const results = [
-        { page: '/home', success: true, loadTime: 1000 }
-      ];
-      const junit = generateJUnit(adapter, results);
-      
-      expect(junit).toMatch(/timestamp="\d{4}-\d{2}-\d{2}T/);
-    });
-  });
-
-  // ============================================================
-  // escapeXml - XML escaping
-  // ============================================================
-  describe('escapeXml (via reflection)', () => {
-    const escapeXml = (adapter: any, str: string) => {
-      return adapter.escapeXml.call(adapter, str);
-    };
-
-    it('should escape all XML special characters', () => {
-      expect(escapeXml(adapter, '&')).toBe('&amp;');
-      expect(escapeXml(adapter, '<')).toBe('&lt;');
-      expect(escapeXml(adapter, '>')).toBe('&gt;');
-      expect(escapeXml(adapter, '"')).toBe('&quot;');
-      expect(escapeXml(adapter, "\'")).toBe('&apos;');
-    });
-
-    it('should escape multiple characters in string', () => {
-      const input = 'Test & <verify> "quote" \'apostrophe\'';
-      const expected = 'Test &amp; &lt;verify&gt; &quot;quote&quot; &apos;apostrophe&apos;';
-      expect(escapeXml(adapter, input)).toBe(expected);
-    });
-
-    it('should not modify safe strings', () => {
-      expect(escapeXml(adapter, 'hello world 123')).toBe('hello world 123');
-    });
-
-    it('should handle empty string', () => {
-      expect(escapeXml(adapter, '')).toBe('');
-    });
-  });
-
-  // ============================================================
-  // Accessibility score calculation logic
-  // ============================================================
-  describe('Accessibility score calculation', () => {
-    it('should calculate perfect score with no violations', () => {
-      const violations: any[] = [];
-      const score = 100 - (
-        violations.filter(v => v.impact === 'critical').length * 25 +
-        violations.filter(v => v.impact === 'serious').length * 10 +
-        violations.filter(v => v.impact === 'moderate').length * 5 +
-        violations.filter(v => v.impact === 'minor').length * 1
-      );
-      expect(Math.max(0, score)).toBe(100);
-    });
-
-    it('should deduct 25 points per critical violation', () => {
-      const violations = [
-        { impact: 'critical' },
-        { impact: 'critical' }
-      ];
-      const score = 100 - (
-        violations.filter(v => v.impact === 'critical').length * 25
-      );
-      expect(Math.max(0, score)).toBe(50);
-    });
-
-    it('should deduct 10 points per serious violation', () => {
-      const violations = [
-        { impact: 'serious' },
-        { impact: 'serious' },
-        { impact: 'serious' }
-      ];
-      const score = 100 - (
-        violations.filter(v => v.impact === 'serious').length * 10
-      );
-      expect(Math.max(0, score)).toBe(70);
-    });
-
-    it('should deduct 5 points per moderate violation', () => {
-      const violations = [
-        { impact: 'moderate' },
-        { impact: 'moderate' }
-      ];
-      const score = 100 - (
-        violations.filter(v => v.impact === 'moderate').length * 5
-      );
-      expect(Math.max(0, score)).toBe(90);
-    });
-
-    it('should deduct 1 point per minor violation', () => {
-      const violations = [
-        { impact: 'minor' },
-        { impact: 'minor' },
-        { impact: 'minor' }
-      ];
-      const score = 100 - (
-        violations.filter(v => v.impact === 'minor').length * 1
-      );
-      expect(Math.max(0, score)).toBe(97);
-    });
-
-    it('should handle mixed violations', () => {
-      const violations = [
-        { impact: 'critical' },  // -25
-        { impact: 'serious' },   // -10
-        { impact: 'moderate' },  // -5
-        { impact: 'minor' }      // -1
-      ];
-      const score = 100 - (
-        violations.filter(v => v.impact === 'critical').length * 25 +
-        violations.filter(v => v.impact === 'serious').length * 10 +
-        violations.filter(v => v.impact === 'moderate').length * 5 +
-        violations.filter(v => v.impact === 'minor').length * 1
-      );
-      expect(Math.max(0, score)).toBe(59);
-    });
-
-    it('should not go below 0', () => {
-      const violations = Array(10).fill({ impact: 'critical' }); // -250 points
-      const score = 100 - (
-        violations.filter(v => v.impact === 'critical').length * 25
-      );
-      expect(Math.max(0, score)).toBe(0);
-    });
-  });
-
-  // ============================================================
-  // Constructor and instance
-  // ============================================================
-  describe('constructor', () => {
-    it('should create adapter instance', () => {
-      const adapter = new PlaywrightUiAdapter();
-      expect(adapter).toBeInstanceOf(PlaywrightUiAdapter);
-    });
-
-    it('should have redactor initialized', () => {
-      const adapter = new PlaywrightUiAdapter();
-      expect((adapter as any).redactor).toBeDefined();
-    });
-  });
-
-  // ============================================================
-  // Login selector defaults
-  // ============================================================
-  describe('Login selectors', () => {
-    it('should have sensible default selectors', () => {
-      const defaultUsernameSelector = 'input[name="username"], input[name="email"], input[type="email"], #username, #email';
-      const defaultPasswordSelector = 'input[name="password"], input[type="password"], #password';
-      const defaultSubmitSelector = 'button[type="submit"], input[type="submit"], button:has-text("Login"), button:has-text("Sign in")';
-
-      // Verify the selectors cover common cases
-      expect(defaultUsernameSelector).toContain('input[name="username"]');
-      expect(defaultUsernameSelector).toContain('input[name="email"]');
-      expect(defaultUsernameSelector).toContain('#username');
-
-      expect(defaultPasswordSelector).toContain('input[type="password"]');
-      expect(defaultPasswordSelector).toContain('#password');
-
-      expect(defaultSubmitSelector).toContain('button[type="submit"]');
-      expect(defaultSubmitSelector).toContain('Login');
-      expect(defaultSubmitSelector).toContain('Sign in');
-    });
-  });
-
-  // ============================================================
-  // performLogin - Login flow tests
-  // ============================================================
-  describe('performLogin (via reflection)', () => {
-    const performLogin = async (adapter: any, login: any) => {
-      return adapter.performLogin.call(adapter, login);
-    };
-
-    it('should perform login with default selectors', async () => {
-      const mockPage = {
-        url: vi.fn().mockReturnValue('https://example.com'),
-        goto: vi.fn(),
-        fill: vi.fn(),
-        click: vi.fn(),
-        waitForLoadState: vi.fn()
-      };
-      (adapter as any).page = mockPage;
-
-      await performLogin(adapter, {
-        username: 'testuser',
-        password: 'testpass'
-      });
-
-      expect(mockPage.fill).toHaveBeenCalledTimes(2);
-      expect(mockPage.click).toHaveBeenCalledTimes(1);
-      expect(mockPage.waitForLoadState).toHaveBeenCalledWith('networkidle', { timeout: 10000 });
-    });
-
-    it('should use custom selectors when provided', async () => {
-      const mockPage = {
-        url: vi.fn().mockReturnValue('https://example.com'),
-        goto: vi.fn(),
-        fill: vi.fn(),
-        click: vi.fn(),
-        waitForLoadState: vi.fn()
-      };
-      (adapter as any).page = mockPage;
-
-      await performLogin(adapter, {
-        username: 'testuser',
-        password: 'testpass',
-        usernameSelector: '#custom-username',
-        passwordSelector: '#custom-password',
-        submitSelector: '#custom-submit'
-      });
-
-      expect(mockPage.fill).toHaveBeenCalledWith('#custom-username', 'testuser');
-      expect(mockPage.fill).toHaveBeenCalledWith('#custom-password', 'testpass');
-      expect(mockPage.click).toHaveBeenCalledWith('#custom-submit');
-    });
-
-    it('should handle login timeout gracefully', async () => {
-      const mockPage = {
-        url: vi.fn().mockReturnValue('https://example.com'),
-        goto: vi.fn(),
-        fill: vi.fn(),
-        click: vi.fn(),
-        waitForLoadState: vi.fn().mockRejectedValue(new Error('Timeout'))
-      };
-      (adapter as any).page = mockPage;
-
-      // performLogin catches waitForLoadState errors and continues
-      await performLogin(adapter, {
-        username: 'testuser',
-        password: 'testpass'
-      });
-
-      expect(mockPage.waitForLoadState).toHaveBeenCalled();
-    });
-  });
-
-  // ============================================================
-  // runAccessibilityTests - Accessibility tests
-  // ============================================================
-  describe('runAccessibilityTests (via reflection)', () => {
-    const runAccessibilityTests = async (adapter: any, budgets?: any) => {
-      return adapter.runAccessibilityTests.call(adapter, budgets);
-    };
-
-    it('should inject axe-core and run accessibility tests', async () => {
-      const mockPage = {
-        addScriptTag: vi.fn(),
-        evaluate: vi.fn().mockResolvedValue({
-          violations: []
-        })
-      };
-      (adapter as any).page = mockPage;
-
-      const result = await runAccessibilityTests(adapter);
-
-      expect(mockPage.addScriptTag).toHaveBeenCalled();
-      expect(mockPage.evaluate).toHaveBeenCalled();
-      expect(result.score).toBe(100);
-      expect(result.violations).toEqual([]);
-    });
-
-    it('should calculate score based on violations', async () => {
-      const mockPage = {
-        addScriptTag: vi.fn(),
-        evaluate: vi.fn().mockResolvedValue({
-          violations: [
-            { impact: 'critical', description: 'Critical issue' },
-            { impact: 'serious', description: 'Serious issue' }
-          ]
-        })
-      };
-      (adapter as any).page = mockPage;
-
-      const result = await runAccessibilityTests(adapter);
-
-      expect(result.score).toBe(65); // 100 - 25 (critical) - 10 (serious)
-      expect(result.violations).toHaveLength(2);
-    });
-
-    it('should fail when score below budget', async () => {
-      const mockPage = {
-        addScriptTag: vi.fn(),
-        evaluate: vi.fn().mockResolvedValue({
-          violations: [
-            { impact: 'critical', description: 'Critical issue' }
-          ]
-        })
-      };
-      (adapter as any).page = mockPage;
-
-      const result = await runAccessibilityTests(adapter, { a11y_min: 90 });
-
-      expect(result.score).toBe(75); // 100 - 25
-      // runAccessibilityTests doesn't return 'passed', just score and violations
-      expect(result.score).toBeLessThan(90);
-    });
-
-    it('should pass when score above budget', async () => {
-      const mockPage = {
-        addScriptTag: vi.fn(),
-        evaluate: vi.fn().mockResolvedValue({
-          violations: [
-            { impact: 'minor', description: 'Minor issue' }
-          ]
-        })
-      };
-      (adapter as any).page = mockPage;
-
-      const result = await runAccessibilityTests(adapter, { a11y_min: 90 });
-
-      expect(result.score).toBe(99); // 100 - 1
-      expect(result.score).toBeGreaterThanOrEqual(90);
-    });
-  });
-
-  // ============================================================
-  // getDomSnapshot - DOM snapshot tests
-  // ============================================================
-  describe('getDomSnapshot (via reflection)', () => {
-    const getDomSnapshot = async (adapter: any) => {
-      return adapter.getDomSnapshot.call(adapter);
-    };
-
-    it('should capture DOM snapshot with metadata', async () => {
-      const mockPage = {
-        url: vi.fn().mockReturnValue('https://example.com'),
-        evaluate: vi.fn().mockResolvedValue({
-          title: 'Test Page',
-          url: 'https://example.com',
-          elements: {
-            buttons: 3,
-            links: 10,
-            forms: 2,
-            inputs: 5
-          }
-        })
-      };
-      (adapter as any).page = mockPage;
-
-      const snapshot = await getDomSnapshot(adapter);
-
-      expect(snapshot.title).toBe('Test Page');
-      expect(snapshot.url).toBe('https://example.com');
-      expect(snapshot.elements.links).toBe(10);
-      expect(snapshot.elements.forms).toBe(2);
-      expect(snapshot.elements.buttons).toBe(3);
-      expect(snapshot.elements.inputs).toBe(5);
-    });
-
-    it('should handle pages with no forms', async () => {
-      const mockPage = {
-        url: vi.fn().mockReturnValue('https://example.com'),
-        evaluate: vi.fn().mockResolvedValue({
-          title: 'Empty Page',
-          url: 'https://example.com',
-          elements: {
-            buttons: 0,
-            links: 0,
-            forms: 0,
-            inputs: 0
-          }
-        })
-      };
-      (adapter as any).page = mockPage;
-
-      const snapshot = await getDomSnapshot(adapter);
-
-      expect(snapshot.elements.forms).toBe(0);
-    });
-
-    it('should handle errors gracefully with defaults', async () => {
-      const mockPage = {
-        url: vi.fn().mockReturnValue('https://example.com'),
-        evaluate: vi.fn().mockRejectedValue(new Error('Content unavailable'))
-      };
-      (adapter as any).page = mockPage;
-
-      // getDomSnapshot catches errors and returns defaults
-      const snapshot = await getDomSnapshot(adapter);
-      expect(snapshot.title).toBe('Unknown');
-      expect(snapshot.url).toBe('https://example.com');
-      expect(snapshot.elements.forms).toBe(0);
-    });
-  });
-
-  // ============================================================
-  // takeScreenshot - Screenshot tests
-  // ============================================================
-  describe('takeScreenshot (via reflection)', () => {
-    const takeScreenshot = async (adapter: any, pageUrl: string) => {
-      return adapter.takeScreenshot.call(adapter, pageUrl);
-    };
-
-    it.skip('should take screenshot and return base64 data URL', async () => {
-      // TODO: Fix this test - screenshot call pattern may have changed
-      const mockScreenshot = Buffer.from('fake-screenshot-data');
-      const mockPage = {
-        screenshot: vi.fn().mockResolvedValue(mockScreenshot)
-      };
-      (adapter as any).page = mockPage;
-
-      const result = await takeScreenshot(adapter, 'https://example.com');
-
-      expect(mockPage.screenshot).toHaveBeenCalledWith({
-        type: 'png',
-        fullPage: false
-      });
-      expect(result).toBe(`data:image/png;base64,${mockScreenshot.toString('base64')}`);
-    });
-
-    it('should handle screenshot failures gracefully', async () => {
-      const mockPage = {
-        screenshot: vi.fn().mockRejectedValue(new Error('Screenshot failed'))
-      };
-      (adapter as any).page = mockPage;
-
-      // takeScreenshot catches errors and returns empty string
-      const result = await takeScreenshot(adapter, 'https://example.com');
-      expect(result).toBe('');
-    });
-
-    it.skip('should use fullPage: false for performance', async () => {
-      // TODO: Fix this test - screenshot call pattern may have changed
-      const mockPage = {
-        screenshot: vi.fn().mockResolvedValue(Buffer.from('data'))
-      };
-      (adapter as any).page = mockPage;
-
-      await takeScreenshot(adapter, 'https://example.com');
-
-      const callArgs = mockPage.screenshot.mock.calls[0][0];
-      expect(callArgs.fullPage).toBe(false);
-      expect(callArgs.type).toBe('png');
-    });
-  });
-
-  // ============================================================
-  // Error handling scenarios
-  // ============================================================
-  describe('Error handling', () => {
-    it('should handle network timeout errors', async () => {
-      const mockPage = {
-        goto: vi.fn().mockRejectedValue(new Error('net::ERR_CONNECTION_TIMED_OUT'))
-      };
-      (adapter as any).page = mockPage;
-
-      // Network errors should be caught during page.goto
-      await expect(mockPage.goto('https://example.com')).rejects.toThrow('ERR_CONNECTION_TIMED_OUT');
-    });
-
-    it('should handle page navigation errors', async () => {
-      const mockPage = {
-        goto: vi.fn().mockRejectedValue(new Error('Navigation failed'))
-      };
-      (adapter as any).page = mockPage;
-
-      await expect(mockPage.goto('https://example.com')).rejects.toThrow('Navigation failed');
-    });
-
-    it('should handle selector not found errors', async () => {
-      const mockPage = {
-        fill: vi.fn().mockRejectedValue(new Error('Selector not found'))
-      };
-      (adapter as any).page = mockPage;
-
-      await expect(mockPage.fill('#missing', 'value')).rejects.toThrow('Selector not found');
-    });
-  });
-
-  // ============================================================
-  // runSmokeTests - Integration tests
-  // ============================================================
-  describe('runSmokeTests (integration)', () => {
-    it('should run smoke tests for single page', async () => {
-      const mockResponse = {
-        ok: vi.fn().mockReturnValue(true),
-        status: vi.fn().mockReturnValue(200)
-      };
-
-      const mockPage = {
-        goto: vi.fn().mockResolvedValue(mockResponse),
-        screenshot: vi.fn().mockResolvedValue(Buffer.from('screenshot')),
-        url: vi.fn().mockReturnValue('https://example.com'),
-        evaluate: vi.fn().mockResolvedValue({
-          title: 'Test Page',
-          url: 'https://example.com',
-          elements: { buttons: 1, links: 5, forms: 0, inputs: 2 }
-        }),
-        addScriptTag: vi.fn(),
-        close: vi.fn()
-      };
-
-      // Mock axe results
-      mockPage.evaluate
-        .mockResolvedValueOnce({ title: 'Test Page', url: 'https://example.com', elements: { buttons: 1, links: 5, forms: 0, inputs: 2 } })
-        .mockResolvedValueOnce({ violations: [] });
-
-      const mockContext = {
-        newPage: vi.fn().mockResolvedValue(mockPage),
-        close: vi.fn()
-      };
-
-      const mockBrowser = {
-        newContext: vi.fn().mockResolvedValue(mockContext),
-        close: vi.fn()
-      };
-
-      const { chromium } = await import('@playwright/test');
-      (chromium.launch as any).mockResolvedValue(mockBrowser);
-
-      const result = await adapter.runSmokeTests({
-        target: { baseUrl: 'https://example.com' }
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.results).toHaveLength(1);
-      expect(result.summary.total).toBe(1);
-      expect(result.summary.passed).toBe(1);
-      expect(result.junit).toBeDefined();
-    });
-
-    it('should run smoke tests for multiple pages', async () => {
-      const mockResponse = {
-        ok: vi.fn().mockReturnValue(true),
-        status: vi.fn().mockReturnValue(200)
-      };
-
-      const mockPage = {
-        goto: vi.fn().mockResolvedValue(mockResponse),
-        screenshot: vi.fn().mockResolvedValue(Buffer.from('screenshot')),
-        url: vi.fn().mockReturnValue('https://example.com'),
-        evaluate: vi.fn()
-          .mockResolvedValueOnce({ title: 'Page 1', url: 'https://example.com', elements: { buttons: 1, links: 5, forms: 0, inputs: 2 } })
-          .mockResolvedValueOnce({ violations: [] })
-          .mockResolvedValueOnce({ title: 'Page 2', url: 'https://example.com/about', elements: { buttons: 2, links: 10, forms: 1, inputs: 3 } })
-          .mockResolvedValueOnce({ violations: [] }),
-        addScriptTag: vi.fn(),
-        close: vi.fn()
-      };
-
-      const mockContext = {
-        newPage: vi.fn().mockResolvedValue(mockPage),
-        close: vi.fn()
-      };
-
-      const mockBrowser = {
-        newContext: vi.fn().mockResolvedValue(mockContext),
-        close: vi.fn()
-      };
-
-      const { chromium } = await import('@playwright/test');
-      (chromium.launch as any).mockResolvedValue(mockBrowser);
-
-      const result = await adapter.runSmokeTests({
-        target: {
-          baseUrl: 'https://example.com',
-          pages: ['https://example.com', 'https://example.com/about']
-        }
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.results).toHaveLength(2);
-      expect(result.summary.total).toBe(2);
-    });
-
-    it('should perform login before testing pages', async () => {
-      const mockResponse = {
-        ok: vi.fn().mockReturnValue(true),
-        status: vi.fn().mockReturnValue(200)
-      };
-
-      const mockPage = {
-        goto: vi.fn().mockResolvedValue(mockResponse),
-        url: vi.fn().mockReturnValue('https://example.com'),
-        fill: vi.fn(),
-        click: vi.fn(),
-        waitForLoadState: vi.fn(),
-        screenshot: vi.fn().mockResolvedValue(Buffer.from('screenshot')),
-        evaluate: vi.fn()
-          .mockResolvedValueOnce({ title: 'Test', url: 'https://example.com', elements: { buttons: 1, links: 5, forms: 0, inputs: 2 } })
-          .mockResolvedValueOnce({ violations: [] }),
-        addScriptTag: vi.fn(),
-        close: vi.fn()
-      };
-
-      const mockContext = {
-        newPage: vi.fn().mockResolvedValue(mockPage),
-        close: vi.fn()
-      };
-
-      const mockBrowser = {
-        newContext: vi.fn().mockResolvedValue(mockContext),
-        close: vi.fn()
-      };
-
-      const { chromium } = await import('@playwright/test');
-      (chromium.launch as any).mockResolvedValue(mockBrowser);
-
-      const result = await adapter.runSmokeTests({
-        target: { baseUrl: 'https://example.com' },
-        login: {
-          username: 'testuser',
-          password: 'testpass'
-        }
-      });
-
-      expect(mockPage.fill).toHaveBeenCalled();
-      expect(mockPage.click).toHaveBeenCalled();
-      expect(result.success).toBe(true);
-    });
-
-    it('should handle page load failures', async () => {
-      const mockResponse = {
-        ok: vi.fn().mockReturnValue(false),
-        status: vi.fn().mockReturnValue(500)
-      };
-
-      const mockPage = {
-        goto: vi.fn().mockResolvedValue(mockResponse),
-        close: vi.fn()
-      };
-
-      const mockContext = {
-        newPage: vi.fn().mockResolvedValue(mockPage),
-        close: vi.fn()
-      };
-
-      const mockBrowser = {
-        newContext: vi.fn().mockResolvedValue(mockContext),
-        close: vi.fn()
-      };
-
-      const { chromium } = await import('@playwright/test');
-      (chromium.launch as any).mockResolvedValue(mockBrowser);
-
-      const result = await adapter.runSmokeTests({
-        target: { baseUrl: 'https://example.com' }
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.results[0].success).toBe(false);
-      expect(result.results[0].error).toContain('500');
-    });
-
-    it('should handle page navigation errors', async () => {
-      const mockPage = {
-        goto: vi.fn().mockRejectedValue(new Error('Navigation timeout')),
-        close: vi.fn()
-      };
-
-      const mockContext = {
-        newPage: vi.fn().mockResolvedValue(mockPage),
-        close: vi.fn()
-      };
-
-      const mockBrowser = {
-        newContext: vi.fn().mockResolvedValue(mockContext),
-        close: vi.fn()
-      };
-
-      const { chromium } = await import('@playwright/test');
-      (chromium.launch as any).mockResolvedValue(mockBrowser);
-
-      const result = await adapter.runSmokeTests({
-        target: { baseUrl: 'https://example.com' }
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.results[0].success).toBe(false);
-      expect(result.results[0].error).toContain('Navigation timeout');
-    });
-
-    it('should fail when accessibility score below budget', async () => {
-      const mockResponse = {
-        ok: vi.fn().mockReturnValue(true),
-        status: vi.fn().mockReturnValue(200)
-      };
-
-      const mockPage = {
-        goto: vi.fn().mockResolvedValue(mockResponse),
-        screenshot: vi.fn().mockResolvedValue(Buffer.from('screenshot')),
-        url: vi.fn().mockReturnValue('https://example.com'),
-        evaluate: vi.fn()
-          .mockResolvedValueOnce({ title: 'Test', url: 'https://example.com', elements: { buttons: 1, links: 5, forms: 0, inputs: 2 } })
-          .mockResolvedValueOnce({ violations: [{ impact: 'critical', description: 'Critical issue' }] }),
-        addScriptTag: vi.fn(),
-        close: vi.fn()
-      };
-
-      const mockContext = {
-        newPage: vi.fn().mockResolvedValue(mockPage),
-        close: vi.fn()
-      };
-
-      const mockBrowser = {
-        newContext: vi.fn().mockResolvedValue(mockContext),
-        close: vi.fn()
-      };
-
-      const { chromium } = await import('@playwright/test');
-      (chromium.launch as any).mockResolvedValue(mockBrowser);
-
-      const result = await adapter.runSmokeTests({
-        target: { baseUrl: 'https://example.com' },
-        budgets: { a11y_min: 90 }
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.results[0].success).toBe(false);
-      expect(result.results[0].error).toContain('Accessibility score');
-    });
-
-    it('should cleanup browser resources after tests', async () => {
-      const mockPage = {
-        goto: vi.fn().mockRejectedValue(new Error('Test error')),
-        close: vi.fn()
-      };
-
-      const mockContext = {
-        newPage: vi.fn().mockResolvedValue(mockPage),
-        close: vi.fn()
-      };
-
-      const mockBrowser = {
-        newContext: vi.fn().mockResolvedValue(mockContext),
-        close: vi.fn()
-      };
-
-      const { chromium } = await import('@playwright/test');
-      (chromium.launch as any).mockResolvedValue(mockBrowser);
-
-      await adapter.runSmokeTests({
-        target: { baseUrl: 'https://example.com' }
-      });
-
-      // Verify cleanup was called
-      expect(mockPage.close).toHaveBeenCalled();
-      expect(mockContext.close).toHaveBeenCalled();
-      expect(mockBrowser.close).toHaveBeenCalled();
-    });
-  });
-
-  // ============================================================
-  // validateConfig - Edge cases
-  // ============================================================
-  describe('validateConfig - edge cases', () => {
-    it('should accept relative page URLs', () => {
-      const result = PlaywrightUiAdapter.validateConfig({
-        baseUrl: 'https://example.com',
-        pages: ['/about', '/contact']
-      });
-
-      expect(result.valid).toBe(true);
-    });
-
-    it('should accept absolute page URLs', () => {
-      const result = PlaywrightUiAdapter.validateConfig({
-        baseUrl: 'https://example.com',
-        pages: ['https://example.com/page1', 'https://other.com/page2']
-      });
-
-      expect(result.valid).toBe(true);
-    });
-  });
-
-  // ============================================================
-  // Auth Support
-  // ============================================================
-  describe('setAuth', () => {
-    it('should set auth credentials', () => {
-      const adapter = new PlaywrightUiAdapter();
-      const credentials = {
-        type: 'bearer' as const,
-        headers: { 'Authorization': 'Bearer test-token' }
-      };
-
-      adapter.setAuth(credentials);
-      expect((adapter as any).auth).toEqual(credentials);
-    });
-
-    it('should unset auth credentials when undefined', () => {
-      const adapter = new PlaywrightUiAdapter();
-      const credentials = {
-        type: 'bearer' as const,
-        headers: { 'Authorization': 'Bearer test-token' }
-      };
-
-      adapter.setAuth(credentials);
-      expect((adapter as any).auth).toEqual(credentials);
-
-      adapter.setAuth(undefined);
-      expect((adapter as any).auth).toBeUndefined();
-    });
-
-    it('should store cookies from credentials', () => {
-      const adapter = new PlaywrightUiAdapter();
-      const credentials = {
-        type: 'ui_login' as const,
-        cookies: [
-          { name: 'session', value: 'abc123', domain: '.example.com' },
-          { name: 'token', value: 'xyz789' }
-        ]
-      };
-
-      adapter.setAuth(credentials);
-      expect((adapter as any).auth?.cookies).toHaveLength(2);
-      expect((adapter as any).auth?.cookies[0].name).toBe('session');
-    });
-
-    it('should store headers for cookie-based auth', () => {
-      const adapter = new PlaywrightUiAdapter();
-      const credentials = {
-        type: 'bearer' as const,
-        headers: { 'Cookie': 'session=abc123' }
-      };
-
-      adapter.setAuth(credentials);
-      expect((adapter as any).auth?.headers?.Cookie).toBe('session=abc123');
-    });
-  });
-});