qa360 2.3.0 → 2.3.1

package/dist/core/utils/smart-wait.js

@@ -0,0 +1,417 @@
+/**
+ * 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
+ */
+/**
+ * Smart Wait Helper
+ */
+export class SmartWait {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    /**
+     * Wait for element to be visible
+     */
+    async visible(locator, options = {}) {
+        const { timeout = 30000 } = options;
+        try {
+            await locator.waitFor({ state: 'visible', timeout });
+            return true;
+        }
+        catch {
+            if (options.throwOnTimeout !== false) {
+                throw new Error(`Element not visible within ${timeout}ms`);
+            }
+            return false;
+        }
+    }
+    /**
+     * Wait for element to be hidden
+     */
+    async hidden(locator, options = {}) {
+        const { timeout = 30000 } = options;
+        try {
+            await locator.waitFor({ state: 'hidden', timeout });
+            return true;
+        }
+        catch {
+            if (options.throwOnTimeout !== false) {
+                throw new Error(`Element not hidden within ${timeout}ms`);
+            }
+            return false;
+        }
+    }
+    /**
+     * Wait for element to be attached to DOM
+     */
+    async attached(locator, options = {}) {
+        const { timeout = 30000 } = options;
+        try {
+            await locator.waitFor({ state: 'attached', timeout });
+            return true;
+        }
+        catch {
+            if (options.throwOnTimeout !== false) {
+                throw new Error(`Element not attached within ${timeout}ms`);
+            }
+            return false;
+        }
+    }
+    /**
+     * Wait for element to be detached from DOM
+     */
+    async detached(locator, options = {}) {
+        const { timeout = 30000 } = options;
+        try {
+            await locator.waitFor({ state: 'detached', timeout });
+            return true;
+        }
+        catch {
+            if (options.throwOnTimeout !== false) {
+                throw new Error(`Element not detached within ${timeout}ms`);
+            }
+            return false;
+        }
+    }
+    /**
+     * Wait for element to reach a specific state
+     */
+    async state(locator, state, options = {}) {
+        const { timeout = 30000 } = options;
+        try {
+            await locator.waitFor({ state, timeout });
+            return true;
+        }
+        catch {
+            if (options.throwOnTimeout !== false) {
+                throw new Error(`Element not ${state} within ${timeout}ms`);
+            }
+            return false;
+        }
+    }
+    /**
+     * Wait for multiple elements to be visible
+     */
+    async allVisible(locators, options = {}) {
+        const { timeout = 30000 } = options;
+        const startTime = Date.now();
+        const results = await Promise.allSettled(locators.map((locator) => locator.waitFor({ state: 'visible', timeout })));
+        return results.map((result, index) => {
+            if (result.status === 'fulfilled') {
+                return true;
+            }
+            if (options.throwOnTimeout !== false) {
+                throw new Error(`Element ${index} not visible within ${timeout}ms`);
+            }
+            return false;
+        });
+    }
+    /**
+     * Wait for at least one of multiple elements to be visible
+     */
+    async anyVisible(locators, options = {}) {
+        const { timeout = 30000, interval = 100 } = options;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            for (const locator of locators) {
+                if (await locator.isVisible().catch(() => false)) {
+                    return true;
+                }
+            }
+            await this.sleep(interval);
+        }
+        if (options.throwOnTimeout !== false) {
+            throw new Error(`No element visible within ${timeout}ms`);
+        }
+        return false;
+    }
+    /**
+     * Wait for element text content to match
+     */
+    async text(locator, text, options = {}) {
+        const { timeout = 30000, interval = 100 } = options;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            try {
+                const actualText = await locator.textContent({ timeout: interval });
+                if (actualText !== null) {
+                    if (typeof text === 'string') {
+                        if (actualText.trim() === text || actualText.includes(text)) {
+                            return true;
+                        }
+                    }
+                    else if (text.test(actualText)) {
+                        return true;
+                    }
+                }
+            }
+            catch {
+                // Element not yet available, continue waiting
+            }
+            await this.sleep(interval);
+        }
+        if (options.throwOnTimeout !== false) {
+            throw new Error(`Element text does not match "${text}" within ${timeout}ms`);
+        }
+        return false;
+    }
+    /**
+     * Wait for element text content to change
+     */
+    async textChange(locator, options = {}) {
+        const { timeout = 30000, interval = 100 } = options;
+        const startTime = Date.now();
+        const initialText = await locator.textContent().catch(() => null);
+        while (Date.now() - startTime < timeout) {
+            const currentText = await locator.textContent().catch(() => null);
+            if (currentText !== initialText) {
+                return true;
+            }
+            await this.sleep(interval);
+        }
+        if (options.throwOnTimeout !== false) {
+            throw new Error(`Element text did not change within ${timeout}ms`);
+        }
+        return false;
+    }
+    /**
+     * Wait for element attribute to have a value
+     */
+    async attribute(locator, name, value, options = {}) {
+        const { timeout = 30000, interval = 100 } = options;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            try {
+                const actualValue = await locator.getAttribute(name);
+                if (actualValue !== null) {
+                    if (typeof value === 'string') {
+                        if (actualValue === value || actualValue.includes(value)) {
+                            return true;
+                        }
+                    }
+                    else if (value.test(actualValue)) {
+                        return true;
+                    }
+                }
+            }
+            catch {
+                // Element not yet available, continue waiting
+            }
+            await this.sleep(interval);
+        }
+        if (options.throwOnTimeout !== false) {
+            throw new Error(`Element attribute "${name}" does not match "${value}" within ${timeout}ms`);
+        }
+        return false;
+    }
+    /**
+     * Wait for element to have a specific CSS class
+     */
+    async hasClass(locator, className, options = {}) {
+        const { timeout = 30000, interval = 100 } = options;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            try {
+                const classes = await locator.getAttribute('class');
+                if (classes && classes.split(/\s+/).includes(className)) {
+                    return true;
+                }
+            }
+            catch {
+                // Element not yet available, continue waiting
+            }
+            await this.sleep(interval);
+        }
+        if (options.throwOnTimeout !== false) {
+            throw new Error(`Element does not have class "${className}" within ${timeout}ms`);
+        }
+        return false;
+    }
+    /**
+     * Wait for element count to match expected
+     */
+    async count(locator, expected, options = {}) {
+        const { timeout = 30000, interval = 100 } = options;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            try {
+                const count = await locator.count();
+                if (count === expected) {
+                    return true;
+                }
+            }
+            catch {
+                // Element not yet available, continue waiting
+            }
+            await this.sleep(interval);
+        }
+        if (options.throwOnTimeout !== false) {
+            throw new Error(`Element count is not ${expected} within ${timeout}ms`);
+        }
+        return false;
+    }
+    /**
+     * Wait for content to stabilize (no changes for specified duration)
+     */
+    async stable(locator, stableDuration = 500, options = {}) {
+        const { timeout = 30000, interval = 100 } = options;
+        const startTime = Date.now();
+        const snapshots = [];
+        let checks = 0;
+        while (Date.now() - startTime < timeout) {
+            checks++;
+            try {
+                const snapshot = await locator.innerHTML();
+                snapshots.push(snapshot);
+                // Keep only last few snapshots for comparison
+                if (snapshots.length > stableDuration / interval + 1) {
+                    snapshots.shift();
+                }
+                // Check if content has been stable
+                if (snapshots.length >= 2) {
+                    const allSame = snapshots.every((s) => s === snapshots[0]);
+                    if (allSame && (Date.now() - startTime >= stableDuration)) {
+                        return {
+                            stable: true,
+                            checks,
+                            elapsed: Date.now() - startTime,
+                            stability: 100,
+                        };
+                    }
+                }
+            }
+            catch {
+                // Element not yet available
+                snapshots.push('');
+            }
+            await this.sleep(interval);
+        }
+        // Calculate stability percentage
+        const uniqueSnapshots = new Set(snapshots).size;
+        const stability = Math.max(0, 100 - (uniqueSnapshots / snapshots.length) * 100);
+        return {
+            stable: false,
+            checks,
+            elapsed: Date.now() - startTime,
+            stability,
+        };
+    }
+    /**
+     * Wait for network idle (no network requests for specified duration)
+     */
+    async networkIdle(idleTime = 500, options = {}) {
+        const { timeout = 30000 } = options;
+        try {
+            await this.page.waitForLoadState('networkidle', { timeout: idleTime });
+            return true;
+        }
+        catch {
+            if (options.throwOnTimeout !== false) {
+                throw new Error(`Network not idle within ${timeout}ms`);
+            }
+            return false;
+        }
+    }
+    /**
+     * Wait for URL to match
+     */
+    async url(match, options = {}) {
+        const { timeout = 30000, interval = 100 } = options;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            const url = this.page.url();
+            if (typeof match === 'string') {
+                if (url === match || url.includes(match)) {
+                    return true;
+                }
+            }
+            else if (match instanceof RegExp) {
+                if (match.test(url)) {
+                    return true;
+                }
+            }
+            else if (match(new URL(url))) {
+                return true;
+            }
+            await this.sleep(interval);
+        }
+        if (options.throwOnTimeout !== false) {
+            throw new Error(`URL does not match "${match}" within ${timeout}ms`);
+        }
+        return false;
+    }
+    /**
+     * Wait for selector to exist in page
+     */
+    async selector(selector, options = {}) {
+        return await this.attached(this.page.locator(selector), options);
+    }
+    /**
+     * Wait for multiple conditions to be met
+     */
+    async all(conditions, options = {}) {
+        const { timeout = 30000, interval = 100 } = options;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            const results = await Promise.all(conditions.map((fn) => fn().catch(() => false)));
+            if (results.every((r) => r)) {
+                return true;
+            }
+            await this.sleep(interval);
+        }
+        if (options.throwOnTimeout !== false) {
+            throw new Error(`Not all conditions met within ${timeout}ms`);
+        }
+        return false;
+    }
+    /**
+     * Wait for at least one condition to be met
+     */
+    async any(conditions, options = {}) {
+        const { timeout = 30000, interval = 100 } = options;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            const results = await Promise.allSettled(conditions.map((fn) => fn()));
+            if (results.some((r) => r.status === 'fulfilled' && r.value === true)) {
+                return true;
+            }
+            await this.sleep(interval);
+        }
+        if (options.throwOnTimeout !== false) {
+            throw new Error(`No condition met within ${timeout}ms`);
+        }
+        return false;
+    }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+/**
+ * Convenience function to create smart wait helper
+ */
+export function smartWait(page) {
+    return new SmartWait(page);
+}
+/**
+ * Convenience functions for common waits
+ */
+export async function waitForVisible(locator, options) {
+    return await new SmartWait(locator.page() || locator._page).visible(locator, options);
+}
+export async function waitForHidden(locator, options) {
+    return await new SmartWait(locator.page() || locator._page).hidden(locator, options);
+}
+export async function waitForText(locator, text, options) {
+    return await new SmartWait(locator.page() || locator._page).text(locator, text, options);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * QA360 Visual Testing Module
+ *
+ * P0 Features: Visual regression testing with pixel diff
+ */
+export { PixelDiff, compareImages, compareImageBuffers, type PixelDiffResult, type PixelDiffOptions, } from './pixel-diff.js';
+export { Screenshot, screenshot, type ScreenshotCaptureOptions, type ScreenshotCompareResult, type BaselineConfig, } from './screenshot-helper.js';

package/dist/core/visual/index.js

@@ -0,0 +1,7 @@
+/**
+ * QA360 Visual Testing Module
+ *
+ * P0 Features: Visual regression testing with pixel diff
+ */
+export { PixelDiff, compareImages, compareImageBuffers, } from './pixel-diff.js';
+export { Screenshot, screenshot, } from './screenshot-helper.js';

package/dist/core/visual/pixel-diff.d.ts

@@ -0,0 +1,87 @@
+/**
+ * QA360 Visual Comparison Module
+ *
+ * P0 Features: Pixel diff for visual regression testing
+ * - Pixel-by-pixel comparison
+ * - Perceptual diff with anti-aliasing tolerance
+ * - Configurable thresholds
+ * - Diff image generation
+ */
+/**
+ * Pixel comparison result
+ */
+export interface PixelDiffResult {
+    /** Whether images are considered identical */
+    identical: boolean;
+    /** Number of differing pixels */
+    diffPixels: number;
+    /** Total pixels compared */
+    totalPixels: number;
+    /** Percentage of difference (0-100) */
+    diffPercentage: number;
+    /** Path to generated diff image */
+    diffImagePath?: string;
+}
+/**
+ * Pixel comparison options
+ */
+export interface PixelDiffOptions {
+    /** Maximum allowed difference percentage (0-100) */
+    threshold?: number;
+    /** Pixel color difference threshold (0-255) */
+    pixelThreshold?: number;
+    /** Whether to generate a diff image */
+    generateDiffImage?: boolean;
+    /** Output directory for diff images */
+    outputDir?: string;
+    /** Antialiasing tolerance (ignore minor color differences) */
+    antialiasing?: boolean;
+}
+/**
+ * Pixel Diff Comparator
+ */
+export declare class PixelDiff {
+    /**
+     * Compare two images pixel by pixel
+     *
+     * @param image1Path - Path to baseline image
+     * @param image2Path - Path to current image
+     * @param options - Comparison options
+     * @returns Comparison result
+     */
+    static compare(image1Path: string, image2Path: string, options?: PixelDiffOptions): Promise<PixelDiffResult>;
+    /**
+     * Compare two image buffers directly
+     *
+     * @param buffer1 - First image buffer (PNG)
+     * @param buffer2 - Second image buffer (PNG)
+     * @param options - Comparison options
+     * @returns Comparison result
+     */
+    static compareBuffers(buffer1: Buffer, buffer2: Buffer, options?: PixelDiffOptions): Promise<PixelDiffResult>;
+    /**
+     * Calculate perceptual color difference
+     * Uses Euclidean distance in RGB space
+     */
+    private static colorDifference;
+    /**
+     * Load image from file path
+     */
+    private static loadImage;
+    /**
+     * Decode PNG buffer to image data
+     */
+    private static decodeBuffer;
+    /**
+     * Save diff image to file
+     */
+    private static saveDiffImage;
+}
+/**
+ * Convenience function to compare two images
+ */
+export declare function compareImages(image1Path: string, image2Path: string, options?: PixelDiffOptions): Promise<PixelDiffResult>;
+/**
+ * Convenience function to compare two image buffers
+ */
+export declare function compareImageBuffers(buffer1: Buffer, buffer2: Buffer, options?: PixelDiffOptions): Promise<PixelDiffResult>;