claude-flow-novice 1.0.0

package/dist/src/testing/performance/PerformanceTestRunner.js

@@ -0,0 +1,401 @@
+import { EventEmitter } from 'events';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+export class PerformanceTestRunner extends EventEmitter {
+    testConfigs = new Map();
+    activeTests = new Map();
+    testResults = new Map();
+    resourceMonitor;
+    reportGenerator;
+    constructor(){
+        super();
+        this.resourceMonitor = new ResourceMonitor();
+        this.reportGenerator = new PerformanceReportGenerator();
+    }
+    // Register performance test configuration
+    registerTest(config) {
+        this.testConfigs.set(config.name, config);
+        console.log(`Registered performance test: ${config.name}`);
+    }
+    // Execute single performance test
+    async runTest(testName, targetFunction) {
+        const config = this.testConfigs.get(testName);
+        if (!config) {
+            throw new Error(`Test configuration not found: ${testName}`);
+        }
+        console.log(`Starting performance test: ${testName}`);
+        const startTime = Date.now();
+        // Start resource monitoring
+        await this.resourceMonitor.startMonitoring(testName);
+        try {
+            // Warmup phase
+            await this.executeWarmup(config, targetFunction);
+            // Main test execution
+            const metrics = await this.executeMainTest(config, targetFunction);
+            // Stop monitoring and collect final metrics
+            const finalMetrics = await this.resourceMonitor.stopMonitoring();
+            // Combine metrics
+            const combinedMetrics = this.combineMetrics(metrics, finalMetrics);
+            // Evaluate test results
+            const result = this.evaluateTestResult(testName, config, combinedMetrics, startTime);
+            this.testResults.set(testName, result);
+            this.emit('testCompleted', result);
+            return result;
+        } catch (error) {
+            const failedResult = {
+                testName: testName,
+                status: 'FAILED',
+                startTime: startTime,
+                endTime: Date.now(),
+                metrics: this.getEmptyMetrics(),
+                violations: [
+                    `Test execution failed: ${error.message}`
+                ],
+                recommendations: [
+                    'Review test configuration and target function'
+                ]
+            };
+            this.testResults.set(testName, failedResult);
+            return failedResult;
+        }
+    }
+    // Execute warmup phase
+    async executeWarmup(config, targetFunction) {
+        console.log(`Executing warmup phase for ${config.warmupDuration}ms`);
+        const warmupEndTime = Date.now() + config.warmupDuration;
+        const warmupConcurrency = Math.min(config.concurrency, 5); // Limited warmup concurrency
+        while(Date.now() < warmupEndTime){
+            const promises = [];
+            for(let i = 0; i < warmupConcurrency; i++){
+                promises.push(this.executeTargetFunction(targetFunction));
+            }
+            await Promise.allSettled(promises);
+            await this.sleep(100); // Short pause between warmup batches
+        }
+    }
+    // Execute main performance test
+    async executeMainTest(config, targetFunction) {
+        console.log(`Executing main test phase for ${config.duration}ms`);
+        const testStartTime = Date.now();
+        const testEndTime = testStartTime + config.duration;
+        const metrics = {
+            requests: 0,
+            successes: 0,
+            failures: 0,
+            latencies: [],
+            startTime: testStartTime
+        };
+        // Ramp up phase
+        const rampUpEndTime = testStartTime + config.rampUpTime;
+        let currentConcurrency = 1;
+        while(Date.now() < testEndTime){
+            const now = Date.now();
+            // Calculate current concurrency based on ramp-up
+            if (now < rampUpEndTime) {
+                const rampUpProgress = (now - testStartTime) / config.rampUpTime;
+                currentConcurrency = Math.ceil(config.concurrency * rampUpProgress);
+            } else if (now > testEndTime - config.rampDownTime) {
+                const rampDownProgress = (testEndTime - now) / config.rampDownTime;
+                currentConcurrency = Math.ceil(config.concurrency * rampDownProgress);
+            } else {
+                currentConcurrency = config.concurrency;
+            }
+            // Execute concurrent requests
+            const promises = [];
+            for(let i = 0; i < currentConcurrency; i++){
+                promises.push(this.executeAndMeasure(targetFunction));
+            }
+            const results = await Promise.allSettled(promises);
+            // Collect metrics
+            for (const result of results){
+                metrics.requests++;
+                if (result.status === 'fulfilled') {
+                    if (result.value.success) {
+                        metrics.successes++;
+                        metrics.latencies.push(result.value.latency);
+                    } else {
+                        metrics.failures++;
+                    }
+                } else {
+                    metrics.failures++;
+                }
+            }
+            // Adaptive delay based on target throughput
+            if (config.targetThroughput) {
+                const currentThroughput = metrics.requests / ((Date.now() - testStartTime) / 1000);
+                if (currentThroughput > config.targetThroughput) {
+                    await this.sleep(50); // Throttle if exceeding target
+                }
+            }
+        }
+        return this.calculateFinalMetrics(metrics, testStartTime);
+    }
+    // Execute target function and measure performance
+    async executeAndMeasure(targetFunction) {
+        const startTime = performance.now();
+        try {
+            await this.executeTargetFunction(targetFunction);
+            const latency = performance.now() - startTime;
+            return {
+                success: true,
+                latency
+            };
+        } catch (error) {
+            const latency = performance.now() - startTime;
+            return {
+                success: false,
+                latency
+            };
+        }
+    }
+    // Execute target function with error handling
+    async executeTargetFunction(targetFunction) {
+        try {
+            const result = targetFunction();
+            // Handle both sync and async functions
+            if (result && typeof result.then === 'function') {
+                return await result;
+            }
+            return result;
+        } catch (error) {
+            throw error;
+        }
+    }
+    // Calculate final performance metrics
+    calculateFinalMetrics(metrics, startTime) {
+        const duration = Date.now() - startTime;
+        const throughput = metrics.requests / (duration / 1000);
+        const successRate = metrics.successes / metrics.requests;
+        const errorRate = metrics.failures / metrics.requests;
+        // Calculate latency percentiles
+        const sortedLatencies = metrics.latencies.sort((a, b)=>a - b);
+        const avgLatency = sortedLatencies.reduce((sum, lat)=>sum + lat, 0) / sortedLatencies.length || 0;
+        const p95Index = Math.floor(sortedLatencies.length * 0.95);
+        const p99Index = Math.floor(sortedLatencies.length * 0.99);
+        const p95Latency = sortedLatencies[p95Index] || 0;
+        const p99Latency = sortedLatencies[p99Index] || 0;
+        return {
+            timestamp: startTime,
+            duration: duration,
+            throughput: throughput,
+            avgLatency: avgLatency,
+            p95Latency: p95Latency,
+            p99Latency: p99Latency,
+            successRate: successRate,
+            errorRate: errorRate,
+            memoryUsage: 0,
+            cpuUsage: 0,
+            networkIO: 0,
+            diskIO: 0
+        };
+    }
+    // Combine performance and resource metrics
+    combineMetrics(perfMetrics, resourceMetrics) {
+        return {
+            ...perfMetrics,
+            memoryUsage: resourceMetrics.avgMemoryUsage || 0,
+            cpuUsage: resourceMetrics.avgCpuUsage || 0,
+            networkIO: resourceMetrics.totalNetworkIO || 0,
+            diskIO: resourceMetrics.totalDiskIO || 0
+        };
+    }
+    // Evaluate test results against thresholds
+    evaluateTestResult(testName, config, metrics, startTime) {
+        const violations = [];
+        const recommendations = [];
+        let status = 'PASSED';
+        // Check throughput
+        if (config.targetThroughput && metrics.throughput < config.targetThroughput * 0.9) {
+            violations.push(`Throughput ${metrics.throughput.toFixed(2)} req/s below target ${config.targetThroughput} req/s`);
+            recommendations.push('Consider optimizing critical path or increasing concurrency');
+            status = 'FAILED';
+        }
+        // Check latency
+        if (config.maxLatency && metrics.p95Latency > config.maxLatency) {
+            violations.push(`P95 latency ${metrics.p95Latency.toFixed(2)}ms exceeds limit ${config.maxLatency}ms`);
+            recommendations.push('Investigate latency bottlenecks and optimize slow operations');
+            status = status === 'PASSED' ? 'WARNING' : status;
+        }
+        // Check success rate
+        const minSuccessRate = config.successRate || 0.95;
+        if (metrics.successRate < minSuccessRate) {
+            violations.push(`Success rate ${(metrics.successRate * 100).toFixed(2)}% below threshold ${(minSuccessRate * 100).toFixed(2)}%`);
+            recommendations.push('Review error handling and system stability');
+            status = 'FAILED';
+        }
+        // Check memory usage
+        if (config.memoryLimit && metrics.memoryUsage > config.memoryLimit) {
+            violations.push(`Memory usage ${metrics.memoryUsage}MB exceeds limit ${config.memoryLimit}MB`);
+            recommendations.push('Optimize memory allocation and implement garbage collection tuning');
+            status = status === 'PASSED' ? 'WARNING' : status;
+        }
+        // Check CPU usage
+        if (config.cpuLimit && metrics.cpuUsage > config.cpuLimit) {
+            violations.push(`CPU usage ${metrics.cpuUsage.toFixed(2)}% exceeds limit ${config.cpuLimit}%`);
+            recommendations.push('Optimize CPU-intensive operations and consider async processing');
+            status = status === 'PASSED' ? 'WARNING' : status;
+        }
+        return {
+            testName: testName,
+            status: status,
+            startTime: startTime,
+            endTime: Date.now(),
+            metrics: metrics,
+            violations: violations,
+            recommendations: recommendations
+        };
+    }
+    // Run multiple tests in sequence
+    async runTestSuite(tests) {
+        const results = [];
+        console.log(`Running performance test suite with ${tests.length} tests`);
+        for (const test of tests){
+            try {
+                const result = await this.runTest(test.name, test.function);
+                results.push(result);
+                // Brief pause between tests
+                await this.sleep(2000);
+            } catch (error) {
+                console.error(`Failed to run test ${test.name}:`, error);
+            }
+        }
+        // Generate comprehensive report
+        await this.generateSuiteReport(results);
+        return results;
+    }
+    // Generate comprehensive test suite report
+    async generateSuiteReport(results) {
+        const report = await this.reportGenerator.generateSuiteReport(results);
+        // Save report to file
+        const reportPath = path.join(process.cwd(), 'performance-reports', `suite-report-${Date.now()}.json`);
+        await fs.mkdir(path.dirname(reportPath), {
+            recursive: true
+        });
+        await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+        console.log(`Performance test suite report saved to: ${reportPath}`);
+    }
+    // Get empty metrics for failed tests
+    getEmptyMetrics() {
+        return {
+            timestamp: Date.now(),
+            duration: 0,
+            throughput: 0,
+            avgLatency: 0,
+            p95Latency: 0,
+            p99Latency: 0,
+            successRate: 0,
+            errorRate: 1,
+            memoryUsage: 0,
+            cpuUsage: 0,
+            networkIO: 0,
+            diskIO: 0
+        };
+    }
+    // Utility sleep function
+    sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    // Get test results
+    getTestResults() {
+        return this.testResults;
+    }
+    // Clear test results
+    clearResults() {
+        this.testResults.clear();
+    }
+}
+// Resource monitoring class
+let ResourceMonitor = class ResourceMonitor {
+    monitoring = false;
+    interval = null;
+    metrics = [];
+    async startMonitoring(testName) {
+        this.monitoring = true;
+        this.metrics = [];
+        this.interval = setInterval(async ()=>{
+            if (!this.monitoring) return;
+            const metric = await this.collectResourceMetrics();
+            this.metrics.push({
+                timestamp: Date.now(),
+                testName: testName,
+                ...metric
+            });
+        }, 1000); // Collect every second
+    }
+    async stopMonitoring() {
+        this.monitoring = false;
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        return this.aggregateMetrics();
+    }
+    async collectResourceMetrics() {
+        const memoryUsage = process.memoryUsage();
+        const cpuUsage = process.cpuUsage();
+        return {
+            memoryRSS: memoryUsage.rss / 1024 / 1024,
+            memoryHeap: memoryUsage.heapUsed / 1024 / 1024,
+            cpuUser: cpuUsage.user,
+            cpuSystem: cpuUsage.system
+        };
+    }
+    aggregateMetrics() {
+        if (this.metrics.length === 0) {
+            return {
+                avgMemoryUsage: 0,
+                maxMemoryUsage: 0,
+                avgCpuUsage: 0,
+                maxCpuUsage: 0,
+                totalNetworkIO: 0,
+                totalDiskIO: 0
+            };
+        }
+        const memoryValues = this.metrics.map((m)=>m.memoryRSS);
+        const cpuValues = this.metrics.map((m)=>(m.cpuUser + m.cpuSystem) / 1000000); // Convert to ms
+        return {
+            avgMemoryUsage: memoryValues.reduce((sum, val)=>sum + val, 0) / memoryValues.length,
+            maxMemoryUsage: Math.max(...memoryValues),
+            avgCpuUsage: cpuValues.reduce((sum, val)=>sum + val, 0) / cpuValues.length,
+            maxCpuUsage: Math.max(...cpuValues),
+            totalNetworkIO: 0,
+            totalDiskIO: 0
+        };
+    }
+};
+// Report generation class
+let PerformanceReportGenerator = class PerformanceReportGenerator {
+    async generateSuiteReport(results) {
+        const totalTests = results.length;
+        const passedTests = results.filter((r)=>r.status === 'PASSED').length;
+        const failedTests = results.filter((r)=>r.status === 'FAILED').length;
+        const warningTests = results.filter((r)=>r.status === 'WARNING').length;
+        const avgThroughput = results.reduce((sum, r)=>sum + r.metrics.throughput, 0) / totalTests;
+        const avgLatency = results.reduce((sum, r)=>sum + r.metrics.avgLatency, 0) / totalTests;
+        const avgSuccessRate = results.reduce((sum, r)=>sum + r.metrics.successRate, 0) / totalTests;
+        return {
+            summary: {
+                totalTests: totalTests,
+                passedTests: passedTests,
+                failedTests: failedTests,
+                warningTests: warningTests,
+                successRate: passedTests / totalTests,
+                avgThroughput: avgThroughput,
+                avgLatency: avgLatency,
+                avgSuccessRate: avgSuccessRate
+            },
+            results: results,
+            timestamp: Date.now(),
+            recommendations: this.generateRecommendations(results)
+        };
+    }
+    generateRecommendations(results) {
+        const recommendations = new Set();
+        results.forEach((result)=>{
+            result.recommendations.forEach((rec)=>recommendations.add(rec));
+        });
+        return Array.from(recommendations);
+    }
+};
+
+//# sourceMappingURL=PerformanceTestRunner.js.map

