qa360 2.2.1 → 2.2.13

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

@@ -0,0 +1,339 @@
+/**
+ * QA360 Playwright Native Adapter
+ *
+ * Zero-overhead adapter that uses Playwright's native API directly.
+ * This bypasses any wrapper logic and gives full access to Playwright's capabilities.
+ *
+ * Benefits:
+ * - Zero performance overhead
+ * - Full Playwright API access
+ * - Native video/trace/screenshot support
+ * - Direct access to browser context, page, locators
+ */
+import { chromium, firefox, webkit } from '@playwright/test';
+import { UIArtifactsManager } from '../artifacts/ui-artifacts.js';
+import { createAssertionsEngine } from '../assertions/index.js';
+/**
+ * Playwright Native Adapter
+ *
+ * Provides zero-overhead access to Playwright with automatic
+ * artifact collection (screenshots, videos, traces).
+ */
+export class PlaywrightNativeAdapter {
+    config;
+    browser;
+    context;
+    page;
+    artifacts;
+    assertions;
+    // Test state tracking
+    testResults = new Map();
+    failureCount = 0;
+    constructor(config) {
+        this.config = config;
+        // Initialize artifacts manager
+        this.artifacts = new UIArtifactsManager('.qa360/artifacts/playwright-native', '.qa360/runs/cas');
+    }
+    /**
+     * Run a single E2E test with full Playwright native access
+     */
+    async runTest(test) {
+        const startTime = Date.now();
+        const testId = test.name || 'unknown';
+        this.artifacts?.startTest(testId);
+        this.testResults.set(testId, []);
+        try {
+            // Setup browser with trace context if enabled
+            await this.setup();
+            // Navigate to start URL
+            const startUrl = test.url || `${this.config.target.baseUrl.replace(/\/$/, '')}${test.path || ''}`;
+            await this.page.goto(startUrl, { timeout: this.config.timeout || 30000 });
+            // Initialize assertions engine
+            this.assertions = createAssertionsEngine(this.page);
+            // Take initial screenshot
+            if (this.config.screenshots !== 'never') {
+                await this.artifacts?.takeScreenshot(this.page, {}, {
+                    testId,
+                    type: 'screenshot',
+                    tags: ['initial'],
+                });
+            }
+            // Execute each step
+            for (let i = 0; i < test.steps.length; i++) {
+                const step = test.steps[i];
+                const stepResult = await this.executeStep(step, i);
+                this.testResults.get(testId).push(stepResult);
+                if (!stepResult.success) {
+                    this.failureCount++;
+                    // Check if we should bail
+                    if (this.config.bail && this.failureCount >= this.config.bail) {
+                        throw new Error(`Bail: ${this.failureCount} failures`);
+                    }
+                    // Check if we should continue on failure
+                    const continueOnFailure = step.continueOnError ?? false;
+                    if (!continueOnFailure) {
+                        break;
+                    }
+                }
+                // Screenshot after each step if configured
+                if (this.config.screenshots === 'always' || (this.config.screenshots === 'only-on-failure' && !stepResult.success)) {
+                    await this.artifacts?.takeAfterScreenshot(this.page, step.action || 'step', i, stepResult.success);
+                }
+            }
+            // All steps passed
+            const duration = Date.now() - startTime;
+            return {
+                success: true,
+                duration,
+                artifacts: this.getArtifactPaths(),
+            };
+        }
+        catch (error) {
+            // Take error screenshot
+            if (this.page) {
+                await this.artifacts?.takeErrorScreenshot(this.page, error);
+            }
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error),
+                artifacts: this.getArtifactPaths(),
+            };
+        }
+        finally {
+            this.artifacts?.endTest();
+            await this.teardown();
+        }
+    }
+    /**
+     * Execute a single step using Playwright native API
+     */
+    async executeStep(step, index) {
+        const startTime = Date.now();
+        try {
+            // Take before screenshot if enabled
+            if (this.config.screenshots === 'always') {
+                await this.artifacts?.takeBeforeScreenshot(this.page, step.action || 'step', index);
+            }
+            // Execute action based on type
+            const result = await this.executeAction(step);
+            // Execute assertions if present
+            if (step.assertions && step.assertions.length > 0 && this.assertions) {
+                for (const assertion of step.assertions) {
+                    const assertionResult = await this.assertions.runAssertion(assertion);
+                    if (!assertionResult.passed && !assertion.soft) {
+                        throw new Error(assertionResult.error || `Assertion failed: ${assertion.type}`);
+                    }
+                }
+            }
+            return {
+                step,
+                success: true,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                step,
+                success: false,
+                duration: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Execute action using Playwright native API
+     */
+    async executeAction(step) {
+        const selector = step.selector;
+        const page = this.page;
+        const timeout = step.timeout || this.config.timeout || 30000;
+        // Ensure selector is defined for actions that need it
+        const needsSelector = ['click', 'dblClick', 'rightClick', 'hover', 'focus', 'fill', 'type',
+            'clear', 'select', 'check', 'uncheck', 'press', 'upload', 'tap', 'scroll'].includes(step.action);
+        if (needsSelector && !selector) {
+            throw new Error(`Selector is required for action: ${step.action}`);
+        }
+        switch (step.action) {
+            case 'navigate':
+                await page.goto(step.value || '', { timeout });
+                break;
+            case 'click':
+                await page.click(selector, { timeout });
+                break;
+            case 'dblClick':
+                await page.dblclick(selector, { timeout });
+                break;
+            case 'rightClick':
+                await page.click(selector, { button: 'right', timeout });
+                break;
+            case 'fill':
+            case 'type':
+                if (step.value) {
+                    await page.fill(selector, step.value, { timeout });
+                }
+                break;
+            case 'clear':
+                await page.fill(selector, '', { timeout });
+                break;
+            case 'select':
+                if (step.value !== undefined) {
+                    await page.selectOption(selector, step.value, { timeout });
+                }
+                break;
+            case 'check':
+                await page.check(selector, { timeout });
+                break;
+            case 'uncheck':
+                await page.uncheck(selector, { timeout });
+                break;
+            case 'hover':
+                await page.hover(selector, { timeout });
+                break;
+            case 'focus':
+                await page.focus(selector, { timeout });
+                break;
+            case 'press':
+                if (step.value) {
+                    await page.press(selector, step.value, { timeout });
+                }
+                break;
+            case 'upload':
+                if (step.value) {
+                    await page.setInputFiles(selector, step.value, { timeout });
+                }
+                break;
+            case 'dragAndDrop':
+                if (step.value) {
+                    const source = page.locator(selector);
+                    const target = page.locator(step.value);
+                    await source.dragTo(target, { timeout });
+                }
+                break;
+            case 'scroll':
+                if (selector) {
+                    await page.locator(selector).scrollIntoViewIfNeeded({ timeout });
+                }
+                break;
+            case 'waitFor':
+            case 'waitForSelector':
+                if (selector) {
+                    await page.waitForSelector(selector, {
+                        state: step.value || undefined,
+                        timeout
+                    });
+                }
+                break;
+            case 'waitForTimeout':
+                await page.waitForTimeout(parseInt(step.value || '0', 10) || 0);
+                break;
+            case 'waitForNavigation':
+                await page.waitForNavigation({ timeout });
+                break;
+            case 'tap':
+                await page.tap(selector, { timeout });
+                break;
+            default:
+                throw new Error(`Unknown action: ${step.action}`);
+        }
+    }
+    /**
+     * Setup browser with trace context
+     */
+    async setup() {
+        const browserType = this.config.browser || 'chromium';
+        const browserTypeObj = browserType === 'firefox' ? firefox : browserType === 'webkit' ? webkit : chromium;
+        // Launch browser
+        this.browser = await browserTypeObj.launch({
+            headless: this.config.headless ?? true,
+            slowMo: this.config.slowMo || 0,
+            devtools: this.config.devtools || false,
+        });
+        // Create context with trace recording if enabled
+        const contextOptions = {
+            viewport: this.config.viewport || { width: 1280, height: 720 },
+            userAgent: this.config.userAgent,
+            locale: this.config.locale || 'en-US',
+            timezoneId: this.config.timezone,
+            acceptDownloads: this.config.acceptDownloads ?? true,
+            ignoreHTTPSErrors: this.config.ignoreHTTPSErrors,
+            bypassCSP: this.config.bypassCSP,
+        };
+        // Add video recording
+        if (this.config.video === 'always' || this.config.video === 'retain-on-failure') {
+            contextOptions.recordVideo = {
+                dir: '.qa360/artifacts/playwright-native/videos',
+                size: this.config.viewport || { width: 1280, height: 720 },
+            };
+        }
+        this.context = await this.browser.newContext(contextOptions);
+        // Add tracing if enabled
+        if (this.config.trace === 'always' || this.config.trace === 'on-first-failure' || this.config.trace === 'retain-on-failure') {
+            // Start tracing (Playwright's trace feature)
+            // Note: tracing needs to be started per test
+        }
+        this.page = await this.context.newPage();
+        // Set default timeout
+        this.page.setDefaultTimeout(this.config.timeout || 30000);
+    }
+    /**
+     * Teardown and save artifacts
+     */
+    async teardown() {
+        if (this.page) {
+            // Stop tracing if enabled
+            // Save trace file
+            await this.page.close();
+        }
+        if (this.context) {
+            // Save video if enabled and tests failed
+            if (this.config.video === 'retain-on-failure' && this.failureCount > 0) {
+                // Videos are automatically saved by Playwright
+            }
+            await this.context.close();
+        }
+        if (this.browser) {
+            await this.browser.close();
+        }
+    }
+    /**
+     * Get artifact paths for result
+     */
+    getArtifactPaths() {
+        return {
+            screenshots: [],
+            videos: [],
+            traces: [],
+        };
+    }
+    /**
+     * Get direct access to Playwright objects
+     */
+    getBrowser() { return this.browser; }
+    getContext() { return this.context; }
+    getPage() { return this.page; }
+    /**
+     * Get locator for direct manipulation
+     */
+    locator(selector) {
+        if (!this.page) {
+            throw new Error('Page not initialized. Call setup() first.');
+        }
+        return this.page.locator(selector);
+    }
+}
+/**
+ * Create a Playwright Native Adapter
+ */
+export function createPlaywrightNativeAdapter(config) {
+    return new PlaywrightNativeAdapter(config);
+}
+/**
+ * Create adapter from WebTarget (convenience function)
+ */
+export function createFromTarget(target, options = {}) {
+    return new PlaywrightNativeAdapter({
+        target,
+        ...options,
+    });
+}

package/cli/dist/core/adapters/playwright-native-api.d.ts

@@ -0,0 +1,183 @@
+/**
+ * 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 { ApiTarget, PackBudgets } from '../types/pack-v1.js';
+import { AuthCredentials } from '../auth/index.js';
+export interface NativeApiTestConfig {
+    target: ApiTarget;
+    budgets?: PackBudgets;
+    timeout?: number;
+    retries?: number;
+    auth?: AuthCredentials;
+    /**
+     * Basic auth credentials (username/password)
+     */
+    basicAuth?: {
+        username: string;
+        password: string;
+    };
+    /**
+     * Request body for POST/PUT/PATCH
+     */
+    body?: Record<string, unknown> | string;
+    /**
+     * Storage state to persist cookies/auth between requests
+     */
+    storageState?: Record<string, unknown> | string;
+    /**
+     * Cache configuration for HTTP responses
+     */
+    cache?: {
+        /** Enable caching (default: false) */
+        enabled?: boolean;
+        /** TTL in milliseconds (default: 300000 = 5 minutes) */
+        ttl?: number;
+        /** Maximum cache size in bytes (default: 10MB) */
+        maxSizeBytes?: number;
+        /** Maximum number of entries (default: 100) */
+        maxSize?: number;
+    };
+}
+export interface ApiTestResult {
+    endpoint: string;
+    method: string;
+    status: number;
+    responseTime: number;
+    success: boolean;
+    error?: string;
+    headers?: Record<string, string>;
+    body?: any;
+    attempts?: number;
+}
+export interface NativeApiSmokeResult {
+    success: boolean;
+    results: ApiTestResult[];
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        avgResponseTime: number;
+        totalAttempts: number;
+    };
+    junit?: string;
+    error?: string;
+}
+/**
+ * Playwright Native API Adapter
+ *
+ * Uses playwright.request.newContext() for direct HTTP requests
+ * without launching a browser.
+ */
+export declare class PlaywrightNativeApiAdapter {
+    private requestContext?;
+    private redactor;
+    private auth?;
+    private cache?;
+    constructor();
+    /**
+     * Set authentication credentials for requests
+     */
+    setAuth(credentials?: AuthCredentials): void;
+    /**
+     * Execute API smoke tests using Playwright's native API
+     */
+    runSmokeTests(config: NativeApiTestConfig): Promise<NativeApiSmokeResult>;
+    /**
+     * Setup Playwright APIRequestContext for HTTP requests
+     */
+    private setupRequestContext;
+    /**
+     * Execute single API test with retry logic using native API
+     */
+    private executeApiTest;
+    /**
+     * Parse test specification string
+     * Format: "GET /path -> 200" or "POST /api/users -> 201"
+     */
+    private parseTestSpec;
+    /**
+     * Check if error is retryable
+     */
+    private isRetryableError;
+    /**
+     * Calculate test summary
+     */
+    private calculateSummary;
+    /**
+     * Generate JUnit XML fragment
+     */
+    private generateJUnit;
+    /**
+     * Escape XML special characters
+     */
+    private escapeXml;
+    /**
+     * Cleanup request context
+     */
+    private cleanup;
+    /**
+     * Validate API target configuration
+     */
+    static validateConfig(target: ApiTarget): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Health check using native API
+     * Quick check if the API is accessible without running full tests
+     */
+    healthCheck(baseUrl: string, path?: string, timeout?: number): Promise<boolean>;
+    /**
+     * Get API info (useful for debugging)
+     * Returns version and capabilities
+     */
+    static getCapabilities(): {
+        adapter: string;
+        browserless: boolean;
+        features: string[];
+    };
+    /**
+     * Get cache statistics if cache is enabled
+     */
+    getCacheStats(): {
+        enabled: boolean;
+        stats?: {
+            hits: number;
+            misses: number;
+            additions: number;
+            evictions: number;
+            size: number;
+            sizeBytes: number;
+            hitRate: number;
+            avgEntrySize: number;
+        };
+    };
+    /**
+     * Clear the cache if enabled
+     */
+    clearCache(): void;
+}
+/**
+ * Factory function to create a native API adapter
+ */
+export declare function createPlaywrightNativeApiAdapter(): PlaywrightNativeApiAdapter;
+/**
+ * Error class for native API adapter
+ */
+export declare class PlaywrightNativeApiError extends Error {
+    code: string;
+    endpoint?: string;
+    method?: string;
+    constructor(message: string, endpoint?: string, method?: string);
+}