@testsmith/perfornium 0.1.0

package/dist/utils/template.d.ts

@@ -0,0 +1,80 @@
+import { FakerConfig } from '../config/types';
+export interface TemplateConfig {
+    file: string;
+    data?: Record<string, any>;
+}
+export declare class TemplateProcessor {
+    private static templateCache;
+    private static handlebarHelpersRegistered;
+    private static baseDir;
+    private get fakerInstance();
+    constructor();
+    /**
+     * Configure faker settings globally (affects all instances)
+     */
+    configureFaker(config: FakerConfig): void;
+    /**
+     * Set base directory for template files
+     */
+    static setBaseDir(dir: string): void;
+    /**
+     * Ensure Handlebars helpers are registered (only once)
+     */
+    private ensureHandlebarsHelpers;
+    /**
+     * Set seed for reproducible data
+     */
+    setSeed(seed: number): void;
+    /**
+     * Get available locales
+     */
+    getAvailableLocales(): string[];
+    /**
+     * Process template string with faker support (maintains backward compatibility)
+     */
+    process(template: string, context: Record<string, any>): string;
+    /**
+     * Process faker expressions and variables in a string
+     */
+    private processFakerAndVariables;
+    /**
+     * Evaluate faker expressions like faker.person.firstName or faker.person.firstName()
+     */
+    private evaluateFakerExpression;
+    /**
+     * Load and compile a Handlebars template file
+     */
+    private loadTemplate;
+    /**
+     * Process Handlebars template specification
+     */
+    private processHandlebarsTemplate;
+    /**
+     * Process CSV data specification
+     */
+    private processCSVData;
+    /**
+     * Synchronous CSV data processing (cached approach)
+     */
+    private processCSVDataSync;
+    /**
+     * Process a template with data
+     */
+    private processTemplate;
+    /**
+     * Clear template cache (useful for development)
+     */
+    static clearCache(): void;
+    /**
+     * Evaluate helper functions like randomInt(1, 100)
+     */
+    private evaluateHelperFunction;
+    /**
+     * Parse function arguments
+     */
+    private parseArguments;
+    /**
+     * Get nested property from object
+     */
+    private getNestedProperty;
+}

package/dist/utils/template.js

