@testsmith/perfornium 0.1.0

package/dist/core/csv-data-provider.js

@@ -0,0 +1,265 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSVDataProvider = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const papaparse_1 = __importDefault(require("papaparse"));
+const logger_1 = require("../utils/logger");
+/** Apply variable name mapping to a row */
+function applyVariableMapping(row, mapping) {
+    if (!mapping || Object.keys(mapping).length === 0) {
+        return row;
+    }
+    const mappedRow = {};
+    for (const [csvColumn, value] of Object.entries(row)) {
+        // Use mapped name if defined, otherwise keep original column name
+        const variableName = mapping[csvColumn] || csvColumn;
+        mappedRow[variableName] = value;
+    }
+    return mappedRow;
+}
+class CSVDataProvider {
+    // Remove test termination callback - we don't need it anymore
+    constructor(filePath, config) {
+        this.data = [];
+        this.originalData = [];
+        this.currentIndex = 0;
+        this.isLoaded = false;
+        this.isExhausted = false;
+        this.globalIndex = 0; // For sequential tracking across all modes
+        this.accessCount = 0; // For random mode tracking
+        this.filePath = filePath;
+        this.config = config;
+    }
+    static getInstance(config) {
+        const fullPath = path.resolve(CSVDataProvider.baseDir, config.file);
+        const key = `${fullPath}-${JSON.stringify(config)}`;
+        if (!CSVDataProvider.instances.has(key)) {
+            CSVDataProvider.instances.set(key, new CSVDataProvider(fullPath, config));
+        }
+        return CSVDataProvider.instances.get(key);
+    }
+    static setBaseDir(dir) {
+        CSVDataProvider.baseDir = dir;
+    }
+    // ... existing loadData method stays the same ...
+    async loadData() {
+        if (this.isLoaded) {
+            return;
+        }
+        const fullPath = path.resolve(CSVDataProvider.baseDir, this.config.file);
+        if (!fs.existsSync(fullPath)) {
+            throw new Error(`CSV file not found: ${fullPath}`);
+        }
+        logger_1.logger.info(`📊 Loading CSV data from: ${this.config.file}`);
+        const encoding = this.config.encoding || 'utf8';
+        const csvContent = fs.readFileSync(fullPath, encoding);
+        const parseConfig = {
+            header: true,
+            delimiter: this.config.delimiter || ',',
+            skipEmptyLines: this.config.skipEmptyLines !== false,
+            dynamicTyping: true,
+            delimitersToGuess: [',', '\t', '|', ';']
+        };
+        const parseResult = papaparse_1.default.parse(csvContent, parseConfig);
+        if (parseResult.errors.length > 0) {
+            logger_1.logger.warn('CSV parsing warnings:', parseResult.errors);
+        }
+        this.originalData = parseResult.data;
+        if (this.config.skipFirstLine) {
+            this.originalData = this.originalData.slice(1);
+        }
+        if (this.config.columns && this.config.columns.length > 0) {
+            this.originalData = this.originalData.map(row => {
+                const filteredRow = {};
+                for (const col of this.config.columns) {
+                    if (row.hasOwnProperty(col)) {
+                        filteredRow[col] = row[col];
+                    }
+                }
+                return filteredRow;
+            });
+        }
+        if (this.config.filter) {
+            this.originalData = this.filterData(this.originalData, this.config.filter);
+        }
+        if (this.config.randomize) {
+            this.originalData = this.shuffleArray([...this.originalData]);
+        }
+        this.data = [...this.originalData];
+        this.isLoaded = true;
+        logger_1.logger.info(`📊 Loaded ${this.data.length} rows from CSV: ${this.config.file}`);
+    }
+    /**
+     * Enhanced getNextRow - returns null when exhausted if cycleOnExhaustion is false
+     */
+    async getNextRow(vuId) {
+        await this.loadData();
+        if (this.originalData.length === 0) {
+            logger_1.logger.warn(`📊 No data available in CSV: ${this.config.file}`);
+            return null;
+        }
+        // If cycling is disabled, use sequential exhaustible access
+        if (this.config.cycleOnExhaustion === false) {
+            if (this.globalIndex >= this.originalData.length) {
+                logger_1.logger.warn(`📊 VU${vuId}: CSV data exhausted in file: ${this.config.file} (next mode, cycling disabled)`);
+                return null; // Just return null, don't terminate test
+            }
+            const row = this.originalData[this.globalIndex];
+            this.globalIndex++;
+            logger_1.logger.info(`📊 VU${vuId} using sequential CSV row ${this.globalIndex}/${this.originalData.length}:`, Object.keys(row));
+            return applyVariableMapping({ ...row }, this.config.variables);
+        }
+        else {
+            // Normal round-robin behavior
+            const index = (vuId - 1) % this.originalData.length;
+            const row = this.originalData[index];
+            logger_1.logger.debug(`📊 VU${vuId} using CSV row ${index + 1}/${this.originalData.length}:`, Object.keys(row));
+            return applyVariableMapping({ ...row }, this.config.variables);
+        }
+    }
+    /**
+     * Enhanced getUniqueRow - returns null when exhausted if cycleOnExhaustion is false
+     */
+    async getUniqueRow(vuId) {
+        await this.loadData();
+        if (this.data.length === 0) {
+            if (this.isExhausted && this.config.cycleOnExhaustion === false) {
+                logger_1.logger.warn(`📊 VU${vuId}: CSV data exhausted and cycling disabled: ${this.config.file}`);
+                return null; // Just return null, don't terminate test
+            }
+            logger_1.logger.warn(`📊 VU${vuId}: No more data available in CSV: ${this.config.file}`);
+            return null;
+        }
+        const row = this.data.shift();
+        logger_1.logger.info(`📊 VU${vuId} using unique CSV row (${this.data.length} remaining):`, Object.keys(row));
+        if (this.data.length === 0) {
+            this.isExhausted = true;
+            if (this.config.cycleOnExhaustion !== false) {
+                logger_1.logger.info(`📊 CSV data exhausted, reloading: ${this.config.file}`);
+                this.data = [...this.originalData];
+                if (this.config.randomize) {
+                    this.data = this.shuffleArray(this.data);
+                }
+                this.isExhausted = false;
+                logger_1.logger.info(`📊 CSV data reloaded: ${this.data.length} rows available`);
+            }
+            else {
+                logger_1.logger.warn(`📊 CSV data exhausted, cycling disabled: ${this.config.file} - future requests will return null`);
+            }
+        }
+        return applyVariableMapping({ ...row }, this.config.variables);
+    }
+    /**
+     * Enhanced getRandomRow - returns null when exhausted if cycleOnExhaustion is false
+     */
+    async getRandomRow(vuId = 0) {
+        await this.loadData();
+        if (this.originalData.length === 0) {
+            logger_1.logger.warn(`📊 No data available for random selection in CSV: ${this.config.file}`);
+            return null;
+        }
+        // If cycling is disabled, track accesses and stop after using all data once
+        if (this.config.cycleOnExhaustion === false) {
+            this.accessCount++;
+            if (this.accessCount > this.originalData.length) {
+                logger_1.logger.warn(`📊 VU${vuId}: CSV data exhausted in file: ${this.config.file} (random mode, cycling disabled, ${this.accessCount} accesses)`);
+                return null; // Just return null, don't terminate test
+            }
+        }
+        const randomIndex = Math.floor(Math.random() * this.originalData.length);
+        const row = this.originalData[randomIndex];
+        logger_1.logger.debug(`📊 VU${vuId} using random CSV row ${randomIndex + 1}/${this.originalData.length} (access ${this.accessCount}):`, Object.keys(row));
+        return applyVariableMapping({ ...row }, this.config.variables);
+    }
+    filterData(data, filterExpression) {
+        try {
+            const operators = ['!=', '>=', '<=', '=', '>', '<'];
+            let operator = '';
+            let parts = [];
+            for (const op of operators) {
+                if (filterExpression.includes(op)) {
+                    operator = op;
+                    parts = filterExpression.split(op).map(p => p.trim());
+                    break;
+                }
+            }
+            if (parts.length !== 2) {
+                logger_1.logger.warn(`Invalid filter expression: ${filterExpression}`);
+                return data;
+            }
+            const [column, value] = parts;
+            const filterValue = isNaN(Number(value)) ? value.replace(/['"]/g, '') : Number(value);
+            return data.filter(row => {
+                const rowValue = row[column];
+                switch (operator) {
+                    case '=':
+                        return rowValue == filterValue;
+                    case '!=':
+                        return rowValue != filterValue;
+                    case '>':
+                        return Number(rowValue) > Number(filterValue);
+                    case '<':
+                        return Number(rowValue) < Number(filterValue);
+                    case '>=':
+                        return Number(rowValue) >= Number(filterValue);
+                    case '<=':
+                        return Number(rowValue) <= Number(filterValue);
+                    default:
+                        return true;
+                }
+            });
+        }
+        catch (error) {
+            logger_1.logger.warn(`Error applying filter "${filterExpression}":`, error);
+            return data;
+        }
+    }
+    shuffleArray(array) {
+        const shuffled = [...array];
+        for (let i = shuffled.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+        }
+        return shuffled;
+    }
+}
+exports.CSVDataProvider = CSVDataProvider;
+CSVDataProvider.instances = new Map();
+CSVDataProvider.baseDir = process.cwd();

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

@@ -0,0 +1,33 @@
+import { VUHooks, ScenarioHooks, LoopHooks, StepHooks, ScriptResult } from '../config/types/hooks';
+export declare class VUHooksManager {
+    private vuHooks?;
+    private vuId;
+    private testName;
+    constructor(testName: string, vuId: number, vuHooks?: VUHooks);
+    executeBeforeVU(variables: Record<string, any>, extractedData: Record<string, any>): Promise<ScriptResult | null>;
+    executeTeardownVU(variables: Record<string, any>, extractedData: Record<string, any>): Promise<ScriptResult | null>;
+}
+export declare class ScenarioHooksManager {
+    private scenarioHooks?;
+    private vuId;
+    private testName;
+    private scenarioName;
+    private scenarioStartTime;
+    constructor(testName: string, vuId: number, scenarioName: string, hooks?: ScenarioHooks & LoopHooks);
+    executeBeforeScenario(variables: Record<string, any>, extractedData: Record<string, any>, csvData?: Record<string, any>): Promise<ScriptResult | null>;
+    executeTeardownScenario(variables: Record<string, any>, extractedData: Record<string, any>, csvData?: Record<string, any>): Promise<ScriptResult | null>;
+    executeBeforeLoop(loopIteration: number, variables: Record<string, any>, extractedData: Record<string, any>, csvData?: Record<string, any>): Promise<ScriptResult | null>;
+    executeAfterLoop(loopIteration: number, variables: Record<string, any>, extractedData: Record<string, any>, csvData?: Record<string, any>): Promise<ScriptResult | null>;
+}
+export declare class StepHooksManager {
+    private stepHooks?;
+    private vuId;
+    private testName;
+    private scenarioName;
+    private stepName;
+    private stepType;
+    constructor(testName: string, vuId: number, scenarioName: string, stepName: string, stepType: string, hooks?: StepHooks);
+    executeBeforeStep(variables: Record<string, any>, extractedData: Record<string, any>, csvData?: Record<string, any>): Promise<ScriptResult | null>;
+    executeOnStepError(error: Error, variables: Record<string, any>, extractedData: Record<string, any>, csvData?: Record<string, any>): Promise<ScriptResult | null>;
+    executeTeardownStep(variables: Record<string, any>, extractedData: Record<string, any>, csvData?: Record<string, any>, stepResult?: any): Promise<ScriptResult | null>;
+}

package/dist/core/hooks-manager.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepHooksManager = exports.ScenarioHooksManager = exports.VUHooksManager = void 0;
+const script_executor_1 = require("./script-executor");
+const logger_1 = require("../utils/logger");
+class VUHooksManager {
+    constructor(testName, vuId, vuHooks) {
+        this.testName = testName;
+        this.vuId = vuId;
+        this.vuHooks = vuHooks;
+    }
+    async executeBeforeVU(variables, extractedData) {
+        if (!this.vuHooks?.beforeVU)
+            return null;
+        const context = script_executor_1.ScriptExecutor.createContext(this.testName, this.vuId, variables, extractedData);
+        return await script_executor_1.ScriptExecutor.executeHookScript(this.vuHooks.beforeVU, context, 'beforeVU');
+    }
+    async executeTeardownVU(variables, extractedData) {
+        if (!this.vuHooks?.teardownVU)
+            return null;
+        const context = script_executor_1.ScriptExecutor.createContext(this.testName, this.vuId, variables, extractedData);
+        return await script_executor_1.ScriptExecutor.executeHookScript(this.vuHooks.teardownVU, context, 'teardownVU');
+    }
+}
+exports.VUHooksManager = VUHooksManager;
+class ScenarioHooksManager {
+    constructor(testName, vuId, scenarioName, hooks) {
+        this.scenarioStartTime = 0;
+        this.testName = testName;
+        this.vuId = vuId;
+        this.scenarioName = scenarioName;
+        this.scenarioHooks = hooks;
+    }
+    async executeBeforeScenario(variables, extractedData, csvData) {
+        if (!this.scenarioHooks?.beforeScenario)
+            return null;
+        this.scenarioStartTime = Date.now();
+        const context = script_executor_1.ScriptExecutor.createContext(this.testName, this.vuId, variables, extractedData, csvData, {
+            scenario_name: this.scenarioName,
+            scenario_start_time: this.scenarioStartTime
+        });
+        const result = await script_executor_1.ScriptExecutor.executeHookScript(this.scenarioHooks.beforeScenario, context, 'beforeScenario');
+        // CRITICAL FIX: Merge both returned variables AND the context's extracted_data
+        if (result?.success) {
+            // Merge variables returned from the hook
+            if (result.variables) {
+                Object.assign(variables, result.variables);
+            }
+            // IMPORTANT: Also merge the context's extracted_data back into the main extracted_data
+            Object.assign(extractedData, context.extracted_data);
+            logger_1.logger.debug(`VU${this.vuId}: beforeScenario extracted data: ${Object.keys(context.extracted_data).join(', ')}`);
+            logger_1.logger.debug(`VU${this.vuId}: beforeScenario extracted values: ${JSON.stringify(context.extracted_data)}`);
+        }
+        return result;
+    }
+    async executeTeardownScenario(variables, extractedData, csvData) {
+        if (!this.scenarioHooks?.teardownScenario)
+            return null;
+        const context = script_executor_1.ScriptExecutor.createContext(this.testName, this.vuId, variables, extractedData, csvData, {
+            scenario_name: this.scenarioName,
+            scenario_start_time: this.scenarioStartTime
+        });
+        return await script_executor_1.ScriptExecutor.executeHookScript(this.scenarioHooks.teardownScenario, context, 'teardownScenario');
+    }
+    async executeBeforeLoop(loopIteration, variables, extractedData, csvData) {
+        if (!this.scenarioHooks?.beforeLoop)
+            return null;
+        const context = script_executor_1.ScriptExecutor.createContext(this.testName, this.vuId, variables, extractedData, csvData, {
+            scenario_name: this.scenarioName,
+            loop_iteration: loopIteration,
+            loop_start_time: Date.now()
+        });
+        return await script_executor_1.ScriptExecutor.executeHookScript(this.scenarioHooks.beforeLoop, context, 'beforeLoop');
+    }
+    async executeAfterLoop(loopIteration, variables, extractedData, csvData) {
+        if (!this.scenarioHooks?.afterLoop)
+            return null;
+        const context = script_executor_1.ScriptExecutor.createContext(this.testName, this.vuId, variables, extractedData, csvData, {
+            scenario_name: this.scenarioName,
+            loop_iteration: loopIteration
+        });
+        return await script_executor_1.ScriptExecutor.executeHookScript(this.scenarioHooks.afterLoop, context, 'afterLoop');
+    }
+}
+exports.ScenarioHooksManager = ScenarioHooksManager;
+class StepHooksManager {
+    constructor(testName, vuId, scenarioName, stepName, stepType, hooks) {
+        this.testName = testName;
+        this.vuId = vuId;
+        this.scenarioName = scenarioName;
+        this.stepName = stepName;
+        this.stepType = stepType;
+        this.stepHooks = hooks;
+    }
+    async executeBeforeStep(variables, extractedData, csvData) {
+        if (!this.stepHooks?.beforeStep)
+            return null;
+        const context = script_executor_1.ScriptExecutor.createContext(this.testName, this.vuId, variables, extractedData, csvData, {
+            scenario_name: this.scenarioName,
+            step_name: this.stepName,
+            step_type: this.stepType,
+            step_start_time: Date.now()
+        });
+        return await script_executor_1.ScriptExecutor.executeHookScript(this.stepHooks.beforeStep, context, 'beforeStep');
+    }
+    async executeOnStepError(error, variables, extractedData, csvData) {
+        if (!this.stepHooks?.onStepError)
+            return null;
+        const context = script_executor_1.ScriptExecutor.createContext(this.testName, this.vuId, variables, extractedData, csvData, {
+            scenario_name: this.scenarioName,
+            step_name: this.stepName,
+            step_type: this.stepType,
+            error
+        });
+        return await script_executor_1.ScriptExecutor.executeHookScript(this.stepHooks.onStepError, context, 'onStepError');
+    }
+    async executeTeardownStep(variables, extractedData, csvData, stepResult) {
+        if (!this.stepHooks?.teardownStep)
+            return null;
+        const context = script_executor_1.ScriptExecutor.createContext(this.testName, this.vuId, variables, extractedData, csvData, {
+            scenario_name: this.scenarioName,
+            step_name: this.stepName,
+            step_type: this.stepType,
+            last_step_result: stepResult
+        });
+        return await script_executor_1.ScriptExecutor.executeHookScript(this.stepHooks.teardownStep, context, 'teardownStep');
+    }
+}
+exports.StepHooksManager = StepHooksManager;

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export { TestRunner } from './test-runner';
+export { VirtualUser } from './virtual-user';
+export { StepExecutor } from './step-executor';
+export { CSVDataProvider } from './csv-data-provider';
+export type { CSVDataRow } from './csv-data-provider';

package/dist/core/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSVDataProvider = exports.StepExecutor = exports.VirtualUser = exports.TestRunner = void 0;
+var test_runner_1 = require("./test-runner");
+Object.defineProperty(exports, "TestRunner", { enumerable: true, get: function () { return test_runner_1.TestRunner; } });
+var virtual_user_1 = require("./virtual-user");
+Object.defineProperty(exports, "VirtualUser", { enumerable: true, get: function () { return virtual_user_1.VirtualUser; } });
+var step_executor_1 = require("./step-executor");
+Object.defineProperty(exports, "StepExecutor", { enumerable: true, get: function () { return step_executor_1.StepExecutor; } });
+var csv_data_provider_1 = require("./csv-data-provider");
+Object.defineProperty(exports, "CSVDataProvider", { enumerable: true, get: function () { return csv_data_provider_1.CSVDataProvider; } });

package/dist/core/script-executor.d.ts

@@ -0,0 +1,14 @@
+import { HookScript, ScriptContext, ScriptResult } from '../config/types/hooks';
+export declare class ScriptExecutor {
+    private static baseDir;
+    private static scriptCache;
+    private static stepExecutor?;
+    static setStepExecutor(stepExecutor: any): void;
+    static createContext(testName: string, vuId: number, variables: Record<string, any>, extractedData: Record<string, any>, csvData?: Record<string, any>, additionalContext?: Partial<ScriptContext>): ScriptContext;
+    static executeHookScript(script: HookScript, context: ScriptContext, hookName: string): Promise<ScriptResult>;
+    private static executeInlineScript;
+    private static executeFileScript;
+    private static executeStepsScript;
+    private static transpileTypeScript;
+    static clearCache(): void;
+}