@testsmith/perfornium 0.1.0

package/dist/config/parser.js

@@ -0,0 +1,330 @@
+"use strict";
+// Updated ConfigParser to support both YAML and TypeScript
+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.ConfigParser = void 0;
+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 logger_1 = require("../utils/logger");
+class ConfigParser {
+    constructor() {
+        this.templateProcessor = new template_1.TemplateProcessor();
+    }
+    async parse(configPath, environment) {
+        logger_1.logger.debug(`ConfigParser.parse called with: ${configPath}, ${environment}`);
+        if (!fs.existsSync(configPath)) {
+            throw new Error(`Configuration file not found: ${configPath}`);
+        }
+        let config;
+        // Determine file type and parse accordingly
+        const ext = path.extname(configPath).toLowerCase();
+        if (ext === '.ts' || ext === '.js') {
+            // Handle TypeScript/JavaScript files
+            config = await this.parseTypeScript(configPath);
+        }
+        else {
+            // Handle YAML/JSON files
+            const configContent = fs.readFileSync(configPath, 'utf8');
+            config = this.parseContent(configContent);
+        }
+        logger_1.logger.debug(`Parsed config.global: ${JSON.stringify(config.global, null, 2)}`);
+        // Setup faker configuration if specified
+        logger_1.logger.debug('About to setup faker...');
+        this.setupFaker(config);
+        logger_1.logger.debug('Faker setup completed');
+        // Setup base directories for CSV and templates if needed
+        this.setupBaseDirectories(config, configPath);
+        // Validate required fields (now includes CSV validation)
+        this.validateRequiredFields(config);
+        if (environment) {
+            const envConfig = await this.loadEnvironmentConfig(environment, path.dirname(configPath));
+            return this.mergeConfigs(config, envConfig);
+        }
+        return config;
+    }
+    async parseTypeScript(configPath) {
+        try {
+            // Resolve to absolute path
+            const absolutePath = path.resolve(configPath);
+            // Check if file exists
+            if (!fs.existsSync(absolutePath)) {
+                throw new Error(`Configuration file not found: ${absolutePath}`);
+            }
+            let module;
+            if (absolutePath.endsWith('.ts')) {
+                // For TypeScript files, we need proper transpilation support
+                try {
+                    // Try to use ts-node/register for TypeScript support
+                    require('ts-node/register');
+                }
+                catch {
+                    // If ts-node is not globally available, try to use it from local node_modules
+                    try {
+                        const tsNodePath = require.resolve('ts-node/register', { paths: [process.cwd()] });
+                        require(tsNodePath);
+                    }
+                    catch {
+                        // If ts-node still not found, provide helpful error
+                        logger_1.logger.warn('ts-node not found. Installing it will enable TypeScript imports.');
+                        logger_1.logger.warn('Install with: npm install --save-dev ts-node typescript');
+                        logger_1.logger.warn('Attempting to run as plain JavaScript...');
+                    }
+                }
+                // Clear require cache
+                if (require.cache[absolutePath]) {
+                    delete require.cache[absolutePath];
+                }
+                try {
+                    // Try to require the file
+                    module = require(absolutePath);
+                }
+                catch (error) {
+                    // If it fails with import/export errors, try alternative approaches
+                    if (error.message.includes('Cannot use import statement') ||
+                        error.message.includes('Unexpected token')) {
+                        // Check if this is a plain config file (no imports) or a DSL file (with imports)
+                        const fileContent = fs.readFileSync(absolutePath, 'utf8');
+                        const hasImports = fileContent.includes('import ') || fileContent.includes('export ');
+                        if (hasImports) {
+                            // This is a DSL file with imports - it needs ts-node
+                            throw new Error('TypeScript file contains imports and requires ts-node for execution.\n' +
+                                'Please install it:\n' +
+                                '  npm install --save-dev ts-node typescript\n' +
+                                'Or globally:\n' +
+                                '  npm install -g ts-node typescript\n\n' +
+                                'Then run your test again.');
+                        }
+                        else {
+                            // This is a plain config file - we can evaluate it
+                            module = this.evaluatePlainTypeScript(fileContent, absolutePath);
+                        }
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            else {
+                // Regular JavaScript file
+                module = require(absolutePath);
+            }
+            // Handle different export styles
+            let config;
+            if (module && module.default) {
+                config = module.default;
+            }
+            else if (module && module.config) {
+                config = module.config;
+            }
+            else if (typeof module === 'object' && module.name) {
+                config = module;
+            }
+            else {
+                throw new Error('File must export a TestConfiguration object as default or named "config"');
+            }
+            // If it's a builder or has a build method, build it
+            if (typeof config === 'object' && 'build' in config && typeof config.build === 'function') {
+                config = config.build();
+            }
+            return config;
+        }
+        catch (error) {
+            // Improve error messages
+            if (error.code === 'MODULE_NOT_FOUND' && error.message.includes('perfornium')) {
+                throw new Error('Cannot find perfornium modules. Make sure you are importing from the correct path:\n' +
+                    '  import { test } from "perfornium/dsl";\n' +
+                    'Or if running from source:\n' +
+                    '  import { test } from "./src/dsl";\n\n' +
+                    'Original error: ' + error.message);
+            }
+            throw new Error(`Failed to load configuration: ${error.message}`);
+        }
+    }
+    evaluatePlainTypeScript(fileContent, absolutePath) {
+        // Create a module context for plain TypeScript files without imports
+        const moduleContext = {
+            exports: {},
+            require: require,
+            module: { exports: {} },
+            __filename: absolutePath,
+            __dirname: path.dirname(absolutePath),
+            process: process,
+            console: console
+        };
+        try {
+            // Wrap in a function and execute
+            const fn = new Function('exports', 'require', 'module', '__filename', '__dirname', 'process', 'console', fileContent);
+            fn(moduleContext.exports, moduleContext.require, moduleContext.module, moduleContext.__filename, moduleContext.__dirname, moduleContext.process, moduleContext.console);
+            return moduleContext.module.exports || moduleContext.exports;
+        }
+        catch (error) {
+            throw new Error(`Failed to evaluate TypeScript file: ${error.message}`);
+        }
+    }
+    // Rest of your existing methods remain the same...
+    setupBaseDirectories(config, configPath) {
+        let baseDir = path.dirname(configPath);
+        // Walk up directories to find templates folder
+        let currentDir = baseDir;
+        while (currentDir !== path.dirname(currentDir)) {
+            if (fs.existsSync(path.join(currentDir, 'templates'))) {
+                baseDir = currentDir;
+                break;
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        const hasCSVScenarios = config.scenarios?.some((s) => s.csv_data);
+        const configStr = JSON.stringify(config);
+        const hasTemplates = configStr.includes('{{template:') || configStr.includes('{{csv:');
+        if (hasCSVScenarios || hasTemplates) {
+            core_1.CSVDataProvider.setBaseDir(baseDir);
+            template_1.TemplateProcessor.setBaseDir(baseDir);
+            logger_1.logger.debug(`Set base directory for CSV/templates: ${baseDir}`);
+        }
+    }
+    setupFaker(config) {
+        logger_1.logger.debug('ConfigParser.setupFaker called');
+        logger_1.logger.debug(`config.global: ${JSON.stringify(config.global, null, 2)}`);
+        if (config.global?.faker) {
+            logger_1.logger.debug(`Found faker config: ${JSON.stringify(config.global.faker)}`);
+            logger_1.logger.debug('About to call configureFaker...');
+            this.templateProcessor.configureFaker(config.global.faker);
+            logger_1.logger.debug('configureFaker call completed');
+        }
+        else {
+            logger_1.logger.debug('No faker config found in global');
+        }
+    }
+    parseContent(content) {
+        const trimmed = content.trim();
+        if (trimmed.startsWith('{')) {
+            return JSON.parse(content);
+        }
+        else {
+            return YAML.parse(content);
+        }
+    }
+    validateRequiredFields(config) {
+        const requiredFields = ['name', 'load', 'scenarios'];
+        for (const field of requiredFields) {
+            if (!config[field]) {
+                throw new Error(`Required field missing: ${field}`);
+            }
+        }
+        if (!config.scenarios || config.scenarios.length === 0) {
+            throw new Error('At least one scenario must be defined');
+        }
+        // Validate CSV configurations in scenarios
+        for (const scenario of config.scenarios) {
+            if (scenario.csv_data) {
+                this.validateCSVConfig(scenario.csv_data, scenario.name);
+            }
+        }
+        if (config.global?.faker?.locale) {
+            const supportedLocales = this.templateProcessor.getAvailableLocales();
+            if (!supportedLocales.includes(config.global.faker.locale)) {
+                throw new Error(`Unsupported faker locale: ${config.global.faker.locale}. Supported locales: ${supportedLocales.join(', ')}`);
+            }
+        }
+    }
+    validateCSVConfig(csvConfig, scenarioName) {
+        if (!csvConfig.file) {
+            throw new Error(`CSV configuration missing 'file' property in scenario: ${scenarioName}`);
+        }
+        // Validate csv_mode if specified
+        const validModes = ['next', 'unique', 'random'];
+        if (csvConfig.mode && !validModes.includes(csvConfig.mode)) {
+            throw new Error(`Invalid csv_mode '${csvConfig.mode}' in scenario ${scenarioName}. Valid modes: ${validModes.join(', ')}`);
+        }
+        // Validate encoding if specified
+        const validEncodings = ['utf8', 'utf-8', 'ascii', 'latin1', 'base64', 'hex'];
+        if (csvConfig.encoding && !validEncodings.includes(csvConfig.encoding)) {
+            logger_1.logger.warn(`Encoding '${csvConfig.encoding}' may not be supported in scenario ${scenarioName}`);
+        }
+    }
+    async loadEnvironmentConfig(environment, baseDir) {
+        const envPaths = [
+            path.join(baseDir, 'config', 'environments', `${environment}.yml`),
+            path.join(baseDir, 'config', 'environments', `${environment}.yaml`),
+            path.join(baseDir, 'config', 'environments', `${environment}.json`),
+            path.join(baseDir, 'config', 'environments', `${environment}.ts`),
+            path.join(baseDir, `${environment}.yml`),
+            path.join(baseDir, `${environment}.yaml`),
+            path.join(baseDir, `${environment}.json`),
+            path.join(baseDir, `${environment}.ts`)
+        ];
+        for (const envPath of envPaths) {
+            if (fs.existsSync(envPath)) {
+                if (envPath.endsWith('.ts')) {
+                    return await this.parseTypeScript(envPath);
+                }
+                else {
+                    const envContent = fs.readFileSync(envPath, 'utf8');
+                    return this.parseContent(envContent);
+                }
+            }
+        }
+        throw new Error(`Environment configuration not found for: ${environment}. Searched paths: ${envPaths.join(', ')}`);
+    }
+    mergeConfigs(base, env) {
+        const mergeReportConfig = (baseReport, envReport) => {
+            if (!baseReport && !envReport)
+                return undefined;
+            return {
+                generate: false,
+                output: 'report.html',
+                ...baseReport,
+                ...envReport
+            };
+        };
+        return {
+            ...base,
+            global: { ...base.global, ...env.global },
+            load: { ...base.load, ...env.load },
+            scenarios: env.scenarios || base.scenarios,
+            outputs: env.outputs || base.outputs,
+            report: mergeReportConfig(base.report, env.report),
+            workers: env.workers || base.workers
+        };
+    }
+    processTemplates(config, _context) {
+        const configStr = JSON.stringify(config);
+        return JSON.parse(configStr);
+    }
+}
+exports.ConfigParser = ConfigParser;

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

@@ -0,0 +1,74 @@
+export interface GlobalConfig {
+    base_url?: string;
+    wsdl_url?: string;
+    timeout?: number;
+    think_time?: string | number;
+    headers?: Record<string, string>;
+    variables?: Record<string, any>;
+    browser?: BrowserConfig;
+    faker?: FakerConfig;
+    debug?: DebugConfig;
+    /** Global CSV data configuration - variables available across all scenarios */
+    csv_data?: GlobalCSVConfig;
+    /** CSV data access mode: next (round-robin), unique (exhaustible), random */
+    csv_mode?: 'next' | 'unique' | 'random';
+}
+export interface GlobalCSVConfig {
+    /** Path to the CSV file */
+    file: string;
+    /** Column delimiter (default: ',') */
+    delimiter?: string;
+    /** File encoding (default: 'utf8') */
+    encoding?: BufferEncoding;
+    /** Skip empty lines (default: true) */
+    skipEmptyLines?: boolean;
+    /** Skip the first line (header row treated as data) */
+    skipFirstLine?: boolean;
+    /** Select only specific columns */
+    columns?: string[];
+    /** Filter expression (e.g., "status=active") */
+    filter?: string;
+    /** Shuffle data randomly */
+    randomize?: boolean;
+    /** Restart from beginning when data is exhausted (default: true) */
+    cycleOnExhaustion?: boolean;
+    /** Map CSV column names to custom variable names: { "csv_column": "variable_name" } */
+    variables?: Record<string, string>;
+}
+export interface FakerConfig {
+    locale?: string;
+    seed?: number;
+}
+export interface BrowserConfig {
+    type: 'chromium' | 'firefox' | 'webkit';
+    headless?: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    slow_mo?: number;
+    base_url?: string;
+    highlight?: boolean | HighlightConfig;
+    clear_storage?: boolean | ClearStorageConfig;
+}
+export interface ClearStorageConfig {
+    local_storage?: boolean;
+    session_storage?: boolean;
+    cookies?: boolean;
+    cache?: boolean;
+}
+export interface HighlightConfig {
+    enabled: boolean;
+    duration?: number;
+    color?: string;
+    style?: 'border' | 'background' | 'both';
+}
+export interface DebugConfig {
+    capture_request_headers?: boolean;
+    capture_request_body?: boolean;
+    capture_response_headers?: boolean;
+    capture_response_body?: boolean;
+    max_response_body_size?: number;
+    capture_only_failures?: boolean;
+    log_level?: 'debug' | 'info' | 'warn' | 'error';
+}

package/dist/config/types/global-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/types/hooks.d.ts

@@ -0,0 +1,58 @@
+import { Step } from "./step-types";
+export interface HookScript {
+    type: 'inline' | 'file' | 'steps';
+    content?: string;
+    file?: string;
+    steps?: Step[];
+    timeout?: number;
+    continueOnError?: boolean;
+}
+export interface TestHooks {
+    beforeTest?: HookScript;
+    onTestError?: HookScript;
+    teardownTest?: HookScript;
+}
+export interface VUHooks {
+    beforeVU?: HookScript;
+    teardownVU?: HookScript;
+}
+export interface ScenarioHooks {
+    beforeScenario?: HookScript;
+    teardownScenario?: HookScript;
+}
+export interface LoopHooks {
+    beforeLoop?: HookScript;
+    afterLoop?: HookScript;
+}
+export interface StepHooks {
+    beforeStep?: HookScript;
+    onStepError?: HookScript;
+    teardownStep?: HookScript;
+}
+export { Scenario } from './scenario-config';
+export interface ScriptResult {
+    success: boolean;
+    result?: any;
+    error?: Error;
+    duration: number;
+    variables?: Record<string, any>;
+}
+export interface ScriptContext {
+    test_name: string;
+    vu_id: number;
+    scenario_name?: string;
+    loop_iteration?: number;
+    step_name?: string;
+    step_type?: string;
+    variables: Record<string, any>;
+    extracted_data: Record<string, any>;
+    csv_data?: Record<string, any>;
+    metrics?: any;
+    logger?: any;
+    error?: Error;
+    last_step_result?: any;
+    test_start_time?: number;
+    scenario_start_time?: number;
+    loop_start_time?: number;
+    step_start_time?: number;
+}

package/dist/config/types/hooks.js

@@ -0,0 +1,3 @@
+"use strict";
+// Hooks interfaces for test lifecycle management
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,33 @@
+export interface ImportableEndpoint {
+    id: string;
+    name: string;
+    method: string;
+    path: string;
+    description?: string;
+    parameters?: Parameter[];
+    requestBody?: RequestBodySchema;
+    responses?: ResponseSchema[];
+    tags?: string[];
+    selected?: boolean;
+}
+export interface Parameter {
+    name: string;
+    in: 'query' | 'header' | 'path' | 'cookie';
+    required: boolean;
+    type: string;
+    description?: string;
+    example?: any;
+    enum?: any[];
+}
+export interface RequestBodySchema {
+    contentType: string;
+    schema: any;
+    example?: any;
+    required: boolean;
+}
+export interface ResponseSchema {
+    statusCode: number;
+    contentType: string;
+    schema: any;
+    example?: any;
+}

package/dist/config/types/import-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from './test-configuration';
+export * from './load-config';
+export * from './scenario-config';
+export * from './step-types';
+export * from './output-config';
+export * from './report-config';
+export * from './worker-config';
+export * from './global-config';
+export * from './runtime-types';
+export * from './hooks';
+export * from './import-types';

package/dist/config/types/index.js

@@ -0,0 +1,27 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./test-configuration"), exports);
+__exportStar(require("./load-config"), exports);
+__exportStar(require("./scenario-config"), exports);
+__exportStar(require("./step-types"), exports);
+__exportStar(require("./output-config"), exports);
+__exportStar(require("./report-config"), exports);
+__exportStar(require("./worker-config"), exports);
+__exportStar(require("./global-config"), exports);
+__exportStar(require("./runtime-types"), exports);
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./import-types"), exports);

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

@@ -0,0 +1,32 @@
+/**
+ * Load configuration supports either:
+ * 1. Single load pattern (simple)
+ * 2. Array of load phases (executed sequentially)
+ */
+export type LoadConfig = LoadPhase | LoadPhase[];
+/**
+ * A single load phase configuration
+ * Multiple phases are executed sequentially
+ */
+export interface LoadPhase {
+    name?: string;
+    pattern: 'basic' | 'stepping' | 'arrivals';
+    vus?: number;
+    virtual_users?: number;
+    ramp_up?: string;
+    duration: string;
+    steps?: LoadStep[];
+    rate?: number;
+}
+/**
+ * Load step for stepping pattern
+ */
+export interface LoadStep {
+    users: number;
+    duration: string;
+    ramp_up?: string;
+}
+/**
+ * Helper to get first/primary load phase
+ */
+export declare function getPrimaryLoadPhase(load: LoadConfig): LoadPhase;

package/dist/config/types/load-config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrimaryLoadPhase = getPrimaryLoadPhase;
+/**
+ * Helper to get first/primary load phase
+ */
+function getPrimaryLoadPhase(load) {
+    return Array.isArray(load) ? load[0] : load;
+}

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

@@ -0,0 +1,10 @@
+export interface OutputConfig {
+    type: 'csv' | 'json' | 'html' | 'influxdb' | 'graphite' | 'webhook';
+    enabled?: boolean;
+    file?: string;
+    url?: string;
+    database?: string;
+    tags?: Record<string, string>;
+    headers?: Record<string, string>;
+    template?: string;
+}

package/dist/config/types/output-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,10 @@
+export interface ReportConfig {
+    generate?: boolean;
+    output: string;
+    percentiles?: number[];
+    template?: string;
+    title?: string;
+    include_charts?: boolean;
+    include_raw_data?: boolean;
+    custom_metrics?: string[];
+}

package/dist/config/types/report-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,6 @@
+export interface VUContext {
+    vu_id: number;
+    iteration: number;
+    variables: Record<string, any>;
+    extracted_data: Record<string, any>;
+}

package/dist/config/types/runtime-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,30 @@
+import { CSVDataConfig } from '../../core/csv-data-provider';
+import { Step } from './step-types';
+import { ScenarioHooks, LoopHooks } from './hooks';
+export interface Scenario {
+    name: string;
+    description?: string;
+    weight?: number;
+    loop?: number | LoopConfig;
+    think_time?: string | number;
+    setup?: string;
+    teardown?: string;
+    variables?: Record<string, any>;
+    steps: Step[];
+    csv_data?: CSVDataConfig;
+    csv_mode?: 'next' | 'unique' | 'random';
+    condition?: string;
+    enabled?: boolean;
+    hooks?: ScenarioHooks & LoopHooks;
+}
+/**
+ * Enhanced loop configuration for scenarios
+ */
+export interface LoopConfig {
+    count?: number;
+    duration?: string;
+    mode?: 'count' | 'duration' | 'while' | 'until';
+    condition?: string;
+    break_on_error?: boolean;
+    max_errors?: number;
+}

package/dist/config/types/scenario-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });