@testsmith/perfornium 0.1.0

package/dist/importers/wsdl-importer.js

@@ -0,0 +1,440 @@
+"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.WSDLImporter = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class WSDLImporter {
+    constructor(wsdlContent) {
+        this.selectedSoapVersions = [];
+        this.wsdlContent = wsdlContent;
+    }
+    detectSoapVersions() {
+        const versions = [];
+        // Find SOAP 1.1 bindings
+        const soap11BindingRegex = /<wsdl:binding[^>]*name="([^"]*)"[^>]*>[\s\S]*?<soap:binding[^>]*>[\s\S]*?<\/wsdl:binding>/g;
+        let soap11Match;
+        while ((soap11Match = soap11BindingRegex.exec(this.wsdlContent)) !== null) {
+            if (!versions.some(v => v.bindingName === soap11Match[1])) {
+                versions.push({
+                    version: '1.1',
+                    bindingName: soap11Match[1],
+                    description: 'SOAP 1.1 (Legacy, widely supported)'
+                });
+            }
+        }
+        // Find SOAP 1.2 bindings
+        const soap12BindingRegex = /<wsdl:binding[^>]*name="([^"]*)"[^>]*>[\s\S]*?<soap12:binding[^>]*>[\s\S]*?<\/wsdl:binding>/g;
+        let soap12Match;
+        while ((soap12Match = soap12BindingRegex.exec(this.wsdlContent)) !== null) {
+            if (!versions.some(v => v.bindingName === soap12Match[1])) {
+                versions.push({
+                    version: '1.2',
+                    bindingName: soap12Match[1],
+                    description: 'SOAP 1.2 (Modern, more features)'
+                });
+            }
+        }
+        return versions;
+    }
+    setSoapVersions(versions) {
+        this.selectedSoapVersions = versions;
+    }
+    extractServices() {
+        const services = [];
+        try {
+            const serviceElements = this.extractServiceElements();
+            for (const serviceElement of serviceElements) {
+                const serviceName = this.extractAttribute(serviceElement.content, 'name') || 'UnknownService';
+                const ports = this.extractPortElements(serviceElement.content);
+                for (const port of ports) {
+                    const bindingName = this.extractAttribute(port.content, 'binding')?.replace('tns:', '') || '';
+                    if (!this.isBindingVersionSelected(bindingName)) {
+                        continue;
+                    }
+                    const endpoint = this.extractEndpointFromPort(port.content);
+                    const soapVersion = this.getSoapVersionFromBinding(bindingName);
+                    const operations = this.extractOperationsFromBinding(bindingName);
+                    for (const operation of operations) {
+                        services.push(this.createImportableEndpoint({
+                            serviceName,
+                            bindingName,
+                            endpoint,
+                            soapVersion,
+                            operation
+                        }));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error parsing WSDL:', error);
+        }
+        return services;
+    }
+    generateOutputFilename(baseFilename) {
+        if (!fs.existsSync(baseFilename)) {
+            return baseFilename;
+        }
+        const ext = path.extname(baseFilename);
+        const nameWithoutExt = path.basename(baseFilename, ext);
+        const dir = path.dirname(baseFilename);
+        let counter = 1;
+        let newFilename;
+        do {
+            newFilename = path.join(dir, `${nameWithoutExt}_${counter}${ext}`);
+            counter++;
+        } while (fs.existsSync(newFilename));
+        return newFilename;
+    }
+    generateScenarios(selectedServices) {
+        return selectedServices.map(service => {
+            const operationName = service.name.split('.').pop() || 'Unknown';
+            const args = this.generateArgsFromSchema(service.requestBody?.schema);
+            const soapVersion = service.tags?.find(tag => tag.startsWith('SOAP-'))?.replace('SOAP-', '') || '1.1';
+            return {
+                name: `test_${service.name.toLowerCase().replace(/\./g, '_')}`,
+                steps: [{
+                        name: service.name,
+                        type: 'soap',
+                        operation: operationName,
+                        args: args,
+                        body: service.requestBody?.example || this.generateSOAPExample(operationName, service.requestBody?.schema, soapVersion),
+                        extract: this.generateSOAPExtractions(operationName)
+                    }]
+            };
+        });
+    }
+    getWsdlUrl(selectedServices) {
+        return selectedServices.length > 0 ? this.extractWsdlUrl(selectedServices[0]) : '';
+    }
+    // Private helper methods
+    extractServiceElements() {
+        const serviceRegex = /<wsdl:service[^>]*name="([^"]*)"[^>]*>([\s\S]*?)<\/wsdl:service>/g;
+        const services = [];
+        let serviceMatch;
+        while ((serviceMatch = serviceRegex.exec(this.wsdlContent)) !== null) {
+            services.push({
+                name: serviceMatch[1],
+                content: serviceMatch[2]
+            });
+        }
+        return services;
+    }
+    extractPortElements(serviceContent) {
+        const portRegex = /<wsdl:port[^>]*name="([^"]*)"[^>]*>([\s\S]*?)<\/wsdl:port>/g;
+        const ports = [];
+        let portMatch;
+        while ((portMatch = portRegex.exec(serviceContent)) !== null) {
+            ports.push({
+                name: portMatch[1],
+                content: portMatch[0] // Include the full port element
+            });
+        }
+        return ports;
+    }
+    extractEndpointFromPort(portContent) {
+        const soapAddressMatch = portContent.match(/location="([^"]*)"/);
+        return soapAddressMatch ? soapAddressMatch[1] : '/soap';
+    }
+    isBindingVersionSelected(bindingName) {
+        if (this.selectedSoapVersions.length === 0) {
+            return true;
+        }
+        const soapVersion = this.getSoapVersionFromBinding(bindingName);
+        return this.selectedSoapVersions.includes(soapVersion);
+    }
+    getSoapVersionFromBinding(bindingName) {
+        const bindingRegex = new RegExp(`<wsdl:binding[^>]*name="${bindingName}"[^>]*>([\\s\\S]*?)<\\/wsdl:binding>`, 'i');
+        const bindingMatch = this.wsdlContent.match(bindingRegex);
+        if (bindingMatch && bindingMatch[1].includes('soap12:binding')) {
+            return '1.2';
+        }
+        return '1.1';
+    }
+    extractOperationsFromBinding(bindingName) {
+        const bindingRegex = new RegExp(`<wsdl:binding[^>]*name="${bindingName}"[^>]*>([\\s\\S]*?)<\\/wsdl:binding>`, 'i');
+        const bindingMatch = this.wsdlContent.match(bindingRegex);
+        if (!bindingMatch)
+            return [];
+        const operations = [];
+        const operationRegex = /<wsdl:operation[^>]*name="([^"]*)"[^>]*>([\s\S]*?)<\/wsdl:operation>/g;
+        let operationMatch;
+        while ((operationMatch = operationRegex.exec(bindingMatch[1])) !== null) {
+            const operationName = operationMatch[1];
+            const operationContent = operationMatch[2];
+            const soapAction = this.extractSoapAction(operationContent);
+            const documentation = this.getOperationDocumentation(operationName);
+            const inputSchema = this.parseSchemaElement(operationName);
+            const outputSchema = this.parseSchemaElement(`${operationName}Response`);
+            operations.push({
+                name: operationName,
+                soapAction,
+                documentation,
+                inputSchema,
+                outputSchema
+            });
+        }
+        return operations;
+    }
+    extractSoapAction(operationContent) {
+        const soapActionMatch = operationContent.match(/soapAction="([^"]*)"/);
+        return soapActionMatch ? soapActionMatch[1] : '';
+    }
+    getOperationDocumentation(operationName) {
+        const operationRegex = new RegExp(`<wsdl:operation[^>]*name="${operationName}"[^>]*>([\\s\\S]*?)<\\/wsdl:operation>`, 'i');
+        const operationMatch = this.wsdlContent.match(operationRegex);
+        if (operationMatch) {
+            const docMatch = operationMatch[1].match(/<wsdl:documentation[^>]*>([\s\S]*?)<\/wsdl:documentation>/i);
+            return docMatch ? docMatch[1].trim() : undefined;
+        }
+        return undefined;
+    }
+    parseSchemaElement(elementName) {
+        const elementRegex = new RegExp(`<s:element[^>]*name="${elementName}"[^>]*>([\\s\\S]*?)<\\/s:element>`, 'i');
+        const elementMatch = this.wsdlContent.match(elementRegex);
+        if (!elementMatch)
+            return { type: 'object', properties: {} };
+        const sequenceMatch = elementMatch[1].match(/<s:sequence[^>]*>([\s\S]*?)<\/s:sequence>/i);
+        if (!sequenceMatch)
+            return { type: 'object', properties: {} };
+        const fields = {};
+        const fieldRegex = /<s:element[^>]*name="([^"]*)"[^>]*type="([^"]*)"[^>]*minOccurs="([^"]*)"[^>]*\/?>|<s:element[^>]*name="([^"]*)"[^>]*type="([^"]*)"[^>]*>/g;
+        let fieldMatch;
+        while ((fieldMatch = fieldRegex.exec(sequenceMatch[1])) !== null) {
+            const name = fieldMatch[1] || fieldMatch[4];
+            const type = fieldMatch[2] || fieldMatch[5];
+            const minOccurs = fieldMatch[3];
+            if (name && type) {
+                fields[name] = {
+                    type: this.mapXsdType(type),
+                    required: minOccurs === '1',
+                    description: `${name} parameter`
+                };
+            }
+        }
+        return { type: 'object', properties: fields };
+    }
+    mapXsdType(xsdType) {
+        const typeMap = {
+            's:int': 'integer',
+            's:string': 'string',
+            's:double': 'number',
+            's:float': 'number',
+            's:boolean': 'boolean',
+            's:dateTime': 'string'
+        };
+        return typeMap[xsdType] || 'string';
+    }
+    createImportableEndpoint(config) {
+        const { serviceName, bindingName, endpoint, soapVersion, operation } = config;
+        return {
+            id: `${serviceName}_${bindingName}_${operation.name}_${soapVersion}`,
+            name: `${serviceName}.${operation.name}`,
+            method: 'POST',
+            path: this.getPathFromUrl(endpoint),
+            description: `${operation.documentation || `${operation.name} operation`} (SOAP ${soapVersion})`,
+            requestBody: {
+                contentType: this.getContentType(soapVersion),
+                schema: operation.inputSchema,
+                example: this.generateSOAPExample(operation.name, operation.inputSchema, soapVersion),
+                required: true
+            },
+            responses: [{
+                    statusCode: 200,
+                    contentType: this.getResponseContentType(soapVersion),
+                    schema: operation.outputSchema,
+                    example: this.generateSOAPResponseExample(operation.name, operation.outputSchema, soapVersion)
+                }],
+            parameters: this.generateSOAPParameters(operation.soapAction, soapVersion),
+            tags: ['SOAP', serviceName, `SOAP-${soapVersion}`],
+            selected: false
+        };
+    }
+    getContentType(soapVersion) {
+        return soapVersion === '1.2'
+            ? 'application/soap+xml; charset=utf-8'
+            : 'text/xml; charset=utf-8';
+    }
+    getResponseContentType(soapVersion) {
+        return soapVersion === '1.2' ? 'application/soap+xml' : 'text/xml';
+    }
+    generateSOAPParameters(soapAction, soapVersion) {
+        if (soapVersion === '1.2') {
+            return [{
+                    name: 'Content-Type',
+                    in: 'header',
+                    required: true,
+                    type: 'string',
+                    description: 'SOAP 1.2 Content Type with action',
+                    example: `application/soap+xml; charset=utf-8; action="${soapAction}"`
+                }];
+        }
+        else {
+            return [{
+                    name: 'SOAPAction',
+                    in: 'header',
+                    required: true,
+                    type: 'string',
+                    description: 'SOAP 1.1 Action header',
+                    example: `"${soapAction}"`
+                }];
+        }
+    }
+    generateSOAPExample(operationName, schema, soapVersion) {
+        const targetNamespace = this.getTargetNamespace();
+        const params = this.generateSampleParameters(schema);
+        if (soapVersion === '1.2') {
+            return `<?xml version="1.0" encoding="utf-8"?>
+<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+                 xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+                 xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
+  <soap12:Body>
+    <${operationName} xmlns="${targetNamespace}">
+      ${params}
+    </${operationName}>
+  </soap12:Body>
+</soap12:Envelope>`;
+        }
+        else {
+            return `<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+               xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+               xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+  <soap:Body>
+    <${operationName} xmlns="${targetNamespace}">
+      ${params}
+    </${operationName}>
+  </soap:Body>
+</soap:Envelope>`;
+        }
+    }
+    generateSOAPResponseExample(operationName, schema, soapVersion) {
+        const targetNamespace = this.getTargetNamespace();
+        const responseParams = this.generateSampleParameters(schema);
+        const responseElementName = `${operationName}Response`;
+        if (soapVersion === '1.2') {
+            return `<?xml version="1.0" encoding="utf-8"?>
+<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+                 xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+                 xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
+  <soap12:Body>
+    <${responseElementName} xmlns="${targetNamespace}">
+      ${responseParams}
+    </${responseElementName}>
+  </soap12:Body>
+</soap12:Envelope>`;
+        }
+        else {
+            return `<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+               xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+               xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+  <soap:Body>
+    <${responseElementName} xmlns="${targetNamespace}">
+      ${responseParams}
+    </${responseElementName}>
+  </soap:Body>
+</soap:Envelope>`;
+        }
+    }
+    generateSampleParameters(schema) {
+        if (!schema?.properties)
+            return '';
+        return Object.entries(schema.properties)
+            .map(([name, prop]) => {
+            const sampleValue = this.getSampleValue(prop.type);
+            return `<${name}>${sampleValue}</${name}>`;
+        })
+            .join('\n      ');
+    }
+    getSampleValue(type) {
+        switch (type) {
+            case 'integer': return 1;
+            case 'number': return 1.0;
+            case 'boolean': return 'true';
+            default: return 'sample';
+        }
+    }
+    generateArgsFromSchema(schema) {
+        if (!schema?.properties)
+            return {};
+        const args = {};
+        Object.entries(schema.properties).forEach(([name, prop]) => {
+            args[name] = this.getSampleValue(prop.type);
+        });
+        return args;
+    }
+    extractWsdlUrl(service) {
+        // Extract base URL from path and construct WSDL URL
+        const basePath = service.path.replace('.asmx', '');
+        return `http://www.dneonline.com${basePath}.asmx?wsdl`;
+    }
+    generateSOAPExtractions(operationName) {
+        return [
+            {
+                name: 'soap_fault',
+                type: 'regex',
+                expression: '<soap:Fault[^>]*>([\\s\\S]*?)</soap:Fault>',
+                optional: true
+            },
+            {
+                name: `${operationName.toLowerCase()}_result`,
+                type: 'regex',
+                expression: `<${operationName}Result[^>]*>([^<]*)</${operationName}Result>`
+            }
+        ];
+    }
+    getPathFromUrl(url) {
+        try {
+            const urlObj = new URL(url);
+            return urlObj.pathname;
+        }
+        catch {
+            const pathMatch = url.match(/^https?:\/\/[^\/]+(.*)$/);
+            return pathMatch ? pathMatch[1] : '/calculator.asmx';
+        }
+    }
+    getTargetNamespace() {
+        const namespaceMatch = this.wsdlContent.match(/targetNamespace="([^"]*)"/);
+        return namespaceMatch ? namespaceMatch[1] : 'http://tempuri.org/';
+    }
+    extractAttribute(xmlString, attributeName) {
+        const regex = new RegExp(`${attributeName}="([^"]*)"`, 'i');
+        const match = xmlString.match(regex);
+        return match ? match[1] : null;
+    }
+}
+exports.WSDLImporter = WSDLImporter;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { test, testData, TestBuilder, ScenarioBuilder, LoadBuilder, load } from './dsl/test-builder';
+export type { ScenarioContext } from './dsl/test-builder';
+export { TestRunner } from './core/test-runner';
+export { ConfigParser } from './config/parser';
+export type { TestConfiguration, Scenario, Step, VUContext } from './config/types';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+// src/index.ts (builds to dist/index.js)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigParser = exports.TestRunner = exports.load = exports.LoadBuilder = exports.ScenarioBuilder = exports.TestBuilder = exports.testData = exports.test = void 0;
+// Export everything from test-builder
+var test_builder_1 = require("./dsl/test-builder");
+Object.defineProperty(exports, "test", { enumerable: true, get: function () { return test_builder_1.test; } });
+Object.defineProperty(exports, "testData", { enumerable: true, get: function () { return test_builder_1.testData; } });
+Object.defineProperty(exports, "TestBuilder", { enumerable: true, get: function () { return test_builder_1.TestBuilder; } });
+Object.defineProperty(exports, "ScenarioBuilder", { enumerable: true, get: function () { return test_builder_1.ScenarioBuilder; } });
+Object.defineProperty(exports, "LoadBuilder", { enumerable: true, get: function () { return test_builder_1.LoadBuilder; } });
+Object.defineProperty(exports, "load", { enumerable: true, get: function () { return test_builder_1.load; } });
+// Export TestRunner and ConfigParser
+var test_runner_1 = require("./core/test-runner");
+Object.defineProperty(exports, "TestRunner", { enumerable: true, get: function () { return test_runner_1.TestRunner; } });
+var parser_1 = require("./config/parser");
+Object.defineProperty(exports, "ConfigParser", { enumerable: true, get: function () { return parser_1.ConfigParser; } });

