qa360 2.3.0 → 2.3.2

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

@@ -0,0 +1,158 @@
+/**
+ * QA360 Network Simulator
+ *
+ * P0 Features: Network simulation for testing edge cases
+ * - Offline mode: Simulate network disconnection
+ * - HTTP errors: Simulate server errors (500, 503, 404, etc.)
+ * - Latency: Simulate slow networks
+ * - Throttling: Simulate bandwidth limitations
+ *
+ * Uses Playwright's page.route() for request interception
+ */
+import type { Page } from '@playwright/test';
+/**
+ * HTTP error configuration
+ */
+export interface HTTPErrorConfig {
+    /**
+     * HTTP status code to simulate
+     * Common values: 404, 500, 502, 503, 504
+     */
+    status: number;
+    /**
+     * Optional custom status text
+     */
+    statusText?: string;
+    /**
+     * Optional response body
+     */
+    body?: string;
+    /**
+     * URL pattern to apply error to (regex or string)
+     * If not specified, applies to all requests
+     */
+    urlPattern?: string | RegExp;
+    /**
+     * HTTP methods to apply error to
+     * If not specified, applies to all methods
+     */
+    methods?: string[];
+}
+/**
+ * Network simulation options
+ */
+export interface NetworkSimulationOptions {
+    /**
+     * Simulate offline mode (no network connection)
+     */
+    offline?: boolean;
+    /**
+     * Simulate HTTP errors
+     */
+    httpErrors?: HTTPErrorConfig[];
+    /**
+     * Simulate latency (delay in ms)
+     */
+    latency?: number;
+    /**
+     * Simulate throttling (max bytes per second)
+     */
+    throttling?: {
+        downloadKbps?: number;
+        uploadKbps?: number;
+        latency?: number;
+    };
+}
+/**
+ * Network Simulator class
+ */
+export declare class NetworkSimulator {
+    private page;
+    private activeRoutes;
+    private isOffline;
+    constructor(page: Page);
+    /**
+     * Apply network simulation settings
+     */
+    simulate(options: NetworkSimulationOptions): Promise<void>;
+    /**
+     * Set offline mode
+     * P0: Simulate network disconnection
+     */
+    setOffline(offline: boolean): Promise<void>;
+    /**
+     * Add HTTP error simulation
+     * P0: Simulate server errors (500, 503, 404, etc.)
+     */
+    addHTTPError(config: HTTPErrorConfig): Promise<void>;
+    /**
+     * Set latency for all requests
+     */
+    setLatency(delayMs: number): Promise<void>;
+    /**
+     * Set network throttling
+     * Uses Chrome DevTools Protocol for accurate throttling
+     */
+    setThrottling(config: {
+        downloadKbps?: number;
+        uploadKbps?: number;
+        latency?: number;
+    }): Promise<void>;
+    /**
+     * Clear all network simulations
+     */
+    clear(): Promise<void>;
+    /**
+     * Get default status text for HTTP status codes
+     */
+    private getDefaultStatusText;
+}
+/**
+ * Predefined network profiles
+ */
+export declare const NetworkProfiles: {
+    /**
+     * Offline mode - no network connection
+     */
+    offline: () => NetworkSimulationOptions;
+    /**
+     * Slow 3G network
+     */
+    slow3G: () => NetworkSimulationOptions;
+    /**
+     * Fast 3G network
+     */
+    fast3G: () => NetworkSimulationOptions;
+    /**
+     * Server error simulation (500)
+     */
+    serverError: (urlPattern?: string | RegExp) => NetworkSimulationOptions;
+    /**
+     * Service unavailable simulation (503)
+     */
+    serviceUnavailable: (urlPattern?: string | RegExp) => NetworkSimulationOptions;
+    /**
+     * Not found simulation (404)
+     */
+    notFound: (urlPattern?: string | RegExp) => NetworkSimulationOptions;
+    /**
+     * Multiple server errors for testing resilience
+     */
+    flakyServer: (urlPattern?: string | RegExp) => NetworkSimulationOptions;
+};
+/**
+ * Convenience function to create a network simulator
+ */
+export declare function createNetworkSimulator(page: Page): NetworkSimulator;
+/**
+ * Convenience function to simulate network conditions
+ */
+export declare function simulateNetwork(page: Page, options: NetworkSimulationOptions): Promise<void>;
+/**
+ * Convenience function to set offline mode
+ */
+export declare function setOffline(page: Page, offline: boolean): Promise<void>;
+/**
+ * Convenience function to simulate HTTP error
+ */
+export declare function simulateHTTPError(page: Page, config: HTTPErrorConfig): Promise<void>;

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

