qa360 2.0.13 → 2.1.0

package/dist/core/adapters/playwright-native-adapter.d.ts

@@ -0,0 +1,121 @@
+/**
+ * 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 { Browser, BrowserContext, Page, Locator } from '@playwright/test';
+import type { WebTarget, PackBudgets, UiTestDefinition, UiTestStep } from '../types/pack-v1.js';
+export interface PlaywrightNativeConfig {
+    target: WebTarget;
+    budgets?: PackBudgets;
+    timeout?: number;
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    headless?: boolean;
+    slowMo?: number;
+    devtools?: boolean;
+    device?: 'desktop' | 'tablet' | 'mobile' | 'custom';
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    userAgent?: string;
+    locale?: string;
+    timezone?: string;
+    screenshots?: 'always' | 'only-on-failure' | 'never';
+    video?: 'always' | 'retain-on-failure' | 'never';
+    trace?: 'always' | 'retain-on-failure' | 'never' | 'on-first-failure';
+    bail?: number;
+    workers?: number;
+    ignoreHTTPSErrors?: boolean;
+    acceptDownloads?: boolean;
+    bypassCSP?: boolean;
+}
+export interface PlaywrightNativeResult {
+    success: boolean;
+    duration: number;
+    artifacts?: {
+        screenshots: string[];
+        videos: string[];
+        traces: string[];
+    };
+    error?: string;
+    coverage?: {
+        lines: number;
+        statements: number;
+        branches: number;
+        functions: number;
+    };
+}
+export interface PlaywrightNativeStepResult {
+    step: UiTestStep;
+    success: boolean;
+    duration: number;
+    error?: string;
+    screenshot?: string;
+}
+/**
+ * Playwright Native Adapter
+ *
+ * Provides zero-overhead access to Playwright with automatic
+ * artifact collection (screenshots, videos, traces).
+ */
+export declare class PlaywrightNativeAdapter {
+    private config;
+    private browser?;
+    private context?;
+    private page?;
+    private artifacts?;
+    private assertions?;
+    private testResults;
+    private failureCount;
+    constructor(config: PlaywrightNativeConfig);
+    /**
+     * Run a single E2E test with full Playwright native access
+     */
+    runTest(test: UiTestDefinition): Promise<PlaywrightNativeResult>;
+    /**
+     * Execute a single step using Playwright native API
+     */
+    private executeStep;
+    /**
+     * Execute action using Playwright native API
+     */
+    private executeAction;
+    /**
+     * Setup browser with trace context
+     */
+    private setup;
+    /**
+     * Teardown and save artifacts
+     */
+    private teardown;
+    /**
+     * Get artifact paths for result
+     */
+    private getArtifactPaths;
+    /**
+     * Get direct access to Playwright objects
+     */
+    getBrowser(): Browser | undefined;
+    getContext(): BrowserContext | undefined;
+    getPage(): Page | undefined;
+    /**
+     * Get locator for direct manipulation
+     */
+    locator(selector: string): Locator;
+}
+/**
+ * Create a Playwright Native Adapter
+ */
+export declare function createPlaywrightNativeAdapter(config: PlaywrightNativeConfig): PlaywrightNativeAdapter;
+/**
+ * Create adapter from WebTarget (convenience function)
+ */
+export declare function createFromTarget(target: WebTarget, options?: Partial<PlaywrightNativeConfig>): PlaywrightNativeAdapter;

package/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/dist/core/adapters/playwright-ui.d.ts

@@ -1,6 +1,13 @@
 /**
  * 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';
@@ -19,6 +26,17 @@ export interface UiTestConfig {
     };
     /** 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;
@@ -27,6 +45,12 @@ export interface UiTestResult {
     error?: string;
     screenshot?: string;
     video?: string;
+    /** Playwright++: Artifacts paths */
+    artifacts?: {
+        screenshots: string[];
+        videos: string[];
+        traces: string[];
+    };
     accessibility?: {
         score: number;
         violations: Array<{
@@ -84,6 +108,12 @@ export declare class PlaywrightUiAdapter {
     private artifactDir;
     private videoDir;
     private traceDir;
+    private artifactsManager?;
+    private failureCount;
+    private currentTestId?;
+    private allScreenshots;
+    private allVideos;
+    private allTraces;
     constructor();
     /**
      * Set authentication credentials for requests
@@ -91,14 +121,17 @@ export declare class PlaywrightUiAdapter {
     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;
     /**
@@ -111,12 +144,17 @@ export declare class PlaywrightUiAdapter {
     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
      */