qa360 2.2.20 → 2.3.1

package/dist/core/utils/retry.js

@@ -0,0 +1,242 @@
+/**
+ * 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
+ */
+/**
+ * Aggregate error from multiple retry attempts
+ */
+export class RetryError extends Error {
+    errors;
+    constructor(errors, message = 'Operation failed after multiple attempts') {
+        super(message);
+        this.errors = errors;
+        this.name = 'RetryError';
+    }
+    /**
+     * Get all error messages
+     */
+    get messages() {
+        return this.errors.map((e) => e.message);
+    }
+    /**
+     * Get formatted error summary
+     */
+    get summary() {
+        return `${this.message}\n${this.errors.map((e, i) => `  ${i + 1}. ${e.message}`).join('\n')}`;
+    }
+}
+/**
+ * Retry Helper
+ */
+export class Retry {
+    /**
+     * Retry an async function with configurable options
+     */
+    static async try(fn, options = {}) {
+        const { maxAttempts = 3, delay = 1000, backoffMultiplier = 2, maxDelay = 30000, jitter = true, retryIf, onRetry, timeout, } = options;
+        const startTime = Date.now();
+        const errors = [];
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                // Execute with timeout if specified
+                const result = timeout
+                    ? await this.withTimeout(fn(), timeout)
+                    : await fn();
+                return result;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                errors.push(err);
+                // Check if error is retryable
+                if (retryIf && !retryIf(err)) {
+                    throw err;
+                }
+                // Don't retry on last attempt
+                if (attempt >= maxAttempts) {
+                    break;
+                }
+                // Call onRetry callback
+                if (onRetry) {
+                    await onRetry(err, attempt);
+                }
+                // Calculate delay with exponential backoff
+                const currentDelay = Math.min(delay * Math.pow(backoffMultiplier, attempt - 1), maxDelay);
+                // Add jitter if enabled
+                const finalDelay = jitter
+                    ? this.addJitter(currentDelay)
+                    : currentDelay;
+                await this.sleep(finalDelay);
+            }
+        }
+        throw new RetryError(errors);
+    }
+    /**
+     * Retry with result returned
+     */
+    static async withResult(fn, options = {}) {
+        const startTime = Date.now();
+        const { maxAttempts = 3, delay = 1000, backoffMultiplier = 2, maxDelay = 30000, jitter = true, retryIf, onRetry, } = options;
+        const errors = [];
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                const value = await fn();
+                return {
+                    success: true,
+                    value,
+                    attempts: attempt,
+                    elapsed: Date.now() - startTime,
+                };
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                errors.push(err);
+                if (retryIf && !retryIf(err)) {
+                    return {
+                        success: false,
+                        error: err,
+                        attempts: attempt,
+                        elapsed: Date.now() - startTime,
+                    };
+                }
+                if (attempt >= maxAttempts) {
+                    break;
+                }
+                if (onRetry) {
+                    await onRetry(err, attempt);
+                }
+                const currentDelay = Math.min(delay * Math.pow(backoffMultiplier, attempt - 1), maxDelay);
+                const finalDelay = jitter
+                    ? this.addJitter(currentDelay)
+                    : currentDelay;
+                await this.sleep(finalDelay);
+            }
+        }
+        return {
+            success: false,
+            error: errors[errors.length - 1],
+            attempts: maxAttempts,
+            elapsed: Date.now() - startTime,
+        };
+    }
+    /**
+     * Retry until a condition is met
+     */
+    static async until(condition, options = {}) {
+        await this.try(async () => {
+            const result = await condition();
+            if (!result) {
+                throw new Error('Condition not met');
+            }
+        }, options);
+    }
+    /**
+     * Retry while a condition is true
+     */
+    static async while(condition, fn, options = {}) {
+        await this.try(async () => {
+            const result = await condition();
+            if (result) {
+                await fn();
+                throw new Error('Condition still true, retrying');
+            }
+        }, options);
+    }
+    /**
+     * Add jitter to delay (±25%)
+     */
+    static addJitter(delay) {
+        const jitterAmount = delay * 0.25;
+        const jitter = (Math.random() - 0.5) * 2 * jitterAmount;
+        return Math.max(0, delay + jitter);
+    }
+    /**
+     * Sleep utility
+     */
+    static sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Add timeout to a promise
+     */
+    static async withTimeout(promise, timeoutMs) {
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs);
+        });
+        return Promise.race([promise, timeoutPromise]);
+    }
+}
+/**
+ * Convenience function for retry
+ */
+export async function retry(fn, options) {
+    return Retry.try(fn, options);
+}
+/**
+ * Common retry predicates
+ */
+export const RetryIf = {
+    /** Retry on network errors */
+    networkError: (error) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (msg.includes('network') ||
+            msg.includes('timeout') ||
+            msg.includes('ECONNREFUSED') ||
+            msg.includes('ETIMEDOUT'));
+    },
+    /** Retry on 5xx errors */
+    serverError: (error) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        return /\b5\d\d\b/.test(msg);
+    },
+    /** Retry on specific error messages */
+    message: (...messages) => {
+        return (error) => {
+            const msg = error instanceof Error ? error.message : String(error);
+            return messages.some((m) => msg.includes(m));
+        };
+    },
+    /** Retry on specific error types */
+    errorType: (...types) => {
+        return (error) => {
+            return types.some((Type) => error instanceof Type);
+        };
+    },
+};
+/**
+ * Common retry configurations
+ */
+export const RetryConfig = {
+    /** Quick retries for transient failures */
+    quick: {
+        maxAttempts: 3,
+        delay: 100,
+        backoffMultiplier: 1.5,
+    },
+    /** Standard retries */
+    standard: {
+        maxAttempts: 3,
+        delay: 1000,
+        backoffMultiplier: 2,
+    },
+    /** Persistent retries for resilient operations */
+    persistent: {
+        maxAttempts: 5,
+        delay: 1000,
+        backoffMultiplier: 2,
+        maxDelay: 10000,
+    },
+    /** Network retries with exponential backoff */
+    network: {
+        maxAttempts: 5,
+        delay: 500,
+        backoffMultiplier: 2,
+        maxDelay: 30000,
+        retryIf: RetryIf.networkError,
+    },
+};

