@testsmith/perfornium 0.6.3 → 0.6.5

package/dist/protocols/web/browser/storage.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageManager = void 0;
+const logger_1 = require("../../../utils/logger");
+class StorageManager {
+    async clearStorageIfConfigured(page, context, clearConfig) {
+        if (!clearConfig)
+            return;
+        const config = typeof clearConfig === 'boolean'
+            ? { local_storage: true, session_storage: true, cookies: true, cache: false }
+            : clearConfig;
+        try {
+            await page.goto('about:blank');
+            if (config.cookies !== false) {
+                await context.clearCookies();
+                logger_1.logger.debug('Cleared cookies');
+            }
+            if (config.local_storage !== false || config.session_storage !== false) {
+                await page.evaluate((opts) => {
+                    if (opts.local_storage !== false) {
+                        try {
+                            localStorage.clear();
+                        }
+                        catch (e) { /* ignore */ }
+                    }
+                    if (opts.session_storage !== false) {
+                        try {
+                            sessionStorage.clear();
+                        }
+                        catch (e) { /* ignore */ }
+                    }
+                }, { local_storage: config.local_storage, session_storage: config.session_storage });
+                if (config.local_storage !== false)
+                    logger_1.logger.debug('Cleared localStorage');
+                if (config.session_storage !== false)
+                    logger_1.logger.debug('Cleared sessionStorage');
+            }
+            logger_1.logger.debug('Browser storage cleared');
+        }
+        catch (error) {
+            logger_1.logger.warn('Failed to clear storage:', error);
+        }
+    }
+}
+exports.StorageManager = StorageManager;

package/dist/protocols/web/commands/index.d.ts

@@ -0,0 +1,5 @@
+export { NavigationCommands } from './navigation';
+export { InteractionCommands } from './interaction';
+export { VerificationCommands } from './verification';
+export { MeasurementCommands } from './measurement';
+export { CommandResult, CommandHandler, HighlightFunction } from './types';

package/dist/protocols/web/commands/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeasurementCommands = exports.VerificationCommands = exports.InteractionCommands = exports.NavigationCommands = void 0;
+var navigation_1 = require("./navigation");
+Object.defineProperty(exports, "NavigationCommands", { enumerable: true, get: function () { return navigation_1.NavigationCommands; } });
+var interaction_1 = require("./interaction");
+Object.defineProperty(exports, "InteractionCommands", { enumerable: true, get: function () { return interaction_1.InteractionCommands; } });
+var verification_1 = require("./verification");
+Object.defineProperty(exports, "VerificationCommands", { enumerable: true, get: function () { return verification_1.VerificationCommands; } });
+var measurement_1 = require("./measurement");
+Object.defineProperty(exports, "MeasurementCommands", { enumerable: true, get: function () { return measurement_1.MeasurementCommands; } });

package/dist/protocols/web/commands/interaction.d.ts

@@ -0,0 +1,13 @@
+import { Page } from 'playwright';
+import { WebAction } from '../../../config';
+import { CommandResult, HighlightFunction } from './types';
+export declare class InteractionCommands {
+    private highlightElement;
+    constructor(highlightElement: HighlightFunction);
+    handleClick(page: Page, action: WebAction): Promise<CommandResult>;
+    handleFill(page: Page, action: WebAction): Promise<CommandResult>;
+    handleSelect(page: Page, action: WebAction): Promise<CommandResult>;
+    handlePress(page: Page, action: WebAction): Promise<CommandResult>;
+    handleHover(page: Page, action: WebAction): Promise<CommandResult>;
+    handleEvaluate(page: Page, action: WebAction): Promise<CommandResult>;
+}

