@testsmith/perfornium 0.1.0

package/dist/cli/commands/worker.d.ts

@@ -0,0 +1,27 @@
+export declare class WorkerServer {
+    private server;
+    private host;
+    private port;
+    private status;
+    private activeRunner;
+    private preparedConfig;
+    private completedRunner;
+    constructor(host?: string, port?: number);
+    private handleRequest;
+    private handleHealth;
+    private handleStatus;
+    private handlePrepare;
+    private handleStart;
+    private handleResults;
+    private handleStop;
+    private readRequestBody;
+    private sendJson;
+    private sendError;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): any;
+}
+export declare function workerCommand(options: {
+    port?: string;
+    host?: string;
+}): Promise<void>;

package/dist/cli/commands/worker.js

@@ -0,0 +1,320 @@
+"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.WorkerServer = void 0;
+exports.workerCommand = workerCommand;
+const logger_1 = require("../../utils/logger");
+const http = __importStar(require("http"));
+const url_1 = require("url");
+const test_runner_1 = require("../../core/test-runner");
+class WorkerServer {
+    constructor(host = 'localhost', port = 8080) {
+        this.activeRunner = null;
+        this.preparedConfig = null;
+        this.completedRunner = null;
+        this.host = host;
+        this.port = port;
+        this.status = {
+            connected: true,
+            running: false,
+            virtualUsers: 0,
+            requestsPerSecond: 0,
+            responseTime: 0,
+            errorRate: 0
+        };
+        this.server = http.createServer((req, res) => {
+            this.handleRequest(req, res);
+        });
+    }
+    async handleRequest(req, res) {
+        // Set CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        const url = new url_1.URL(req.url || '/', `http://${req.headers.host}`);
+        const method = req.method || 'GET';
+        try {
+            switch (`${method} ${url.pathname}`) {
+                case 'GET /health':
+                    await this.handleHealth(res);
+                    break;
+                case 'GET /status':
+                    await this.handleStatus(res);
+                    break;
+                case 'POST /prepare':
+                    await this.handlePrepare(req, res);
+                    break;
+                case 'POST /start':
+                    await this.handleStart(req, res);
+                    break;
+                case 'GET /results':
+                    await this.handleResults(res);
+                    break;
+                case 'POST /stop':
+                    await this.handleStop(res);
+                    break;
+                default:
+                    this.sendError(res, 404, 'Not Found', `Endpoint ${method} ${url.pathname} not found`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.error(`❌ Error handling ${method} ${url.pathname}:`, error);
+            this.sendError(res, 500, 'Internal Server Error', error.message);
+        }
+    }
+    async handleHealth(res) {
+        this.sendJson(res, 200, {
+            status: 'healthy',
+            timestamp: new Date().toISOString(),
+            uptime: process.uptime(),
+            memory: process.memoryUsage()
+        });
+    }
+    async handleStatus(res) {
+        this.sendJson(res, 200, {
+            ...this.status,
+            timestamp: new Date().toISOString(),
+            uptime: process.uptime(),
+            activeRunner: this.activeRunner ? 'running' : 'idle'
+        });
+    }
+    async handlePrepare(req, res) {
+        const body = await this.readRequestBody(req);
+        try {
+            const testConfig = JSON.parse(body);
+            this.preparedConfig = testConfig;
+            logger_1.logger.info(`📋 Test prepared: ${testConfig.name}`);
+            this.sendJson(res, 200, {
+                status: 'prepared',
+                testName: testConfig.name,
+                timestamp: new Date().toISOString()
+            });
+        }
+        catch (error) {
+            this.sendError(res, 400, 'Bad Request', `Invalid test configuration: ${error.message}`);
+        }
+    }
+    async handleStart(req, res) {
+        if (!this.preparedConfig) {
+            this.sendError(res, 400, 'Bad Request', 'No test configuration prepared. Call /prepare first.');
+            return;
+        }
+        if (this.status.running) {
+            this.sendError(res, 409, 'Conflict', 'Test is already running');
+            return;
+        }
+        try {
+            const body = await this.readRequestBody(req);
+            let startOptions = {};
+            if (body) {
+                startOptions = JSON.parse(body);
+            }
+            // If startTime is provided (for synchronized start), wait until that time
+            if (startOptions.startTime) {
+                const delay = startOptions.startTime - Date.now();
+                if (delay > 0) {
+                    logger_1.logger.info(`⏰ Waiting ${delay}ms for synchronized start...`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+            this.activeRunner = new test_runner_1.TestRunner(this.preparedConfig);
+            this.status.running = true;
+            const { getPrimaryLoadPhase } = await Promise.resolve().then(() => __importStar(require('../../config/types/load-config')));
+            const primaryPhase = getPrimaryLoadPhase(this.preparedConfig.load);
+            this.status.virtualUsers = primaryPhase.virtual_users || primaryPhase.vus || 1;
+            logger_1.logger.info(`🚀 Starting test: ${this.preparedConfig.name}`);
+            // Start the test asynchronously and collect results
+            this.activeRunner.run().then(() => {
+                this.status.running = false;
+                logger_1.logger.info(`✅ Test completed: ${this.preparedConfig?.name}`);
+                // Store completed runner for results retrieval
+                this.completedRunner = this.activeRunner;
+                // Get final metrics and store them for retrieval
+                if (this.activeRunner) {
+                    const metrics = this.activeRunner.getMetrics();
+                    this.status.responseTime = metrics.getSummary().avg_response_time || 0;
+                    this.status.requestsPerSecond = metrics.getSummary().requests_per_second || 0;
+                    this.status.errorRate = (1 - (metrics.getSummary().success_rate / 100)) * 100;
+                }
+                this.activeRunner = null;
+            }).catch((error) => {
+                this.status.running = false;
+                this.activeRunner = null;
+                logger_1.logger.error(`❌ Test failed: ${error.message}`);
+            });
+            this.sendJson(res, 200, {
+                status: 'started',
+                testName: this.preparedConfig.name,
+                virtualUsers: this.status.virtualUsers,
+                timestamp: new Date().toISOString()
+            });
+        }
+        catch (error) {
+            this.status.running = false;
+            this.sendError(res, 500, 'Internal Server Error', `Failed to start test: ${error.message}`);
+        }
+    }
+    async handleResults(res) {
+        if (!this.completedRunner) {
+            this.sendError(res, 404, 'Not Found', 'No completed test results available');
+            return;
+        }
+        try {
+            const metrics = this.completedRunner.getMetrics();
+            const summary = metrics.getSummary();
+            const results = metrics.getResults();
+            this.sendJson(res, 200, {
+                summary,
+                results,
+                worker: {
+                    host: this.host,
+                    port: this.port,
+                    timestamp: new Date().toISOString()
+                }
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', `Failed to get results: ${error.message}`);
+        }
+    }
+    async handleStop(res) {
+        if (!this.status.running || !this.activeRunner) {
+            this.sendError(res, 400, 'Bad Request', 'No test is currently running');
+            return;
+        }
+        try {
+            await this.activeRunner.stop();
+            this.status.running = false;
+            this.activeRunner = null;
+            logger_1.logger.info(`⏹️ Test stopped`);
+            this.sendJson(res, 200, {
+                status: 'stopped',
+                timestamp: new Date().toISOString()
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', `Failed to stop test: ${error.message}`);
+        }
+    }
+    async readRequestBody(req) {
+        return new Promise((resolve) => {
+            let body = '';
+            req.on('data', chunk => {
+                body += chunk.toString();
+            });
+            req.on('end', () => {
+                resolve(body);
+            });
+        });
+    }
+    sendJson(res, statusCode, data) {
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    }
+    sendError(res, statusCode, error, message) {
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            error,
+            message,
+            timestamp: new Date().toISOString()
+        }));
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server.listen(this.port, this.host, () => {
+                logger_1.logger.info(`🚀 Worker server started on ${this.host}:${this.port}`);
+                logger_1.logger.info(`📋 Available endpoints:`);
+                logger_1.logger.info(`   GET  http://${this.host}:${this.port}/health`);
+                logger_1.logger.info(`   GET  http://${this.host}:${this.port}/status`);
+                logger_1.logger.info(`   POST http://${this.host}:${this.port}/prepare`);
+                logger_1.logger.info(`   POST http://${this.host}:${this.port}/start`);
+                logger_1.logger.info(`   POST http://${this.host}:${this.port}/stop`);
+                logger_1.logger.info(`   GET  http://${this.host}:${this.port}/results`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.activeRunner) {
+                this.activeRunner.stop().catch(err => logger_1.logger.error('❌ Error stopping runner:', err));
+            }
+            this.server.close(() => {
+                logger_1.logger.info('👋 Worker server stopped');
+                resolve();
+            });
+        });
+    }
+    getStatus() {
+        return {
+            host: this.host,
+            port: this.port,
+            status: this.status,
+            uptime: process.uptime(),
+            memory: process.memoryUsage()
+        };
+    }
+}
+exports.WorkerServer = WorkerServer;
+// Updated worker command function
+async function workerCommand(options) {
+    const port = parseInt(options.port || '8080');
+    const host = options.host || 'localhost';
+    const workerServer = new WorkerServer(host, port);
+    // Handle graceful shutdown
+    const shutdown = async () => {
+        logger_1.logger.info('🛑 Received shutdown signal, stopping worker...');
+        await workerServer.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    try {
+        await workerServer.start();
+        // Keep the process alive
+        process.on('exit', () => {
+            logger_1.logger.info('👋 Worker process exiting');
+        });
+    }
+    catch (error) {
+        logger_1.logger.error(`❌ Failed to start worker: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export { ConfigParser } from './parser';
+export * from './types';

package/dist/config/index.js

@@ -0,0 +1,20 @@
+"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 });
+exports.ConfigParser = void 0;
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "ConfigParser", { enumerable: true, get: function () { return parser_1.ConfigParser; } });
+__exportStar(require("./types"), exports);

package/dist/config/parser.d.ts

@@ -0,0 +1,19 @@
+import { TestConfiguration } from './types';
+export declare class ConfigParser {
+    private templateProcessor;
+    parse(configPath: string, environment?: string): Promise<TestConfiguration>;
+    private parseTypeScript;
+    private evaluatePlainTypeScript;
+    private setupBaseDirectories;
+    private setupFaker;
+    private parseContent;
+    private validateRequiredFields;
+    private validateCSVConfig;
+    private loadEnvironmentConfig;
+    private mergeConfigs;
+    processTemplates(config: TestConfiguration, _context: {
+        env: NodeJS.ProcessEnv;
+        timestamp: number;
+        datetime: string;
+    }): TestConfiguration;
+}