@testsmith/perfornium 0.1.0

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

@@ -0,0 +1,139 @@
+import { StepHooks } from "./hooks";
+export type Step = RESTStep | SOAPStep | WebStep | CustomStep | WaitStep | ScriptStep;
+export interface BaseStep {
+    name?: string;
+    type?: 'rest' | 'soap' | 'web' | 'custom' | 'wait' | 'script';
+    condition?: string;
+    continueOnError?: boolean;
+    hooks?: StepHooks;
+    retry?: RetryConfig;
+    thresholds?: ThresholdConfig[];
+    think_time?: string | number;
+}
+export interface ThresholdConfig {
+    metric: 'response_time' | 'status_code' | 'error_rate' | 'throughput' | 'custom';
+    value: number | string;
+    operator?: 'lt' | 'lte' | 'gt' | 'gte' | 'eq' | 'ne';
+    severity?: 'warning' | 'error' | 'critical';
+    description?: string;
+    action?: 'log' | 'fail_step' | 'fail_scenario' | 'fail_test' | 'abort';
+    custom_script?: string;
+}
+export interface RetryConfig {
+    max_attempts: number;
+    delay?: string | number;
+    backoff?: 'linear' | 'exponential';
+}
+export interface RESTStep extends BaseStep {
+    type?: 'rest';
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | string;
+    path: string;
+    headers?: Record<string, string>;
+    body?: string | object;
+    json?: string | object;
+    jsonFile?: string;
+    overrides?: Record<string, any>;
+    xml?: string;
+    form?: Record<string, string>;
+    multipart?: Record<string, string | File | Blob>;
+    timeout?: number;
+    checks?: CheckConfig[];
+    extract?: ExtractConfig[];
+    query?: Record<string, string | number | boolean>;
+    auth?: {
+        type: 'basic' | 'bearer' | 'digest' | 'oauth';
+        username?: string;
+        password?: string;
+        token?: string;
+    };
+}
+export interface SOAPStep extends BaseStep {
+    type: 'soap';
+    wsdl?: string;
+    operation: string;
+    args: any;
+    body?: string;
+    checks?: CheckConfig[];
+    extract?: ExtractConfig[];
+}
+export interface WebStep extends BaseStep {
+    type: 'web';
+    action: WebAction;
+    checks?: CheckConfig[];
+    extract?: ExtractConfig[];
+}
+export interface CustomStep extends BaseStep {
+    type: 'custom';
+    script: string;
+    timeout?: number;
+}
+export interface WaitStep extends BaseStep {
+    type: 'wait';
+    duration: string | number;
+}
+export interface ScriptStep extends BaseStep {
+    type: 'script';
+    file: string;
+    function: string;
+    params?: Record<string, any>;
+    returns?: string;
+    timeout?: number;
+}
+export interface WebAction {
+    name?: string;
+    expected_text?: string;
+    command: 'goto' | 'click' | 'fill' | 'press' | 'select' | 'hover' | 'screenshot' | 'wait_for_selector' | 'wait_for_text' | 'verify_text' | 'verify_contains' | 'verify_not_exists' | 'verify_exists' | 'verify_visible' | 'evaluate' | 'measure_web_vitals' | 'measure_verification' | 'performance_audit' | 'accessibility_audit' | 'wait_for_load_state' | 'network_idle' | 'dom_ready';
+    selector?: string;
+    url?: string;
+    value?: string | string[];
+    key?: string;
+    text?: string;
+    script?: string;
+    timeout?: number;
+    options?: Record<string, any>;
+    measureWebVitals?: boolean;
+    collectWebVitals?: boolean;
+    webVitalsWaitTime?: number;
+    webVitalsThresholds?: {
+        lcp?: {
+            good: number;
+            poor: number;
+        };
+        fid?: {
+            good: number;
+            poor: number;
+        };
+        cls?: {
+            good: number;
+            poor: number;
+        };
+        fcp?: {
+            good: number;
+            poor: number;
+        };
+        ttfb?: {
+            good: number;
+            poor: number;
+        };
+    };
+    measureVerification?: boolean;
+    verificationName?: string;
+    auditCategories?: ('performance' | 'accessibility' | 'best-practices' | 'seo')[];
+    lighthouse?: boolean;
+    waitUntil?: 'load' | 'domcontentloaded' | 'networkidle' | 'commit';
+    networkIdleTimeout?: number;
+}
+export interface CheckConfig {
+    type: 'status' | 'response_time' | 'json_path' | 'text_contains' | 'selector' | 'url_contains' | 'custom';
+    value?: any;
+    operator?: 'equals' | 'contains' | 'exists' | 'lt' | 'gt' | 'lte' | 'gte';
+    description?: string;
+    script?: string;
+}
+export interface ExtractConfig {
+    name: string;
+    type: 'json_path' | 'regex' | 'header' | 'selector' | 'custom';
+    expression: string;
+    script?: string;
+    default?: any;
+}

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

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