package/dist/protocols/web/commands/interaction.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionCommands = void 0;
+class InteractionCommands {
+    constructor(highlightElement) {
+        this.highlightElement = highlightElement;
+    }
+    async handleClick(page, action) {
+        const timeout = action.timeout || 30000;
+        const selector = action.selector;
+        await page.waitForSelector(selector, {
+            state: 'visible',
+            timeout
+        });
+        await this.highlightElement(page, selector);
+        await page.locator(selector).click({ timeout });
+        return { clicked: selector };
+    }
+    async handleFill(page, action) {
+        const timeout = action.timeout || 30000;
+        await page.waitForSelector(action.selector, {
+            state: 'visible',
+            timeout
+        });
+        await this.highlightElement(page, action.selector);
+        await page.locator(action.selector).fill(action.value, { timeout });
+        return { filled: action.selector, value: action.value };
+    }
+    async handleSelect(page, action) {
+        const timeout = action.timeout || 30000;
+        await page.waitForSelector(action.selector, {
+            state: 'visible',
+            timeout
+        });
+        await this.highlightElement(page, action.selector);
+        await page.locator(action.selector).selectOption(action.value, { timeout });
+        return { selected: action.selector, value: action.value };
+    }
+    async handlePress(page, action) {
+        const timeout = action.timeout || 30000;
+        const key = action.key;
+        if (action.selector) {
+            await page.waitForSelector(action.selector, {
+                state: 'visible',
+                timeout
+            });
+            await this.highlightElement(page, action.selector);
+            await page.locator(action.selector).press(key, { timeout });
+            return { pressed: key, selector: action.selector };
+        }
+        else {
+            await page.keyboard.press(key);
+            return { pressed: key };
+        }
+    }
+    async handleHover(page, action) {
+        await page.hover(action.selector);
+        return { hovered: action.selector };
+    }
+    async handleEvaluate(page, action) {
+        if (action.script) {
+            const result = await page.evaluate(action.script);
+            return { evaluation_result: result };
+        }
+        throw new Error('No script provided for evaluate command');
+    }
+}
+exports.InteractionCommands = InteractionCommands;

package/dist/protocols/web/commands/measurement.d.ts

@@ -0,0 +1,16 @@
+import { Page } from 'playwright';
+import { WebAction } from '../../../config';
+import { CommandResult } from './types';
+import { CoreWebVitals, VerificationStepMetrics } from '../core-web-vitals';
+export declare class MeasurementCommands {
+    handleMeasureWebVitals(page: Page, action: WebAction): Promise<CommandResult & {
+        web_vitals: CoreWebVitals;
+    }>;
+    handlePerformanceAudit(page: Page, action: WebAction, verificationMetrics?: VerificationStepMetrics): Promise<CommandResult>;
+    handleScreenshot(page: Page, action: WebAction): Promise<CommandResult>;
+    collectWebVitalsIfNeeded(page: Page, action: WebAction, shouldCollect: boolean): Promise<CoreWebVitals | undefined>;
+    evaluateVitals(webVitals: CoreWebVitals, thresholds?: any): {
+        score: 'good' | 'needs-improvement' | 'poor';
+        details: any;
+    };
+}

package/dist/protocols/web/commands/measurement.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeasurementCommands = void 0;
+const core_web_vitals_1 = require("../core-web-vitals");
+class MeasurementCommands {
+    async handleMeasureWebVitals(page, action) {
+        const webVitals = await core_web_vitals_1.CoreWebVitalsCollector.collectVitals(page, action.webVitalsWaitTime || 3000);
+        return { web_vitals: webVitals };
+    }
+    async handlePerformanceAudit(page, action, verificationMetrics) {
+        const performanceMetrics = await core_web_vitals_1.WebPerformanceCollector.collectAllMetrics(page, verificationMetrics);
+        return { performance_audit: performanceMetrics };
+    }
+    async handleScreenshot(page, action) {
+        const screenshot = await page.screenshot({
+            type: 'png',
+            fullPage: action.options?.fullPage || false
+        });
+        return {
+            screenshot: screenshot.length,
+            screenshot_data: action.options?.includeData ? screenshot.toString('base64') : undefined
+        };
+    }
+    async collectWebVitalsIfNeeded(page, action, shouldCollect) {
+        if (!shouldCollect)
+            return undefined;
+        return core_web_vitals_1.CoreWebVitalsCollector.collectVitals(page, action.webVitalsWaitTime || 1000);
+    }
+    evaluateVitals(webVitals, thresholds) {
+        return core_web_vitals_1.CoreWebVitalsCollector.evaluateVitals(webVitals, thresholds);
+    }
+}
+exports.MeasurementCommands = MeasurementCommands;

package/dist/protocols/web/commands/navigation.d.ts