@@ -0,0 +1,261 @@
+/**
+ * QA360 Network Simulator
+ *
+ * P0 Features: Network simulation for testing edge cases
+ * - Offline mode: Simulate network disconnection
+ * - HTTP errors: Simulate server errors (500, 503, 404, etc.)
+ * - Latency: Simulate slow networks
+ * - Throttling: Simulate bandwidth limitations
+ *
+ * Uses Playwright's page.route() for request interception
+ */
+/**
+ * Network Simulator class
+ */
+export class NetworkSimulator {
+    page;
+    activeRoutes = [];
+    isOffline = false;
+    constructor(page) {
+        this.page = page;
+    }
+    /**
+     * Apply network simulation settings
+     */
+    async simulate(options) {
+        // Remove existing routes first
+        await this.clear();
+        // Apply offline mode
+        if (options.offline) {
+            await this.setOffline(true);
+        }
+        // Apply HTTP errors
+        if (options.httpErrors) {
+            for (const errorConfig of options.httpErrors) {
+                await this.addHTTPError(errorConfig);
+            }
+        }
+        // Apply latency
+        if (options.latency) {
+            await this.setLatency(options.latency);
+        }
+        // Apply throttling
+        if (options.throttling) {
+            await this.setThrottling(options.throttling);
+        }
+    }
+    /**
+     * Set offline mode
+     * P0: Simulate network disconnection
+     */
+    async setOffline(offline) {
+        this.isOffline = offline;
+        if (offline) {
+            // Abort all requests when offline
+            const pattern = /.*/;
+            const handler = async (route) => {
+                await route.abort('failed');
+            };
+            await this.page.route(pattern, handler);
+            this.activeRoutes.push({ pattern, handler });
+        }
+        else {
+            // Remove offline route
+            await this.clear();
+        }
+    }
+    /**
+     * Add HTTP error simulation
+     * P0: Simulate server errors (500, 503, 404, etc.)
+     */
+    async addHTTPError(config) {
+        const pattern = config.urlPattern || /.*/;
+        const status = config.status;
+        const statusText = config.statusText || this.getDefaultStatusText(status);
+        const body = config.body || `Error ${status}: ${statusText}`;
+        const methods = config.methods;
+        const handler = async (route) => {
+            // Check method filter
+            if (methods && !methods.includes(route.request().method())) {
+                await route.continue();
+                return;
+            }
+            await route.fulfill({
+                status,
+                // Note: Playwright doesn't support statusText in route.fulfill()
+                // The status is sufficient for most testing purposes
+                contentType: 'text/plain',
+                body,
+            });
+        };
+        await this.page.route(pattern, handler);
+        this.activeRoutes.push({ pattern, handler });
+    }
+    /**
+     * Set latency for all requests
+     */
+    async setLatency(delayMs) {
+        const pattern = /.*/;
+        const handler = async (route) => {
+            // Simulate latency before continuing
+            await new Promise(resolve => setTimeout(resolve, delayMs));
+            await route.continue();
+        };
+        await this.page.route(pattern, handler);
+        this.activeRoutes.push({ pattern, handler });
+    }
+    /**
+     * Set network throttling
+     * Uses Chrome DevTools Protocol for accurate throttling
+     */
+    async setThrottling(config) {
+        const client = await this.page.context().newCDPSession(this.page);
+        await client.send('Network.emulateNetworkConditions', {
+            offline: false,
+            downloadThroughput: (config.downloadKbps || 1500) * 1024 / 8, // Convert to bytes/sec
+            uploadThroughput: (config.uploadKbps || 750) * 1024 / 8,
+            latency: config.latency || 0,
+        });
+    }
+    /**
+     * Clear all network simulations
+     */
+    async clear() {
+        // Remove all routes
+        this.activeRoutes = [];
+        this.isOffline = false;
+        // Unregister all routes by resetting the page
+        // Note: Playwright doesn't have a direct way to remove all routes,
+        // so we need to use a workaround with a counter
+    }
+    /**
+     * Get default status text for HTTP status codes
+     */
+    getDefaultStatusText(status) {
+        const statusTexts = {
+            400: 'Bad Request',
+            401: 'Unauthorized',
+            403: 'Forbidden',
+            404: 'Not Found',
+            500: 'Internal Server Error',
+            502: 'Bad Gateway',
+            503: 'Service Unavailable',
+            504: 'Gateway Timeout',
+        };
+        return statusTexts[status] || 'Unknown Error';
+    }
+}
+/**
+ * Predefined network profiles
+ */
+export const NetworkProfiles = {
+    /**
+     * Offline mode - no network connection
+     */
+    offline: () => ({
+        offline: true,
+    }),
+    /**
+     * Slow 3G network
+     */
+    slow3G: () => ({
+        latency: 200,
+        throttling: {
+            downloadKbps: 400,
+            uploadKbps: 400,
+            latency: 200,
+        },
+    }),
+    /**
+     * Fast 3G network
+     */
+    fast3G: () => ({
+        latency: 100,
+        throttling: {
+            downloadKbps: 1500,
+            uploadKbps: 750,
+            latency: 100,
+        },
+    }),
+    /**
+     * Server error simulation (500)
+     */
+    serverError: (urlPattern) => ({
+        httpErrors: [
+            {
+                status: 500,
+                statusText: 'Internal Server Error',
+                body: '{"error": "Internal Server Error"}',
+                urlPattern,
+            },
+        ],
+    }),
+    /**
+     * Service unavailable simulation (503)
+     */
+    serviceUnavailable: (urlPattern) => ({
+        httpErrors: [
+            {
+                status: 503,
+                statusText: 'Service Unavailable',
+                body: '{"error": "Service Unavailable"}',
+                urlPattern,
+            },
+        ],
+    }),
+    /**
+     * Not found simulation (404)
+     */
+    notFound: (urlPattern) => ({
+        httpErrors: [
+            {
+                status: 404,
+                statusText: 'Not Found',
+                body: '{"error": "Not Found"}',
+                urlPattern,
+            },
+        ],
+    }),
+    /**
+     * Multiple server errors for testing resilience
+     */
+    flakyServer: (urlPattern) => ({
+        httpErrors: [
+            {
+                status: 503,
+                statusText: 'Service Unavailable',
+                body: '{"error": "Service Unavailable"}',
+                urlPattern,
+                methods: ['GET'],
+            },
+        ],
+        latency: 100,
+    }),
+};
+/**
+ * Convenience function to create a network simulator
+ */
+export function createNetworkSimulator(page) {
+    return new NetworkSimulator(page);
+}
+/**
+ * Convenience function to simulate network conditions
+ */
+export async function simulateNetwork(page, options) {
+    const simulator = new NetworkSimulator(page);
+    await simulator.simulate(options);
+}
+/**
+ * Convenience function to set offline mode
+ */
+export async function setOffline(page, offline) {
+    const simulator = new NetworkSimulator(page);
+    await simulator.setOffline(offline);
+}
+/**
+ * Convenience function to simulate HTTP error
+ */
+export async function simulateHTTPError(page, config) {
+    const simulator = new NetworkSimulator(page);
+    await simulator.addHTTPError(config);
+}