package/dist/config/types/test-configuration.d.ts

@@ -0,0 +1,18 @@
+import { GlobalConfig } from './global-config';
+import { LoadConfig } from './load-config';
+import { Scenario } from './scenario-config';
+import { OutputConfig } from './output-config';
+import { ReportConfig } from './report-config';
+import { WorkerConfig } from './worker-config';
+import { DebugConfig } from './global-config';
+export interface TestConfiguration {
+    name: string;
+    description?: string;
+    global?: GlobalConfig;
+    load: LoadConfig;
+    scenarios: Scenario[];
+    outputs?: OutputConfig[];
+    report?: ReportConfig;
+    workers?: WorkerConfig;
+    debug?: DebugConfig;
+}

package/dist/config/types/test-configuration.js

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

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

@@ -0,0 +1,12 @@
+export interface DistributedWorkerConfig {
+    enabled: boolean;
+    workers: string[];
+    coordinator_port?: number;
+    load_balancing?: 'round_robin' | 'least_loaded' | 'random';
+}
+export interface WorkerConfig extends DistributedWorkerConfig {
+    host?: string;
+    port?: number;
+    capacity?: number;
+    region?: string;
+}

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

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

package/dist/config/validator.d.ts

@@ -0,0 +1,19 @@
+import { TestConfiguration } from './types';
+export declare class ConfigValidator {
+    validate(config: TestConfiguration): ValidationResult;
+    private validateLoadConfig;
+    private validateScenarios;
+    private validateStep;
+    private validateRESTStep;
+    private validateSOAPStep;
+    private validateWebStep;
+    private validateCustomStep;
+    private validateWaitStep;
+    private validateScriptStep;
+    private validateOutputs;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}