package/dist/core/utils/smart-wait.d.ts

@@ -0,0 +1,133 @@
+/**
+ * QA360 Smart Wait Module
+ *
+ * P0: Smart element waiting strategies
+ * - Wait for element visibility
+ * - Wait for element to be hidden/removed
+ * - Wait for element state changes
+ * - Wait for network idle
+ * - Wait for content stability
+ * - Polling with smart intervals
+ */
+import type { Page, Locator } from '@playwright/test';
+/**
+ * Wait options
+ */
+export interface SmartWaitOptions {
+    /** Maximum time to wait in ms (default: 30000) */
+    timeout?: number;
+    /** Polling interval in ms (default: 100) */
+    interval?: number;
+    /** Whether to throw error on timeout (default: true) */
+    throwOnTimeout?: boolean;
+}
+/**
+ * Element state for waiting
+ */
+export type ElementState = 'attached' | 'detached' | 'visible' | 'hidden';
+/**
+ * Stability wait result
+ */
+export interface StabilityResult {
+    /** Whether content was stable */
+    stable: boolean;
+    /** Number of checks performed */
+    checks: number;
+    /** Total time waited in ms */
+    elapsed: number;
+    /** Stability percentage (0-100) */
+    stability: number;
+}
+/**
+ * Smart Wait Helper
+ */
+export declare class SmartWait {
+    private page;
+    constructor(page: Page);
+    /**
+     * Wait for element to be visible
+     */
+    visible(locator: Locator, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for element to be hidden
+     */
+    hidden(locator: Locator, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for element to be attached to DOM
+     */
+    attached(locator: Locator, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for element to be detached from DOM
+     */
+    detached(locator: Locator, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for element to reach a specific state
+     */
+    state(locator: Locator, state: ElementState, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for multiple elements to be visible
+     */
+    allVisible(locators: Locator[], options?: SmartWaitOptions): Promise<boolean[]>;
+    /**
+     * Wait for at least one of multiple elements to be visible
+     */
+    anyVisible(locators: Locator[], options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for element text content to match
+     */
+    text(locator: Locator, text: string | RegExp, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for element text content to change
+     */
+    textChange(locator: Locator, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for element attribute to have a value
+     */
+    attribute(locator: Locator, name: string, value: string | RegExp, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for element to have a specific CSS class
+     */
+    hasClass(locator: Locator, className: string, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for element count to match expected
+     */
+    count(locator: Locator, expected: number, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for content to stabilize (no changes for specified duration)
+     */
+    stable(locator: Locator, stableDuration?: number, options?: SmartWaitOptions): Promise<StabilityResult>;
+    /**
+     * Wait for network idle (no network requests for specified duration)
+     */
+    networkIdle(idleTime?: number, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for URL to match
+     */
+    url(match: string | RegExp | ((url: URL) => boolean), options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for selector to exist in page
+     */
+    selector(selector: string, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for multiple conditions to be met
+     */
+    all(conditions: Array<() => Promise<boolean>>, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Wait for at least one condition to be met
+     */
+    any(conditions: Array<() => Promise<boolean>>, options?: SmartWaitOptions): Promise<boolean>;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+}
+/**
+ * Convenience function to create smart wait helper
+ */
+export declare function smartWait(page: Page): SmartWait;
+/**
+ * Convenience functions for common waits
+ */
+export declare function waitForVisible(locator: Locator, options?: SmartWaitOptions): Promise<boolean>;
+export declare function waitForHidden(locator: Locator, options?: SmartWaitOptions): Promise<boolean>;
+export declare function waitForText(locator: Locator, text: string | RegExp, options?: SmartWaitOptions): Promise<boolean>;