qa360 2.3.0 → 2.3.1

package/dist/core/network/network-manager.d.ts

@@ -0,0 +1,237 @@
+/**
+ * QA360 Network Manager
+ *
+ * P0 Features: Advanced network control for testing
+ * - Block routes: Prevent specific requests from completing
+ * - Mock routes: Return custom responses for specific requests
+ * - Wait for request: Wait until a specific request is made
+ * - Wait for response: Wait until a specific response is received
+ *
+ * Uses Playwright's page.route(), page.waitForRequest(), page.waitForResponse()
+ */
+import type { Page, Request, Response } from '@playwright/test';
+/**
+ * Route blocking configuration
+ */
+export interface BlockRouteConfig {
+    /**
+     * URL pattern to block (regex, string, or function)
+     */
+    urlPattern: string | RegExp | ((url: string) => boolean);
+    /**
+     * Optional HTTP methods to block
+     * If not specified, blocks all methods
+     */
+    methods?: string[];
+}
+/**
+ * Route mocking configuration
+ */
+export interface MockRouteConfig {
+    /**
+     * URL pattern to mock (regex, string, or function)
+     */
+    urlPattern: string | RegExp | ((url: string) => boolean);
+    /**
+     * HTTP status to return
+     */
+    status: number;
+    /**
+     * Response headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Response body (string or JSON)
+     */
+    body?: string | Record<string, unknown>;
+    /**
+     * Content type
+     */
+    contentType?: string;
+    /**
+     * Optional HTTP methods to mock
+     */
+    methods?: string[];
+}
+/**
+ * Wait for request configuration
+ */
+export interface WaitForRequestOptions {
+    /**
+     * URL pattern to wait for
+     */
+    urlPattern?: string | RegExp | ((url: string) => boolean);
+    /**
+     * HTTP method to wait for
+     */
+    method?: string;
+    /**
+     * Timeout in milliseconds
+     */
+    timeout?: number;
+}
+/**
+ * Wait for response configuration
+ */
+export interface WaitForResponseOptions {
+    /**
+     * URL pattern to wait for
+     */
+    urlPattern?: string | RegExp | ((url: string) => boolean);
+    /**
+     * HTTP status to wait for
+     */
+    status?: number;
+    /**
+     * Timeout in milliseconds
+     */
+    timeout?: number;
+}
+/**
+ * Network Manager class
+ * Provides advanced network control capabilities
+ */
+export declare class NetworkManager {
+    private page;
+    private blockedRoutes;
+    private mockedRoutes;
+    constructor(page: Page);
+    /**
+     * Block routes matching the given pattern
+     * P0: Block specific requests (analytics, trackers, etc.)
+     */
+    blockRoute(config: BlockRouteConfig): Promise<void>;
+    /**
+     * Mock routes with custom responses
+     * P0: Return fake responses for testing
+     */
+    mockRoute(config: MockRouteConfig): Promise<void>;
+    /**
+     * Wait for a request matching the given pattern
+     * P0: Wait for specific API calls
+     */
+    waitForRequest(options?: WaitForRequestOptions): Promise<Request>;
+    /**
+     * Wait for a response matching the given pattern
+     * P0: Wait for specific API responses
+     */
+    waitForResponse(options?: WaitForResponseOptions): Promise<Response>;
+    /**
+     * Unblock all blocked routes
+     */
+    unblockRoutes(): Promise<void>;
+    /**
+     * Unmock all mocked routes
+     */
+    unmockRoutes(): Promise<void>;
+    /**
+     * Get all blocked routes
+     */
+    getBlockedRoutes(): BlockRouteConfig[];
+    /**
+     * Get all mocked routes
+     */
+    getMockedRoutes(): MockRouteConfig[];
+    /**
+     * Check if a URL matches a pattern
+     */
+    private matchPattern;
+    /**
+     * Get content type based on body
+     */
+    private getContentType;
+}
+/**
+ * Convenience function to create a network manager
+ */
+export declare function createNetworkManager(page: Page): NetworkManager;
+/**
+ * Predefined common blocking patterns
+ */
+export declare const BlockPatterns: {
+    /**
+     * Block Google Analytics
+     */
+    googleAnalytics: string;
+    /**
+     * Block Google Tag Manager
+     */
+    googleTagManager: string;
+    /**
+     * Block Facebook Pixel
+     */
+    facebookPixel: string;
+    /**
+     * Block DoubleClick
+     */
+    doubleClick: string;
+    /**
+     * Block all analytics
+     */
+    allAnalytics: string[];
+    /**
+     * Block images
+     */
+    images: string;
+    /**
+     * Block fonts
+     */
+    fonts: string;
+    /**
+     * Block CSS
+     */
+    css: string;
+    /**
+     * Block JavaScript
+     */
+    javascript: string;
+};
+/**
+ * Predefined common mock responses
+ */
+export declare const MockResponses: {
+    /**
+     * Mock successful API response
+     */
+    successResponse: (data?: Record<string, unknown>) => MockRouteConfig;
+    /**
+     * Mock error API response
+     */
+    errorResponse: (message?: string) => MockRouteConfig;
+    /**
+     * Mock empty list response
+     */
+    emptyList: () => MockRouteConfig;
+    /**
+     * Mock 404 Not Found
+     */
+    notFound: () => MockRouteConfig;
+    /**
+     * Mock 401 Unauthorized
+     */
+    unauthorized: () => MockRouteConfig;
+    /**
+     * Mock slow response (with latency)
+     * Note: This doesn't add actual delay, use NetworkSimulator for that
+     */
+    slowResponse: (data?: Record<string, unknown>) => MockRouteConfig;
+};
+/**
+ * Convenience functions for common operations
+ */
+/**
+ * Block all analytics and tracking scripts
+ */
+export declare function blockAnalytics(page: Page): Promise<void>;
+/**
+ * Mock all API responses
+ */
+export declare function mockAllAPI(page: Page, response: MockRouteConfig): Promise<void>;
+/**
+ * Wait for API request
+ */
+export declare function waitForAPIRequest(page: Page, urlPattern: string | RegExp, timeout?: number): Promise<Request>;
+/**
+ * Wait for API response
+ */
+export declare function waitForAPIResponse(page: Page, urlPattern: string | RegExp, timeout?: number): Promise<Response>;

