qa360 2.3.0 → 2.3.2

package/dist/core/storage/storage-helpers.js

@@ -0,0 +1,315 @@
+/**
+ * QA360 Storage Helpers Module
+ *
+ * P0: Simplified access to browser storage APIs
+ * - LocalStorage helpers with type safety
+ * - SessionStorage helpers with type safety
+ * - JSON serialization/deserialization
+ * - Prefix support for namespacing
+ */
+/**
+ * LocalStorage Helper
+ */
+export class LocalStorage {
+    page;
+    options;
+    constructor(page, options = {}) {
+        this.page = page;
+        this.options = options;
+    }
+    /**
+     * Get a value from localStorage
+     */
+    async get(key) {
+        const fullKey = this.getFullKey(key);
+        const result = await this.page.evaluate(({ k }) => {
+            const value = localStorage.getItem(k);
+            return {
+                exists: value !== null,
+                rawValue: value,
+            };
+        }, { k: fullKey });
+        if (!result.exists) {
+            return { exists: false, value: null, rawValue: null };
+        }
+        const value = this.options.json !== false
+            ? this.tryParseJSON(result.rawValue)
+            : result.rawValue;
+        return {
+            exists: true,
+            value: value,
+            rawValue: result.rawValue,
+        };
+    }
+    /**
+     * Set a value in localStorage
+     */
+    async set(key, value) {
+        const fullKey = this.getFullKey(key);
+        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+        await this.page.evaluate(({ k, v }) => {
+            localStorage.setItem(k, v);
+        }, { k: fullKey, v: stringValue });
+    }
+    /**
+     * Remove a value from localStorage
+     */
+    async remove(key) {
+        const fullKey = this.getFullKey(key);
+        await this.page.evaluate(({ k }) => {
+            localStorage.removeItem(k);
+        }, { k: fullKey });
+    }
+    /**
+     * Check if a key exists
+     */
+    async has(key) {
+        const result = await this.get(key);
+        return result.exists;
+    }
+    /**
+     * Get all keys (with prefix if configured)
+     */
+    async keys() {
+        const prefix = this.options.prefix || '';
+        return await this.page.evaluate(({ p }) => {
+            const keys = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key && (!p || key.startsWith(p))) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        }, { p: prefix });
+    }
+    /**
+     * Clear all keys (with prefix if configured)
+     */
+    async clear() {
+        const prefix = this.options.prefix || '';
+        await this.page.evaluate(({ p }) => {
+            if (!p) {
+                localStorage.clear();
+                return;
+            }
+            // Clear only keys with prefix
+            const keysToRemove = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key && key.startsWith(p)) {
+                    keysToRemove.push(key);
+                }
+            }
+            keysToRemove.forEach(key => localStorage.removeItem(key));
+        }, { p: prefix });
+    }
+    /**
+     * Get the number of items (with prefix if configured)
+     */
+    async size() {
+        const keys = await this.keys();
+        return keys.length;
+    }
+    /**
+     * Get all items as an object (with prefix stripped if configured)
+     */
+    async getAll() {
+        const keys = await this.keys();
+        const result = {};
+        for (const key of keys) {
+            const shortKey = this.options.prefix ? key.slice(this.options.prefix.length) : key;
+            const item = await this.get(shortKey);
+            if (item.exists && item.value !== null) {
+                result[shortKey] = item.value;
+            }
+        }
+        return result;
+    }
+    /**
+     * Set multiple items at once
+     */
+    async setMany(items) {
+        for (const [key, value] of Object.entries(items)) {
+            await this.set(key, value);
+        }
+    }
+    /**
+     * Remove multiple items at once
+     */
+    async removeMany(keys) {
+        for (const key of keys) {
+            await this.remove(key);
+        }
+    }
+    getFullKey(key) {
+        return this.options.prefix ? `${this.options.prefix}${key}` : key;
+    }
+    tryParseJSON(value) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+}
+/**
+ * SessionStorage Helper
+ */
+export class SessionStorage {
+    page;
+    options;
+    constructor(page, options = {}) {
+        this.page = page;
+        this.options = options;
+    }
+    /**
+     * Get a value from sessionStorage
+     */
+    async get(key) {
+        const fullKey = this.getFullKey(key);
+        const result = await this.page.evaluate(({ k }) => {
+            const value = sessionStorage.getItem(k);
+            return {
+                exists: value !== null,
+                rawValue: value,
+            };
+        }, { k: fullKey });
+        if (!result.exists) {
+            return { exists: false, value: null, rawValue: null };
+        }
+        const value = this.options.json !== false
+            ? this.tryParseJSON(result.rawValue)
+            : result.rawValue;
+        return {
+            exists: true,
+            value: value,
+            rawValue: result.rawValue,
+        };
+    }
+    /**
+     * Set a value in sessionStorage
+     */
+    async set(key, value) {
+        const fullKey = this.getFullKey(key);
+        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+        await this.page.evaluate(({ k, v }) => {
+            sessionStorage.setItem(k, v);
+        }, { k: fullKey, v: stringValue });
+    }
+    /**
+     * Remove a value from sessionStorage
+     */
+    async remove(key) {
+        const fullKey = this.getFullKey(key);
+        await this.page.evaluate(({ k }) => {
+            sessionStorage.removeItem(k);
+        }, { k: fullKey });
+    }
+    /**
+     * Check if a key exists
+     */
+    async has(key) {
+        const result = await this.get(key);
+        return result.exists;
+    }
+    /**
+     * Get all keys (with prefix if configured)
+     */
+    async keys() {
+        const prefix = this.options.prefix || '';
+        return await this.page.evaluate(({ p }) => {
+            const keys = [];
+            for (let i = 0; i < sessionStorage.length; i++) {
+                const key = sessionStorage.key(i);
+                if (key && (!p || key.startsWith(p))) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        }, { p: prefix });
+    }
+    /**
+     * Clear all keys (with prefix if configured)
+     */
+    async clear() {
+        const prefix = this.options.prefix || '';
+        await this.page.evaluate(({ p }) => {
+            if (!p) {
+                sessionStorage.clear();
+                return;
+            }
+            // Clear only keys with prefix
+            const keysToRemove = [];
+            for (let i = 0; i < sessionStorage.length; i++) {
+                const key = sessionStorage.key(i);
+                if (key && key.startsWith(p)) {
+                    keysToRemove.push(key);
+                }
+            }
+            keysToRemove.forEach(key => sessionStorage.removeItem(key));
+        }, { p: prefix });
+    }
+    /**
+     * Get the number of items (with prefix if configured)
+     */
+    async size() {
+        const keys = await this.keys();
+        return keys.length;
+    }
+    /**
+     * Get all items as an object (with prefix stripped if configured)
+     */
+    async getAll() {
+        const keys = await this.keys();
+        const result = {};
+        for (const key of keys) {
+            const shortKey = this.options.prefix ? key.slice(this.options.prefix.length) : key;
+            const item = await this.get(shortKey);
+            if (item.exists && item.value !== null) {
+                result[shortKey] = item.value;
+            }
+        }
+        return result;
+    }
+    /**
+     * Set multiple items at once
+     */
+    async setMany(items) {
+        for (const [key, value] of Object.entries(items)) {
+            await this.set(key, value);
+        }
+    }
+    /**
+     * Remove multiple items at once
+     */
+    async removeMany(keys) {
+        for (const key of keys) {
+            await this.remove(key);
+        }
+    }
+    getFullKey(key) {
+        return this.options.prefix ? `${this.options.prefix}${key}` : key;
+    }
+    tryParseJSON(value) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+}
+/**
+ * Convenience function to create LocalStorage helper
+ */
+export function createLocalStorage(page, options) {
+    return new LocalStorage(page, options);
+}
+/**
+ * Convenience function to create SessionStorage helper
+ */
+export function createSessionStorage(page, options) {
+    return new SessionStorage(page, options);
+}

package/dist/core/test-helpers/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QA360 Test Helpers Module
+ *
+ * P0: Helper functions for test setup and teardown
+ */
+export { StateReset, resetPageState, resetToBlank, setupTest, teardownTest, type StateResetOptions, } from './state-reset.js';

package/dist/core/test-helpers/index.js

@@ -0,0 +1,6 @@
+/**
+ * QA360 Test Helpers Module
+ *
+ * P0: Helper functions for test setup and teardown
+ */
+export { StateReset, resetPageState, resetToBlank, setupTest, teardownTest, } from './state-reset.js';

package/dist/core/test-helpers/state-reset.d.ts

@@ -0,0 +1,119 @@
+/**
+ * QA360 State Reset Module
+ *
+ * P0: Clean slate between tests
+ * - Clear localStorage
+ * - Clear sessionStorage
+ * - Clear cookies
+ * - Clear caches
+ * - Reset navigation state
+ * - Clear all storage
+ */
+import type { Page, BrowserContext } from '@playwright/test';
+/**
+ * State reset options
+ */
+export interface StateResetOptions {
+    /** Clear localStorage */
+    clearLocalStorage?: boolean;
+    /** Clear sessionStorage */
+    clearSessionStorage?: boolean;
+    /** Clear cookies */
+    clearCookies?: boolean;
+    /** Clear all storage */
+    clearAll?: boolean;
+    /** Reset navigation to blank page */
+    resetNavigation?: boolean;
+    /** Clear browser cache */
+    clearCache?: boolean;
+    /** Wait for network idle before proceeding */
+    waitForNetworkIdle?: boolean;
+}
+/**
+ * State Reset Helper
+ *
+ * Provides methods to reset browser state between tests
+ */
+export declare class StateReset {
+    /**
+     * Reset all state for a page
+     *
+     * @param page - Playwright page to reset
+     * @param options - Reset options
+     */
+    static resetPage(page: Page, options?: StateResetOptions): Promise<void>;
+    /**
+     * Reset all state for a browser context
+     *
+     * @param context - Playwright browser context to reset
+     * @param options - Reset options
+     */
+    static resetContext(context: BrowserContext, options?: StateResetOptions): Promise<void>;
+    /**
+     * Complete reset: clears everything
+     *
+     * @param context - Browser context
+     * @param page - Optional specific page to reset
+     */
+    static resetAll(context: BrowserContext, page?: Page): Promise<void>;
+    /**
+     * Reset to a blank state (useful between tests)
+     *
+     * @param page - Playwright page
+     */
+    static resetToBlank(page: Page): Promise<void>;
+    /**
+     * Clean up before a test
+     *
+     * @param page - Playwright page
+     * @param baseUrl - Base URL to navigate to after cleanup
+     */
+    static setupTest(page: Page, baseUrl?: string): Promise<void>;
+    /**
+     * Clean up after a test
+     *
+     * @param context - Browser context
+     * @param page - Playwright page
+     */
+    static teardownTest(context: BrowserContext, page: Page): Promise<void>;
+    /**
+     * Clear specific storage keys
+     *
+     * @param page - Playwright page
+     * @param keys - Keys to clear (supports wildcards with *)
+     * @param storage - Storage type ('localStorage' or 'sessionStorage')
+     */
+    static clearKeys(page: Page, keys: string[], storage?: 'localStorage' | 'sessionStorage'): Promise<void>;
+    /**
+     * Get storage size (useful for debugging)
+     *
+     * @param page - Playwright page
+     * @returns Storage size info
+     */
+    static getStorageSize(page: Page): Promise<{
+        localStorage: {
+            entries: number;
+            size: number;
+        };
+        sessionStorage: {
+            entries: number;
+            size: number;
+        };
+    }>;
+}
+/**
+ * Convenience function to reset page state
+ */
+export declare function resetPageState(page: Page, options?: StateResetOptions): Promise<void>;
+/**
+ * Convenience function to reset to blank
+ */
+export declare function resetToBlank(page: Page): Promise<void>;
+/**
+ * Convenience function to setup test
+ */
+export declare function setupTest(page: Page, baseUrl?: string): Promise<void>;
+/**
+ * Convenience function to teardown test
+ */
+export declare function teardownTest(context: BrowserContext, page: Page): Promise<void>;

package/dist/core/test-helpers/state-reset.js

@@ -0,0 +1,234 @@
+/**
+ * QA360 State Reset Module
+ *
+ * P0: Clean slate between tests
+ * - Clear localStorage
+ * - Clear sessionStorage
+ * - Clear cookies
+ * - Clear caches
+ * - Reset navigation state
+ * - Clear all storage
+ */
+/**
+ * State Reset Helper
+ *
+ * Provides methods to reset browser state between tests
+ */
+export class StateReset {
+    /**
+     * Reset all state for a page
+     *
+     * @param page - Playwright page to reset
+     * @param options - Reset options
+     */
+    static async resetPage(page, options = {}) {
+        const { clearLocalStorage = true, clearSessionStorage = true, clearAll = false, resetNavigation = false, waitForNetworkIdle = false, } = options;
+        // Clear storage
+        if (clearAll || clearLocalStorage) {
+            await page.evaluate(() => {
+                localStorage.clear();
+            });
+        }
+        if (clearAll || clearSessionStorage) {
+            await page.evaluate(() => {
+                sessionStorage.clear();
+            });
+        }
+        // Reset navigation if requested
+        if (resetNavigation) {
+            await page.goto('about:blank', { waitUntil: 'domcontentloaded' });
+        }
+        // Wait for network idle if requested
+        if (waitForNetworkIdle) {
+            try {
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {
+                    // Ignore timeout - might not be applicable
+                });
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+    }
+    /**
+     * Reset all state for a browser context
+     *
+     * @param context - Playwright browser context to reset
+     * @param options - Reset options
+     */
+    static async resetContext(context, options = {}) {
+        const { clearCookies = true, clearCache = false, clearAll = false, } = options;
+        // Clear cookies
+        if (clearAll || clearCookies) {
+            await context.clearCookies();
+        }
+        // Clear cache (requires permission)
+        if (clearAll || clearCache) {
+            const pages = context.pages();
+            for (const page of pages) {
+                try {
+                    // Clear caches via CDP
+                    const client = await context.newCDPSession(page);
+                    await client.send('Network.clearBrowserCache');
+                }
+                catch {
+                    // Ignore CDP errors
+                }
+            }
+        }
+        // Reset all pages in context
+        const pages = context.pages();
+        for (const page of pages) {
+            await this.resetPage(page, options);
+        }
+    }
+    /**
+     * Complete reset: clears everything
+     *
+     * @param context - Browser context
+     * @param page - Optional specific page to reset
+     */
+    static async resetAll(context, page) {
+        const resetOptions = {
+            clearAll: true,
+            resetNavigation: true,
+            clearCache: true,
+        };
+        // Reset all pages or specific page
+        if (page) {
+            await this.resetPage(page, resetOptions);
+        }
+        await this.resetContext(context, resetOptions);
+    }
+    /**
+     * Reset to a blank state (useful between tests)
+     *
+     * @param page - Playwright page
+     */
+    static async resetToBlank(page) {
+        // Try to clear storage BEFORE navigating to blank (blank pages don't allow storage access)
+        try {
+            await page.evaluate(() => {
+                if (typeof localStorage !== 'undefined') {
+                    localStorage.clear();
+                }
+                if (typeof sessionStorage !== 'undefined') {
+                    sessionStorage.clear();
+                }
+            });
+        }
+        catch {
+            // Ignore errors if storage is not accessible
+        }
+        await page.goto('about:blank', { waitUntil: 'domcontentloaded' });
+    }
+    /**
+     * Clean up before a test
+     *
+     * @param page - Playwright page
+     * @param baseUrl - Base URL to navigate to after cleanup
+     */
+    static async setupTest(page, baseUrl) {
+        // Reset to blank first
+        await this.resetToBlank(page);
+        // Navigate to base URL if provided
+        if (baseUrl) {
+            await page.goto(baseUrl, { waitUntil: 'domcontentloaded' });
+        }
+    }
+    /**
+     * Clean up after a test
+     *
+     * @param context - Browser context
+     * @param page - Playwright page
+     */
+    static async teardownTest(context, page) {
+        await this.resetPage(page, {
+            clearLocalStorage: true,
+            clearSessionStorage: true,
+            resetNavigation: false, // Don't reset nav during teardown
+        });
+        // Close any additional pages
+        const pages = context.pages();
+        for (const p of pages) {
+            if (p !== page) {
+                await p.close().catch(() => { });
+            }
+        }
+    }
+    /**
+     * Clear specific storage keys
+     *
+     * @param page - Playwright page
+     * @param keys - Keys to clear (supports wildcards with *)
+     * @param storage - Storage type ('localStorage' or 'sessionStorage')
+     */
+    static async clearKeys(page, keys, storage = 'localStorage') {
+        await page.evaluate((args) => {
+            const { keysToClear, storageType } = args;
+            const store = storageType === 'localStorage' ? localStorage : sessionStorage;
+            const allKeys = Object.keys(store);
+            for (const key of keysToClear) {
+                if (key.includes('*')) {
+                    // Wildcard match
+                    const pattern = new RegExp(key.replace(/\*/g, '.*'));
+                    for (const k of allKeys) {
+                        if (pattern.test(k)) {
+                            store.removeItem(k);
+                        }
+                    }
+                }
+                else {
+                    store.removeItem(key);
+                }
+            }
+        }, { keysToClear: keys, storageType: storage });
+    }
+    /**
+     * Get storage size (useful for debugging)
+     *
+     * @param page - Playwright page
+     * @returns Storage size info
+     */
+    static async getStorageSize(page) {
+        return await page.evaluate(() => {
+            const getSize = (store) => {
+                let size = 0;
+                const keys = Object.keys(store);
+                for (const key of keys) {
+                    const value = store.getItem(key) || '';
+                    size += value.length + key.length;
+                }
+                return { entries: keys.length, size };
+            };
+            return {
+                localStorage: getSize(localStorage),
+                sessionStorage: getSize(sessionStorage),
+            };
+        });
+    }
+}
+/**
+ * Convenience function to reset page state
+ */
+export async function resetPageState(page, options) {
+    return StateReset.resetPage(page, options);
+}
+/**
+ * Convenience function to reset to blank
+ */
+export async function resetToBlank(page) {
+    return StateReset.resetToBlank(page);
+}
+/**
+ * Convenience function to setup test
+ */
+export async function setupTest(page, baseUrl) {
+    return StateReset.setupTest(page, baseUrl);
+}
+/**
+ * Convenience function to teardown test
+ */
+export async function teardownTest(context, page) {
+    return StateReset.teardownTest(context, page);
+}