@@ -0,0 +1,11 @@
+import { Page } from 'playwright';
+import { WebAction, BrowserConfig } from '../../../config';
+import { CommandResult } from './types';
+export declare class NavigationCommands {
+    private config;
+    constructor(config: BrowserConfig);
+    handleGoto(page: Page, action: WebAction): Promise<CommandResult>;
+    handleWaitForLoadState(page: Page, action: WebAction): Promise<CommandResult>;
+    handleNetworkIdle(page: Page, action: WebAction): Promise<CommandResult>;
+    handleDomReady(page: Page, action: WebAction): Promise<CommandResult>;
+}

package/dist/protocols/web/commands/navigation.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NavigationCommands = void 0;
+class NavigationCommands {
+    constructor(config) {
+        this.config = config;
+    }
+    async handleGoto(page, action) {
+        const fullUrl = action.url?.startsWith('http')
+            ? action.url
+            : `${this.config.base_url}${action.url || ''}`;
+        const response = await page.goto(fullUrl, {
+            timeout: action.timeout || 30000,
+            waitUntil: action.waitUntil || 'domcontentloaded'
+        });
+        return {
+            url: page.url(),
+            status: response?.status(),
+            headers: await response?.allHeaders(),
+            loading_time: Date.now() - performance.now()
+        };
+    }
+    async handleWaitForLoadState(page, action) {
+        const waitUntil = action.waitUntil === 'commit' ? 'load' : (action.waitUntil || 'load');
+        await page.waitForLoadState(waitUntil, {
+            timeout: action.timeout || 30000
+        });
+        return { load_state: waitUntil };
+    }
+    async handleNetworkIdle(page, action) {
+        await page.waitForLoadState('networkidle', {
+            timeout: action.networkIdleTimeout || 30000
+        });
+        return { network_idle: true };
+    }
+    async handleDomReady(page, action) {
+        await page.waitForLoadState('domcontentloaded', {
+            timeout: action.timeout || 30000
+        });
+        return { dom_ready: true };
+    }
+}
+exports.NavigationCommands = NavigationCommands;

package/dist/protocols/web/commands/types.d.ts

@@ -0,0 +1,12 @@
+import { Page } from 'playwright';
+import { WebAction } from '../../../config';
+export interface CommandResult {
+    [key: string]: any;
+    action_time?: number;
+}
+export interface CommandHandler {
+    execute(page: Page, action: WebAction): Promise<CommandResult>;
+}
+export interface HighlightFunction {
+    (page: Page, selector: string): Promise<void>;
+}

package/dist/protocols/web/commands/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/protocols/web/commands/verification.d.ts

@@ -0,0 +1,11 @@
+import { Page } from 'playwright';
+import { WebAction } from '../../../config';
+import { CommandResult } from './types';
+export declare class VerificationCommands {
+    handleWaitForSelector(page: Page, action: WebAction): Promise<CommandResult>;
+    handleVerifyExists(page: Page, action: WebAction): Promise<CommandResult>;
+    handleVerifyVisible(page: Page, action: WebAction): Promise<CommandResult>;
+    handleVerifyText(page: Page, action: WebAction): Promise<CommandResult>;
+    handleVerifyContains(page: Page, action: WebAction): Promise<CommandResult>;
+    handleVerifyNotExists(page: Page, action: WebAction): Promise<CommandResult>;
+}

