qa360 2.3.0 → 2.3.1

package/dist/core/crawler/wait-strategies.js

@@ -0,0 +1,399 @@
+/**
+ * Wait Strategies
+ *
+ * P1 - Advanced wait conditions for E2E tests
+ *
+ * Supports:
+ * - Network idle (no active network requests)
+ * - Element stable (position/size not changing)
+ * - DOM content loaded
+ * - Custom condition polling
+ * - Multiple wait strategies with timeout
+ *
+ * @see https://playwright.dev/docs/actionability
+ */
+/**
+ * Wait Strategies class
+ */
+export class WaitStrategies {
+    defaultTimeout;
+    defaultInterval;
+    constructor(config = {}) {
+        this.defaultTimeout = config.timeout || 30000;
+        this.defaultInterval = config.interval || 100;
+    }
+    /**
+     * Wait for network to be idle
+     */
+    async waitForNetworkIdle(page, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const idleTime = config.idleTime || 500;
+        const ignoreUrls = config.ignoreUrls || [];
+        const startTime = Date.now();
+        let lastActivityTime = Date.now();
+        let activeRequests = 0;
+        const shouldIgnore = (url) => {
+            for (const pattern of ignoreUrls) {
+                if (typeof pattern === 'string' && url.includes(pattern)) {
+                    return true;
+                }
+                if (pattern instanceof RegExp && pattern.test(url)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const onRequest = (request) => {
+            if (!shouldIgnore(request.url())) {
+                activeRequests++;
+                lastActivityTime = Date.now();
+            }
+        };
+        const onResponse = (response) => {
+            if (!shouldIgnore(response.url())) {
+                activeRequests--;
+                lastActivityTime = Date.now();
+            }
+        };
+        page.on('request', onRequest);
+        page.on('response', onResponse);
+        try {
+            while (Date.now() - startTime < timeout) {
+                const currentTime = Date.now();
+                const timeSinceLastActivity = currentTime - lastActivityTime;
+                if (activeRequests === 0 && timeSinceLastActivity >= idleTime) {
+                    return {
+                        success: true,
+                        duration: currentTime - startTime,
+                    };
+                }
+                await new Promise(resolve => setTimeout(resolve, this.defaultInterval));
+            }
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: `Timeout waiting for network idle (${activeRequests} requests still active)`,
+            };
+        }
+        finally {
+            page.off('request', onRequest);
+            page.off('response', onResponse);
+        }
+    }
+    /**
+     * Wait for element to be stable (position/size not changing)
+     */
+    async waitForStable(page, selector, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const stableTime = config.stableTime || 500;
+        const tolerance = config.tolerance || 2;
+        const startTime = Date.now();
+        let lastBox = null;
+        let stableSince = null;
+        while (Date.now() - startTime < timeout) {
+            const box = await page.locator(selector).first().boundingBox();
+            if (!box) {
+                return {
+                    success: false,
+                    error: `Element not found: ${selector}`,
+                };
+            }
+            if (lastBox) {
+                const positionChanged = Math.abs(box.x - lastBox.x) > tolerance ||
+                    Math.abs(box.y - lastBox.y) > tolerance;
+                const sizeChanged = Math.abs(box.width - lastBox.width) > tolerance ||
+                    Math.abs(box.height - lastBox.height) > tolerance;
+                if (positionChanged || sizeChanged) {
+                    stableSince = null;
+                }
+                else if (stableSince === null) {
+                    stableSince = Date.now();
+                }
+                else if (Date.now() - stableSince >= stableTime) {
+                    return {
+                        success: true,
+                        duration: Date.now() - startTime,
+                    };
+                }
+            }
+            lastBox = box;
+            await new Promise(resolve => setTimeout(resolve, this.defaultInterval));
+        }
+        return {
+            success: false,
+            duration: Date.now() - startTime,
+            error: `Element did not become stable within ${timeout}ms`,
+        };
+    }
+    /**
+     * Wait for DOM content to be loaded
+     */
+    async waitForDOMContent(page, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        try {
+            await page.waitForLoadState('domcontentloaded', { timeout });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: e instanceof Error ? e.message : String(e),
+            };
+        }
+    }
+    /**
+     * Wait for network to be mostly idle (allows some background requests)
+     */
+    async waitForNetworkMostlyIdle(page, config = {}) {
+        const modifiedConfig = { ...config, idleTime: (config.idleTime || 500) / 2 };
+        return this.waitForNetworkIdle(page, modifiedConfig);
+    }
+    /**
+     * Wait for element to be visible and stable
+     */
+    async waitForVisibleAndStable(page, selector, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        try {
+            // Wait for visible first
+            await page.locator(selector).first().waitFor({ state: 'visible', timeout });
+            // Then wait for stable
+            return await this.waitForStable(page, selector, {
+                ...config,
+                timeout: timeout - (Date.now() - startTime),
+            });
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: e instanceof Error ? e.message : String(e),
+            };
+        }
+    }
+    /**
+     * Wait for custom condition
+     */
+    async waitForCondition(page, condition, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const interval = config.interval || this.defaultInterval;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            if (await condition()) {
+                return {
+                    success: true,
+                    duration: Date.now() - startTime,
+                };
+            }
+            await new Promise(resolve => setTimeout(resolve, interval));
+        }
+        return {
+            success: false,
+            duration: Date.now() - startTime,
+            error: 'Condition not met within timeout',
+        };
+    }
+    /**
+     * Wait for any element in a list to be visible
+     */
+    async waitForAnyElement(page, selectors, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        try {
+            await page.waitForFunction((selectors) => {
+                return selectors.some((sel) => {
+                    const el = document.querySelector(sel);
+                    if (!el)
+                        return false;
+                    const style = window.getComputedStyle(el);
+                    return style.visibility !== 'hidden' && style.display !== 'none';
+                });
+            }, selectors, { timeout });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: `No element found from selectors: ${selectors.join(', ')}`,
+            };
+        }
+    }
+    /**
+     * Wait for text to appear in element
+     */
+    async waitForText(page, selector, text, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        try {
+            await page.locator(selector).first().waitFor({ state: 'visible', timeout });
+            await page.waitForFunction(({ sel, text }) => {
+                const el = document.querySelector(sel);
+                if (!el)
+                    return false;
+                const content = el.textContent || '';
+                if (typeof text === 'string') {
+                    return content.includes(text);
+                }
+                return text.test(content);
+            }, { sel: selector, text }, { timeout: timeout - (Date.now() - startTime) });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: `Text "${text}" not found in ${selector}`,
+            };
+        }
+    }
+    /**
+     * Wait for element count to match expected
+     */
+    async waitForElementCount(page, selector, count, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        try {
+            await page.waitForFunction(({ sel, expected }) => {
+                return document.querySelectorAll(sel).length === expected;
+            }, { sel: selector, expected: count }, { timeout });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: `Element count did not reach ${count} for ${selector}`,
+            };
+        }
+    }
+    /**
+     * Wait for URL to match pattern
+     */
+    async waitForURL(page, pattern, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        try {
+            await page.waitForURL(pattern, { timeout });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: `URL did not match pattern: ${pattern}`,
+            };
+        }
+    }
+    /**
+     * Wait for console message matching pattern
+     */
+    async waitForConsoleMessage(page, pattern, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        const messageType = config.type || 'log';
+        try {
+            await page.waitForConsoleMessage((msg) => {
+                if (msg.type() !== messageType)
+                    return false;
+                const text = msg.text();
+                if (typeof pattern === 'string') {
+                    return text.includes(pattern);
+                }
+                return pattern.test(text);
+            }, { timeout });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: `Console message not found matching: ${pattern}`,
+            };
+        }
+    }
+    /**
+     * Wait for page title
+     */
+    async waitForTitle(page, title, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        try {
+            await page.waitForTitle(title, { timeout });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: `Title did not match: ${title}`,
+            };
+        }
+    }
+    /**
+     * Wait for multiple conditions (all must be true)
+     */
+    async waitForAll(page, conditions, config = {}) {
+        const results = await Promise.all(conditions.map(condition => this.waitForCondition(page, condition, config)));
+        const allSuccess = results.every(r => r.success);
+        const maxDuration = Math.max(...results.map(r => r.duration || 0));
+        return {
+            success: allSuccess,
+            duration: maxDuration,
+            error: allSuccess ? undefined : 'Not all conditions were met',
+        };
+    }
+    /**
+     * Wait for multiple conditions (any can be true)
+     */
+    async waitForAny(page, conditions, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        const interval = config.interval || this.defaultInterval;
+        while (Date.now() - startTime < timeout) {
+            const results = await Promise.all(conditions.map(condition => condition()));
+            if (results.some(r => r === true)) {
+                return {
+                    success: true,
+                    duration: Date.now() - startTime,
+                };
+            }
+            await new Promise(resolve => setTimeout(resolve, interval));
+        }
+        return {
+            success: false,
+            duration: Date.now() - startTime,
+            error: 'No condition was met within timeout',
+        };
+    }
+}
+/**
+ * Factory function to create Wait Strategies
+ */
+export function createWaitStrategies(config) {
+    return new WaitStrategies(config);
+}
+export default WaitStrategies;

