qa360 2.1.2 → 2.1.4

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

@@ -1,339 +0,0 @@
-/**
- * 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/dist/core/adapters/playwright-native-api.d.ts

@@ -1,183 +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 { 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);
-}