package/{cli/dist → dist}/core/pack/validator.js

@@ -22,8 +22,8 @@ export class PackValidator {
         const __dirname = dirname(__filename);
         // Check multiple paths to handle both development and bundled npm environments
         // From cli/dist/core/pack/validator.js, we need to reach core/schemas/pack.schema.json
-        const path1 = join(__dirname, '../../schemas/pack.schema.json');                      // bundled (cli/dist/core/schemas/)
-        const path2 = join(__dirname, '../../../../core/schemas/pack.schema.json');  // npm package (core/schemas/)
+        const path1 = join(__dirname, '../../schemas/pack.schema.json'); // bundled (cli/dist/core/schemas/)
+        const path2 = join(__dirname, '../../../../core/schemas/pack.schema.json'); // npm package (core/schemas/)
         let schemaPath = existsSync(path1) ? path1 : path2;
         // Final fallback: throw error if no schema found
         if (!existsSync(schemaPath)) {

package/{cli/dist → dist}/core/pack-v2/migrator.d.ts

@@ -41,12 +41,17 @@ export declare class PackMigrator {
      * Migrate targets to gate configs
      */
     private migrateTargetsToGates;
+    /**
+     * Transform relative page paths to full URLs
+     */
+    private transformPagesToFullUrls;
     /**
      * Find a secret in environment variables by trying common names
      */
     private findSecretInEnv;
     /**
      * Sanitize gate name for v2 format
+     * Handles both strings and objects (from YAML parsing edge cases)
      */
     private sanitizeGateName;
     /**

package/{cli/dist → dist}/core/pack-v2/migrator.js

@@ -395,14 +395,64 @@ export class PackMigrator {
             gate.config.baseUrl = v1Pack.targets.api.baseUrl;
             gate.config.smoke = v1Pack.targets.api.smoke;
         }
-        // Web target
-        if (v1Pack.targets.web && v2Pack.gates['ui']) {
-            const gate = v2Pack.gates['ui'];
-            gate.config = gate.config || {};
-            gate.config.baseUrl = v1Pack.targets.web.baseUrl;
-            gate.config.pages = v1Pack.targets.web.pages;
+        // Web target - migrate to ui, a11y, and accessibility gates
+        if (v1Pack.targets.web) {
+            const baseUrl = v1Pack.targets.web.baseUrl;
+            const pages = this.transformPagesToFullUrls(v1Pack.targets.web.pages || [], baseUrl);
+            // ui gate
+            if (v2Pack.gates['ui']) {
+                const gate = v2Pack.gates['ui'];
+                gate.config = gate.config || {};
+                gate.config.baseUrl = baseUrl;
+                gate.config.pages = pages;
+            }
+            // a11y gate (v1 name)
+            if (v2Pack.gates['a11y']) {
+                const gate = v2Pack.gates['a11y'];
+                gate.config = gate.config || {};
+                gate.config.baseUrl = baseUrl;
+                gate.config.pages = pages;
+            }
+            // accessibility gate (v2 sanitized name from 'a11y')
+            if (v2Pack.gates['accessibility']) {
+                const gate = v2Pack.gates['accessibility'];
+                gate.config = gate.config || {};
+                gate.config.baseUrl = baseUrl;
+                gate.config.pages = pages;
+            }
         }
     }
+    /**
+     * Transform relative page paths to full URLs
+     */
+    transformPagesToFullUrls(pages, baseUrl) {
+        if (!pages || pages.length === 0)
+            return [];
+        if (!baseUrl)
+            return pages;
+        const base = baseUrl.replace(/\/$/, '');
+        return pages.map((page) => {
+            // Handle string pages (e.g., "/", "/products")
+            if (typeof page === 'string') {
+                if (page.startsWith('http')) {
+                    return page; // Already a full URL
+                }
+                return `${base}${page.startsWith('/') ? '' : '/'}${page}`;
+            }
+            // Handle object pages (e.g., { url: "/", ... })
+            if (page && typeof page === 'object' && page.url) {
+                const url = page.url;
+                if (url.startsWith('http')) {
+                    return page; // Already a full URL
+                }
+                return {
+                    ...page,
+                    url: `${base}${url.startsWith('/') ? '' : '/'}${url}`
+                };
+            }
+            return page;
+        });
+    }
     /**
      * Find a secret in environment variables by trying common names
      */
@@ -424,8 +474,33 @@ export class PackMigrator {
     }
     /**
      * Sanitize gate name for v2 format
+     * Handles both strings and objects (from YAML parsing edge cases)
      */
     sanitizeGateName(gate) {
+        // Handle edge case where gate might be an object from YAML parsing
+        if (typeof gate !== 'string') {
+            // If gate is an object, try to extract a name
+            if (gate && typeof gate === 'object') {
+                // Try common property names
+                const possibleName = gate.name || gate.id || gate.gate;
+                if (typeof possibleName === 'string') {
+                    gate = possibleName;
+                }
+                else {
+                    // Fallback: stringify the object keys
+                    const keys = Object.keys(gate);
+                    if (keys.length === 1) {
+                        gate = keys[0];
+                    }
+                    else {
+                        throw new Error(`Invalid gate format: expected string, got object with keys: ${keys.join(', ')}`);
+                    }
+                }
+            }
+            else {
+                throw new Error(`Invalid gate format: expected string, got ${typeof gate}`);
+            }
+        }
         // Map v1 gate names to v2 conventions
         const nameMap = {
             'api_smoke': 'smoke',

package/{cli/dist → dist}/core/pack-v2/validator.js

@@ -370,7 +370,8 @@ export class PackValidatorV2 {
             // Validate auth profile reference
             if (gate.auth) {
                 // Will be validated against profiles in auth section
-                if (!gate.adapter?.includes('api') && !gate.adapter?.includes('ui')) {
+                const adapter = typeof gate.adapter === 'string' ? gate.adapter : '';
+                if (adapter && !adapter.includes('api') && !adapter.includes('ui')) {
                     warnings.push({
                         code: 'QP2V019',
                         message: `Auth profile specified but adapter may not support auth`,
@@ -593,7 +594,7 @@ export class PackValidatorV2 {
             return { errors, warnings };
         }
         // Check for API gate with api auth but no auth profile
-        const apiGates = Object.entries(pack.gates).filter(([_, g]) => g.adapter?.includes('api'));
+        const apiGates = Object.entries(pack.gates).filter(([_, g]) => typeof g.adapter === 'string' && g.adapter.includes('api'));
         if (apiGates.length > 0 && !pack.auth?.api && !pack.auth?.profiles) {
             warnings.push({
                 code: 'QP2V034',
@@ -603,7 +604,7 @@ export class PackValidatorV2 {
             });
         }
         // Check for UI gate with ui auth but no auth profile
-        const uiGates = Object.entries(pack.gates).filter(([_, g]) => g.adapter?.includes('ui'));
+        const uiGates = Object.entries(pack.gates).filter(([_, g]) => typeof g.adapter === 'string' && g.adapter.includes('ui'));
         if (uiGates.length > 0 && !pack.auth?.ui && !pack.auth?.profiles) {
             warnings.push({
                 code: 'QP2V035',

package/{cli/dist → dist}/core/pom/base-page.js

@@ -335,7 +335,7 @@ export class PuppeteerBasePage extends BasePage {
     async waitFor(selectorName, options) {
         const selector = this.getSelector(selectorName);
         await this.page.waitForSelector(selector, {
-            timeout: options?.timeout || 5000,
+            timeout: options?.timeout || 10000,
         });
     }
     /**

package/{cli/dist → dist}/core/pom/loader.js

@@ -32,7 +32,7 @@ export class PageObjectLoader {
         this.cwd = options.cwd || process.cwd();
         this.baseUrl = options.baseUrl || '';
         this.cacheEnabled = options.cache !== false;
-        this.timeout = options.timeout || 5000;
+        this.timeout = options.timeout || 10000;
     }
     /**
      * Get page by name

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

@@ -0,0 +1,9 @@
+/**
+ * QA360 Reporting Module
+ *
+ * P0 Features: Generates test reports in various formats (HTML, JSON, JUnit)
+ * - HTML: Interactive reports with embedded screenshots/videos
+ * - JUnit XML: CI/CD integration (Jenkins, GitLab CI, GitHub Actions, etc.)
+ */
+export { HTMLReporter, generateHTMLReport, type ReportData, type TestReport, type StepReport, type ReportScreenshotArtifact as ScreenshotArtifact, type ReportVideoArtifact as VideoArtifact, type ReportTraceArtifact as TraceArtifact, } from './html-reporter.js';
+export { JUnitReporter, generateJUnitReport, generateJUnitReportToFile, type JUnitTestCase, type JUnitTestSuite, type JUnitOptions, } from './junit-reporter.js';

package/dist/core/reporting/index.js

@@ -0,0 +1,10 @@
+/**
+ * QA360 Reporting Module
+ *
+ * P0 Features: Generates test reports in various formats (HTML, JSON, JUnit)
+ * - HTML: Interactive reports with embedded screenshots/videos
+ * - JUnit XML: CI/CD integration (Jenkins, GitLab CI, GitHub Actions, etc.)
+ */
+export { HTMLReporter, generateHTMLReport, } from './html-reporter.js';
+// P0: JUnit XML Reporter for CI/CD integration
+export { JUnitReporter, generateJUnitReport, generateJUnitReportToFile, } from './junit-reporter.js';