@testsmith/perfornium 0.6.4 → 0.6.6

package/dist/cli/cli.js

@@ -10,6 +10,7 @@ const init_1 = require("./commands/init");
 const mock_1 = require("./commands/mock");
 const dashboard_1 = require("./commands/dashboard");
 const native_recorder_1 = require("../recorder/native-recorder");
+const continue_recorder_1 = require("../recorder/continue-recorder");
 const distributed_1 = require("./commands/distributed");
 // Add new import commands
 const import_1 = require("./commands/import");
@@ -77,13 +78,27 @@ program
 program
     .command('record')
     .description('Record web interactions for test creation (Ctrl+W to add wait points)')
-    .argument('<url>', 'Starting URL for recording')
+    .argument('[url]', 'Starting URL for recording (required unless using --continue)')
+    .option('-c, --continue <file>', 'Continue recording from last step of existing scenario file')
     .option('-o, --output <file>', 'Output file for recorded scenario')
     .option('--viewport <viewport>', 'Browser viewport size (e.g., 1920x1080)')
     .option('--base-url <url>', 'Base URL to relativize recorded URLs')
     .option('-b, --browser <browser>', 'Browser to use: chromium, chrome, msedge, firefox, webkit', 'chromium')
     .option('-f, --format <format>', 'Output format: yaml, json, or typescript', 'yaml')
     .action(async (url, options) => {
+    // Handle --continue mode
+    if (options.continue) {
+        await (0, continue_recorder_1.startContinueRecording)(options.continue, {
+            format: options.format,
+            browser: options.browser
+        });
+        return;
+    }
+    // Normal recording mode requires URL
+    if (!url) {
+        console.error('Error: URL is required for recording. Use --continue <file> to continue from an existing scenario.');
+        process.exit(1);
+    }
     // Auto-determine file extension if output not specified
     // Save to tests/web directory by default
     if (!options.output) {

package/dist/cli/commands/distributed.js

@@ -105,8 +105,8 @@ async function distributedCommand(configPath, options) {
         // Generate report if requested
         if (options.report || testConfig.report?.generate) {
             try {
-                const { EnhancedHTMLReportGenerator } = await Promise.resolve().then(() => __importStar(require('../../reporting/enhanced-html-generator')));
-                const generator = new EnhancedHTMLReportGenerator();
+                const { HTMLReportGenerator } = await Promise.resolve().then(() => __importStar(require('../../reporting/html-generator')));
+                const generator = new HTMLReportGenerator();
                 const timestamp = timestamp_helper_1.TimestampHelper.getTimestamp('file');
                 const reportFilename = `distributed-report-${timestamp}.html`;
                 // Always use timestamped filename for distributed reports in reports folder

package/dist/cli/commands/report.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.reportCommand = reportCommand;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const enhanced_html_generator_1 = require("../../reporting/enhanced-html-generator");
+const html_generator_1 = require("../../reporting/html-generator");
 const logger_1 = require("../../utils/logger");
 async function reportCommand(resultsPath, options) {
     try {
@@ -54,7 +54,7 @@ async function reportCommand(resultsPath, options) {
             logger_1.logger.error('❌ Only JSON results files are currently supported');
             process.exit(1);
         }
-        const generator = new enhanced_html_generator_1.EnhancedHTMLReportGenerator();
+        const generator = new html_generator_1.HTMLReportGenerator();
         const outputPath = options.output || 'report.html';
         await generator.generate({
             testName: options.title || resultsData.testName || 'Performance Test',

package/dist/cli/commands/run.js

@@ -305,6 +305,8 @@ async function runCommand(configPath, options) {
                 process.exit(0);
             });
             await runner.run();
+            // Force exit to ensure process terminates (timers may still be active)
+            process.exit(0);
         }
     }
     catch (error) {

package/dist/config/parser.js

@@ -39,7 +39,7 @@ const YAML = __importStar(require("yaml"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const template_1 = require("../utils/template");
-const core_1 = require("../core");
+const data_1 = require("../core/data");
 const logger_1 = require("../utils/logger");
 class ConfigParser {
     constructor() {
@@ -263,7 +263,7 @@ class ConfigParser {
         const configStr = JSON.stringify(config);
         const hasTemplates = configStr.includes('{{template:') || configStr.includes('{{csv:');
         if (hasCSVScenarios || hasTemplates) {
-            core_1.CSVDataProvider.setBaseDir(baseDir);
+            data_1.DataProvider.setBaseDir(baseDir);
             template_1.TemplateProcessor.setBaseDir(baseDir);
             logger_1.logger.debug(`Set base directory for CSV/templates: ${baseDir}`);
         }

package/dist/config/types/global-config.d.ts

@@ -12,6 +12,24 @@ export interface GlobalConfig {
     csv_data?: GlobalCSVConfig;
     /** CSV data access mode: next (round-robin), unique (exhaustible), random */
     csv_mode?: 'next' | 'unique' | 'random';
+    /** InfluxDB configuration for storing test metrics (optional) */
+    influxdb?: InfluxDBConfig;
+}
+export interface InfluxDBConfig {
+    /** Enable InfluxDB storage for test metrics */
+    enabled: boolean;
+    /** InfluxDB server URL (default: http://localhost:8086 or INFLUXDB_URL env var) */
+    url?: string;
+    /** InfluxDB authentication token (default: INFLUXDB_TOKEN env var) */
+    token?: string;
+    /** InfluxDB organization (default: 'perfornium' or INFLUXDB_ORG env var) */
+    org?: string;
+    /** InfluxDB bucket name (default: 'metrics' or INFLUXDB_BUCKET env var) */
+    bucket?: string;
+    /** Write batch size (default: 100) */
+    batch_size?: number;
+    /** Flush interval in ms (default: 1000) */
+    flush_interval?: number;
 }
 export interface GlobalCSVConfig {
     /** Path to the CSV file */
@@ -28,12 +46,52 @@ export interface GlobalCSVConfig {
     columns?: string[];
     /** Filter expression (e.g., "status=active") */
     filter?: string;
-    /** Shuffle data randomly */
+    /** Shuffle data randomly (alias for distribution.order = 'random') */
     randomize?: boolean;
-    /** Restart from beginning when data is exhausted (default: true) */
+    /** Restart from beginning when data is exhausted (default: true) - legacy, use distribution.on_exhausted */
     cycleOnExhaustion?: boolean;
     /** Map CSV column names to custom variable names: { "csv_column": "variable_name" } */
     variables?: Record<string, string>;
+    /**
+     * Value Change Policy - determines when a new value is fetched
+     * - each_use: New value for every request/step (default for unique scope)
+     * - each_iteration: New value at the start of each iteration (default for global/local scope)
+     * - each_vu: Same value for all iterations of a VU (sticky per VU)
+     */
+    change_policy?: 'each_use' | 'each_iteration' | 'each_vu';
+    /**
+     * Value Distribution Policy - comprehensive control over data distribution
+     */
+    distribution?: DataDistributionPolicy;
+}
+/**
+ * Value Distribution Policy
+ * Controls how data values are distributed across virtual users
+ */
+export interface DataDistributionPolicy {
+    /**
+     * Scope - determines value sharing between VUs
+     * - local: Each VU has its own copy of the data (values can repeat across VUs)
+     * - global: Values are shared across all VUs (round-robin distribution)
+     * - unique: Global scope with exclusive locking - a value can only be used by one VU at a time,
+     *           returned to the pool when the VU's iteration/use completes
+     */
+    scope?: 'local' | 'global' | 'unique';
+    /**
+     * Order - how values are selected from the data
+     * - sequential: Values are taken in the order they appear in the file
+     * - random: Values are taken in random order
+     * - any: Best-effort sequential (more efficient, may vary under high concurrency)
+     */
+    order?: 'sequential' | 'random' | 'any';
+    /**
+     * On Exhausted - what happens when all values have been used
+     * - cycle: Start over from the beginning (default)
+     * - stop_vu: Stop the current VU (it won't get more data)
+     * - stop_test: Stop the entire test
+     * - no_value: Return undefined/empty for subsequent requests
+     */
+    on_exhausted?: 'cycle' | 'stop_vu' | 'stop_test' | 'no_value';
 }
 export interface FakerConfig {
     locale?: string;
@@ -52,6 +110,28 @@ export interface BrowserConfig {
     clear_storage?: boolean | ClearStorageConfig;
     /** Capture screenshot on test failure */
     screenshot_on_failure?: boolean | ScreenshotConfig;
+    /** Capture HTTP network calls during web tests */
+    network_capture?: NetworkCaptureConfig;
+}
+export interface NetworkCaptureConfig {
+    /** Enable network call capturing */
+    enabled: boolean;
+    /** Glob patterns for URLs to capture - if empty, captures all */
+    include_patterns?: string[];
+    /** Glob patterns for URLs to exclude */
+    exclude_patterns?: string[];
+    /** Capture request body (default: false) */
+    capture_request_body?: boolean;
+    /** Capture response body (default: false) */
+    capture_response_body?: boolean;
+    /** Maximum body size to capture in bytes (default: 10240 = 10KB) */
+    max_body_size?: number;
+    /** Only capture bodies with these content types */
+    content_type_filters?: string[];
+    /** Store network calls in TestResult.custom_metrics (default: true) */
+    store_inline?: boolean;
+    /** Emit NETWORK events for dashboard live updates (default: true) */
+    store_separate?: boolean;
 }
 export interface ScreenshotConfig {
     enabled: boolean;

package/dist/config/types/scenario-config.d.ts

@@ -1,6 +1,6 @@
-import { CSVDataConfig } from '../../core/csv-data-provider';
 import { Step } from './step-types';
 import { ScenarioHooks, LoopHooks } from './hooks';
+import { GlobalCSVConfig } from './global-config';
 export interface Scenario {
     name: string;
     description?: string;
@@ -11,7 +11,7 @@ export interface Scenario {
     teardown?: string;
     variables?: Record<string, any>;
     steps: Step[];
-    csv_data?: CSVDataConfig;
+    csv_data?: GlobalCSVConfig;
     csv_mode?: 'next' | 'unique' | 'random';
     condition?: string;
     enabled?: boolean;

package/dist/config/types/step-types.d.ts

@@ -97,7 +97,7 @@ export interface RendezvousStep extends BaseStep {
 export interface WebAction {
     name?: string;
     expected_text?: string;
-    command: 'goto' | 'click' | 'fill' | 'press' | 'select' | 'hover' | 'screenshot' | 'wait_for_selector' | 'wait_for_text' | 'verify_text' | 'verify_contains' | 'verify_not_exists' | 'verify_exists' | 'verify_visible' | 'evaluate' | 'measure_web_vitals' | 'measure_verification' | 'performance_audit' | 'accessibility_audit' | 'wait_for_load_state' | 'network_idle' | 'dom_ready';
+    command: 'goto' | 'click' | 'fill' | 'press' | 'select' | 'hover' | 'screenshot' | 'wait_for_selector' | 'wait_for_text' | 'verify_text' | 'verify_contains' | 'verify_not_exists' | 'verify_exists' | 'verify_visible' | 'verify_value' | 'evaluate' | 'measure_web_vitals' | 'measure_verification' | 'performance_audit' | 'accessibility_audit' | 'wait_for_load_state' | 'network_idle' | 'dom_ready';
     selector?: string;
     url?: string;
     value?: string | string[];

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

@@ -0,0 +1,70 @@
+import { Scenario } from '../../config/types/hooks';
+import { GlobalCSVConfig } from '../../config/types/global-config';
+import { DataRow } from './data-provider';
+export interface DataOptions {
+    config: GlobalCSVConfig;
+    /** Legacy mode option - maps to distribution.order */
+    mode?: 'next' | 'unique' | 'random';
+}
+export interface DataContext {
+    csv_data?: DataRow;
+    global_csv_data?: DataRow;
+    variables: Record<string, any>;
+}
+/**
+ * Data Manager for VU data lifecycle:
+ * - Manages global and scenario-specific data providers
+ * - Handles iteration start/end for checkout/checkin
+ * - Supports change policies (each_use, each_iteration, each_vu)
+ * - Supports distribution scopes (local, global, unique)
+ * - Supports exhaustion policies (cycle, stop_vu, stop_test, no_value)
+ */
+export declare class DataManager {
+    private vuId;
+    private currentIteration;
+    private globalProvider?;
+    private scenarioProviders;
+    private shouldStopVU;
+    private shouldStopTest;
+    constructor(vuId: number, globalData?: DataOptions);
+    /**
+     * Map legacy mode to new distribution config
+     */
+    private mapLegacyMode;
+    /**
+     * Initialize providers for scenarios
+     */
+    initializeForScenarios(scenarios: Scenario[]): Promise<void>;
+    /**
+     * Called at the start of each iteration
+     */
+    startIteration(iteration: number): void;
+    /**
+     * Called at the end of each iteration - releases any checked-out rows
+     */
+    endIteration(iteration: number): void;
+    /**
+     * Load global CSV data into context
+     */
+    loadGlobalData(context: DataContext): Promise<boolean>;
+    /**
+     * Load scenario-specific CSV data into context
+     */
+    loadScenarioData(scenario: Scenario, context: DataContext): Promise<boolean>;
+    /**
+     * Handle exhaustion result and set stop flags
+     */
+    private handleExhaustionResult;
+    /**
+     * Check if VU should stop due to data exhaustion
+     */
+    shouldStop(): boolean;
+    /**
+     * Check if test should stop
+     */
+    shouldStopEntireTest(): boolean;
+    /**
+     * Get status for debugging
+     */
+    getStatus(): Record<string, any>;
+}

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

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataManager = void 0;
+const data_provider_1 = require("./data-provider");
+const logger_1 = require("../../utils/logger");
+/**
+ * Data Manager for VU data lifecycle:
+ * - Manages global and scenario-specific data providers
+ * - Handles iteration start/end for checkout/checkin
+ * - Supports change policies (each_use, each_iteration, each_vu)
+ * - Supports distribution scopes (local, global, unique)
+ * - Supports exhaustion policies (cycle, stop_vu, stop_test, no_value)
+ */
+class DataManager {
+    constructor(vuId, globalData) {
+        this.currentIteration = 0;
+        this.scenarioProviders = new Map();
+        this.shouldStopVU = false;
+        this.shouldStopTest = false;
+        this.vuId = vuId;
+        if (globalData?.config) {
+            // Apply legacy mode mapping if no distribution is set
+            const config = { ...globalData.config };
+            if (globalData.mode && !config.distribution) {
+                config.distribution = this.mapLegacyMode(globalData.mode);
+                logger_1.logger.debug(`VU${vuId}: Mapped legacy mode '${globalData.mode}' to distribution`);
+            }
+            this.globalProvider = data_provider_1.DataProvider.getInstance(config);
+            logger_1.logger.debug(`VU${vuId}: Global data provider configured`);
+        }
+    }
+    /**
+     * Map legacy mode to new distribution config
+     */
+    mapLegacyMode(mode) {
+        switch (mode) {
+            case 'unique':
+                return { scope: 'unique', order: 'sequential', on_exhausted: 'stop_vu' };
+            case 'random':
+                return { scope: 'global', order: 'random', on_exhausted: 'cycle' };
+            case 'next':
+            default:
+                return { scope: 'global', order: 'sequential', on_exhausted: 'cycle' };
+        }
+    }
+    /**
+     * Initialize providers for scenarios
+     */
+    async initializeForScenarios(scenarios) {
+        const csvScenarios = scenarios.filter(s => s.csv_data);
+        for (const scenario of csvScenarios) {
+            const csvConfig = scenario.csv_data;
+            if (csvConfig) {
+                try {
+                    const provider = data_provider_1.DataProvider.getInstance(csvConfig);
+                    await provider.loadData();
+                    this.scenarioProviders.set(scenario.name, provider);
+                    logger_1.logger.debug(`VU${this.vuId}: Initialized data provider for scenario "${scenario.name}"`);
+                }
+                catch (error) {
+                    logger_1.logger.warn(`VU${this.vuId}: Failed to initialize data for scenario "${scenario.name}":`, error);
+                }
+            }
+        }
+    }
+    /**
+     * Called at the start of each iteration
+     */
+    startIteration(iteration) {
+        this.currentIteration = iteration;
+    }
+    /**
+     * Called at the end of each iteration - releases any checked-out rows
+     */
+    endIteration(iteration) {
+        if (this.globalProvider) {
+            this.globalProvider.releaseRow(this.vuId, iteration);
+        }
+        for (const provider of this.scenarioProviders.values()) {
+            provider.releaseRow(this.vuId, iteration);
+        }
+    }
+    /**
+     * Load global CSV data into context
+     */
+    async loadGlobalData(context) {
+        if (!this.globalProvider) {
+            return true;
+        }
+        if (this.shouldStopVU || this.shouldStopTest) {
+            return false;
+        }
+        try {
+            const result = await this.globalProvider.getRow(this.vuId, this.currentIteration);
+            if (result.row) {
+                context.global_csv_data = result.row;
+                for (const [key, value] of Object.entries(result.row)) {
+                    context.variables[key] = value;
+                    logger_1.logger.debug(`VU${this.vuId}: Set global data variable: ${key} = ${value}`);
+                }
+                return true;
+            }
+            return this.handleExhaustionResult(result);
+        }
+        catch (error) {
+            logger_1.logger.warn(`VU${this.vuId}: Failed to load global data:`, error);
+            return true;
+        }
+    }
+    /**
+     * Load scenario-specific CSV data into context
+     */
+    async loadScenarioData(scenario, context) {
+        const provider = this.scenarioProviders.get(scenario.name);
+        if (!provider) {
+            return true;
+        }
+        if (this.shouldStopVU || this.shouldStopTest) {
+            return false;
+        }
+        try {
+            const result = await provider.getRow(this.vuId, this.currentIteration);
+            if (result.row) {
+                context.csv_data = result.row;
+                for (const [key, value] of Object.entries(result.row)) {
+                    if (!(key in context.variables)) {
+                        context.variables[key] = value;
+                        logger_1.logger.debug(`VU${this.vuId}: Set scenario data variable: ${key} = ${value}`);
+                    }
+                }
+                return true;
+            }
+            return this.handleExhaustionResult(result);
+        }
+        catch (error) {
+            logger_1.logger.warn(`VU${this.vuId}: Failed to load scenario data:`, error);
+            return true;
+        }
+    }
+    /**
+     * Handle exhaustion result and set stop flags
+     */
+    handleExhaustionResult(result) {
+        if (result.action === 'stop_test') {
+            this.shouldStopTest = true;
+            throw new Error('CSV_DATA_EXHAUSTED_STOP_TEST');
+        }
+        if (result.action === 'stop_vu') {
+            this.shouldStopVU = true;
+            return false;
+        }
+        // no_value: continue but with null data
+        return true;
+    }
+    /**
+     * Check if VU should stop due to data exhaustion
+     */
+    shouldStop() {
+        return this.shouldStopVU || this.shouldStopTest;
+    }
+    /**
+     * Check if test should stop
+     */
+    shouldStopEntireTest() {
+        return this.shouldStopTest;
+    }
+    /**
+     * Get status for debugging
+     */
+    getStatus() {
+        const status = {
+            vuId: this.vuId,
+            iteration: this.currentIteration,
+            shouldStopVU: this.shouldStopVU,
+            shouldStopTest: this.shouldStopTest
+        };
+        if (this.globalProvider) {
+            status.globalProvider = this.globalProvider.getStatus();
+        }
+        for (const [name, provider] of this.scenarioProviders) {
+            status[`scenario_${name}`] = provider.getStatus();
+        }
+        return status;
+    }
+}
+exports.DataManager = DataManager;

package/dist/core/data/data-provider.d.ts

@@ -0,0 +1,85 @@
+import { GlobalCSVConfig } from '../../config/types/global-config';
+export interface DataRow {
+    [key: string]: string | number | boolean;
+}
+export interface CheckedOutRow {
+    row: DataRow;
+    vuId: number;
+    iteration: number;
+    checkoutTime: number;
+}
+/**
+ * Result from getting a data row
+ */
+export interface DataResult {
+    row: DataRow | null;
+    exhausted: boolean;
+    action?: 'stop_vu' | 'stop_test' | 'no_value';
+}
+/**
+ * Data Provider with full support for:
+ * - Simple API: getNextRow, getUniqueRow, getRandomRow (for templates)
+ * - Advanced API: getRow with distribution/change policies (for VUs)
+ * - Value Change Policy (each_use, each_iteration, each_vu)
+ * - Value Distribution (scope: local/global/unique, order: sequential/random/any)
+ * - Exhaustion Policy (cycle, stop_vu, stop_test, no_value)
+ */
+export declare class DataProvider {
+    private static instances;
+    private config;
+    private filePath;
+    private data;
+    private originalData;
+    private isLoaded;
+    private globalIndex;
+    private checkedOutRows;
+    private availableIndices;
+    private vuCache;
+    private iterationCache;
+    private isExhausted;
+    private exhaustedVUs;
+    private accessCount;
+    private constructor();
+    static getInstance(config: GlobalCSVConfig): DataProvider;
+    static setBaseDir(dir: string): void;
+    static clearInstances(): void;
+    /**
+     * Get next row in sequence (cycles by default)
+     */
+    getNextRow(vuId: number): Promise<DataRow | null>;
+    /**
+     * Get unique row (each row used once, then cycles or exhausts)
+     */
+    getUniqueRow(vuId: number): Promise<DataRow | null>;
+    /**
+     * Get random row
+     */
+    getRandomRow(vuId?: number): Promise<DataRow | null>;
+    /**
+     * Get a data row for a VU with full policy support
+     */
+    getRow(vuId: number, iteration?: number): Promise<DataResult>;
+    /**
+     * Release a checked-out row back to the pool (for unique scope)
+     */
+    releaseRow(vuId: number, iteration: number): void;
+    private getDistribution;
+    private getChangePolicy;
+    loadData(): Promise<void>;
+    private getNewRow;
+    private getLocalRow;
+    private getGlobalRow;
+    private getUniqueRowAdvanced;
+    private handleExhaustion;
+    private filterData;
+    /**
+     * Get current status for debugging
+     */
+    getStatus(): {
+        totalRows: number;
+        availableRows: number;
+        checkedOutRows: number;
+        exhausted: boolean;
+        exhaustedVUs: number[];
+    };
+}