@@ -0,0 +1,513 @@
+"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.TemplateProcessor = void 0;
+const csv_data_provider_1 = require("../core/csv-data-provider");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const Handlebars = __importStar(require("handlebars"));
+const logger_1 = require("./logger");
+const timestamp_helper_1 = require("./timestamp-helper");
+const faker_manager_1 = require("./faker-manager");
+class TemplateProcessor {
+    // Instance gets faker from the lazy-loading manager
+    get fakerInstance() {
+        return faker_manager_1.fakerManager.getFaker();
+    }
+    constructor() {
+        this.ensureHandlebarsHelpers();
+    }
+    /**
+     * Configure faker settings globally (affects all instances)
+     */
+    configureFaker(config) {
+        logger_1.logger.debug(`configureFaker called with: ${JSON.stringify(config)}`);
+        logger_1.logger.debug(`Current global locale: ${faker_manager_1.fakerManager.currentLocale}`);
+        const availableLocales = faker_manager_1.fakerManager.getAvailableLocales();
+        if (config.locale && availableLocales.includes(config.locale)) {
+            faker_manager_1.fakerManager.setLocale(config.locale);
+            logger_1.logger.debug(`Global faker locale set to: ${config.locale}`);
+        }
+        else if (config.locale) {
+            logger_1.logger.warn(`Locale "${config.locale}" not available. Available: ${availableLocales.join(', ')}`);
+        }
+        if (config.seed !== undefined) {
+            faker_manager_1.fakerManager.setSeed(config.seed);
+            logger_1.logger.debug(`Global seed set to: ${config.seed}`);
+        }
+    }
+    /**
+     * Set base directory for template files
+     */
+    static setBaseDir(dir) {
+        TemplateProcessor.baseDir = dir;
+    }
+    /**
+     * Ensure Handlebars helpers are registered (only once)
+     */
+    ensureHandlebarsHelpers() {
+        if (TemplateProcessor.handlebarHelpersRegistered) {
+            return;
+        }
+        // Faker helpers
+        Handlebars.registerHelper('faker', (path) => {
+            return this.getNestedProperty(this.fakerInstance, path)();
+        });
+        // Random helpers
+        Handlebars.registerHelper('randomInt', (min, max) => {
+            return this.fakerInstance.number.int({ min, max });
+        });
+        Handlebars.registerHelper('randomChoice', (...args) => {
+            // Remove the last argument (Handlebars options)
+            const choices = args.slice(0, -1);
+            return this.fakerInstance.helpers.arrayElement(choices);
+        });
+        Handlebars.registerHelper('uuid', () => {
+            return this.fakerInstance.string.uuid();
+        });
+        Handlebars.registerHelper('timestamp', (format) => {
+            const fmt = (format || 'unix');
+            return timestamp_helper_1.TimestampHelper.getTimestamp(fmt);
+        });
+        Handlebars.registerHelper('isoDate', (days = 0) => {
+            const date = new Date();
+            date.setDate(date.getDate() + days);
+            return date.toISOString();
+        });
+        // Conditional helpers
+        Handlebars.registerHelper('eq', (a, b) => a === b);
+        Handlebars.registerHelper('ne', (a, b) => a !== b);
+        Handlebars.registerHelper('gt', (a, b) => a > b);
+        Handlebars.registerHelper('lt', (a, b) => a < b);
+        // Array helpers
+        Handlebars.registerHelper('length', (array) => array ? array.length : 0);
+        Handlebars.registerHelper('first', (array) => array && array.length > 0 ? array[0] : null);
+        Handlebars.registerHelper('last', (array) => array && array.length > 0 ? array[array.length - 1] : null);
+        TemplateProcessor.handlebarHelpersRegistered = true;
+        logger_1.logger.debug('Handlebars helpers registered');
+    }
+    /**
+     * Set seed for reproducible data
+     */
+    setSeed(seed) {
+        this.fakerInstance.seed(seed);
+    }
+    /**
+     * Get available locales
+     */
+    getAvailableLocales() {
+        return faker_manager_1.fakerManager.getAvailableLocales();
+    }
+    /**
+     * Process template string with faker support (maintains backward compatibility)
+     */
+    process(template, context) {
+        // ALWAYS set a unique seed before processing ANY templates
+        const vuId = context.vu_id || context.__VU || 1;
+        const iteration = context.iteration || context.__ITER || 0;
+        // Create a truly unique seed for each call
+        const timestamp = Date.now();
+        const randomComponent = Math.floor(Math.random() * 10000);
+        const uniqueSeed = timestamp + (vuId * 100000) + (iteration * 1000) + randomComponent;
+        this.fakerInstance.seed(uniqueSeed);
+        // Test the seed immediately
+        const testName = this.fakerInstance.person.firstName();
+        logger_1.logger.debug(`VU${vuId} Iter${iteration}: Seed ${uniqueSeed} (locale: ${faker_manager_1.fakerManager.currentLocale}) -> Test: "${testName}"`);
+        // Reset the seed again (in case the test call changed the state)
+        this.fakerInstance.seed(uniqueSeed);
+        let result = template;
+        // Helper functions available in templates
+        const helpers = {
+            randomInt: (min = 1, max = 100) => this.fakerInstance.number.int({ min, max }),
+            randomFloat: (min = 0, max = 1, fractionDigits = 2) => this.fakerInstance.number.float({ min, max, fractionDigits }),
+            randomChoice: (...choices) => this.fakerInstance.helpers.arrayElement(choices),
+            uuid: () => this.fakerInstance.string.uuid(),
+            isoDate: (days = 0) => {
+                const date = new Date();
+                date.setDate(date.getDate() + days);
+                return date.toISOString();
+            }
+        };
+        // FIRST: Process all faker expressions and context variables to resolve them
+        const processedVariables = { ...context.variables };
+        const processedExtractedData = { ...context.extracted_data };
+        // Process faker expressions in variables
+        for (const [key, value] of Object.entries(processedVariables)) {
+            if (typeof value === 'string') {
+                processedVariables[key] = this.processFakerAndVariables(value, context, helpers);
+            }
+        }
+        // Process faker expressions in extracted data
+        for (const [key, value] of Object.entries(processedExtractedData)) {
+            if (typeof value === 'string') {
+                processedExtractedData[key] = this.processFakerAndVariables(value, context, helpers);
+            }
+        }
+        // Enhanced context with processed variables
+        const enhancedContext = {
+            ...context,
+            faker: this.fakerInstance,
+            variables: processedVariables,
+            extracted_data: processedExtractedData,
+            ...helpers
+        };
+        // Process CSV data {{csv:file.csv}} or {{csv:file.csv|mode=unique}}
+        result = result.replace(/\{\{csv:([^}]+)\}\}/g, (match, csvSpec) => {
+            try {
+                const value = this.processCSVData(csvSpec, enhancedContext);
+                logger_1.logger.debug(`VU${vuId} Iter${iteration}: CSV data ${csvSpec} processed`);
+                return typeof value === 'string' ? value : JSON.stringify(value);
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to process CSV data "${csvSpec}":`, error);
+                return match;
+            }
+        });
+        // Process Handlebars templates {{template:file.json}} with optional data
+        result = result.replace(/\{\{template:([^}]+)\}\}/g, (match, templateSpec) => {
+            try {
+                const value = this.processHandlebarsTemplate(templateSpec, enhancedContext);
+                logger_1.logger.debug(`VU${vuId} Iter${iteration}: Handlebars template ${templateSpec} processed`);
+                // The value is already a minified JSON string, return it directly
+                // No need to JSON.stringify again as that would double-escape
+                return value;
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to process Handlebars template "${templateSpec}":`, error);
+                return match;
+            }
+        });
+        // Process remaining templates with the processed context
+        result = this.processFakerAndVariables(result, enhancedContext, helpers);
+        return result;
+    }
+    /**
+     * Process faker expressions and variables in a string
+     */
+    processFakerAndVariables(template, context, helpers) {
+        const vuId = context.vu_id || context.__VU || 1;
+        const iteration = context.iteration || context.__ITER || 0;
+        let result = template;
+        // Process environment variables {{env.VAR_NAME}}
+        result = result.replace(/\{\{env\.([^}]+)\}\}/g, (match, varName) => {
+            return process.env[varName] || '';
+        });
+        // Process faker expressions {{faker.person.firstName}} or {{faker.person.firstName()}}
+        result = result.replace(/\{\{(faker\.[^}]+)\}\}/g, (match, expression) => {
+            try {
+                const value = this.evaluateFakerExpression(expression);
+                logger_1.logger.debug(`VU${vuId} Iter${iteration}: ${expression} -> "${value}"`);
+                return value;
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to evaluate faker expression "${expression}":`, error);
+                return match;
+            }
+        });
+        // Process helper functions {{randomInt(1, 100)}}
+        result = result.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*\([^}]*\))\}/g, (match, expression) => {
+            try {
+                const value = this.evaluateHelperFunction(expression, helpers);
+                logger_1.logger.debug(`VU${vuId} Iter${iteration}: ${expression} -> "${value}"`);
+                return value;
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to evaluate helper function "${expression}":`, error);
+                return match;
+            }
+        });
+        // Process context variables {{variable_name}}
+        result = result.replace(/\{\{([^}]+)\}\}/g, (match, varName) => {
+            // Skip if it looks like it was already processed
+            if (varName.includes('(') || varName.startsWith('faker.') || varName.startsWith('template:')) {
+                return match;
+            }
+            const keys = varName.split('.');
+            let value = context;
+            for (const key of keys) {
+                if (value && typeof value === 'object' && key in value) {
+                    value = value[key];
+                }
+                else {
+                    return match;
+                }
+            }
+            return String(value);
+        });
+        // Process special variables
+        result = result.replace(/\{\{__VU\}\}/g, () => String(context.__VU || 0));
+        result = result.replace(/\{\{__ITER\}\}/g, () => String(context.__ITER || 0));
+        // Enhanced timestamp replacement with file-safe format by default
+        result = result.replace(/\{\{timestamp(?::([^}]+))?\}\}/g, (_match, format) => {
+            const fmt = (format || 'file');
+            return timestamp_helper_1.TimestampHelper.getTimestamp(fmt);
+        });
+        return result;
+    }
+    /**
+     * Evaluate faker expressions like faker.person.firstName or faker.person.firstName()
+     */
+    evaluateFakerExpression(expression) {
+        // Remove 'faker.' prefix
+        const path = expression.replace(/^faker\./, '');
+        logger_1.logger.debug(`Evaluating faker expression: "${path}" (locale: ${faker_manager_1.fakerManager.currentLocale})`);
+        // Check if it's a function call
+        const funcMatch = path.match(/^(.+)\(\)$/);
+        if (funcMatch) {
+            // It's a function call like person.firstName()
+            const funcPath = funcMatch[1];
+            const func = this.getNestedProperty(this.fakerInstance, funcPath);
+            if (typeof func === 'function') {
+                const result = String(func());
+                logger_1.logger.debug(`Function call ${funcPath}() -> "${result}"`);
+                return result;
+            }
+        }
+        else {
+            // It's a property access like person.firstName (also call it as function)
+            const func = this.getNestedProperty(this.fakerInstance, path);
+            if (typeof func === 'function') {
+                const result = String(func());
+                logger_1.logger.debug(`Property access ${path} -> "${result}"`);
+                return result;
+            }
+        }
+        throw new Error(`Faker method not found: ${expression}`);
+    }
+    /**
+     * Load and compile a Handlebars template file
+     */
+    loadTemplate(templatePath) {
+        const fullPath = path.resolve(TemplateProcessor.baseDir, templatePath);
+        if (TemplateProcessor.templateCache.has(fullPath)) {
+            return TemplateProcessor.templateCache.get(fullPath);
+        }
+        if (!fs.existsSync(fullPath)) {
+            throw new Error(`Template file not found: ${fullPath}`);
+        }
+        const templateContent = fs.readFileSync(fullPath, 'utf8');
+        const compiledTemplate = Handlebars.compile(templateContent);
+        TemplateProcessor.templateCache.set(fullPath, compiledTemplate);
+        logger_1.logger.debug(`Template compiled and cached: ${templatePath}`);
+        return compiledTemplate;
+    }
+    /**
+     * Process Handlebars template specification
+     */
+    processHandlebarsTemplate(templateSpec, context) {
+        // Parse template specification: "file.json" or "file.json|data=value,key=value"
+        const [templateFile, dataSpec] = templateSpec.split('|');
+        const templateConfig = {
+            file: templateFile.trim(),
+            data: {}
+        };
+        // Parse data specification if provided
+        if (dataSpec) {
+            const dataPairs = dataSpec.split(',');
+            for (const pair of dataPairs) {
+                const [key, value] = pair.split('=').map(s => s.trim());
+                if (key && value) {
+                    // Try to parse value as JSON, fallback to string
+                    try {
+                        templateConfig.data[key] = JSON.parse(value);
+                    }
+                    catch {
+                        templateConfig.data[key] = value;
+                    }
+                }
+            }
+        }
+        return this.processTemplate(templateConfig, context);
+    }
+    /**
+     * Process CSV data specification
+     */
+    processCSVData(csvSpec, context) {
+        // Parse CSV specification: "file.csv" or "file.csv|mode=unique,column=email"
+        const [csvFile, optionsSpec] = csvSpec.split('|');
+        const csvConfig = {
+            file: csvFile.trim(),
+            cycleOnExhaustion: true // Default to cycle
+        };
+        let mode = 'next'; // default mode
+        let column;
+        // Parse options if provided
+        if (optionsSpec) {
+            const options = optionsSpec.split(',');
+            for (const option of options) {
+                const [key, value] = option.split('=').map(s => s.trim());
+                if (key === 'mode') {
+                    mode = value;
+                }
+                else if (key === 'column') {
+                    column = value;
+                }
+                else if (key === 'delimiter') {
+                    csvConfig.delimiter = value;
+                }
+                else if (key === 'filter') {
+                    csvConfig.filter = value;
+                }
+                else if (key === 'randomize') {
+                    csvConfig.randomize = value === 'true';
+                }
+            }
+        }
+        const csvProvider = csv_data_provider_1.CSVDataProvider.getInstance(csvConfig);
+        const vuId = context.vu_id || context.__VU || 1;
+        // This returns a Promise, but we need sync processing for string replacement
+        // We'll need to handle this differently - see the async version below
+        return this.processCSVDataSync(csvProvider, mode, column, vuId);
+    }
+    /**
+     * Synchronous CSV data processing (cached approach)
+     */
+    processCSVDataSync(csvProvider, mode, column, vuId) {
+        // For now, return a placeholder that will be resolved later
+        // In a real implementation, you'd want to pre-load CSV data
+        return `CSV_DATA_${vuId}_${mode}_${column || 'all'}`;
+    }
+    /**
+     * Process a template with data
+     */
+    processTemplate(templateConfig, context) {
+        const template = this.loadTemplate(templateConfig.file);
+        // Merge data sources: processed variables + extracted data + template data
+        const templateData = {
+            ...context.variables, // These are now processed (faker expressions resolved)
+            ...context.extracted_data, // These are now processed
+            ...templateConfig.data, // Inline overrides
+            // Add context info
+            vu_id: context.vu_id,
+            iteration: context.iteration,
+            timestamp: Date.now(),
+        };
+        logger_1.logger.debug(`Processing Handlebars template: ${templateConfig.file}`);
+        const result = template(templateData);
+        logger_1.logger.debug(`Raw template result: ${result}`);
+        // If the result looks like JSON, minify it to remove line breaks
+        const trimmed = result.trim();
+        if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+            (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+            try {
+                // Parse and re-stringify to minify (remove whitespace/line breaks)
+                const parsed = JSON.parse(trimmed);
+                const minified = JSON.stringify(parsed);
+                logger_1.logger.debug(`Minified JSON result: ${minified}`);
+                // IMPORTANT: When returning JSON as a string to be embedded in another JSON,
+                // we need to escape it properly. JSON.stringify will handle the escaping.
+                const escaped = JSON.stringify(minified);
+                // Remove the outer quotes that JSON.stringify adds
+                const escapedContent = escaped.slice(1, -1);
+                logger_1.logger.debug(`Escaped for embedding: ${escapedContent}`);
+                return escapedContent;
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to minify JSON, returning original:`, error);
+                return result;
+            }
+        }
+        // For non-JSON content, return as-is
+        return result;
+    }
+    /**
+     * Clear template cache (useful for development)
+     */
+    static clearCache() {
+        TemplateProcessor.templateCache.clear();
+        logger_1.logger.debug('Template cache cleared');
+    }
+    /**
+     * Evaluate helper functions like randomInt(1, 100)
+     */
+    evaluateHelperFunction(expression, helpers) {
+        const funcMatch = expression.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\((.*)\)$/);
+        if (!funcMatch) {
+            throw new Error(`Invalid function call: ${expression}`);
+        }
+        const [, funcName, argsStr] = funcMatch;
+        const func = helpers[funcName];
+        if (typeof func !== 'function') {
+            throw new Error(`Function not found: ${funcName}`);
+        }
+        // Parse arguments (simple implementation)
+        const args = this.parseArguments(argsStr);
+        return String(func(...args));
+    }
+    /**
+     * Parse function arguments
+     */
+    parseArguments(argsStr) {
+        if (!argsStr.trim()) {
+            return [];
+        }
+        return argsStr.split(',').map(arg => {
+            const trimmed = arg.trim();
+            // String literal
+            if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+                (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+                return trimmed.slice(1, -1);
+            }
+            // Number
+            else if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+                return parseFloat(trimmed);
+            }
+            // Boolean
+            else if (trimmed === 'true' || trimmed === 'false') {
+                return trimmed === 'true';
+            }
+            // Default to string
+            else {
+                return trimmed;
+            }
+        });
+    }
+    /**
+     * Get nested property from object
+     */
+    getNestedProperty(obj, path) {
+        return path.split('.').reduce((current, key) => {
+            if (current && typeof current === 'object' && key in current) {
+                return current[key];
+            }
+            throw new Error(`Property "${key}" not found in path "${path}"`);
+        }, obj);
+    }
+}
+exports.TemplateProcessor = TemplateProcessor;
+// Static/global configuration shared across all instances
+TemplateProcessor.templateCache = new Map();
+TemplateProcessor.handlebarHelpersRegistered = false;
+TemplateProcessor.baseDir = process.cwd();

package/dist/utils/test-output-writer.d.ts

@@ -0,0 +1,56 @@
+export type OutputFormat = 'yaml' | 'json' | 'typescript';
+export interface TestOutputConfig {
+    name: string;
+    description?: string;
+    baseUrl?: string;
+    scenarios: any[];
+    format: OutputFormat;
+    outputPath: string;
+    sourceType?: 'recorder' | 'openapi' | 'wsdl' | 'har' | 'postman';
+    metadata?: {
+        recordedAt?: string;
+        importedFrom?: string;
+        sourceUrl?: string;
+        [key: string]: any;
+    };
+}
+export interface DSLGenerationOptions {
+    includeDataGeneration?: boolean;
+    includeCSVSupport?: boolean;
+    includeHooks?: boolean;
+    includeCustomLogic?: boolean;
+    includeMultipleLoadPatterns?: boolean;
+}
+export declare class TestOutputWriter {
+    private config;
+    private dslOptions;
+    constructor(config: TestOutputConfig, dslOptions?: DSLGenerationOptions);
+    write(): Promise<string>;
+    private generateYAML;
+    private generateJSON;
+    private generateTypeScriptDSL;
+    private generateTestConfiguration;
+    private generateScenarioDSL;
+    private generateWebStep;
+    private generateCustomLogicExample;
+    private generateStepsDSL;
+    private generateFillStep;
+    private generateRESTStep;
+    private generateSOAPStep;
+    private generateExportSection;
+    private generateAlternativeLoadPatterns;
+    private getSourceInfo;
+    private generateDataSection;
+    private generateTestScenarios;
+    private generateHooks;
+    private generateVerifyStep;
+    private buildTestConfiguration;
+    private hasWebScenarios;
+    private getVirtualUsers;
+    private getRampUp;
+    private getDuration;
+    private formatJSONForDSL;
+    private toCamelCase;
+    private escape;
+    static getSafeFilename(filepath: string): Promise<string>;
+}