qa360 2.1.2 → 2.1.4

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

@@ -1,461 +0,0 @@
-/**
- * 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) {
-        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('API target requires baseUrl');
-        }
-        else {
-            try {
-                new URL(target.baseUrl);
-            }
-            catch {
-                errors.push('API target baseUrl must be a valid URL');
-            }
-        }
-        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/dist/core/adapters/playwright-ui.d.ts

@@ -1,197 +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 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
-     */
-    private cleanup;
-    /**
-     * Validate UI target configuration
-     */
-    static validateConfig(target: WebTarget): {
-        valid: boolean;
-        errors: string[];
-    };
-}