package/dist/core/network/network-manager.js

@@ -0,0 +1,343 @@
+/**
+ * QA360 Network Manager
+ *
+ * P0 Features: Advanced network control for testing
+ * - Block routes: Prevent specific requests from completing
+ * - Mock routes: Return custom responses for specific requests
+ * - Wait for request: Wait until a specific request is made
+ * - Wait for response: Wait until a specific response is received
+ *
+ * Uses Playwright's page.route(), page.waitForRequest(), page.waitForResponse()
+ */
+/**
+ * Network Manager class
+ * Provides advanced network control capabilities
+ */
+export class NetworkManager {
+    page;
+    blockedRoutes = [];
+    mockedRoutes = [];
+    constructor(page) {
+        this.page = page;
+    }
+    /**
+     * Block routes matching the given pattern
+     * P0: Block specific requests (analytics, trackers, etc.)
+     */
+    async blockRoute(config) {
+        const { urlPattern, methods } = config;
+        const handler = async (route) => {
+            const request = route.request();
+            const url = request.url();
+            const method = request.method();
+            // Check if URL matches pattern
+            const matches = this.matchPattern(url, urlPattern);
+            if (!matches) {
+                await route.continue();
+                return;
+            }
+            // Check if method matches
+            if (methods && !methods.includes(method)) {
+                await route.continue();
+                return;
+            }
+            // Abort the request
+            await route.abort('failed');
+        };
+        // Create URL pattern wrapper for Playwright
+        const playwrightUrlPattern = typeof urlPattern === 'function'
+            ? (url) => this.matchPattern(url.href, urlPattern)
+            : urlPattern;
+        await this.page.route(playwrightUrlPattern, handler);
+        this.blockedRoutes.push(config);
+    }
+    /**
+     * Mock routes with custom responses
+     * P0: Return fake responses for testing
+     */
+    async mockRoute(config) {
+        const { urlPattern, status, headers, body, contentType, methods } = config;
+        const handler = async (route) => {
+            const request = route.request();
+            const url = request.url();
+            const method = request.method();
+            // Check if URL matches pattern
+            const matches = this.matchPattern(url, urlPattern);
+            if (!matches) {
+                await route.continue();
+                return;
+            }
+            // Check if method matches
+            if (methods && !methods.includes(method)) {
+                await route.continue();
+                return;
+            }
+            // Prepare response
+            const responseHeaders = {
+                'content-type': contentType || this.getContentType(body),
+                ...headers,
+            };
+            let responseBody;
+            if (typeof body === 'string') {
+                responseBody = body;
+            }
+            else if (body !== undefined) {
+                responseBody = JSON.stringify(body);
+            }
+            else {
+                responseBody = '';
+            }
+            await route.fulfill({
+                status,
+                headers: responseHeaders,
+                body: responseBody,
+            });
+        };
+        // Create URL pattern wrapper for Playwright
+        const playwrightUrlPattern = typeof urlPattern === 'function'
+            ? (url) => this.matchPattern(url.href, urlPattern)
+            : urlPattern;
+        await this.page.route(playwrightUrlPattern, handler);
+        this.mockedRoutes.push(config);
+    }
+    /**
+     * Wait for a request matching the given pattern
+     * P0: Wait for specific API calls
+     */
+    async waitForRequest(options = {}) {
+        const { urlPattern = /.*/, method, timeout = 30000 } = options;
+        if (method) {
+            // Wait for request with specific method
+            return await this.page.waitForRequest((request) => {
+                const urlMatches = this.matchPattern(request.url(), urlPattern);
+                const methodMatches = request.method() === method;
+                return urlMatches && methodMatches;
+            }, { timeout });
+        }
+        return await this.page.waitForRequest((request) => this.matchPattern(request.url(), urlPattern), { timeout });
+    }
+    /**
+     * Wait for a response matching the given pattern
+     * P0: Wait for specific API responses
+     */
+    async waitForResponse(options = {}) {
+        const { urlPattern = /.*/, status, timeout = 30000 } = options;
+        if (status) {
+            // Wait for response with specific status using predicate
+            return await this.page.waitForResponse((response) => {
+                const urlMatches = this.matchPattern(response.url(), urlPattern);
+                const statusMatches = response.status() === status;
+                return urlMatches && statusMatches;
+            }, { timeout });
+        }
+        return await this.page.waitForResponse((response) => this.matchPattern(response.url(), urlPattern), { timeout });
+    }
+    /**
+     * Unblock all blocked routes
+     */
+    async unblockRoutes() {
+        // Clear all blocked routes
+        this.blockedRoutes = [];
+        // Note: Playwright doesn't provide a way to remove specific routes,
+        // so we need to recreate the page or use a workaround
+        // For now, we track them manually and users can call this for bookkeeping
+    }
+    /**
+     * Unmock all mocked routes
+     */
+    async unmockRoutes() {
+        // Clear all mocked routes
+        this.mockedRoutes = [];
+    }
+    /**
+     * Get all blocked routes
+     */
+    getBlockedRoutes() {
+        return [...this.blockedRoutes];
+    }
+    /**
+     * Get all mocked routes
+     */
+    getMockedRoutes() {
+        return [...this.mockedRoutes];
+    }
+    /**
+     * Check if a URL matches a pattern
+     */
+    matchPattern(url, pattern) {
+        if (typeof pattern === 'string') {
+            // Convert glob pattern to regex
+            const regexPattern = pattern
+                .replace(/\*/g, '.*')
+                .replace(/\?/g, '.');
+            return new RegExp(regexPattern).test(url);
+        }
+        if (pattern instanceof RegExp) {
+            return pattern.test(url);
+        }
+        if (typeof pattern === 'function') {
+            return pattern(url);
+        }
+        return false;
+    }
+    /**
+     * Get content type based on body
+     */
+    getContentType(body) {
+        if (body === undefined) {
+            return 'text/plain';
+        }
+        if (typeof body === 'string') {
+            // Try to detect if it's JSON
+            try {
+                JSON.parse(body);
+                return 'application/json';
+            }
+            catch {
+                return 'text/plain';
+            }
+        }
+        return 'application/json';
+    }
+}
+/**
+ * Convenience function to create a network manager
+ */
+export function createNetworkManager(page) {
+    return new NetworkManager(page);
+}
+/**
+ * Predefined common blocking patterns
+ */
+export const BlockPatterns = {
+    /**
+     * Block Google Analytics
+     */
+    googleAnalytics: '**/google-analytics.com/**',
+    /**
+     * Block Google Tag Manager
+     */
+    googleTagManager: '**/googletagmanager.com/**',
+    /**
+     * Block Facebook Pixel
+     */
+    facebookPixel: '**/facebook.com/tr/**',
+    /**
+     * Block DoubleClick
+     */
+    doubleClick: '**/doubleclick.net/**',
+    /**
+     * Block all analytics
+     */
+    allAnalytics: ['**/analytics/**', '**/tracking/**', '**/telemetry/**'],
+    /**
+     * Block images
+     */
+    images: '**/*.{png,jpg,jpeg,gif,webp,svg}',
+    /**
+     * Block fonts
+     */
+    fonts: '**/*.{woff,woff2,ttf,otf,eot}',
+    /**
+     * Block CSS
+     */
+    css: '**/*.css',
+    /**
+     * Block JavaScript
+     */
+    javascript: '**/*.js',
+};
+/**
+ * Predefined common mock responses
+ */
+export const MockResponses = {
+    /**
+     * Mock successful API response
+     */
+    successResponse: (data = {}) => ({
+        urlPattern: '**/api/**',
+        status: 200,
+        body: { success: true, data },
+        contentType: 'application/json',
+    }),
+    /**
+     * Mock error API response
+     */
+    errorResponse: (message = 'Error') => ({
+        urlPattern: '**/api/**',
+        status: 500,
+        body: { success: false, error: message },
+        contentType: 'application/json',
+    }),
+    /**
+     * Mock empty list response
+     */
+    emptyList: () => ({
+        urlPattern: '**/api/**',
+        status: 200,
+        body: '[]',
+        contentType: 'application/json',
+    }),
+    /**
+     * Mock 404 Not Found
+     */
+    notFound: () => ({
+        urlPattern: '**/api/**',
+        status: 404,
+        body: { error: 'Not Found' },
+        contentType: 'application/json',
+    }),
+    /**
+     * Mock 401 Unauthorized
+     */
+    unauthorized: () => ({
+        urlPattern: '**/api/**',
+        status: 401,
+        body: { error: 'Unauthorized' },
+        contentType: 'application/json',
+    }),
+    /**
+     * Mock slow response (with latency)
+     * Note: This doesn't add actual delay, use NetworkSimulator for that
+     */
+    slowResponse: (data = {}) => ({
+        urlPattern: '**/api/**',
+        status: 200,
+        body: { success: true, data },
+        contentType: 'application/json',
+    }),
+};
+/**
+ * Convenience functions for common operations
+ */
+/**
+ * Block all analytics and tracking scripts
+ */
+export async function blockAnalytics(page) {
+    const manager = new NetworkManager(page);
+    await manager.blockRoute({ urlPattern: BlockPatterns.googleAnalytics });
+    await manager.blockRoute({ urlPattern: BlockPatterns.googleTagManager });
+    await manager.blockRoute({ urlPattern: BlockPatterns.facebookPixel });
+    await manager.blockRoute({ urlPattern: BlockPatterns.doubleClick });
+}
+/**
+ * Mock all API responses
+ */
+export async function mockAllAPI(page, response) {
+    const manager = new NetworkManager(page);
+    await manager.mockRoute(response);
+}
+/**
+ * Wait for API request
+ */
+export async function waitForAPIRequest(page, urlPattern, timeout = 30000) {
+    const manager = new NetworkManager(page);
+    return await manager.waitForRequest({ urlPattern, timeout });
+}
+/**
+ * Wait for API response
+ */
+export async function waitForAPIResponse(page, urlPattern, timeout = 30000) {
+    const manager = new NetworkManager(page);
+    return await manager.waitForResponse({ urlPattern, timeout });
+}