package/dist/load-patterns/arrivals.d.ts

@@ -0,0 +1,7 @@
+import { LoadPattern, VUFactory } from './base';
+export declare class ArrivalsPattern implements LoadPattern {
+    execute(config: any, vuFactory: VUFactory): Promise<void>;
+    private createAndRunVU;
+    private createVU;
+    private runVUForDuration;
+}

package/dist/load-patterns/arrivals.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrivalsPattern = void 0;
+const time_1 = require("../utils/time");
+const logger_1 = require("../utils/logger");
+class ArrivalsPattern {
+    async execute(config, vuFactory) {
+        const rate = config.rate; // users per second
+        const duration = (0, time_1.parseTime)(config.duration || '5m');
+        const rampUp = (0, time_1.parseTime)(config.ramp_up || '0s');
+        const vuDuration = (0, time_1.parseTime)(config.vu_duration || '30s'); // How long each VU runs
+        if (!rate || rate <= 0) {
+            throw new Error('Arrivals pattern requires a positive rate');
+        }
+        logger_1.logger.info(`🎯 Arrivals: ${rate} users/sec, test duration: ${(duration / 1000).toFixed(1)}s, VU duration: ${(vuDuration / 1000).toFixed(1)}s`);
+        const targetIntervalMs = 1000 / rate;
+        let vuId = 0;
+        let currentRate = 0;
+        const testStartTime = Date.now();
+        const testEndTime = testStartTime + duration;
+        // Gradually ramp up to target rate
+        if (rampUp > 0) {
+            const rampSteps = Math.ceil(rampUp / 1000); // 1 second intervals
+            const rateIncrement = rate / rampSteps;
+            for (let step = 1; step <= rampSteps && Date.now() < testEndTime; step++) {
+                currentRate = Math.min(rate, step * rateIncrement);
+                const stepInterval = 1000 / currentRate;
+                logger_1.logger.debug(`📈 Ramp-up step ${step}/${rampSteps}: ${currentRate.toFixed(2)} users/sec`);
+                const stepEndTime = Math.min(Date.now() + 1000, testEndTime);
+                while (Date.now() < stepEndTime) {
+                    const vuStartTime = Date.now();
+                    // CRITICAL: Create and run VU but don't block the arrivals rate
+                    this.createAndRunVU(vuFactory, ++vuId, vuDuration, vuStartTime);
+                    await (0, time_1.sleep)(stepInterval);
+                    if (Date.now() >= testEndTime) {
+                        break;
+                    }
+                }
+            }
+        }
+        // Run at target rate for remaining duration
+        const remainingTestTime = testEndTime - Date.now();
+        if (remainingTestTime > 0) {
+            logger_1.logger.debug(`🎯 Running at target rate: ${rate} users/sec for ${(remainingTestTime / 1000).toFixed(1)}s`);
+            while (Date.now() < testEndTime) {
+                const vuStartTime = Date.now();
+                // CRITICAL: Create and run VU but don't block the arrivals rate
+                this.createAndRunVU(vuFactory, ++vuId, vuDuration, vuStartTime);
+                await (0, time_1.sleep)(targetIntervalMs);
+            }
+        }
+        // Wait for the last VUs to complete (they might run beyond test end time)
+        const lastVUEndTime = Date.now() + vuDuration;
+        const finalWaitTime = Math.max(lastVUEndTime - Date.now(), 0);
+        if (finalWaitTime > 0) {
+            logger_1.logger.debug(`⏳ Waiting ${(finalWaitTime / 1000).toFixed(1)}s for last VUs to complete...`);
+            await (0, time_1.sleep)(finalWaitTime);
+        }
+        logger_1.logger.debug('✅ Arrivals pattern completed');
+    }
+    async createAndRunVU(vuFactory, vuId, durationMs, startTime) {
+        // Run VU creation and execution asynchronously to not block arrivals rate
+        (async () => {
+            try {
+                logger_1.logger.debug(`Creating VU ${vuId}...`);
+                const vu = await this.createVU(vuFactory, vuId);
+                logger_1.logger.debug(`VU ${vuId} ready`);
+                // Record VU start for metrics and reporting
+                const metrics = vuFactory.getMetrics();
+                metrics.recordVUStart(vu.getId());
+                logger_1.logger.debug(`👤 Started VU ${vu.getId()}`);
+                // Run VU for its individual duration
+                await this.runVUForDuration(vu, durationMs, startTime);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('terminated due to CSV data exhaustion')) {
+                    logger_1.logger.info(`⏹️ VU ${vuId} terminated due to CSV data exhaustion`);
+                }
+                else {
+                    logger_1.logger.error(`❌ Failed to create/run VU ${vuId}:`, error);
+                }
+            }
+        })();
+    }
+    async createVU(vuFactory, id) {
+        // Handle both sync and async factories
+        const vu = vuFactory.create(id);
+        if (vu instanceof Promise) {
+            return await vu;
+        }
+        return vu;
+    }
+    async runVUForDuration(vu, durationMs, startTime) {
+        const endTime = startTime + durationMs;
+        while (Date.now() < endTime && vu.isRunning()) {
+            try {
+                await vu.executeScenarios();
+                if (Date.now() >= endTime) {
+                    break;
+                }
+                await (0, time_1.sleep)(100); // Small pause between iterations
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('terminated due to CSV data exhaustion')) {
+                    logger_1.logger.info(`⏹️ VU ${vu.getId()} terminated due to CSV data exhaustion`);
+                    break; // Exit the loop, VU is already stopped
+                }
+                logger_1.logger.error(`❌ VU ${vu.getId()} error:`, error);
+                break;
+            }
+        }
+        // VU cleanup happens automatically when it goes out of scope
+        logger_1.logger.debug(`🏁 VU ${vu.getId()} completed after ${((Date.now() - startTime) / 1000).toFixed(1)}s`);
+    }
+}
+exports.ArrivalsPattern = ArrivalsPattern;

package/dist/load-patterns/base.d.ts

@@ -0,0 +1,9 @@
+import { VirtualUser } from '../core';
+import { MetricsCollector } from '../metrics/collector';
+export interface LoadPattern {
+    execute(config: any, vuFactory: VUFactory): Promise<void>;
+}
+export interface VUFactory {
+    create: (id: number) => VirtualUser | Promise<VirtualUser>;
+    getMetrics: () => MetricsCollector;
+}

package/dist/load-patterns/base.js

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

package/dist/load-patterns/basic.d.ts

@@ -0,0 +1,7 @@
+import { LoadPattern, VUFactory } from './base';
+export declare class BasicPattern implements LoadPattern {
+    execute(config: any, vuFactory: VUFactory): Promise<void>;
+    private createVU;
+    private runVUOnce;
+    private runVUForDuration;
+}