package/dist/core/fixtures/factories.d.ts

@@ -0,0 +1,180 @@
+/**
+ * QA360 Fixtures Module
+ *
+ * P0: Reusable test data and factory functions
+ * - Factories for creating test entities
+ * - Fake data generation
+ * - Seeded random for deterministic tests
+ */
+/**
+ * Factory options
+ */
+export interface FactoryOptions {
+    /** Optional overrides for default values */
+    overrides?: Record<string, unknown>;
+    /** Optional relationships to other entities */
+    relations?: Record<string, unknown>;
+}
+/**
+ * Base factory interface
+ */
+export interface Factory<T> {
+    build(options?: FactoryOptions): T;
+    buildMany(count: number, options?: FactoryOptions): T[];
+}
+/**
+ * User entity factory
+ */
+export interface User {
+    id?: string;
+    username: string;
+    email: string;
+    password: string;
+    firstName?: string;
+    lastName?: string;
+    role?: 'user' | 'admin' | 'moderator';
+    active?: boolean;
+    createdAt?: Date;
+}
+/**
+ * Test result factory
+ */
+export interface TestResult {
+    id?: string;
+    name: string;
+    status: 'passed' | 'failed' | 'skipped';
+    duration: number;
+    error?: string;
+}
+/**
+ * API response factory
+ */
+export interface ApiResponse {
+    status: number;
+    data?: unknown;
+    error?: string;
+    headers?: Record<string, string>;
+}
+/**
+ * User Factory
+ */
+export declare class UserFactory implements Factory<User> {
+    private static counter;
+    build(options?: FactoryOptions): User;
+    buildMany(count: number, options?: FactoryOptions): User[];
+    /**
+     * Create an admin user
+     */
+    admin(options?: FactoryOptions): User;
+    /**
+     * Create an inactive user
+     */
+    inactive(options?: FactoryOptions): User;
+}
+/**
+ * Test Result Factory
+ */
+export declare class TestResultFactory implements Factory<TestResult> {
+    private static counter;
+    build(options?: FactoryOptions): TestResult;
+    buildMany(count: number, options?: FactoryOptions): TestResult[];
+    /**
+     * Create a passed test
+     */
+    passed(options?: FactoryOptions): TestResult;
+    /**
+     * Create a failed test
+     */
+    failed(options?: FactoryOptions): TestResult;
+    /**
+     * Create a skipped test
+     */
+    skipped(options?: FactoryOptions): TestResult;
+}
+/**
+ * API Response Factory
+ */
+export declare class ApiResponseFactory implements Factory<ApiResponse> {
+    build(options?: FactoryOptions): ApiResponse;
+    buildMany(count: number, options?: FactoryOptions): ApiResponse[];
+    /**
+     * Create a success response
+     */
+    success(data?: unknown, options?: FactoryOptions): ApiResponse;
+    /**
+     * Create an error response
+     */
+    error(status?: number, message?: string, options?: FactoryOptions): ApiResponse;
+    /**
+     * Create a not found response
+     */
+    notFound(options?: FactoryOptions): ApiResponse;
+    /**
+     * Create an unauthorized response
+     */
+    unauthorized(options?: FactoryOptions): ApiResponse;
+}
+/**
+ * Fake data generator with seeded random
+ */
+export declare class FakeData {
+    private static seed;
+    /**
+     * Set the seed for deterministic random generation
+     */
+    static setSeed(seed: number): void;
+    /**
+     * Seeded random number generator (Mulberry32)
+     */
+    private static random;
+    /**
+     * Generate a random integer between min and max (inclusive)
+     */
+    static integer(min: number, max: number): number;
+    /**
+     * Generate a random float between min and max
+     */
+    static float(min: number, max: number): number;
+    /**
+     * Generate a random string
+     */
+    static string(length?: number, charset?: string): string;
+    /**
+     * Generate a random email
+     */
+    static email(): string;
+    /**
+     * Generate a random URL
+     */
+    static url(): string;
+    /**
+     * Generate a random UUID v4
+     */
+    static uuid(): string;
+    /**
+     * Generate a random date
+     */
+    static date(minYear?: number, maxYear?: number): Date;
+    /**
+     * Generate a random boolean
+     */
+    static boolean(): boolean;
+    /**
+     * Pick a random element from an array
+     */
+    static pick<T>(array: T[]): T;
+    /**
+     * Generate a random name
+     */
+    static name(): string;
+    /**
+     * Generate a random paragraph
+     */
+    static paragraph(sentences?: number): string;
+}
+/**
+ * Convenience functions
+ */
+export declare const userFactory: UserFactory;
+export declare const testResultFactory: TestResultFactory;
+export declare const apiResponseFactory: ApiResponseFactory;