package/dist/src/testing/performance/PerformanceTestRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/testing/performance/PerformanceTestRunner.ts"],"names":["EventEmitter","promises","fs","path","PerformanceTestRunner","testConfigs","Map","activeTests","testResults","resourceMonitor","reportGenerator","ResourceMonitor","PerformanceReportGenerator","registerTest","config","set","name","console","log","runTest","testName","targetFunction","get","Error","startTime","Date","now","startMonitoring","executeWarmup","metrics","executeMainTest","finalMetrics","stopMonitoring","combinedMetrics","combineMetrics","result","evaluateTestResult","emit","error","failedResult","status","endTime","getEmptyMetrics","violations","message","recommendations","warmupDuration","warmupEndTime","warmupConcurrency","Math","min","concurrency","i","push","executeTargetFunction","Promise","allSettled","sleep","duration","testStartTime","testEndTime","requests","successes","failures","latencies","rampUpEndTime","rampUpTime","currentConcurrency","rampUpProgress","ceil","rampDownTime","rampDownProgress","executeAndMeasure","results","value","success","latency","targetThroughput","currentThroughput","calculateFinalMetrics","performance","then","throughput","successRate","errorRate","sortedLatencies","sort","a","b","avgLatency","reduce","sum","lat","length","p95Index","floor","p99Index","p95Latency","p99Latency","timestamp","memoryUsage","cpuUsage","networkIO","diskIO","perfMetrics","resourceMetrics","avgMemoryUsage","avgCpuUsage","totalNetworkIO","totalDiskIO","toFixed","maxLatency","minSuccessRate","memoryLimit","cpuLimit","runTestSuite","tests","test","function","generateSuiteReport","report","reportPath","join","process","cwd","mkdir","dirname","recursive","writeFile","JSON","stringify","ms","resolve","setTimeout","getTestResults","clearResults","clear","monitoring","interval","setInterval","metric","collectResourceMetrics","clearInterval","aggregateMetrics","memoryRSS","rss","memoryHeap","heapUsed","cpuUser","user","cpuSystem","system","maxMemoryUsage","maxCpuUsage","memoryValues","map","m","cpuValues","val","max","totalTests","passedTests","filter","r","failedTests","warningTests","avgThroughput","avgSuccessRate","summary","generateRecommendations","Set","forEach","rec","add","Array","from"],"mappings":"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"}