@testsmith/perfornium 0.6.4 → 0.6.6

package/dist/core/virtual-user.js

@@ -2,147 +2,55 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VirtualUser = void 0;
 const step_executor_1 = require("./step-executor");
-const csv_data_provider_1 = require("./csv-data-provider");
 const hooks_manager_1 = require("./hooks-manager");
-const time_1 = require("../utils/time");
 const logger_1 = require("../utils/logger");
+const data_1 = require("./data");
+const strategies_1 = require("./strategies");
 class VirtualUser {
     constructor(id, metrics, handlers, testName = 'Load Test', vuHooks, globalThinkTime, globalCSV) {
         this.isActive = true;
         this.scenarios = [];
-        this.csvProviders = new Map();
         logger_1.logger.debug(`VirtualUser ${id} created`);
         this.id = id;
         this.metrics = metrics;
         this.handlers = handlers;
         this.testName = testName;
-        this.globalThinkTime = globalThinkTime; // Store global think time
-        this.stepExecutor = new step_executor_1.StepExecutor(handlers, testName); // Pass testName to StepExecutor
+        this.stepExecutor = new step_executor_1.StepExecutor(handlers, testName);
         this.vuHooksManager = new hooks_manager_1.VUHooksManager(testName, id, vuHooks);
-        // Initialize global CSV if configured
-        if (globalCSV?.config) {
-            this.globalCSVMode = globalCSV.mode || 'next';
-            this.globalCSVProvider = csv_data_provider_1.CSVDataProvider.getInstance(globalCSV.config);
-            logger_1.logger.debug(`VU${id}: Global CSV configured (mode: ${this.globalCSVMode})`);
-        }
+        // Initialize managers and strategies
+        this.dataManager = new data_1.DataManager(id, globalCSV);
+        this.thinkTimeStrategy = new strategies_1.ThinkTimeStrategy(globalThinkTime);
+        this.scenarioSelector = new strategies_1.ScenarioSelector();
         this.context = {
             vu_id: id,
             iteration: 0,
             variables: {},
             extracted_data: {}
-            // csv_data and global_csv_data will be added only when needed
         };
     }
-    // FIXED: Now async to support CSV initialization
     async setScenarios(scenarios) {
         logger_1.logger.debug(`VU${this.id}: setScenarios called with ${scenarios.length} scenarios`);
         this.scenarios = scenarios;
-        // Debug: Let's see what the scenarios look like
         for (const scenario of scenarios) {
             logger_1.logger.debug(`VU${this.id}: Scenario "${scenario.name}" config: ${JSON.stringify(scenario, null, 2)}`);
         }
-        // Initialize CSV providers only if needed
-        await this.initializeCSVProvidersIfNeeded();
+        await this.dataManager.initializeForScenarios(scenarios);
         logger_1.logger.debug(`VU${this.id}: setScenarios completed`);
     }
-    /**
-     * Initialize CSV providers only for scenarios that need them
-     */
-    async initializeCSVProvidersIfNeeded() {
-        const csvScenarios = this.scenarios.filter(s => s.csv_data);
-        if (csvScenarios.length === 0) {
-            // No CSV scenarios - skip initialization entirely
-            logger_1.logger.debug(`VU${this.id}: No CSV scenarios found, skipping CSV initialization`);
-            return;
-        }
-        logger_1.logger.debug(`VU${this.id}: Found ${csvScenarios.length} scenarios with CSV data`);
-        for (const scenario of csvScenarios) {
-            const csvScenario = scenario; // Cast to access CSV properties
-            logger_1.logger.debug(`VU${this.id}: Processing CSV for scenario "${scenario.name}": ${JSON.stringify(csvScenario.csv_data)}`);
-            if (csvScenario.csv_data) {
-                try {
-                    const provider = csv_data_provider_1.CSVDataProvider.getInstance(csvScenario.csv_data);
-                    await provider.loadData();
-                    this.csvProviders.set(scenario.name, provider);
-                    logger_1.logger.debug(`VU${this.id}: Initialized CSV provider for scenario "${scenario.name}"`);
-                }
-                catch (error) {
-                    logger_1.logger.warn(`VU${this.id}: Failed to initialize CSV for scenario "${scenario.name}":`, error);
-                    // Don't fail the entire VU - just log the warning and continue
-                }
-            }
-        }
-        logger_1.logger.debug(`VU${this.id}: CSV initialization completed. Providers: ${this.csvProviders.size}`);
-    }
-    /**
-     * Load global CSV data and merge into context variables
-     * Called once at the start of each VU execution cycle
-     */
-    async loadGlobalCSVData() {
-        if (!this.globalCSVProvider) {
-            return;
-        }
-        try {
-            await this.globalCSVProvider.loadData();
-            let csvData = null;
-            switch (this.globalCSVMode) {
-                case 'unique':
-                    csvData = await this.globalCSVProvider.getUniqueRow(this.id);
-                    break;
-                case 'random':
-                    csvData = await this.globalCSVProvider.getRandomRow(this.id);
-                    break;
-                case 'next':
-                default:
-                    csvData = await this.globalCSVProvider.getNextRow(this.id);
-                    break;
-            }
-            if (csvData) {
-                this.context.global_csv_data = csvData;
-                // Merge global CSV data into variables (can be overridden by scenario CSV)
-                logger_1.logger.debug(`VU${this.id}: Adding global CSV columns to variables: ${Object.keys(csvData).join(', ')}`);
-                for (const [key, value] of Object.entries(csvData)) {
-                    this.context.variables[key] = value;
-                    logger_1.logger.debug(`VU${this.id}: Set global CSV variable: ${key} = ${value}`);
-                }
-                logger_1.logger.debug(`VU ${this.id}: Loaded global CSV data: ${Object.keys(csvData).join(', ')}`);
-            }
-            else {
-                logger_1.logger.debug(`VU${this.id}: Global CSV data exhausted - stopping VU`);
-                delete this.context.global_csv_data;
-                await this.stop();
-                throw new Error(`VU${this.id} terminated due to global CSV data exhaustion`);
-            }
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('terminated due to global CSV')) {
-                throw error;
-            }
-            logger_1.logger.warn(`📊 VU ${this.id}: Failed to load global CSV data:`, error);
-            delete this.context.global_csv_data;
-        }
-    }
-    // This method executes scenarios once (called repeatedly by load patterns)
     async executeScenarios() {
         if (!this.isActive || this.scenarios.length === 0) {
             return;
         }
         // Load global CSV data first (available to all scenarios)
-        try {
-            await this.loadGlobalCSVData();
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('terminated due to global CSV')) {
-                logger_1.logger.warn(`📊 VU ${this.id}: Stopping due to global CSV exhaustion`);
-                return;
-            }
-            // Log but continue if global CSV fails for other reasons
-            logger_1.logger.warn(`📊 VU ${this.id}: Global CSV loading failed, continuing without:`, error);
+        const globalCsvLoaded = await this.dataManager.loadGlobalData(this.context);
+        if (!globalCsvLoaded) {
+            logger_1.logger.warn(`📊 VU ${this.id}: Stopping due to global CSV exhaustion`);
+            await this.stop();
+            return;
         }
         // Execute beforeVU hook
         try {
             const beforeVUResult = await this.vuHooksManager.executeBeforeVU(this.context.variables, this.context.extracted_data);
-            // Merge any variables returned by beforeVU hook
             if (beforeVUResult?.variables) {
                 Object.assign(this.context.variables, beforeVUResult.variables);
                 logger_1.logger.debug(`VU${this.id}: beforeVU hook set variables: ${Object.keys(beforeVUResult.variables).join(', ')}`);
@@ -150,10 +58,9 @@ class VirtualUser {
         }
         catch (error) {
             logger_1.logger.error(`❌ VU ${this.id} beforeVU hook failed:`, error);
-            // Continue execution even if beforeVU fails
         }
         try {
-            const selectedScenarios = this.selectScenarios(this.scenarios);
+            const selectedScenarios = this.scenarioSelector.selectScenarios(this.scenarios);
             for (const scenario of selectedScenarios) {
                 if (!this.isActive)
                     break;
@@ -167,7 +74,6 @@ class VirtualUser {
             }
         }
         finally {
-            // Execute teardownVU hook
             try {
                 await this.vuHooksManager.executeTeardownVU(this.context.variables, this.context.extracted_data);
             }
@@ -191,7 +97,12 @@ class VirtualUser {
         }
         // Load CSV data if this scenario uses it (completely optional)
         logger_1.logger.debug(`About to load CSV data if needed...`);
-        await this.loadCSVDataIfNeeded(scenario);
+        const csvLoaded = await this.dataManager.loadScenarioData(scenario, this.context);
+        if (!csvLoaded) {
+            logger_1.logger.debug(`VU${this.id}: CSV data exhausted for scenario "${scenario.name}" - stopping`);
+            await this.stop();
+            throw new Error(`VU${this.id} terminated due to CSV data exhaustion in scenario "${scenario.name}"`);
+        }
         logger_1.logger.debug(`CSV data loading completed`);
         logger_1.logger.debug(`Context variables after CSV setup: ${JSON.stringify(this.context.variables)}`);
         // Create scenario hooks manager
@@ -237,11 +148,8 @@ class VirtualUser {
                 catch (error) {
                     logger_1.logger.error(`❌ VU ${this.id} beforeLoop hook failed:`, error);
                 }
-                // For unique CSV mode, get new CSV data each iteration
-                const csvScenario = scenario;
-                if (csvScenario.csv_mode === 'unique' && iteration > 0 && this.csvProviders.has(scenario.name)) {
-                    await this.loadCSVDataIfNeeded(scenario);
-                }
+                // Start iteration tracking for data manager (handles change_policy)
+                this.dataManager.startIteration(iteration);
                 try {
                     // Execute all steps in sequence
                     for (let stepIndex = 0; stepIndex < scenario.steps.length; stepIndex++) {
@@ -258,18 +166,12 @@ class VirtualUser {
                                 this.metrics.recordResult(result);
                             }
                             // Apply hierarchical think time: step > scenario > global
-                            // Skip think time if the NEXT step is a verification/wait step - they measure app
-                            // responsiveness and should run immediately after the triggering action
+                            // Skip think time if the NEXT step is a verification/wait step
                             const nextStep = scenario.steps[stepIndex + 1];
-                            const nextCommand = nextStep?.action?.command || '';
-                            const nextIsVerificationOrWait = nextCommand.startsWith('verify_') ||
-                                nextCommand.startsWith('wait_for_') ||
-                                nextCommand === 'measure_web_vitals' ||
-                                nextCommand === 'performance_audit';
-                            if (!nextIsVerificationOrWait) {
-                                const effectiveThinkTime = this.getEffectiveThinkTime(step, scenario);
+                            if (!this.thinkTimeStrategy.shouldSkipThinkTime(nextStep)) {
+                                const effectiveThinkTime = this.thinkTimeStrategy.getEffectiveThinkTime(step, scenario);
                                 if (effectiveThinkTime !== undefined) {
-                                    await this.applyThinkTime(effectiveThinkTime);
+                                    await this.thinkTimeStrategy.applyThinkTime(effectiveThinkTime);
                                 }
                             }
                         }
@@ -296,9 +198,11 @@ class VirtualUser {
                     }
                     throw error;
                 }
+                // End iteration tracking (releases checked-out data for unique scope)
+                this.dataManager.endIteration(iteration);
                 // Think time between iterations (except after last iteration)
                 if (iteration < loops - 1) {
-                    await this.applyThinkTime(scenario.think_time);
+                    await this.thinkTimeStrategy.applyThinkTime(scenario.think_time);
                 }
             }
         }
@@ -316,97 +220,6 @@ class VirtualUser {
             }
         }
     }
-    // ... rest of your existing methods remain exactly the same
-    async loadCSVDataIfNeeded(scenario) {
-        const csvScenario = scenario;
-        logger_1.logger.debug(`VU${this.id}: Checking CSV need for scenario "${scenario.name}"`);
-        logger_1.logger.debug(`VU${this.id}: Has csv_data config: ${!!csvScenario.csv_data}`);
-        logger_1.logger.debug(`VU${this.id}: Has CSV provider: ${this.csvProviders.has(scenario.name)}`);
-        if (!csvScenario.csv_data || !this.csvProviders.has(scenario.name)) {
-            logger_1.logger.debug(`VU${this.id}: No CSV data needed for scenario "${scenario.name}"`);
-            delete this.context.csv_data;
-            return;
-        }
-        try {
-            logger_1.logger.debug(`VU${this.id}: Loading CSV data for scenario "${scenario.name}"...`);
-            const csvData = await this.loadCSVDataForScenario(csvScenario);
-            if (csvData) {
-                this.context.csv_data = csvData;
-                logger_1.logger.debug(`VU${this.id}: Adding CSV columns to variables: ${Object.keys(csvData).join(', ')}`);
-                for (const [key, value] of Object.entries(csvData)) {
-                    if (!(key in this.context.variables)) {
-                        this.context.variables[key] = value;
-                        logger_1.logger.debug(`VU${this.id}: Added CSV variable: ${key} = ${value}`);
-                    }
-                    else {
-                        logger_1.logger.debug(`VU${this.id}: Skipped CSV variable ${key} (already in variables)`);
-                    }
-                }
-                logger_1.logger.debug(`VU ${this.id}: Loaded CSV data for scenario "${scenario.name}": ${Object.keys(csvData).join(', ')}`);
-            }
-            else {
-                logger_1.logger.debug(`VU${this.id}: No CSV data available - terminating this VU`);
-                delete this.context.csv_data;
-                this.stop();
-                throw new Error(`VU${this.id} terminated due to CSV data exhaustion in scenario "${scenario.name}"`);
-            }
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('terminated due to CSV data exhaustion')) {
-                throw error;
-            }
-            logger_1.logger.warn(`VU ${this.id}: Failed to load CSV data for scenario "${scenario.name}":`, error);
-            delete this.context.csv_data;
-            logger_1.logger.debug(`VU${this.id}: Continuing with fallback variables after CSV error`);
-        }
-    }
-    async loadCSVDataForScenario(scenario) {
-        const provider = this.csvProviders.get(scenario.name);
-        if (!provider) {
-            return null;
-        }
-        const mode = scenario.csv_mode || 'next';
-        switch (mode) {
-            case 'unique':
-                return await provider.getUniqueRow(this.id);
-            case 'random':
-                return await provider.getRandomRow();
-            case 'next':
-            default:
-                return await provider.getNextRow(this.id);
-        }
-    }
-    /**
-     * Select scenarios based on weights using proportional distribution.
-     *
-     * Weights determine the probability of a scenario being selected:
-     * - scenario1 (weight: 50) + scenario2 (weight: 25) + scenario3 (weight: 25) = 100
-     * - 50% of VUs will run scenario1, 25% scenario2, 25% scenario3
-     *
-     * If weights don't sum to 100, they are normalized proportionally.
-     */
-    selectScenarios(scenarios) {
-        if (scenarios.length === 0) {
-            return [];
-        }
-        if (scenarios.length === 1) {
-            return scenarios;
-        }
-        // Calculate total weight
-        const totalWeight = scenarios.reduce((sum, s) => sum + (s.weight ?? 100), 0);
-        // Generate random value between 0 and totalWeight
-        const random = Math.random() * totalWeight;
-        // Select scenario based on cumulative weight
-        let cumulative = 0;
-        for (const scenario of scenarios) {
-            cumulative += (scenario.weight ?? 100);
-            if (random < cumulative) {
-                return [scenario];
-            }
-        }
-        // Fallback to last scenario (should not reach here)
-        return [scenarios[scenarios.length - 1]];
-    }
     async executeSetup(setupScript) {
         try {
             await this.executeScript(setupScript, 'setup');
@@ -435,59 +248,6 @@ class VirtualUser {
             timeoutPromise
         ]);
     }
-    /**
-     * Get effective think time using hierarchical override:
-     * Step think_time > Scenario think_time > Global think_time
-     */
-    getEffectiveThinkTime(step, scenario) {
-        // Step level has highest priority
-        if (step.think_time !== undefined) {
-            return step.think_time;
-        }
-        // Scenario level is next
-        if (scenario.think_time !== undefined) {
-            return scenario.think_time;
-        }
-        // Global level is fallback
-        return this.globalThinkTime;
-    }
-    async applyThinkTime(thinkTime) {
-        if (!thinkTime) {
-            // No think time specified at any level - skip
-            return;
-        }
-        if (typeof thinkTime === 'number') {
-            logger_1.logger.debug(`Applying thinktime: ${thinkTime} seconds`);
-            await (0, time_1.sleep)(thinkTime * 1000);
-            return;
-        }
-        const rangeMatch = thinkTime.match(/^(\d+(?:\.\d+)?)-(\d+(?:\.\d+)?)([sm])?$/);
-        if (rangeMatch) {
-            const [, minStr, maxStr, unit] = rangeMatch;
-            let min = parseFloat(minStr);
-            let max = parseFloat(maxStr);
-            if (unit === 's' || !unit) {
-                min *= 1000;
-                max *= 1000;
-            }
-            const thinkTimeMs = (0, time_1.randomBetween)(min, max);
-            await (0, time_1.sleep)(thinkTimeMs);
-        }
-        else {
-            try {
-                const thinkTimeMs = (0, time_1.parseTime)(thinkTime);
-                await (0, time_1.sleep)(thinkTimeMs);
-            }
-            catch (error) {
-                logger_1.logger.warn(`⚠️ Invalid think time format: ${thinkTime}`);
-                await (0, time_1.sleep)((0, time_1.randomBetween)(1000, 3000));
-            }
-        }
-    }
-    // stop(): void {
-    //   this.isActive = false;
-    //   logger.debug(`⏹️ VU ${this.id} stopped`);
-    // }
     async stop() {
         this.isActive = false;
         logger_1.logger.debug(`⏹️ VU ${this.id} stopping...`);

package/dist/dashboard/routes/api.d.ts

@@ -0,0 +1,64 @@
+import * as http from 'http';
+import { LiveTest, InfrastructureMetrics } from '../types';
+import { FileScanner } from '../services/file-scanner';
+import { ResultsManager } from '../services/results-manager';
+import { TestExecutor } from '../services/test-executor';
+import { WorkersManager } from '../services/workers-manager';
+import { InfluxDBService } from '../services/influxdb-service';
+export declare class ApiRoutes {
+    private fileScanner;
+    private resultsManager;
+    private testExecutor;
+    private workersManager;
+    private liveTests;
+    private influxService;
+    private testMetricsWriter;
+    private onInfraUpdate?;
+    constructor(fileScanner: FileScanner, resultsManager: ResultsManager, testExecutor: TestExecutor, workersManager: WorkersManager, liveTests: Map<string, LiveTest>, callbacks?: {
+        onInfraUpdate?: (data: InfrastructureMetrics) => void;
+    }, influxService?: InfluxDBService);
+    initialize(): Promise<void>;
+    handleGetResults(res: http.ServerResponse): Promise<void>;
+    handleGetResult(res: http.ServerResponse, id: string): Promise<void>;
+    handleDeleteResult(res: http.ServerResponse, id: string): Promise<void>;
+    handleExportResult(res: http.ServerResponse, id: string, url: URL): Promise<void>;
+    handleImportResult(req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+    private resultToCSV;
+    handleCompare(res: http.ServerResponse, ids: string[]): Promise<void>;
+    handleGetLive(res: http.ServerResponse): void;
+    handleGetTests(res: http.ServerResponse): Promise<void>;
+    handleRunTest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+    handleStopTest(res: http.ServerResponse, testId: string): void;
+    handleGetWorkers(res: http.ServerResponse): Promise<void>;
+    handleInfraMetrics(req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+    handleGetInfra(res: http.ServerResponse, host?: string): Promise<void>;
+    handleGetInfraByTestRun(res: http.ServerResponse, startTime: string, endTime: string): Promise<void>;
+    handleExportInfra(req: http.IncomingMessage, res: http.ServerResponse, url: URL): Promise<void>;
+    handleImportInfra(req: http.IncomingMessage, res: http.ServerResponse, url: URL): Promise<void>;
+    handleGetInfraStatus(res: http.ServerResponse): Promise<void>;
+    /**
+     * Get a snapshot of all current infrastructure metrics for saving with test results
+     */
+    getInfraSnapshot(): Record<string, InfrastructureMetrics[]>;
+    /**
+     * Query infrastructure metrics for a specific test run time range
+     */
+    getInfraForTestRun(startTime: Date, endTime: Date): Promise<Record<string, InfrastructureMetrics[]>>;
+    /**
+     * Get list of test runs stored in InfluxDB
+     */
+    handleGetTestRuns(res: http.ServerResponse): Promise<void>;
+    /**
+     * Query test results from InfluxDB for a specific test run
+     */
+    handleGetTestMetrics(res: http.ServerResponse, url: URL): Promise<void>;
+    /**
+     * Export test data from InfluxDB
+     */
+    handleExportTestData(res: http.ServerResponse, url: URL): Promise<void>;
+    /**
+     * Get InfluxDB status for test metrics
+     */
+    handleGetTestMetricsStatus(res: http.ServerResponse): Promise<void>;
+    private readBody;
+}