@testsmith/perfornium 0.6.4 → 0.6.5

package/dist/core/csv-data-provider.d.ts

@@ -1,47 +0,0 @@
-export interface CSVDataConfig {
-    file: string;
-    delimiter?: string;
-    encoding?: BufferEncoding;
-    skipEmptyLines?: boolean;
-    skipFirstLine?: boolean;
-    columns?: string[];
-    filter?: string;
-    randomize?: boolean;
-    cycleOnExhaustion?: boolean;
-    /** Map CSV column names to custom variable names: { "csv_column": "variable_name" } */
-    variables?: Record<string, string>;
-}
-export interface CSVDataRow {
-    [key: string]: string | number | boolean;
-}
-export declare class CSVDataProvider {
-    private static instances;
-    private static baseDir;
-    private filePath;
-    private data;
-    private originalData;
-    private currentIndex;
-    private config;
-    private isLoaded;
-    private isExhausted;
-    private globalIndex;
-    private accessCount;
-    private constructor();
-    static getInstance(config: CSVDataConfig): CSVDataProvider;
-    static setBaseDir(dir: string): void;
-    loadData(): Promise<void>;
-    /**
-     * Enhanced getNextRow - returns null when exhausted if cycleOnExhaustion is false
-     */
-    getNextRow(vuId: number): Promise<CSVDataRow | null>;
-    /**
-     * Enhanced getUniqueRow - returns null when exhausted if cycleOnExhaustion is false
-     */
-    getUniqueRow(vuId: number): Promise<CSVDataRow | null>;
-    /**
-     * Enhanced getRandomRow - returns null when exhausted if cycleOnExhaustion is false
-     */
-    getRandomRow(vuId?: number): Promise<CSVDataRow | null>;
-    private filterData;
-    private shuffleArray;
-}

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

@@ -1,265 +0,0 @@
-"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/reporting/generator.d.ts

@@ -1,42 +0,0 @@
-import { TestResult, MetricsSummary } from '../metrics/types';
-import { ReportConfig } from '../config/types';
-export interface ReportData {
-    testName: string;
-    summary: MetricsSummary;
-    results: TestResult[];
-}
-export declare class HTMLReportGenerator {
-    constructor();
-    private registerHelpers;
-    generate(data: ReportData, config: ReportConfig, outputPath: string): Promise<void>;
-    /**
-     * Enhanced step statistics with min, max, and additional percentiles
-     * Only includes measurable results (verifications, not actions like click/fill)
-     */
-    private calculateStepStatistics;
-    /**
-     * Calculate requests per second over time
-     */
-    private calculateRequestsPerSecondData;
-    /**
-     * Calculate responses per second over time (successful responses)
-     */
-    private calculateResponsesPerSecondData;
-    /**
-     * Generate proper filename with timestamp and test name from config
-     */
-    generateFilename(testName: string, type: 'html' | 'csv' | 'json' | 'summary', configPath?: string): string;
-    /**
-     * Extract test name from YAML config file
-     */
-    private extractTestNameFromConfig;
-    private calculateVURampupData;
-    private calculateTimelineData;
-    private prepareChartData;
-    private groupByScenario;
-    private calculateStepResponseTimes;
-    private calculateScenarioStatistics;
-    private getDefaultTemplatePath;
-    private getBuiltInTemplate;
-    private getEnhancedTemplate;
-}