qa360 2.1.7 → 2.2.0

package/dist/core/adapters/playwright-ui.js

@@ -1,840 +0,0 @@
-/**
- * QA360 Playwright UI Adapter (Extended)
- * Complete UI E2E testing with all Playwright actions
- *
- * Playwright++ Features:
- * - Video recording (always/retain-on-fail/never)
- * - Automatic screenshots (before/after steps, on error)
- * - Trace capture for debugging
- * - Artifacts management with CAS
- * - HTML report generation
- */
-import { chromium, firefox, webkit } from '@playwright/test';
-import { SecurityRedactor } from '../security/redactor.js';
-import { createAssertionsEngine } from '../assertions/index.js';
-import { UIArtifactsManager } from '../artifacts/index.js';
-import { HTMLReporter } from '../reporting/index.js';
-import { mkdirSync, existsSync } from 'fs';
-import { join } from 'path';
-export class PlaywrightUiAdapter {
-    browser;
-    context;
-    page;
-    redactor;
-    auth;
-    assertions;
-    // Storage for artifacts
-    artifactDir;
-    videoDir;
-    traceDir;
-    // Playwright++: Artifacts manager
-    artifactsManager;
-    failureCount = 0;
-    currentTestId;
-    allScreenshots = [];
-    allVideos = [];
-    allTraces = [];
-    constructor() {
-        this.redactor = SecurityRedactor.forLogs();
-        this.artifactDir = '.qa360/artifacts/ui';
-        this.videoDir = `${this.artifactDir}/videos`;
-        this.traceDir = `${this.artifactDir}/traces`;
-    }
-    /**
-     * Set authentication credentials for requests
-     */
-    setAuth(credentials) {
-        this.auth = credentials;
-    }
-    /**
-     * Execute UI smoke tests with accessibility
-     * Playwright++: Supports artifacts, screenshots, video, trace, HTML reporting
-     */
-    async runSmokeTests(config) {
-        const startTime = Date.now();
-        const outputDir = config.artifacts?.outputDir || this.artifactDir;
-        // Ensure output directories exist
-        for (const dir of [outputDir, this.videoDir, this.traceDir]) {
-            if (!existsSync(dir)) {
-                mkdirSync(dir, { recursive: true });
-            }
-        }
-        // Initialize artifacts manager if Playwright++ features enabled
-        const artifactsEnabled = config.artifacts?.screenshots !== 'never' ||
-            config.artifacts?.video !== 'never' ||
-            config.artifacts?.trace !== 'never';
-        if (artifactsEnabled) {
-            this.artifactsManager = new UIArtifactsManager(outputDir, '.qa360/runs/cas');
-        }
-        try {
-            // Store auth config
-            this.auth = config.auth;
-            this.failureCount = 0;
-            this.allScreenshots = [];
-            this.allVideos = [];
-            this.allTraces = [];
-            await this.setupBrowser(config);
-            const results = [];
-            const pages = config.target.pages || [config.target.baseUrl];
-            console.log(`🖥️  Running UI smoke tests (${pages.length} pages)`);
-            // Optional login first
-            if (config.login) {
-                await this.performLogin(config.login);
-            }
-            for (const pageUrl of pages) {
-                // Start artifacts for this test
-                this.currentTestId = `smoke-${this.failureCount}`;
-                this.artifactsManager?.startTest(this.currentTestId);
-                const testResult = await this.testPage(pageUrl, config);
-                results.push(testResult);
-                if (testResult.success) {
-                    const a11yInfo = testResult.accessibility ?
-                        ` | A11y: ${testResult.accessibility.score}% (${testResult.accessibility.violations.length} issues)` : '';
-                    console.log(`  ✅ ${pageUrl} -> ${testResult.loadTime}ms${a11yInfo}`);
-                }
-                else {
-                    this.failureCount++;
-                    console.log(`  ❌ ${pageUrl} -> ${testResult.error}`);
-                    // Check bail condition
-                    if (config.bail && this.failureCount >= config.bail) {
-                        console.log(`  🛑 Bailing after ${this.failureCount} failures`);
-                        break;
-                    }
-                }
-                this.artifactsManager?.endTest();
-            }
-            // Run E2E tests if defined
-            let e2eResults = [];
-            if (config.target.uiTests && config.target.uiTests.length > 0) {
-                console.log(`🧪 Running E2E tests (${config.target.uiTests.length} tests)`);
-                for (const test of config.target.uiTests) {
-                    if (test.enabled !== false) {
-                        // Start artifacts for this test
-                        this.currentTestId = `e2e-${test.name}`;
-                        this.artifactsManager?.startTest(this.currentTestId);
-                        const result = await this.runE2eTest(test, config);
-                        e2eResults.push(result);
-                        const status = result.success ? '✅' : '❌';
-                        console.log(`  ${status} ${test.name} (${result.duration}ms)`);
-                        if (!result.success) {
-                            console.log(`      Error: ${result.error}`);
-                            this.failureCount++;
-                            // Check bail condition
-                            if (config.bail && this.failureCount >= config.bail) {
-                                console.log(`  🛑 Bailing after ${this.failureCount} failures`);
-                                this.artifactsManager?.endTest();
-                                break;
-                            }
-                        }
-                        this.artifactsManager?.endTest();
-                    }
-                }
-            }
-            const summary = this.calculateSummary(results, e2eResults);
-            const junit = this.generateJUnit(results, e2eResults);
-            // Playwright++: Generate HTML report if requested
-            if (config.htmlReport) {
-                await this.generateHtmlReport(config, results, e2eResults, summary);
-            }
-            return {
-                success: summary.failed === 0,
-                results,
-                e2eResults,
-                summary,
-                junit
-            };
-        }
-        finally {
-            await this.cleanup(config);
-        }
-    }
-    /**
-     * Run a single E2E test
-     * Playwright++: Takes before/after screenshots, captures artifacts on failure
-     */
-    async runE2eTest(test, config) {
-        const startTime = Date.now();
-        const steps = [];
-        const screenshotMode = config.artifacts?.screenshots || 'never';
-        try {
-            // Determine starting URL
-            const startUrl = test.url || `${config.target.baseUrl.replace(/\/$/, '')}${test.path || ''}`;
-            // Navigate to start URL
-            console.log(`    📍 Navigate to: ${startUrl}`);
-            await this.page.goto(startUrl, { timeout: test.timeout || config.timeout || 30000 });
-            // Take initial screenshot
-            if (screenshotMode === 'always') {
-                await this.artifactsManager?.takeScreenshot(this.page, {}, {
-                    testId: this.currentTestId || 'unknown',
-                    type: 'screenshot',
-                    tags: ['initial'],
-                });
-            }
-            // Initialize assertions engine
-            this.assertions = createAssertionsEngine(this.page);
-            // Execute each step
-            for (let i = 0; i < test.steps.length; i++) {
-                const step = test.steps[i];
-                // Take before screenshot if configured
-                if (screenshotMode === 'always') {
-                    await this.artifactsManager?.takeBeforeScreenshot(this.page, step.action || 'step', i);
-                }
-                const stepResult = await this.executeStep(step, config);
-                steps.push(stepResult);
-                // Take after screenshot (always on failure, or always if configured)
-                if (screenshotMode === 'always' || (screenshotMode === 'only-on-failure' && !stepResult.success)) {
-                    await this.artifactsManager?.takeAfterScreenshot(this.page, step.action || 'step', i, stepResult.success);
-                }
-                if (!stepResult.success) {
-                    // Take error screenshot
-                    await this.artifactsManager?.takeErrorScreenshot(this.page, new Error(stepResult.error || 'Step failed'), step.action);
-                    return {
-                        test,
-                        success: false,
-                        steps,
-                        duration: Date.now() - startTime,
-                        error: stepResult.error,
-                    };
-                }
-            }
-            return {
-                test,
-                success: true,
-                steps,
-                duration: Date.now() - startTime,
-            };
-        }
-        catch (error) {
-            // Take error screenshot
-            await this.artifactsManager?.takeErrorScreenshot(this.page, error);
-            return {
-                test,
-                success: false,
-                steps,
-                duration: Date.now() - startTime,
-                error: this.redactor.redact(error instanceof Error ? error.message : 'Unknown error'),
-            };
-        }
-    }
-    /**
-     * Execute a single UI test step
-     * Playwright++: Enhanced error handling with artifacts
-     */
-    async executeStep(step, config) {
-        const startTime = Date.now();
-        let screenshot;
-        try {
-            const { action, selector, value, options = {}, expected } = step;
-            const opts = { timeout: 5000, ...options };
-            switch (action) {
-                case 'navigate':
-                    await this.page.goto(value, opts);
-                    break;
-                case 'click':
-                    await this.page.click(selector, opts);
-                    break;
-                case 'dblClick':
-                    await this.page.dblclick(selector, opts);
-                    break;
-                case 'rightClick':
-                    await this.page.click(selector, { ...opts, button: 'right' });
-                    break;
-                case 'hover':
-                    await this.page.hover(selector, opts);
-                    break;
-                case 'focus':
-                    await this.page.focus(selector, opts);
-                    break;
-                case 'fill':
-                    await this.page.fill(selector, value, opts);
-                    break;
-                case 'type':
-                    await this.page.type(selector, value, opts);
-                    break;
-                case 'clear':
-                    await this.page.fill(selector, '', opts);
-                    break;
-                case 'select':
-                    if (value !== undefined) {
-                        await this.page.selectOption(selector, value, opts);
-                    }
-                    break;
-                case 'check':
-                    await this.page.check(selector, opts);
-                    break;
-                case 'uncheck':
-                    await this.page.uncheck(selector, opts);
-                    break;
-                case 'upload':
-                    if (value !== undefined) {
-                        await this.page.setInputFiles(selector, value, opts);
-                    }
-                    break;
-                case 'press': {
-                    const delay = options?.delay;
-                    const pressOpts = delay !== undefined ? { delay } : {};
-                    await this.page.keyboard.press(value, pressOpts);
-                    break;
-                }
-                case 'waitFor':
-                case 'waitForSelector':
-                    await this.page.waitForSelector(selector, opts);
-                    break;
-                case 'waitForNavigation':
-                    await this.page.waitForNavigation(opts);
-                    break;
-                case 'waitForTimeout':
-                    await this.page.waitForTimeout(parseInt(value, 10));
-                    break;
-                case 'scroll':
-                    if (selector) {
-                        await this.page.evaluate((sel) => {
-                            const el = document.querySelector(sel);
-                            if (el)
-                                el.scrollIntoView({ behavior: 'smooth', block: 'center' });
-                        }, selector);
-                    }
-                    break;
-                case 'dragAndDrop':
-                    await this.page.dragAndDrop(selector, value, opts);
-                    break;
-                case 'tap':
-                    await this.page.tap(selector, opts);
-                    break;
-                default:
-                    throw new Error(`Unknown action: ${action}`);
-            }
-            // Add wait after action if specified
-            if (step.wait) {
-                await this.page.waitForTimeout(step.wait);
-            }
-            // Take screenshot on failure if configured (will be checked in catch block)
-            // or take screenshot if requested
-            // Verify expected outcomes
-            if (expected) {
-                await this.verifyExpected(expected);
-            }
-            return {
-                step,
-                success: true,
-                duration: Date.now() - startTime,
-                screenshot,
-            };
-        }
-        catch (error) {
-            // Take screenshot on failure
-            try {
-                const buffer = await this.page.screenshot({ type: 'png' });
-                screenshot = `data:image/png;base64,${buffer.toString('base64')}`;
-            }
-            catch { }
-            return {
-                step,
-                success: false,
-                duration: Date.now() - startTime,
-                error: this.redactor.redact(error instanceof Error ? error.message : 'Unknown error'),
-                screenshot,
-            };
-        }
-    }
-    /**
-     * Verify expected outcomes after a step
-     */
-    async verifyExpected(expected) {
-        if (!expected)
-            return;
-        if (expected.url !== undefined) {
-            const currentUrl = this.page.url();
-            if (currentUrl !== expected.url) {
-                throw new Error(`URL mismatch: expected "${expected.url}", got "${currentUrl}"`);
-            }
-        }
-        if (expected.urlContains !== undefined) {
-            const currentUrl = this.page.url();
-            if (!currentUrl.includes(expected.urlContains)) {
-                throw new Error(`URL does not contain "${expected.urlContains}": "${currentUrl}"`);
-            }
-        }
-        if (expected.visible !== undefined) {
-            const element = this.page.locator(expected.visible);
-            if (!(await element.isVisible())) {
-                throw new Error(`Expected element to be visible: ${expected.visible}`);
-            }
-        }
-        if (expected.hidden !== undefined) {
-            const element = this.page.locator(expected.hidden);
-            if (!(await element.isHidden())) {
-                throw new Error(`Expected element to be hidden: ${expected.hidden}`);
-            }
-        }
-        if (expected.elementText) {
-            const element = this.page.locator(expected.elementText.selector);
-            const text = await element.textContent();
-            if (text !== expected.elementText.text) {
-                throw new Error(`Text mismatch for ${expected.elementText.selector}: expected "${expected.elementText.text}", got "${text}"`);
-            }
-        }
-    }
-    /**
-     * Test single page with accessibility
-     */
-    async testPage(pageUrl, config) {
-        try {
-            const startTime = Date.now();
-            // Navigate to page
-            const response = await this.page.goto(pageUrl, {
-                timeout: config.timeout || 30000,
-                waitUntil: 'networkidle'
-            });
-            const loadTime = Date.now() - startTime;
-            if (!response || !response.ok()) {
-                return {
-                    page: pageUrl,
-                    success: false,
-                    loadTime,
-                    error: `HTTP ${response?.status() || 'unknown'}: Failed to load page`
-                };
-            }
-            // Take screenshot based on config
-            const screenshot = await this.takeScreenshot(pageUrl, config.target.screenshot);
-            // Get DOM snapshot
-            const domSnapshot = await this.getDomSnapshot();
-            // Run accessibility tests
-            const accessibility = await this.runAccessibilityTests(config.budgets);
-            // Check if accessibility meets budget
-            const a11yPassed = !config.budgets?.a11y_min ||
-                (accessibility?.score !== undefined && accessibility.score >= config.budgets.a11y_min);
-            return {
-                page: pageUrl,
-                success: a11yPassed,
-                loadTime,
-                screenshot,
-                accessibility,
-                domSnapshot,
-                error: a11yPassed ? undefined :
-                    `Accessibility score ${accessibility?.score || 0}% below budget ${config.budgets?.a11y_min}%`
-            };
-        }
-        catch (error) {
-            return {
-                page: pageUrl,
-                success: false,
-                loadTime: 0,
-                error: this.redactor.redact(error instanceof Error ? error.message : 'Unknown error')
-            };
-        }
-    }
-    /**
-     * Setup browser with all options
-     * Playwright++: Enhanced video/trace recording support
-     */
-    async setupBrowser(config) {
-        // Determine browser type
-        const browserType = config.target.browser || 'chromium';
-        const browserTypeObj = browserType === 'firefox' ? firefox : browserType === 'webkit' ? webkit : chromium;
-        // Determine headed mode (CLI override > target config > default headless)
-        const headless = config.cliHeaded ?? config.target.headless ?? true;
-        // Launch browser
-        this.browser = await browserTypeObj.launch({
-            headless,
-            args: ['--no-sandbox', '--disable-dev-shm-usage'],
-            slowMo: config.target.slowMo || 0,
-        });
-        // Build extra HTTP headers with auth
-        const extraHTTPHeaders = {
-            'User-Agent': 'QA360-UI-Test/1.0'
-        };
-        if (this.auth?.headers) {
-            Object.assign(extraHTTPHeaders, this.auth.headers);
-        }
-        // Setup viewport based on device or explicit config
-        let viewport = { width: 1280, height: 720 };
-        if (config.target.device === 'mobile') {
-            viewport = { width: 375, height: 667 };
-        }
-        else if (config.target.device === 'tablet') {
-            viewport = { width: 768, height: 1024 };
-        }
-        else if (config.target.viewport) {
-            viewport = config.target.viewport;
-        }
-        // Playwright++: Determine video recording mode
-        const videoMode = config.artifacts?.video ?? config.target.video;
-        const shouldRecordVideo = videoMode === 'always' || videoMode === 'retain-on-failure';
-        // Create context with video recording if enabled
-        const recordVideo = shouldRecordVideo
-            ? { dir: this.videoDir, size: viewport }
-            : undefined;
-        this.context = await this.browser.newContext({
-            viewport,
-            userAgent: 'QA360-UI-Test/1.0',
-            extraHTTPHeaders,
-            recordVideo,
-        });
-        // Playwright++: Start tracing if enabled
-        const traceMode = config.artifacts?.trace ?? config.target.trace;
-        if (traceMode === 'always' || traceMode === 'on-first-failure' || traceMode === 'retain-on-failure') {
-            // Start tracing - will be saved in cleanup
-            // Note: Playwright's trace API is context.startTracing()
-            // Implementation depends on Playwright version
-        }
-        // Add cookies from auth credentials after context creation
-        if (this.auth?.cookies && this.auth.cookies.length > 0) {
-            await this.context.addCookies(this.auth.cookies.map(c => ({
-                name: c.name,
-                value: c.value,
-                domain: c.domain || '',
-                path: c.path || '/',
-                httpOnly: c.httpOnly || false,
-                secure: c.secure || false
-            })));
-        }
-        this.page = await this.context.newPage();
-    }
-    /**
-     * Determine if video should be recorded
-     */
-    shouldRecordVideo(mode) {
-        return mode === 'always' || mode === 'retain-on-fail';
-    }
-    /**
-     * Playwright++: Generate HTML report
-     */
-    async generateHtmlReport(config, results, e2eResults, summary) {
-        const reportPath = config.htmlReport || join(config.artifacts?.outputDir || this.artifactDir, 'report.html');
-        const timestamp = new Date().toISOString();
-        const reportData = {
-            title: `QA360 UI Test Report - ${timestamp}`,
-            summary: {
-                total: summary.total,
-                passed: summary.passed,
-                failed: summary.failed,
-                skipped: 0,
-                duration: summary.avgLoadTime * summary.total,
-                timestamp,
-            },
-            tests: [
-                ...results.map((r, i) => ({
-                    id: `smoke-${i}`,
-                    name: `UI Smoke: ${r.page}`,
-                    status: (r.success ? 'passed' : 'failed'),
-                    duration: r.loadTime,
-                    error: r.error,
-                    steps: [],
-                    artifacts: r.artifacts,
-                })),
-                ...e2eResults.map((r, i) => ({
-                    id: `e2e-${i}`,
-                    name: r.test.name || 'E2E Test',
-                    status: (r.success ? 'passed' : 'failed'),
-                    duration: r.duration,
-                    error: r.error,
-                    steps: r.steps.map((s, j) => ({
-                        name: s.step.action || `Step ${j + 1}`,
-                        action: s.step.action || 'step',
-                        selector: s.step.selector,
-                        value: s.step.value,
-                        status: (s.success ? 'passed' : 'failed'),
-                        duration: s.duration,
-                        error: s.error,
-                    })),
-                    artifacts: undefined,
-                })),
-            ],
-            artifacts: {
-                screenshots: this.allScreenshots.map(s => ({
-                    path: s.localPath,
-                    timestamp: s.metadata.timestamp,
-                    type: 'after',
-                })),
-                videos: this.allVideos.map(v => ({ path: v, duration: 0 })),
-                traces: this.allTraces.map(t => ({ path: t, format: 'zip' })),
-            },
-            environment: {
-                browser: config.target.browser || 'chromium',
-                platform: process.platform,
-                nodeVersion: process.version,
-            },
-        };
-        HTMLReporter.generate(reportData, reportPath);
-        console.log(`\n📊 HTML report generated: ${reportPath}`);
-    }
-    /**
-     * Perform login if configured
-     */
-    async performLogin(login) {
-        if (!login || !login.username || !login.password) {
-            return;
-        }
-        console.log(`  🔐 Performing login...`);
-        const loginUrl = login.url || this.page.url();
-        await this.page.goto(loginUrl);
-        // Fill login form
-        const usernameSelector = login.usernameSelector ||
-            'input[name="username"], input[name="email"], input[type="email"], #username, #email';
-        const passwordSelector = login.passwordSelector ||
-            'input[name="password"], input[type="password"], #password';
-        const submitSelector = login.submitSelector ||
-            'button[type="submit"], input[type="submit"], button:has-text("Login"), button:has-text("Sign in")';
-        await this.page.fill(usernameSelector, login.username);
-        await this.page.fill(passwordSelector, login.password);
-        await this.page.click(submitSelector);
-        // Wait for navigation or login completion
-        try {
-            await this.page.waitForLoadState('networkidle', { timeout: 10000 });
-        }
-        catch {
-            // Continue even if navigation doesn't complete
-        }
-    }
-    /**
-     * Run accessibility tests using axe-core
-     */
-    async runAccessibilityTests(budgets) {
-        try {
-            // Inject axe-core
-            await this.page.addScriptTag({
-                url: 'https://unpkg.com/axe-core@4.8.2/axe.min.js'
-            });
-            // Run axe analysis
-            const axeResults = await this.page.evaluate(() => {
-                return new Promise((resolve) => {
-                    // @ts-ignore - axe is injected
-                    if (typeof axe !== 'undefined') {
-                        // @ts-ignore
-                        axe.run((err, results) => {
-                            if (err) {
-                                resolve({ violations: [], passes: [], incomplete: [] });
-                            }
-                            else {
-                                resolve(results);
-                            }
-                        });
-                    }
-                    else {
-                        resolve({ violations: [], passes: [], incomplete: [] });
-                    }
-                });
-            });
-            // Process violations
-            const violations = axeResults.violations?.map((violation) => ({
-                id: violation.id,
-                impact: violation.impact || 'minor',
-                description: violation.description || violation.help || 'Accessibility issue',
-                nodes: violation.nodes?.length || 0
-            })) || [];
-            // Calculate score (simple scoring: 100 - weighted violations)
-            const criticalCount = violations.filter((v) => v.impact === 'critical').length;
-            const seriousCount = violations.filter((v) => v.impact === 'serious').length;
-            const moderateCount = violations.filter((v) => v.impact === 'moderate').length;
-            const minorCount = violations.filter((v) => v.impact === 'minor').length;
-            const score = Math.max(0, 100 - (criticalCount * 25 +
-                seriousCount * 10 +
-                moderateCount * 5 +
-                minorCount * 1));
-            return {
-                score: Math.round(score),
-                violations
-            };
-        }
-        catch (error) {
-            console.log(`    ⚠️  Accessibility test failed: ${error}`);
-            return {
-                score: 0,
-                violations: [{
-                        id: 'axe-error',
-                        impact: 'critical',
-                        description: 'Failed to run accessibility analysis',
-                        nodes: 0
-                    }]
-            };
-        }
-    }
-    /**
-     * Get DOM snapshot for debugging
-     */
-    async getDomSnapshot() {
-        try {
-            const snapshot = await this.page.evaluate(() => {
-                return {
-                    title: document.title,
-                    url: window.location.href,
-                    elements: {
-                        buttons: document.querySelectorAll('button, input[type="button"], input[type="submit"]').length,
-                        links: document.querySelectorAll('a[href]').length,
-                        forms: document.querySelectorAll('form').length,
-                        inputs: document.querySelectorAll('input, textarea, select').length
-                    }
-                };
-            });
-            return snapshot;
-        }
-        catch {
-            return {
-                title: 'Unknown',
-                url: this.page.url(),
-                elements: { buttons: 0, links: 0, forms: 0, inputs: 0 }
-            };
-        }
-    }
-    /**
-     * Take screenshot for debugging
-     */
-    async takeScreenshot(pageUrl, mode) {
-        const shouldTake = mode === 'always' || mode === 'only-on-fail';
-        if (!shouldTake)
-            return '';
-        try {
-            const screenshot = await this.page.screenshot({
-                type: 'png',
-                fullPage: false // Just viewport for performance
-            });
-            // Return base64 data URL for embedding
-            return `data:image/png;base64,${screenshot.toString('base64')}`;
-        }
-        catch {
-            return '';
-        }
-    }
-    /**
-     * Calculate test summary
-     */
-    calculateSummary(results, e2eResults = []) {
-        const smokeTests = results.length;
-        const e2eTests = e2eResults.length;
-        const total = smokeTests + e2eTests;
-        const smokePassed = results.filter(r => r.success).length;
-        const e2ePassed = e2eResults.filter(r => r.success).length;
-        const passed = smokePassed + e2ePassed;
-        const failed = total - passed;
-        const avgLoadTime = smokeTests > 0 ?
-            Math.round(results.reduce((sum, r) => sum + r.loadTime, 0) / smokeTests) : 0;
-        const a11yScores = results
-            .map(r => r.accessibility?.score)
-            .filter((score) => typeof score === 'number');
-        const avgA11yScore = a11yScores.length > 0 ?
-            Math.round(a11yScores.reduce((sum, score) => sum + score, 0) / a11yScores.length) : 0;
-        return {
-            total,
-            passed,
-            failed,
-            avgLoadTime,
-            avgA11yScore
-        };
-    }
-    /**
-     * Generate JUnit XML fragment
-     */
-    generateJUnit(results, e2eResults = []) {
-        const summary = this.calculateSummary(results, e2eResults);
-        const timestamp = new Date().toISOString();
-        let junit = `<?xml version="1.0" encoding="UTF-8"?>
-<testsuites>
-  <testsuite name="UI Smoke Tests" tests="${results.length}" failures="${results.filter(r => !r.success).length}" time="${summary.avgLoadTime / 1000}" timestamp="${timestamp}">
-`;
-        for (const result of results) {
-            const testName = `UI Test: ${result.page}`;
-            const time = result.loadTime / 1000;
-            junit += `    <testcase name="${this.escapeXml(testName)}" time="${time}">
-`;
-            if (!result.success) {
-                junit += `      <failure message="${this.escapeXml(result.error || 'Test failed')}">${this.escapeXml(JSON.stringify(result, null, 2))}</failure>
-`;
-            }
-            junit += `    </testcase>
-`;
-        }
-        junit += `  </testsuite>
-`;
-        // Add E2E test suite
-        if (e2eResults.length > 0) {
-            const e2eFailed = e2eResults.filter(r => !r.success).length;
-            const e2eDuration = e2eResults.reduce((sum, r) => sum + r.duration, 0) / 1000;
-            junit += `  <testsuite name="E2E Tests" tests="${e2eResults.length}" failures="${e2eFailed}" time="${e2eDuration}" timestamp="${timestamp}">
-`;
-            for (const result of e2eResults) {
-                const testName = result.test.name;
-                const time = result.duration / 1000;
-                junit += `    <testcase name="${this.escapeXml(testName)}" time="${time}">
-`;
-                if (!result.success) {
-                    const failedSteps = result.steps.filter(s => !s.success);
-                    const failureDetails = failedSteps.map(s => `${s.step.action}: ${s.error}`).join('; ');
-                    junit += `      <failure message="${this.escapeXml(result.error || 'Test failed')}">${this.escapeXml(failureDetails)}</failure>
-`;
-                }
-                junit += `    </testcase>
-`;
-            }
-            junit += `  </testsuite>
-`;
-        }
-        junit += `</testsuites>`;
-        return junit;
-    }
-    /**
-     * Escape XML special characters
-     */
-    escapeXml(str) {
-        return str
-            .replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;')
-            .replace(/'/g, '&apos;');
-    }
-    /**
-     * Cleanup browser resources
-     */
-    async cleanup(config) {
-        // Save video/trace artifacts if configured
-        if (this.page && (config.target.video === 'retain-on-fail' || config.target.trace === 'retain-on-fail')) {
-            // Check if tests failed and retain artifacts
-            const hasFailures = false; // Would need to track this
-            if (!hasFailures) {
-                // Clean up artifacts if all tests passed
-                // TODO: Implement artifact cleanup
-            }
-        }
-        if (this.page) {
-            await this.page.close();
-        }
-        if (this.context) {
-            await this.context.close();
-        }
-        if (this.browser) {
-            await this.browser.close();
-        }
-    }
-    /**
-     * Validate UI target configuration
-     */
-    static validateConfig(target) {
-        const errors = [];
-        if (!target.baseUrl) {
-            errors.push('UI target requires baseUrl');
-        }
-        else {
-            try {
-                new URL(target.baseUrl);
-            }
-            catch {
-                errors.push('UI target baseUrl must be a valid URL');
-            }
-        }
-        if (target.pages) {
-            for (const page of target.pages) {
-                try {
-                    new URL(page, target.baseUrl);
-                }
-                catch {
-                    errors.push(`Invalid page URL: ${page}`);
-                }
-            }
-        }
-        return {
-            valid: errors.length === 0,
-            errors
-        };
-    }
-}