qa360 2.2.1 → 2.2.7

package/cli/dist/core/adapters/playwright-native-api.js

@@ -0,0 +1,465 @@
+/**
+ * QA360 Playwright Native API Adapter
+ *
+ * Uses Playwright's native APIRequestContext for HTTP testing.
+ * No browser launch required - lighter and faster than browser-based approach.
+ *
+ * @see https://playwright.dev/docs/api/class-apirequestcontext
+ *
+ * Benefits over browser-based approach:
+ * - No browser overhead (faster startup, lower memory)
+ * - Direct HTTP requests
+ * - Same API testing capabilities
+ * - Better for CI/CD environments
+ */
+import * as playwright from 'playwright';
+import { SecurityRedactor } from '../security/redactor.js';
+import { ResponseCache, generateCacheKey } from '../cache/lru-cache.js';
+/**
+ * Playwright Native API Adapter
+ *
+ * Uses playwright.request.newContext() for direct HTTP requests
+ * without launching a browser.
+ */
+export class PlaywrightNativeApiAdapter {
+    requestContext;
+    redactor;
+    auth;
+    cache;
+    constructor() {
+        this.redactor = SecurityRedactor.forLogs();
+    }
+    /**
+     * Set authentication credentials for requests
+     */
+    setAuth(credentials) {
+        this.auth = credentials;
+    }
+    /**
+     * Execute API smoke tests using Playwright's native API
+     */
+    async runSmokeTests(config) {
+        try {
+            this.auth = config.auth;
+            // Initialize cache if enabled
+            if (config.cache?.enabled) {
+                this.cache = new ResponseCache({
+                    maxSize: config.cache.maxSize ?? 100,
+                    ttl: config.cache.ttl ?? 300000,
+                    maxSizeBytes: config.cache.maxSizeBytes ?? 10 * 1024 * 1024,
+                    verbose: false
+                });
+                console.log(`📦 Cache enabled: max=${config.cache.maxSize ?? 100}, ttl=${config.cache.ttl ?? 300000}ms`);
+            }
+            await this.setupRequestContext(config);
+            const results = [];
+            const smokeTests = config.target.smoke || [`GET ${config.target.baseUrl}/health -> 200`];
+            console.log(`🌐 Running API smoke tests with Playwright Native (${smokeTests.length} endpoints)`);
+            for (const test of smokeTests) {
+                // Check cache first if enabled
+                const cacheKey = this.cache ? generateCacheKey({
+                    method: test.split(' ')[0],
+                    url: config.target.baseUrl,
+                    headers: this.auth?.headers
+                }) : '';
+                let testResult;
+                if (this.cache) {
+                    testResult = await this.cache.getOrFetch(cacheKey, () => this.executeApiTest(test, config));
+                    const cached = this.cache.has(cacheKey);
+                    const cacheIndicator = cached ? '📦' : '🌐';
+                    if (testResult.success) {
+                        console.log(`  ${cacheIndicator} ✅ ${testResult.method} ${testResult.endpoint} -> ${testResult.status} (${testResult.responseTime}ms)`);
+                    }
+                    else {
+                        const errorMsg = testResult.error || 'Request failed';
+                        const retryInfo = testResult.attempts && testResult.attempts > 1
+                            ? ` (after ${testResult.attempts} attempts)`
+                            : '';
+                        console.log(`  ${cacheIndicator} ❌ ${testResult.method} ${testResult.endpoint} -> ${errorMsg}${retryInfo}`);
+                    }
+                }
+                else {
+                    testResult = await this.executeApiTest(test, config);
+                    if (testResult.success) {
+                        console.log(`  ✅ ${testResult.method} ${testResult.endpoint} -> ${testResult.status} (${testResult.responseTime}ms)`);
+                    }
+                    else {
+                        const errorMsg = testResult.error || 'Request failed';
+                        const retryInfo = testResult.attempts && testResult.attempts > 1
+                            ? ` (after ${testResult.attempts} attempts)`
+                            : '';
+                        console.log(`  ❌ ${testResult.method} ${testResult.endpoint} -> ${errorMsg}${retryInfo}`);
+                    }
+                }
+                results.push(testResult);
+            }
+            const summary = this.calculateSummary(results);
+            const junit = this.generateJUnit(results);
+            let error;
+            if (summary.failed > 0) {
+                const failedTests = results.filter(r => !r.success);
+                const errorMessages = failedTests.map(t => t.error).filter(Boolean);
+                error = errorMessages.length > 0
+                    ? `${summary.failed} endpoint(s) failed: ${errorMessages[0]}${errorMessages.length > 1 ? ` (and ${errorMessages.length - 1} more)` : ''}`
+                    : `${summary.failed} endpoint(s) failed`;
+            }
+            return {
+                success: summary.failed === 0,
+                results,
+                summary,
+                junit,
+                error
+            };
+        }
+        finally {
+            await this.cleanup();
+        }
+    }
+    /**
+     * Setup Playwright APIRequestContext for HTTP requests
+     */
+    async setupRequestContext(config) {
+        const baseOptions = {
+            userAgent: 'QA360-Native-API/1.0',
+        };
+        const headers = {
+            'Accept': 'application/json, text/plain, */*',
+            'Accept-Encoding': 'gzip, deflate, br',
+        };
+        // Add auth headers if provided
+        if (this.auth?.headers) {
+            Object.assign(headers, this.auth.headers);
+        }
+        baseOptions.extraHTTPHeaders = headers;
+        // Add storage state if provided
+        if (config.storageState) {
+            baseOptions.storageState = config.storageState;
+        }
+        // Set timeout
+        if (config.timeout) {
+            baseOptions.timeout = config.timeout;
+        }
+        // Create API request context using Playwright
+        this.requestContext = await playwright.request.newContext(baseOptions);
+        // Set basic auth if provided in config
+        if (config.basicAuth) {
+            // Note: setHTTPCredentials may not exist on APIRequestContext
+            // Using HTTPCredentials via newContext options instead
+            const creds = { username: config.basicAuth.username, password: config.basicAuth.password };
+            // Set in context options - basic auth is handled via headers
+            const authHeader = 'Basic ' + Buffer.from(`${creds.username}:${creds.password}`).toString('base64');
+            headers['Authorization'] = authHeader;
+            baseOptions.extraHTTPHeaders = headers;
+            // Recreate context with auth headers
+            await this.requestContext.dispose();
+            this.requestContext = await playwright.request.newContext(baseOptions);
+        }
+    }
+    /**
+     * Execute single API test with retry logic using native API
+     */
+    async executeApiTest(testSpec, config) {
+        const { method, endpoint, expectedStatus } = this.parseTestSpec(testSpec, config.target.baseUrl);
+        const maxRetries = config.retries || 0;
+        let lastError = '';
+        let lastResponse = null;
+        let attempts = 0;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            attempts++;
+            const startTime = Date.now();
+            try {
+                // Build request options
+                const requestOptions = {
+                    method: method,
+                    timeout: config.timeout || 30000,
+                    failOnStatusCode: false, // Don't throw on non-2xx responses
+                };
+                // Add body for POST/PUT/PATCH (from config)
+                if (['POST', 'PUT', 'PATCH'].includes(method) && config.body) {
+                    requestOptions.data = config.body;
+                }
+                // Make the request using Playwright's native API
+                lastResponse = await this.requestContext.fetch(endpoint, requestOptions);
+                const responseTime = Date.now() - startTime;
+                const status = lastResponse.status();
+                const success = status === expectedStatus;
+                // Get response headers
+                const responseHeaders = lastResponse.headers();
+                const headers = {};
+                for (const [key, value] of Object.entries(responseHeaders)) {
+                    headers[key] = value;
+                }
+                // Get response body safely
+                let body;
+                try {
+                    const contentType = headers['content-type'] || '';
+                    if (contentType.includes('application/json')) {
+                        body = await lastResponse.json();
+                    }
+                    else {
+                        const text = await lastResponse.text();
+                        body = text.substring(0, 500); // Limit body size
+                    }
+                }
+                catch {
+                    body = '[Response body not readable]';
+                }
+                return {
+                    endpoint,
+                    method,
+                    status,
+                    responseTime,
+                    success,
+                    error: success ? undefined : `Expected status ${expectedStatus}, got ${status}`,
+                    headers,
+                    body: this.redactor.redactObject(body),
+                    attempts
+                };
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error.message : 'Unknown error';
+                // Check if this is a retryable error
+                const isRetryable = this.isRetryableError(lastError);
+                if (isRetryable && attempt < maxRetries) {
+                    const waitTime = 1000 * Math.pow(2, attempt); // Exponential backoff
+                    console.log(`    🔄 Retry ${attempt + 1}/${maxRetries} for ${method} ${endpoint} (${lastError}) - waiting ${waitTime}ms`);
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                    continue;
+                }
+                break;
+            }
+        }
+        // If we get here, all retries failed or request threw an error
+        return {
+            endpoint,
+            method,
+            status: lastResponse?.status() || 0,
+            responseTime: 0,
+            success: false,
+            error: this.redactor.redact(lastError),
+            attempts
+        };
+    }
+    /**
+     * Parse test specification string
+     * Format: "GET /path -> 200" or "POST /api/users -> 201"
+     */
+    parseTestSpec(spec, baseUrl) {
+        // Validate baseUrl first
+        if (!baseUrl || typeof baseUrl !== 'string') {
+            throw new Error('baseUrl is required in gate configuration. Add "baseUrl: https://your-api.com" to the config section.');
+        }
+        const match = spec.match(/^(\w+)\s+(.+?)\s*->\s*(\d+)$/);
+        if (!match) {
+            throw new Error(`Invalid test spec format: ${spec}. Expected: "METHOD /path -> STATUS"`);
+        }
+        const [, method, path, statusStr] = match;
+        const expectedStatus = parseInt(statusStr, 10);
+        // Build full endpoint URL
+        let endpoint = path;
+        if (!path.startsWith('http')) {
+            endpoint = baseUrl.replace(/\/$/, '') + (path.startsWith('/') ? path : `/${path}`);
+        }
+        return {
+            method: method.toUpperCase(),
+            endpoint,
+            expectedStatus
+        };
+    }
+    /**
+     * Check if error is retryable
+     */
+    isRetryableError(error) {
+        const retryablePatterns = [
+            /ECONNRESET/,
+            /ETIMEDOUT/,
+            /ECONNREFUSED/,
+            /502 Bad Gateway/,
+            /503 Service Unavailable/,
+            /504 Gateway Timeout/,
+            /timeout/i,
+            /network/i,
+            /fetch failed/i,
+            /EPROTO/,
+        ];
+        return retryablePatterns.some(pattern => pattern.test(error));
+    }
+    /**
+     * Calculate test summary
+     */
+    calculateSummary(results) {
+        const total = results.length;
+        const passed = results.filter(r => r.success).length;
+        const failed = total - passed;
+        const avgResponseTime = total > 0 ?
+            Math.round(results.reduce((sum, r) => sum + r.responseTime, 0) / total) : 0;
+        const totalAttempts = results.reduce((sum, r) => sum + (r.attempts || 1), 0);
+        return { total, passed, failed, avgResponseTime, totalAttempts };
+    }
+    /**
+     * Generate JUnit XML fragment
+     */
+    generateJUnit(results) {
+        const summary = this.calculateSummary(results);
+        const timestamp = new Date().toISOString();
+        let junit = `<?xml version="1.0" encoding="UTF-8"?>
+<testsuite name="API Smoke Tests (Playwright Native)" tests="${summary.total}" failures="${summary.failed}" time="${summary.avgResponseTime / 1000}" timestamp="${timestamp}">
+`;
+        for (const result of results) {
+            const testName = `${result.method} ${result.endpoint}`;
+            const time = result.responseTime / 1000;
+            junit += `  <testcase name="${this.escapeXml(testName)}" time="${time}">
+`;
+            if (!result.success) {
+                const failureDetails = {
+                    error: result.error,
+                    status: result.status,
+                    attempts: result.attempts || 1
+                };
+                junit += `    <failure message="${this.escapeXml(result.error || 'Test failed')}">${this.escapeXml(JSON.stringify(failureDetails, null, 2))}</failure>
+`;
+            }
+            junit += `  </testcase>
+`;
+        }
+        junit += `</testsuite>`;
+        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 request context
+     */
+    async cleanup() {
+        if (this.requestContext) {
+            await this.requestContext.dispose();
+            this.requestContext = undefined;
+        }
+    }
+    /**
+     * Validate API target configuration
+     */
+    static validateConfig(target) {
+        const errors = [];
+        if (!target.baseUrl) {
+            errors.push('baseUrl is required in gate config. Add: "baseUrl: https://your-api.com"');
+        }
+        else {
+            try {
+                new URL(target.baseUrl);
+            }
+            catch {
+                errors.push(`baseUrl "${target.baseUrl}" is not a valid URL. Expected format: https://api.example.com`);
+            }
+        }
+        if (target.smoke) {
+            for (const test of target.smoke) {
+                if (!/^\w+\s+.+\s*->\s*\d+$/.test(test)) {
+                    errors.push(`Invalid smoke test format: ${test}. Expected: "METHOD /path -> STATUS"`);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Health check using native API
+     * Quick check if the API is accessible without running full tests
+     */
+    async healthCheck(baseUrl, path = '/health', timeout = 5000) {
+        try {
+            await this.setupRequestContext({
+                target: { baseUrl },
+                timeout
+            });
+            const endpoint = baseUrl.replace(/\/$/, '') + (path.startsWith('/') ? path : `/${path}`);
+            const response = await this.requestContext.fetch(endpoint, {
+                method: 'GET',
+                timeout,
+                failOnStatusCode: false
+            });
+            // Consider 2xx and 3xx as healthy
+            return response.status() >= 200 && response.status() < 400;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            await this.cleanup();
+        }
+    }
+    /**
+     * Get API info (useful for debugging)
+     * Returns version and capabilities
+     */
+    static getCapabilities() {
+        return {
+            adapter: 'playwright-native',
+            browserless: true,
+            features: [
+                'REST API testing',
+                'GraphQL support',
+                'Basic auth',
+                'Bearer token auth',
+                'Custom headers',
+                'Request/response interception',
+                'Retry logic with exponential backoff',
+                'Storage state for cookie persistence',
+                'Timeout configuration',
+                'LRU cache for HTTP responses'
+            ]
+        };
+    }
+    /**
+     * Get cache statistics if cache is enabled
+     */
+    getCacheStats() {
+        if (!this.cache) {
+            return { enabled: false };
+        }
+        return {
+            enabled: true,
+            stats: this.cache.getStats()
+        };
+    }
+    /**
+     * Clear the cache if enabled
+     */
+    clearCache() {
+        if (this.cache) {
+            this.cache.clear();
+            console.log('📦 Cache cleared');
+        }
+    }
+}
+/**
+ * Factory function to create a native API adapter
+ */
+export function createPlaywrightNativeApiAdapter() {
+    return new PlaywrightNativeApiAdapter();
+}
+/**
+ * Error class for native API adapter
+ */
+export class PlaywrightNativeApiError extends Error {
+    code = 'PLAYWRIGHT_NATIVE_API_ERROR';
+    endpoint;
+    method;
+    constructor(message, endpoint, method) {
+        super(message);
+        this.name = 'PlaywrightNativeApiError';
+        this.endpoint = endpoint;
+        this.method = method;
+    }
+}

package/cli/dist/core/adapters/playwright-ui.d.ts

@@ -0,0 +1,197 @@
+/**
+ * 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 type { WebTarget, PackBudgets, UiTestDefinition, UiTestStep } from '../types/pack-v1.js';
+import { AuthCredentials } from '../auth/index.js';
+export interface UiTestConfig {
+    target: WebTarget;
+    budgets?: PackBudgets;
+    timeout?: number;
+    auth?: AuthCredentials;
+    login?: {
+        url?: string;
+        username?: string;
+        password?: string;
+        usernameSelector?: string;
+        passwordSelector?: string;
+        submitSelector?: string;
+    };
+    /** CLI override for headed mode */
+    cliHeaded?: boolean;
+    /** Playwright++: Artifacts configuration */
+    artifacts?: {
+        screenshots?: 'always' | 'only-on-failure' | 'never';
+        video?: 'always' | 'retain-on-failure' | 'never';
+        trace?: 'always' | 'retain-on-failure' | 'never' | 'on-first-failure';
+        outputDir?: string;
+    };
+    /** Playwright++: HTML report generation */
+    htmlReport?: string;
+    /** Playwright++: Bail after N failures */
+    bail?: number;
+}
+export interface UiTestResult {
+    page: string;
+    success: boolean;
+    loadTime: number;
+    error?: string;
+    screenshot?: string;
+    video?: string;
+    /** Playwright++: Artifacts paths */
+    artifacts?: {
+        screenshots: string[];
+        videos: string[];
+        traces: string[];
+    };
+    accessibility?: {
+        score: number;
+        violations: Array<{
+            id: string;
+            impact: 'minor' | 'moderate' | 'serious' | 'critical';
+            description: string;
+            nodes: number;
+        }>;
+    };
+    domSnapshot?: {
+        title: string;
+        url: string;
+        elements: {
+            buttons: number;
+            links: number;
+            forms: number;
+            inputs: number;
+        };
+    };
+}
+export interface UiTestStepResult {
+    step: UiTestStep;
+    success: boolean;
+    error?: string;
+    duration: number;
+    screenshot?: string;
+}
+export interface UiE2eResult {
+    test: UiTestDefinition;
+    success: boolean;
+    steps: UiTestStepResult[];
+    duration: number;
+    error?: string;
+}
+export interface UiSmokeResult {
+    success: boolean;
+    results: UiTestResult[];
+    e2eResults?: UiE2eResult[];
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        avgLoadTime: number;
+        avgA11yScore: number;
+    };
+    junit?: string;
+}
+export declare class PlaywrightUiAdapter {
+    private browser?;
+    private context?;
+    private page?;
+    private redactor;
+    private auth?;
+    private assertions?;
+    private artifactDir;
+    private videoDir;
+    private traceDir;
+    private artifactsManager?;
+    private failureCount;
+    private currentTestId?;
+    private allScreenshots;
+    private allVideos;
+    private allTraces;
+    constructor();
+    /**
+     * Set authentication credentials for requests
+     */
+    setAuth(credentials?: AuthCredentials): void;
+    /**
+     * Execute UI smoke tests with accessibility
+     * Playwright++: Supports artifacts, screenshots, video, trace, HTML reporting
+     */
+    runSmokeTests(config: UiTestConfig): Promise<UiSmokeResult>;
+    /**
+     * Run a single E2E test
+     * Playwright++: Takes before/after screenshots, captures artifacts on failure
+     */
+    runE2eTest(test: UiTestDefinition, config: UiTestConfig): Promise<UiE2eResult>;
+    /**
+     * Execute a single UI test step
+     * Playwright++: Enhanced error handling with artifacts
+     */
+    private executeStep;
+    /**
+     * Verify expected outcomes after a step
+     */
+    private verifyExpected;
+    /**
+     * Test single page with accessibility
+     */
+    private testPage;
+    /**
+     * Setup browser with all options
+     * Playwright++: Enhanced video/trace recording support
+     */
+    private setupBrowser;
+    /**
+     * Determine if video should be recorded
+     */
+    private shouldRecordVideo;
+    /**
+     * Playwright++: Generate HTML report
+     */
+    private generateHtmlReport;
+    /**
+     * Perform login if configured
+     */
+    private performLogin;
+    /**
+     * Run accessibility tests using axe-core
+     */
+    private runAccessibilityTests;
+    /**
+     * Get DOM snapshot for debugging
+     */
+    private getDomSnapshot;
+    /**
+     * Take screenshot for debugging
+     */
+    private takeScreenshot;
+    /**
+     * Calculate test summary
+     */
+    private calculateSummary;
+    /**
+     * Generate JUnit XML fragment
+     */
+    private generateJUnit;
+    /**
+     * Escape XML special characters
+     */
+    private escapeXml;
+    /**
+     * Cleanup browser resources and manage artifacts
+     */
+    private cleanup;
+    /**
+     * Validate UI target configuration
+     */
+    static validateConfig(target: WebTarget): {
+        valid: boolean;
+        errors: string[];
+    };
+}