package/dist/config/validator.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidator = void 0;
+class ConfigValidator {
+    validate(config) {
+        const errors = [];
+        const warnings = [];
+        // Basic validation
+        if (!config.name) {
+            errors.push('Test name is required');
+        }
+        if (!config.load) {
+            errors.push('Load configuration is required');
+        }
+        else {
+            this.validateLoadConfig(config.load, errors, warnings);
+        }
+        if (!config.scenarios || config.scenarios.length === 0) {
+            errors.push('At least one scenario must be configured');
+        }
+        else {
+            this.validateScenarios(config.scenarios, errors, warnings);
+        }
+        // Validate outputs
+        if (config.outputs) {
+            this.validateOutputs(config.outputs, errors, warnings);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    validateLoadConfig(load, errors, warnings) {
+        const validPatterns = ['basic', 'stepping', 'arrivals', 'mixed'];
+        if (!validPatterns.includes(load.pattern)) {
+            errors.push(`Invalid load pattern: ${load.pattern}. Valid patterns: ${validPatterns.join(', ')}`);
+        }
+        if (load.pattern === 'basic') {
+            if (!load.virtual_users) {
+                errors.push('virtual_users is required for basic load pattern');
+            }
+            if (!load.duration) {
+                warnings.push('duration not specified for basic pattern');
+            }
+        }
+        if (load.pattern === 'stepping') {
+            if (!load.steps || load.steps.length === 0) {
+                errors.push('steps configuration is required for stepping load pattern');
+            }
+        }
+        if (load.pattern === 'arrivals') {
+            if (!load.rate) {
+                errors.push('rate is required for arrivals load pattern');
+            }
+        }
+        // Validate reasonable limits
+        if (load.virtual_users && load.virtual_users > 1000) {
+            warnings.push(`High virtual user count (${load.virtual_users}). Consider distributed testing.`);
+        }
+    }
+    validateScenarios(scenarios, errors, warnings) {
+        scenarios.forEach((scenario, index) => {
+            if (!scenario.name) {
+                errors.push(`Scenario at index ${index} must have a name`);
+            }
+            if (!scenario.steps || scenario.steps.length === 0) {
+                errors.push(`Scenario '${scenario.name}' must have at least one step`);
+            }
+            // Validate steps
+            scenario.steps?.forEach((step, stepIndex) => {
+                this.validateStep(step, stepIndex, scenario.name, errors, warnings);
+            });
+            // Validate weights
+            if (scenario.weight && (scenario.weight < 0 || scenario.weight > 100)) {
+                warnings.push(`Scenario '${scenario.name}' weight should be between 0-100`);
+            }
+        });
+        // Check total weights
+        const totalWeight = scenarios.reduce((sum, s) => sum + (s.weight || 100), 0);
+        if (totalWeight > scenarios.length * 100) {
+            warnings.push('Total scenario weights exceed 100% per scenario');
+        }
+    }
+    validateStep(step, index, scenarioName, errors, warnings) {
+        const stepType = step.type || 'rest';
+        if (!stepType) {
+            errors.push(`Step at index ${index} in scenario '${scenarioName}' must have a type`);
+            return;
+        }
+        const validTypes = ['rest', 'soap', 'web', 'custom', 'wait', 'script'];
+        if (!validTypes.includes(stepType)) {
+            errors.push(`Invalid step type '${stepType}' at index ${index} in scenario '${scenarioName}'`);
+        }
+        // Type-specific validation
+        switch (stepType) {
+            case 'rest':
+                this.validateRESTStep(step, index, scenarioName, errors, warnings);
+                break;
+            case 'soap':
+                this.validateSOAPStep(step, index, scenarioName, errors);
+                break;
+            case 'web':
+                this.validateWebStep(step, index, scenarioName, errors);
+                break;
+            case 'custom':
+                this.validateCustomStep(step, index, scenarioName, errors, warnings);
+                break;
+            case 'wait':
+                this.validateWaitStep(step, index, scenarioName, errors);
+                break;
+            case 'script':
+                this.validateScriptStep(step, index, scenarioName, errors);
+                break;
+        }
+    }
+    validateRESTStep(step, index, scenarioName, errors, warnings) {
+        if (!step.method) {
+            errors.push(`REST step at index ${index} in scenario '${scenarioName}' must have a method`);
+        }
+        if (!step.path) {
+            errors.push(`REST step at index ${index} in scenario '${scenarioName}' must have a path`);
+        }
+        const validMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+        if (step.method && !validMethods.includes(step.method.toUpperCase())) {
+            warnings.push(`Unusual HTTP method '${step.method}' in scenario '${scenarioName}'`);
+        }
+    }
+    validateSOAPStep(step, index, scenarioName, errors) {
+        if (!step.operation) {
+            errors.push(`SOAP step at index ${index} in scenario '${scenarioName}' must have an operation`);
+        }
+    }
+    validateWebStep(step, index, scenarioName, errors) {
+        if (!step.action) {
+            errors.push(`Web step at index ${index} in scenario '${scenarioName}' must have an action`);
+            return;
+        }
+        if (!step.action.command) {
+            errors.push(`Web action at index ${index} in scenario '${scenarioName}' must have a command`);
+        }
+        const validCommands = ['goto', 'click', 'fill', 'press', 'select', 'hover', 'screenshot', 'wait_for_selector', 'wait_for_text', 'evaluate', 'verify_text', 'verify_contains', 'verify_not_exists', 'verify_exists', 'verify_visible', 'measure_web_vitals', 'performance_audit', 'wait_for_load_state', 'network_idle', 'dom_ready'];
+        if (step.action.command && !validCommands.includes(step.action.command)) {
+            errors.push(`Invalid web command '${step.action.command}' at index ${index} in scenario '${scenarioName}'`);
+        }
+    }
+    validateCustomStep(step, index, scenarioName, errors, warnings) {
+        if (!step.script) {
+            errors.push(`Custom step at index ${index} in scenario '${scenarioName}' must have a script`);
+        }
+        if (step.script && step.script.includes('eval(')) {
+            warnings.push(`Custom step in scenario '${scenarioName}' uses eval() which may be unsafe`);
+        }
+    }
+    validateWaitStep(step, index, scenarioName, errors) {
+        if (!step.duration) {
+            errors.push(`Wait step at index ${index} in scenario '${scenarioName}' must have a duration`);
+        }
+    }
+    validateScriptStep(step, index, scenarioName, errors) {
+        if (!step.file) {
+            errors.push(`Script step at index ${index} in scenario '${scenarioName}' must have a file`);
+        }
+        if (!step.function) {
+            errors.push(`Script step at index ${index} in scenario '${scenarioName}' must have a function name`);
+        }
+    }
+    validateOutputs(outputs, errors, warnings) {
+        const validTypes = ['csv', 'json', 'influxdb', 'graphite', 'webhook'];
+        outputs.forEach((output, index) => {
+            if (!output.type) {
+                errors.push(`Output at index ${index} must have a type`);
+                return;
+            }
+            if (!validTypes.includes(output.type)) {
+                errors.push(`Invalid output type '${output.type}' at index ${index}`);
+            }
+            // Type-specific validation
+            if (['csv', 'json'].includes(output.type) && !output.file) {
+                errors.push(`${output.type.toUpperCase()} output at index ${index} must specify a file`);
+            }
+            if (['influxdb', 'graphite', 'webhook'].includes(output.type) && !output.url) {
+                errors.push(`${output.type} output at index ${index} must specify a URL`);
+            }
+            if (output.type === 'influxdb' && !output.database) {
+                errors.push(`InfluxDB output at index ${index} must specify a database`);
+            }
+        });
+        // Check for duplicate file outputs
+        const fileOutputs = outputs.filter(o => o.file);
+        const filePaths = fileOutputs.map(o => o.file);
+        const duplicates = filePaths.filter((path, index) => filePaths.indexOf(path) !== index);
+        if (duplicates.length > 0) {
+            warnings.push(`Duplicate output files detected: ${duplicates.join(', ')}`);
+        }
+    }
+}
+exports.ConfigValidator = ConfigValidator;

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

@@ -0,0 +1,47 @@
+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;
+}