package/dist/protocols/web/commands/verification.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationCommands = void 0;
+class VerificationCommands {
+    async handleWaitForSelector(page, action) {
+        await page.waitForSelector(action.selector, {
+            timeout: action.timeout || 30000
+        });
+        return { waited_for: action.selector };
+    }
+    async handleVerifyExists(page, action) {
+        await page.waitForSelector(action.selector, {
+            state: 'attached',
+            timeout: action.timeout || 30000
+        });
+        const elementCount = await page.locator(action.selector).count();
+        return {
+            verified: 'exists',
+            selector: action.selector,
+            name: action.name,
+            found_elements: elementCount,
+            element_count: elementCount
+        };
+    }
+    async handleVerifyVisible(page, action) {
+        await page.waitForSelector(action.selector, {
+            state: 'visible',
+            timeout: action.timeout || 30000
+        });
+        return {
+            verified: 'visible',
+            selector: action.selector,
+            name: action.name,
+            is_visible: true
+        };
+    }
+    async handleVerifyText(page, action) {
+        await page.waitForSelector(action.selector, {
+            state: 'attached',
+            timeout: action.timeout || 30000
+        });
+        const textLocator = page.locator(action.selector);
+        const actualText = await textLocator.textContent();
+        const expectedText = action.expected_text;
+        if (!actualText || !actualText.includes(expectedText)) {
+            throw new Error(`Verification failed: Element "${action.selector}" text "${actualText}" does not contain expected text "${expectedText}"${action.name ? ` (${action.name})` : ''}`);
+        }
+        return {
+            verified: 'text',
+            selector: action.selector,
+            name: action.name,
+            expected_text: expectedText,
+            actual_text: actualText,
+            text_match: true
+        };
+    }
+    async handleVerifyContains(page, action) {
+        await page.waitForSelector(action.selector, {
+            state: 'attached',
+            timeout: action.timeout || 30000
+        });
+        const textLocator = page.locator(action.selector);
+        const actualText = await textLocator.textContent();
+        const expectedText = action.value;
+        if (!actualText || !actualText.includes(expectedText)) {
+            throw new Error(`Verification failed: Element "${action.selector}" text "${actualText}" does not contain "${expectedText}"${action.name ? ` (${action.name})` : ''}`);
+        }
+        return {
+            verified: 'contains',
+            selector: action.selector,
+            name: action.name,
+            expected_text: expectedText,
+            actual_text: actualText,
+            text_match: true
+        };
+    }
+    async handleVerifyNotExists(page, action) {
+        try {
+            await page.waitForSelector(action.selector, {
+                state: 'detached',
+                timeout: action.timeout || 5000
+            });
+        }
+        catch (error) {
+            const count = await page.locator(action.selector).count();
+            if (count > 0) {
+                throw new Error(`Verification failed: Element "${action.selector}" exists but should not exist${action.name ? ` (${action.name})` : ''}`);
+            }
+        }
+        return {
+            verified: 'not_exists',
+            selector: action.selector,
+            name: action.name,
+            found_elements: 0
+        };
+    }
+}
+exports.VerificationCommands = VerificationCommands;

package/dist/protocols/web/handler.d.ts

@@ -1,30 +1,31 @@
 import { ProtocolHandler, ProtocolResult } from '../base';
 import { VUContext, WebAction, BrowserConfig } from '../../config';
 import { VerificationStepMetrics } from './core-web-vitals';
+import { CapturedNetworkCall } from '../../metrics/types';
+import { NetworkCallCallback } from './network';
 export declare class WebHandler implements ProtocolHandler {
-    private browsers;
-    private contexts;
-    private pages;
-    private verificationMetrics;
     private config;
-    constructor(config: BrowserConfig);
+    private verificationMetrics;
+    private browserManager;
+    private networkManager;
+    private storageManager;
+    private highlighter;
+    private screenshotCapture;
+    private navigationCommands;
+    private interactionCommands;
+    private verificationCommands;
+    private measurementCommands;
+    constructor(config: BrowserConfig, onNetworkCall?: NetworkCallCallback);
     initialize(): Promise<void>;
     execute(action: WebAction, context: VUContext): Promise<ProtocolResult>;
-    private handleGoto;
-    private handleClick;
-    private handleFill;
-    private handleSelect;
-    private handlePress;
-    private handleWaitForSelector;
-    private handleVerifyExists;
-    private handleVerifyVisible;
-    private handleVerifyText;
-    private handleVerifyContains;
-    private handleVerifyNotExists;
-    private handleLegacyAction;
+    private executeWithTiming;
+    private executeInteractionWithMeasurement;
+    private executeVerificationWithMeasurement;
+    private executeVerification;
+    private handleExecutionError;
     private getPage;
-    private createBrowserForVU;
     getVerificationMetrics(vuId: number): VerificationStepMetrics[];
+    getNetworkCalls(vuId: number): CapturedNetworkCall[];
     getAggregatedVerificationMetrics(): {
         total_verifications: number;
         success_rate: number;
@@ -39,16 +40,4 @@ export declare class WebHandler implements ProtocolHandler {
         connected: boolean;
     } | null;
     getActiveVUCount(): number;
-    /**
-     * Clear browser storage (localStorage, sessionStorage, cookies) if configured
-     */
-    private clearStorageIfConfigured;
-    /**
-     * Highlight an element before interacting with it (for debugging)
-     */
-    private highlightElement;
-    /**
-     * Capture a screenshot when a test step fails
-     */
-    private captureFailureScreenshot;
 }