qa360 2.2.20 → 2.3.1

package/dist/core/storage/cookie-manager.js

@@ -0,0 +1,268 @@
+/**
+ * QA360 Cookie Manager Module
+ *
+ * P0: Cookie manipulation helpers
+ * - Get/set/delete cookies with type safety
+ * - Cookie filtering and searching
+ * - Domain/path scoping
+ * - Expiration handling
+ */
+/**
+ * Cookie Manager
+ */
+export class CookieManager {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * Get all cookies
+     */
+    async all() {
+        return await this.context.cookies();
+    }
+    /**
+     * Get cookies matching filter criteria
+     */
+    async filter(options) {
+        const cookies = await this.context.cookies();
+        return cookies.filter((cookie) => this.matchesFilter(cookie, options));
+    }
+    /**
+     * Get a specific cookie by name
+     */
+    async get(name) {
+        const cookies = await this.context.cookies();
+        return cookies.find((c) => c.name === name);
+    }
+    /**
+     * Get a cookie value by name
+     */
+    async getValue(name) {
+        const cookie = await this.get(name);
+        return cookie?.value;
+    }
+    /**
+     * Check if a cookie exists
+     */
+    async has(name) {
+        const cookie = await this.get(name);
+        return cookie !== undefined;
+    }
+    /**
+     * Set a cookie
+     */
+    async set(options) {
+        const cookie = this.normalizeCookieOptions(options);
+        await this.context.addCookies([cookie]);
+    }
+    /**
+     * Set multiple cookies at once
+     */
+    async setMany(cookies) {
+        const normalizedCookies = cookies.map((c) => this.normalizeCookieOptions(c));
+        await this.context.addCookies(normalizedCookies);
+    }
+    /**
+     * Update an existing cookie
+     */
+    async update(name, updates) {
+        const existing = await this.get(name);
+        if (!existing) {
+            throw new Error(`Cookie "${name}" not found`);
+        }
+        await this.set({
+            name,
+            value: existing.value,
+            domain: existing.domain,
+            path: existing.path,
+            expires: existing.expires,
+            sameSite: existing.sameSite,
+            secure: existing.secure,
+            httpOnly: existing.httpOnly,
+            ...updates,
+        });
+    }
+    /**
+     * Delete a cookie by name
+     */
+    async delete(name) {
+        await this.context.clearCookies({ name });
+    }
+    /**
+     * Delete multiple cookies by name
+     */
+    async deleteMany(names) {
+        // Delete each cookie individually since clearCookies with filters
+        // may not work as expected with just name
+        for (const name of names) {
+            await this.delete(name);
+        }
+    }
+    /**
+     * Delete cookies matching filter criteria
+     */
+    async deleteFilter(options) {
+        const cookies = await this.filter(options);
+        await this.context.clearCookies(...cookies.map((c) => ({ name: c.name })));
+    }
+    /**
+     * Clear all cookies
+     */
+    async clear() {
+        await this.context.clearCookies();
+    }
+    /**
+     * Clear cookies for a specific domain
+     */
+    async clearDomain(domain) {
+        await this.deleteFilter({ domain });
+    }
+    /**
+     * Get cookies count
+     */
+    async count() {
+        const cookies = await this.context.cookies();
+        return cookies.length;
+    }
+    /**
+     * Export cookies as JSON string
+     */
+    async export() {
+        const cookies = await this.context.cookies();
+        return JSON.stringify(cookies, null, 2);
+    }
+    /**
+     * Import cookies from JSON string or array
+     */
+    async import(data) {
+        const cookies = typeof data === 'string' ? JSON.parse(data) : data;
+        await this.context.addCookies(cookies);
+    }
+    /**
+     * Get cookies grouped by domain
+     */
+    async byDomain() {
+        const cookies = await this.context.cookies();
+        const grouped = {};
+        for (const cookie of cookies) {
+            const domain = cookie.domain || 'unknown';
+            if (!grouped[domain]) {
+                grouped[domain] = [];
+            }
+            grouped[domain].push(cookie);
+        }
+        return grouped;
+    }
+    /**
+     * Set a session cookie (no expiration)
+     */
+    async setSession(name, value, options = {}) {
+        await this.set({
+            name,
+            value,
+            ...options,
+        });
+    }
+    /**
+     * Set a cookie with max-age (in seconds)
+     */
+    async setWithMaxAge(name, value, maxAge, options = {}) {
+        await this.set({
+            name,
+            value,
+            maxAge,
+            ...options,
+        });
+    }
+    /**
+     * Set a cookie that expires in days
+     */
+    async setExpiringIn(name, value, days, options = {}) {
+        const expires = Math.floor(Date.now() / 1000) + days * 24 * 60 * 60;
+        await this.set({
+            name,
+            value,
+            expires,
+            ...options,
+        });
+    }
+    /**
+     * Normalize cookie options to Playwright format
+     */
+    normalizeCookieOptions(options) {
+        const cookie = {
+            name: options.name,
+            value: options.value,
+            sameSite: options.sameSite || 'Lax',
+            secure: options.secure ?? false,
+            httpOnly: options.httpOnly ?? false,
+        };
+        // URL is preferred - Playwright will infer domain and path from it
+        if (options.url) {
+            cookie.url = options.url;
+        }
+        else {
+            // Only set path when not using URL (Playwright infers path from URL)
+            cookie.path = options.path || '/';
+            // Set domain when not using URL
+            if (options.domain) {
+                cookie.domain = options.domain;
+            }
+        }
+        // Handle expiration
+        if (options.maxAge !== undefined) {
+            cookie.expires = Math.floor(Date.now() / 1000) + options.maxAge;
+        }
+        else if (options.expires !== undefined) {
+            cookie.expires = options.expires;
+        }
+        return cookie;
+    }
+    /**
+     * Check if cookie matches filter criteria
+     */
+    matchesFilter(cookie, filter) {
+        if (filter.name && !this.wildcardMatch(cookie.name, filter.name)) {
+            return false;
+        }
+        if (filter.domain && cookie.domain !== filter.domain) {
+            return false;
+        }
+        if (filter.path && cookie.path !== filter.path) {
+            return false;
+        }
+        if (filter.secure !== undefined && cookie.secure !== filter.secure) {
+            return false;
+        }
+        if (filter.httpOnly !== undefined && cookie.httpOnly !== filter.httpOnly) {
+            return false;
+        }
+        if (filter.sameSite && cookie.sameSite !== filter.sameSite) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Simple wildcard matching
+     */
+    wildcardMatch(text, pattern) {
+        if (!pattern.includes('*')) {
+            return text === pattern;
+        }
+        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+        return regex.test(text);
+    }
+}
+/**
+ * Convenience function to create cookie manager
+ */
+export function cookies(context) {
+    return new CookieManager(context);
+}
+/**
+ * Convenience function to create cookie manager from page
+ */
+export function cookiesFromPage(page) {
+    return new CookieManager(page.context());
+}

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

@@ -0,0 +1,7 @@
+/**
+ * QA360 Storage Module
+ *
+ * P0: Browser storage helpers and management
+ */
+export { LocalStorage, SessionStorage, createLocalStorage, createSessionStorage, type StorageOptions, type StorageResult, } from './storage-helpers.js';
+export { CookieManager, cookies, cookiesFromPage, type CookieSetOptions, type CookieFilterOptions, } from './cookie-manager.js';

package/dist/core/storage/index.js

@@ -0,0 +1,7 @@
+/**
+ * QA360 Storage Module
+ *
+ * P0: Browser storage helpers and management
+ */
+export { LocalStorage, SessionStorage, createLocalStorage, createSessionStorage, } from './storage-helpers.js';
+export { CookieManager, cookies, cookiesFromPage, } from './cookie-manager.js';

package/dist/core/storage/storage-helpers.d.ts

@@ -0,0 +1,138 @@
+/**
+ * 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
+ */
+import type { Page } from '@playwright/test';
+/**
+ * Storage options
+ */
+export interface StorageOptions {
+    /** Key prefix for namespacing */
+    prefix?: string;
+    /** Auto-parse JSON values */
+    json?: boolean;
+}
+/**
+ * Storage get result with metadata
+ */
+export interface StorageResult<T = unknown> {
+    /** Whether the key exists */
+    exists: boolean;
+    /** The value (parsed if json=true) */
+    value: T | null;
+    /** The raw string value */
+    rawValue: string | null;
+}
+/**
+ * LocalStorage Helper
+ */
+export declare class LocalStorage {
+    private page;
+    private options;
+    constructor(page: Page, options?: StorageOptions);
+    /**
+     * Get a value from localStorage
+     */
+    get<T = string>(key: string): Promise<StorageResult<T>>;
+    /**
+     * Set a value in localStorage
+     */
+    set(key: string, value: unknown): Promise<void>;
+    /**
+     * Remove a value from localStorage
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Check if a key exists
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Get all keys (with prefix if configured)
+     */
+    keys(): Promise<string[]>;
+    /**
+     * Clear all keys (with prefix if configured)
+     */
+    clear(): Promise<void>;
+    /**
+     * Get the number of items (with prefix if configured)
+     */
+    size(): Promise<number>;
+    /**
+     * Get all items as an object (with prefix stripped if configured)
+     */
+    getAll<T = unknown>(): Promise<Record<string, T>>;
+    /**
+     * Set multiple items at once
+     */
+    setMany(items: Record<string, unknown>): Promise<void>;
+    /**
+     * Remove multiple items at once
+     */
+    removeMany(keys: string[]): Promise<void>;
+    private getFullKey;
+    private tryParseJSON;
+}
+/**
+ * SessionStorage Helper
+ */
+export declare class SessionStorage {
+    private page;
+    private options;
+    constructor(page: Page, options?: StorageOptions);
+    /**
+     * Get a value from sessionStorage
+     */
+    get<T = string>(key: string): Promise<StorageResult<T>>;
+    /**
+     * Set a value in sessionStorage
+     */
+    set(key: string, value: unknown): Promise<void>;
+    /**
+     * Remove a value from sessionStorage
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Check if a key exists
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Get all keys (with prefix if configured)
+     */
+    keys(): Promise<string[]>;
+    /**
+     * Clear all keys (with prefix if configured)
+     */
+    clear(): Promise<void>;
+    /**
+     * Get the number of items (with prefix if configured)
+     */
+    size(): Promise<number>;
+    /**
+     * Get all items as an object (with prefix stripped if configured)
+     */
+    getAll<T = unknown>(): Promise<Record<string, T>>;
+    /**
+     * Set multiple items at once
+     */
+    setMany(items: Record<string, unknown>): Promise<void>;
+    /**
+     * Remove multiple items at once
+     */
+    removeMany(keys: string[]): Promise<void>;
+    private getFullKey;
+    private tryParseJSON;
+}
+/**
+ * Convenience function to create LocalStorage helper
+ */
+export declare function createLocalStorage(page: Page, options?: StorageOptions): LocalStorage;
+/**
+ * Convenience function to create SessionStorage helper
+ */
+export declare function createSessionStorage(page: Page, options?: StorageOptions): SessionStorage;