@testsmith/perfornium 0.1.0

package/dist/core/script-executor.js

@@ -0,0 +1,290 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptExecutor = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+class ScriptExecutor {
+    static setStepExecutor(stepExecutor) {
+        ScriptExecutor.stepExecutor = stepExecutor;
+    }
+    // Add the createContext static method
+    static createContext(testName, vuId, variables, extractedData, csvData, additionalContext) {
+        return {
+            test_name: testName,
+            vu_id: vuId,
+            variables: { ...variables },
+            extracted_data: { ...extractedData },
+            csv_data: csvData ? { ...csvData } : undefined,
+            ...additionalContext
+        };
+    }
+    static async executeHookScript(script, context, hookName) {
+        const startTime = Date.now();
+        try {
+            logger_1.logger.debug(`Executing ${hookName} hook for VU${context.vu_id}`);
+            let result;
+            switch (script.type) {
+                case 'inline':
+                    if (!script.content) {
+                        throw new Error('Inline script content is required');
+                    }
+                    result = await ScriptExecutor.executeInlineScript(script.content, context);
+                    break;
+                case 'file':
+                    if (!script.file) {
+                        throw new Error('File script path is required');
+                    }
+                    result = await ScriptExecutor.executeFileScript(script.file, context, hookName);
+                    break;
+                case 'steps':
+                    if (!script.steps || script.steps.length === 0) {
+                        throw new Error('Steps script requires at least one step');
+                    }
+                    result = await ScriptExecutor.executeStepsScript(script.steps, context, hookName);
+                    break;
+                default:
+                    throw new Error(`Invalid script type: ${script.type}`);
+            }
+            const duration = Date.now() - startTime;
+            logger_1.logger.debug(`${hookName} hook completed in ${duration}ms for VU${context.vu_id}`);
+            return {
+                success: true,
+                result: result.value || result,
+                duration,
+                variables: result.variables || {}
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            logger_1.logger.error(`${hookName} hook failed for VU${context.vu_id}:`, error);
+            const shouldContinue = script.continueOnError !== false;
+            if (!shouldContinue) {
+                throw error;
+            }
+            return {
+                success: false,
+                error: error,
+                duration
+            };
+        }
+    }
+    static async executeInlineScript(content, context) {
+        const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+        const wrappedContent = `
+      let returnValue = undefined;
+      let variables = {};
+      
+      function setVariable(key, value) {
+        variables[key] = value;
+        context.variables[key] = value;
+      }
+      
+      function getVariable(key) {
+        return context.variables[key] || context.extracted_data[key] || context.csv_data?.[key];
+      }
+      
+      const utils = {
+        randomInt: (min = 1, max = 100) => Math.floor(Math.random() * (max - min + 1)) + min,
+        randomChoice: (...choices) => choices[Math.floor(Math.random() * choices.length)],
+        uuid: () => require('crypto').randomUUID(),
+        sleep: (ms) => new Promise(resolve => setTimeout(resolve, ms)),
+        timestamp: () => Date.now(),
+        isoDate: (days = 0) => {
+          const date = new Date();
+          date.setDate(date.getDate() + days);
+          return date.toISOString();
+        }
+      };
+      
+      try {
+        ${content}
+      } catch (error) {
+        throw new Error(\`Script execution failed: \${error.message}\`);
+      }
+      
+      return { value: returnValue, variables };
+    `;
+        const compiledFunction = new AsyncFunction('context', 'require', 'console', 'logger', wrappedContent);
+        const timeout = 30000;
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`Hook script timeout after ${timeout}ms`)), timeout);
+        });
+        return Promise.race([
+            compiledFunction(context, require, console, logger_1.logger),
+            timeoutPromise
+        ]);
+    }
+    static async executeFileScript(filePath, context, hookName) {
+        const fullPath = path.resolve(ScriptExecutor.baseDir, filePath);
+        if (!fs.existsSync(fullPath)) {
+            throw new Error(`Script file not found: ${fullPath}`);
+        }
+        let content = fs.readFileSync(fullPath, 'utf8');
+        // Handle TypeScript files (basic transpilation)
+        if (filePath.endsWith('.ts')) {
+            content = ScriptExecutor.transpileTypeScript(content, filePath);
+        }
+        // Determine if it's a module export or direct script
+        const isModule = content.includes('module.exports') || content.includes('export');
+        if (isModule) {
+            // Handle as module
+            const tempFilePath = path.join(os.tmpdir(), `hook-${Date.now()}-${Math.random().toString(36).substring(7)}.js`);
+            fs.writeFileSync(tempFilePath, content);
+            try {
+                delete require.cache[tempFilePath];
+                const moduleExports = require(tempFilePath);
+                let hookFunction;
+                if (typeof moduleExports === 'function') {
+                    hookFunction = moduleExports;
+                }
+                else if (moduleExports.default && typeof moduleExports.default === 'function') {
+                    hookFunction = moduleExports.default;
+                }
+                else {
+                    throw new Error('Module must export a function');
+                }
+                // Execute the hook function with helper utilities
+                const helpers = {
+                    setVariable: (key, value) => {
+                        context.variables[key] = value;
+                    },
+                    getVariable: (key) => context.variables[key] || context.extracted_data[key] || context.csv_data?.[key],
+                    utils: {
+                        randomInt: (min = 1, max = 100) => Math.floor(Math.random() * (max - min + 1)) + min,
+                        randomChoice: (...choices) => choices[Math.floor(Math.random() * choices.length)],
+                        uuid: () => require('crypto').randomUUID(),
+                        sleep: (ms) => new Promise(resolve => setTimeout(resolve, ms)),
+                        timestamp: () => Date.now(),
+                        isoDate: (days = 0) => {
+                            const date = new Date();
+                            date.setDate(date.getDate() + days);
+                            return date.toISOString();
+                        }
+                    }
+                };
+                const result = await hookFunction(context, helpers);
+                return {
+                    value: result,
+                    variables: {} // Variables are set directly on context through helpers
+                };
+            }
+            finally {
+                // Cleanup temp file
+                try {
+                    fs.unlinkSync(tempFilePath);
+                }
+                catch (e) {
+                    // Ignore cleanup errors
+                }
+            }
+        }
+        else {
+            // Handle as direct script (same as inline)
+            return ScriptExecutor.executeInlineScript(content, context);
+        }
+    }
+    static async executeStepsScript(steps, context, hookName) {
+        if (!ScriptExecutor.stepExecutor) {
+            throw new Error('StepExecutor not configured for hook step execution');
+        }
+        const results = [];
+        // Create a temporary VU context from script context
+        const vuContext = {
+            vu_id: context.vu_id,
+            iteration: context.loop_iteration || 0,
+            variables: { ...context.variables },
+            extracted_data: { ...context.extracted_data }
+        };
+        for (const step of steps) {
+            try {
+                logger_1.logger.debug(`Executing hook step: ${step.name || step.type}`);
+                const result = await ScriptExecutor.stepExecutor.executeStepInternal(step, vuContext, context.scenario_name || 'hook', Date.now());
+                results.push({
+                    stepName: step.name || step.type,
+                    success: result.success,
+                    duration: result.duration,
+                    error: result.error
+                });
+                // CRITICAL FIX: Update both context objects with extracted data
+                Object.assign(context.variables, vuContext.variables);
+                Object.assign(context.extracted_data, vuContext.extracted_data);
+                // Log what was extracted for debugging
+                if (Object.keys(vuContext.extracted_data).length > 0) {
+                    logger_1.logger.debug(`VU${context.vu_id}: Hook step extracted data: ${Object.keys(vuContext.extracted_data).join(', ')}`);
+                    logger_1.logger.debug(`VU${context.vu_id}: Extracted values: ${JSON.stringify(vuContext.extracted_data)}`);
+                }
+            }
+            catch (error) {
+                results.push({
+                    stepName: step.name || step.type,
+                    success: false,
+                    error: error.message
+                });
+                // Continue with next step unless continueOnError is false
+                if (step.continueOnError === false) {
+                    throw error;
+                }
+            }
+        }
+        return {
+            value: results,
+            variables: {
+                ...vuContext.variables,
+                ...vuContext.extracted_data // CRITICAL: Include extracted data in returned variables
+            }
+        };
+    }
+    static transpileTypeScript(content, filePath) {
+        // Basic TypeScript to JavaScript transpilation
+        return content
+            .replace(/:\s*\w+(\[\])?(\s*\|\s*\w+(\[\])?)*\s*[=;,)]/g, (match) => {
+            return match.slice(-1);
+        })
+            .replace(/interface\s+\w+\s*{[^}]*}/g, '')
+            .replace(/type\s+\w+\s*=\s*[^;]+;/g, '')
+            .replace(/import\s+.*?from\s+['"][^'"]+['"];?/g, '')
+            .replace(/export\s+/g, '');
+    }
+    static clearCache() {
+        ScriptExecutor.scriptCache.clear();
+        logger_1.logger.info('Script cache cleared');
+    }
+}
+exports.ScriptExecutor = ScriptExecutor;
+ScriptExecutor.baseDir = process.cwd();
+ScriptExecutor.scriptCache = new Map();

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

