qa360 2.3.0 → 2.3.2

package/dist/core/utils/device-emulation.js

@@ -0,0 +1,380 @@
+/**
+ * QA360 Device Emulation Module
+ *
+ * P0: Mobile and tablet device emulation
+ * - Predefined device profiles
+ * - Viewport resizing
+ * - User agent emulation
+ * - Touch/Mouse interaction switching
+ * - Device pixel ratio handling
+ * - Orientation (portrait/landscape)
+ */
+/**
+ * Device Emulation Helper
+ */
+export class DeviceEmulator {
+    page;
+    static profiles = {
+        // Desktop profiles
+        'desktop-1920x1080': {
+            name: 'Desktop 1920x1080',
+            width: 1920,
+            height: 1080,
+            deviceScaleFactor: 1,
+            isMobile: false,
+            hasTouch: false,
+            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            category: 'desktop',
+        },
+        'desktop-1366x768': {
+            name: 'Desktop 1366x768',
+            width: 1366,
+            height: 768,
+            deviceScaleFactor: 1,
+            isMobile: false,
+            hasTouch: false,
+            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            category: 'desktop',
+        },
+        'macbook-16': {
+            name: 'MacBook Pro 16"',
+            width: 1536,
+            height: 960,
+            deviceScaleFactor: 2,
+            isMobile: false,
+            hasTouch: false,
+            userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            category: 'desktop',
+        },
+        // Tablet profiles
+        'ipad-pro': {
+            name: 'iPad Pro 12.9"',
+            width: 1024,
+            height: 1366,
+            deviceScaleFactor: 2,
+            isMobile: true,
+            hasTouch: true,
+            userAgent: 'Mozilla/5.0 (iPad; CPU OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
+            category: 'tablet',
+        },
+        'ipad': {
+            name: 'iPad',
+            width: 768,
+            height: 1024,
+            deviceScaleFactor: 2,
+            isMobile: true,
+            hasTouch: true,
+            userAgent: 'Mozilla/5.0 (iPad; CPU OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
+            category: 'tablet',
+        },
+        'ipad-mini': {
+            name: 'iPad Mini',
+            width: 768,
+            height: 1024,
+            deviceScaleFactor: 2,
+            isMobile: true,
+            hasTouch: true,
+            userAgent: 'Mozilla/5.0 (iPad; CPU OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
+            category: 'tablet',
+        },
+        'surface-pro': {
+            name: 'Surface Pro',
+            width: 912,
+            height: 1368,
+            deviceScaleFactor: 2,
+            isMobile: false,
+            hasTouch: true,
+            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            category: 'tablet',
+        },
+        // Mobile profiles
+        'iphone-15-pro-max': {
+            name: 'iPhone 15 Pro Max',
+            width: 430,
+            height: 932,
+            deviceScaleFactor: 3,
+            isMobile: true,
+            hasTouch: true,
+            userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
+            category: 'mobile',
+        },
+        'iphone-15-pro': {
+            name: 'iPhone 15 Pro',
+            width: 393,
+            height: 852,
+            deviceScaleFactor: 3,
+            isMobile: true,
+            hasTouch: true,
+            userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
+            category: 'mobile',
+        },
+        'iphone-se': {
+            name: 'iPhone SE',
+            width: 375,
+            height: 667,
+            deviceScaleFactor: 2,
+            isMobile: true,
+            hasTouch: true,
+            userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
+            category: 'mobile',
+        },
+        'pixel-7-pro': {
+            name: 'Google Pixel 7 Pro',
+            width: 412,
+            height: 915,
+            deviceScaleFactor: 2.625,
+            isMobile: true,
+            hasTouch: true,
+            userAgent: 'Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36',
+            category: 'mobile',
+        },
+        'samsung-s23': {
+            name: 'Samsung Galaxy S23',
+            width: 360,
+            height: 780,
+            deviceScaleFactor: 3,
+            isMobile: true,
+            hasTouch: true,
+            userAgent: 'Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36',
+            category: 'mobile',
+        },
+    };
+    constructor(page) {
+        this.page = page;
+    }
+    /**
+     * Get all available device profiles
+     */
+    static getProfiles() {
+        return { ...DeviceEmulator.profiles };
+    }
+    /**
+     * Get a specific device profile
+     */
+    static getProfile(name) {
+        return DeviceEmulator.profiles[name];
+    }
+    /**
+     * Get all profiles by category
+     */
+    static getProfilesByCategory(category) {
+        return Object.values(DeviceEmulator.profiles).filter((p) => p.category === category);
+    }
+    /**
+     * Emulate a device by name
+     */
+    async emulate(device) {
+        const profile = DeviceEmulator.getProfile(device);
+        if (!profile) {
+            throw new Error(`Unknown device profile: ${device}`);
+        }
+        await this.emulateProfile(profile);
+    }
+    /**
+     * Emulate a device profile
+     */
+    async emulateProfile(profile) {
+        const viewport = {
+            width: profile.width,
+            height: profile.height,
+            deviceScaleFactor: profile.deviceScaleFactor,
+            isMobile: profile.isMobile,
+            hasTouch: profile.hasTouch,
+        };
+        await this.page.setViewportSize(viewport);
+        await this.page.emulateMedia({ media: 'screen' });
+        // Set user agent via extra HTTP headers (works for new contexts)
+        // For page-level emulation, we need to use CDP or reload with new UA
+        const context = this.page.context();
+        await context.setExtraHTTPHeaders({
+            'User-Agent': profile.userAgent,
+        });
+    }
+    /**
+     * Set viewport size
+     */
+    async setViewport(width, height, options = {}) {
+        const viewport = {
+            width,
+            height,
+            deviceScaleFactor: options.deviceScaleFactor ?? 1,
+            isMobile: options.isMobile ?? false,
+            hasTouch: options.hasTouch ?? false,
+        };
+        await this.page.setViewportSize(viewport);
+    }
+    /**
+     * Set viewport to predefined dimensions
+     */
+    async desktop() {
+        await this.setViewport(1920, 1080);
+        await this.page.emulateMedia({ media: 'screen' });
+    }
+    async tablet() {
+        await this.setViewport(768, 1024, { isMobile: false, hasTouch: true });
+        await this.page.emulateMedia({ media: 'screen' });
+    }
+    async mobile() {
+        await this.setViewport(375, 667, { isMobile: true, hasTouch: true, deviceScaleFactor: 2 });
+        await this.page.emulateMedia({ media: 'screen' });
+    }
+    /**
+     * Set screen orientation
+     */
+    async setOrientation(orientation) {
+        const current = this.page.viewportSize();
+        if (!current)
+            return;
+        if (orientation === 'landscape' && current.width < current.height) {
+            await this.setViewport(current.height, current.width);
+        }
+        else if (orientation === 'portrait' && current.width > current.height) {
+            await this.setViewport(current.height, current.width);
+        }
+    }
+    /**
+     * Rotate device (swap width and height)
+     */
+    async rotate() {
+        const current = this.page.viewportSize();
+        if (!current)
+            return;
+        await this.setViewport(current.height, current.width);
+    }
+    /**
+     * Set device pixel ratio
+     */
+    async setDeviceScaleFactor(dpr) {
+        const current = this.page.viewportSize();
+        if (!current)
+            return;
+        // Note: deviceScaleFactor must be set via context, not page
+        // This is a simplified version - for full support, recreate context with new viewport
+        await this.page.setViewportSize({
+            width: current.width,
+            height: current.height,
+        });
+    }
+    /**
+     * Enable/disable touch emulation
+     */
+    async setTouch(enabled) {
+        const current = this.page.viewportSize();
+        if (!current)
+            return;
+        // Note: hasTouch must be set via context, not page
+        // This is a simplified version - for full support, recreate context with new viewport
+        await this.page.setViewportSize({
+            width: current.width,
+            height: current.height,
+        });
+    }
+    /**
+     * Get current viewport info
+     */
+    async getViewport() {
+        return this.page.viewportSize();
+    }
+    /**
+     * Test at multiple viewport sizes (responsive testing)
+     */
+    async testAtSizes(sizes, testFn) {
+        const results = [];
+        for (const size of sizes) {
+            try {
+                await this.setViewport(size.width, size.height);
+                await testFn();
+                results.push({ size, passed: true });
+            }
+            catch (error) {
+                results.push({
+                    size,
+                    passed: false,
+                    error: error,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Test at multiple breakpoints (common responsive sizes)
+     */
+    async testResponsive(testFn) {
+        const breakpoints = [
+            { name: 'mobile', width: 375, height: 667 },
+            { name: 'tablet', width: 768, height: 1024 },
+            { name: 'desktop', width: 1920, height: 1080 },
+        ];
+        const results = [];
+        for (const bp of breakpoints) {
+            try {
+                await this.setViewport(bp.width, bp.height);
+                await testFn();
+                results.push({ breakpoint: bp.name, passed: true });
+            }
+            catch (error) {
+                results.push({
+                    breakpoint: bp.name,
+                    passed: false,
+                    error: error,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Test on multiple device profiles
+     */
+    async testOnDevices(devices, testFn) {
+        const results = [];
+        for (const device of devices) {
+            try {
+                await this.emulate(device);
+                await testFn();
+                results.push({ device, passed: true });
+            }
+            catch (error) {
+                results.push({
+                    device,
+                    passed: false,
+                    error: error,
+                });
+            }
+        }
+        return results;
+    }
+}
+/**
+ * Convenience function to create device emulator
+ */
+export function device(page) {
+    return new DeviceEmulator(page);
+}
+/**
+ * Common viewport presets
+ */
+export const Viewport = {
+    // Desktop
+    'desktop-xl': { width: 2560, height: 1440 },
+    'desktop-lg': { width: 1920, height: 1080 },
+    'desktop-md': { width: 1366, height: 768 },
+    'desktop-sm': { width: 1024, height: 768 },
+    // Tablet
+    'tablet-lg': { width: 1024, height: 1366 },
+    'tablet-md': { width: 768, height: 1024 },
+    'tablet-sm': { width: 600, height: 960 },
+    // Mobile
+    'mobile-lg': { width: 428, height: 926 },
+    'mobile-md': { width: 390, height: 844 },
+    'mobile-sm': { width: 375, height: 667 },
+    'mobile-xs': { width: 320, height: 568 },
+};
+/**
+ * Common device lists
+ */
+export const Devices = {
+    desktop: ['desktop-1920x1080', 'desktop-1366x768', 'macbook-16'],
+    tablet: ['ipad-pro', 'ipad', 'ipad-mini', 'surface-pro'],
+    mobile: ['iphone-15-pro-max', 'iphone-15-pro', 'iphone-se', 'pixel-7-pro', 'samsung-s23'],
+    popular: ['desktop-1920x1080', 'ipad', 'iphone-15-pro', 'pixel-7-pro'],
+};

package/dist/core/utils/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * QA360 Utility Modules
+ *
+ * P0: Helper utilities for testing
+ */
+export { Retry, retry, RetryIf, RetryConfig, RetryError, type RetryOptions, type RetryResult, } from './retry.js';
+export { SmartWait, smartWait, waitForVisible, waitForHidden, waitForText, type SmartWaitOptions, type ElementState, type StabilityResult, } from './smart-wait.js';
+export { DeviceEmulator, device, Viewport, Devices, type ViewportConfig, type DeviceProfile, type Orientation, } from './device-emulation.js';

package/dist/core/utils/index.js

@@ -0,0 +1,8 @@
+/**
+ * QA360 Utility Modules
+ *
+ * P0: Helper utilities for testing
+ */
+export { Retry, retry, RetryIf, RetryConfig, RetryError, } from './retry.js';
+export { SmartWait, smartWait, waitForVisible, waitForHidden, waitForText, } from './smart-wait.js';
+export { DeviceEmulator, device, Viewport, Devices, } from './device-emulation.js';

package/dist/core/utils/retry.d.ts

@@ -0,0 +1,145 @@
+/**
+ * QA360 Retry Module
+ *
+ * P0: Auto-retry logic for failed actions
+ * - Configurable retry attempts and delays
+ * - Exponential backoff support
+ * - Jitter for avoiding thundering herd
+ * - Retry condition predicates
+ * - Timeout support
+ */
+/**
+ * Retry options
+ */
+export interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    maxAttempts?: number;
+    /** Initial delay between retries in ms (default: 1000) */
+    delay?: number;
+    /** Multiplier for exponential backoff (default: 2) */
+    backoffMultiplier?: number;
+    /** Maximum delay between retries in ms (default: 30000) */
+    maxDelay?: number;
+    /** Whether to add jitter to delay (default: true) */
+    jitter?: boolean;
+    /** Function to determine if error is retryable (default: retry all errors) */
+    retryIf?: (error: unknown) => boolean;
+    /** Function to call before each retry */
+    onRetry?: (error: unknown, attempt: number) => void | Promise<void>;
+    /** Overall timeout in ms (default: no timeout) */
+    timeout?: number;
+    /** Whether to throw last error or aggregate (default: throw last) */
+    throwLast?: boolean;
+}
+/**
+ * Retry result
+ */
+export interface RetryResult<T> {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** The result value if successful */
+    value?: T;
+    /** The error if failed */
+    error?: Error;
+    /** Number of attempts made */
+    attempts: number;
+    /** Total time elapsed in ms */
+    elapsed: number;
+}
+/**
+ * Aggregate error from multiple retry attempts
+ */
+export declare class RetryError extends Error {
+    errors: Error[];
+    constructor(errors: Error[], message?: string);
+    /**
+     * Get all error messages
+     */
+    get messages(): string[];
+    /**
+     * Get formatted error summary
+     */
+    get summary(): string;
+}
+/**
+ * Retry Helper
+ */
+export declare class Retry {
+    /**
+     * Retry an async function with configurable options
+     */
+    static try<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+    /**
+     * Retry with result returned
+     */
+    static withResult<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<RetryResult<T>>;
+    /**
+     * Retry until a condition is met
+     */
+    static until(condition: () => boolean | Promise<boolean>, options?: RetryOptions): Promise<void>;
+    /**
+     * Retry while a condition is true
+     */
+    static while(condition: () => boolean | Promise<boolean>, fn: () => Promise<void>, options?: RetryOptions): Promise<void>;
+    /**
+     * Add jitter to delay (±25%)
+     */
+    private static addJitter;
+    /**
+     * Sleep utility
+     */
+    private static sleep;
+    /**
+     * Add timeout to a promise
+     */
+    private static withTimeout;
+}
+/**
+ * Convenience function for retry
+ */
+export declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Common retry predicates
+ */
+export declare const RetryIf: {
+    /** Retry on network errors */
+    networkError: (error: unknown) => boolean;
+    /** Retry on 5xx errors */
+    serverError: (error: unknown) => boolean;
+    /** Retry on specific error messages */
+    message: (...messages: string[]) => (error: unknown) => boolean;
+    /** Retry on specific error types */
+    errorType: (...types: Array<new (...args: unknown[]) => Error>) => (error: unknown) => boolean;
+};
+/**
+ * Common retry configurations
+ */
+export declare const RetryConfig: {
+    /** Quick retries for transient failures */
+    quick: {
+        maxAttempts: number;
+        delay: number;
+        backoffMultiplier: number;
+    };
+    /** Standard retries */
+    standard: {
+        maxAttempts: number;
+        delay: number;
+        backoffMultiplier: number;
+    };
+    /** Persistent retries for resilient operations */
+    persistent: {
+        maxAttempts: number;
+        delay: number;
+        backoffMultiplier: number;
+        maxDelay: number;
+    };
+    /** Network retries with exponential backoff */
+    network: {
+        maxAttempts: number;
+        delay: number;
+        backoffMultiplier: number;
+        maxDelay: number;
+        retryIf: (error: unknown) => boolean;
+    };
+};