@@ -0,0 +1,41 @@
+import { Step, VUContext } from '../config';
+import { ProtocolHandler } from '../protocols/base';
+import { TestResult } from '../metrics/types';
+export declare class StepExecutor {
+    private handlers;
+    private templateProcessor;
+    private testName;
+    constructor(handlers: Map<string, ProtocolHandler>, testName?: string);
+    executeStep(step: Step, context: VUContext, scenarioName: string): Promise<TestResult>;
+    executeStepInternal(step: Step, context: VUContext, scenarioName: string, startTime: number): Promise<TestResult>;
+    private shouldRecordStep;
+    private executeRESTStep;
+    /**
+     * Load JSON payload from file and apply overrides
+     * Supports dot notation for nested paths in overrides
+     */
+    private processJsonFile;
+    /**
+     * Apply overrides to a JSON object using dot notation for nested paths
+     * Override values are processed through the template processor
+     */
+    private applyOverrides;
+    /**
+     * Set a value at a nested path using dot notation
+     * Example: setNestedValue(obj, 'user.profile.name', 'John')
+     */
+    private setNestedValue;
+    private executeSOAPStep;
+    private executeWebStep;
+    private executeCustomStep;
+    private executeWaitStep;
+    private executeScriptStep;
+    private executeScript;
+    private evaluateCondition;
+    private processTemplate;
+    private runChecks;
+    private checkCustom;
+    private extractData;
+    private extractCustom;
+    private getJsonPath;
+}