claude-flow-novice 1.0.0

package/dist/src/automation/test-pipeline/RegressionTestManager.js

@@ -0,0 +1,545 @@
+/**
+ * RegressionTestManager - Advanced regression testing with swarm coordination
+ * Intelligent test selection, execution, and failure analysis
+ */ export class RegressionTestManager {
+    testRegistry = new Map();
+    executionHistory = new Map();
+    swarmCoordinated;
+    impactAnalysisEnabled;
+    riskBasedTesting;
+    constructor(config){
+        this.swarmCoordinated = config.swarmCoordination?.enabled || false;
+        this.impactAnalysisEnabled = config.testSelection?.impactAnalysis || false;
+        this.riskBasedTesting = config.testSelection?.riskBasedTesting || false;
+    }
+    /**
+   * Initialize regression test manager
+   */ async initialize() {
+        console.log('🔄 Initializing Regression Test Manager');
+        try {
+            // Discover and register existing tests
+            await this.discoverTests();
+            // Load execution history
+            await this.loadExecutionHistory();
+            // Initialize test dependency graph
+            await this.buildDependencyGraph();
+            console.log(`✅ Initialized with ${this.testRegistry.size} regression tests`);
+        } catch (error) {
+            console.error('❌ Failed to initialize Regression Test Manager:', error);
+            throw error;
+        }
+    }
+    /**
+   * Perform impact analysis for changed files
+   */ async performImpactAnalysis(changedFiles) {
+        console.log(`🔍 Performing impact analysis for ${changedFiles.length} changed files`);
+        const analysis = {
+            changedFiles,
+            affectedTests: [],
+            riskLevel: 'low',
+            recommendedTests: [],
+            estimatedExecutionTime: 0
+        };
+        if (!this.impactAnalysisEnabled) {
+            analysis.recommendedTests = Array.from(this.testRegistry.values());
+            analysis.estimatedExecutionTime = this.calculateTotalExecutionTime(analysis.recommendedTests);
+            return analysis;
+        }
+        // Analyze file dependencies and identify affected tests
+        for (const file of changedFiles){
+            const affectedTests = await this.identifyAffectedTests(file);
+            analysis.affectedTests.push(...affectedTests);
+        }
+        // Remove duplicates
+        analysis.affectedTests = this.deduplicateTests(analysis.affectedTests);
+        // Calculate risk level based on affected components
+        analysis.riskLevel = this.calculateRiskLevel(changedFiles, analysis.affectedTests);
+        // Generate test recommendations based on risk and impact
+        analysis.recommendedTests = await this.generateTestRecommendations(analysis);
+        // Estimate execution time
+        analysis.estimatedExecutionTime = this.calculateTotalExecutionTime(analysis.recommendedTests);
+        console.log(`📊 Impact analysis complete: ${analysis.recommendedTests.length} tests recommended (Risk: ${analysis.riskLevel})`);
+        return analysis;
+    }
+    /**
+   * Create optimized execution plan with swarm coordination
+   */ async createExecutionPlan(tests) {
+        console.log(`📋 Creating execution plan for ${tests.length} tests`);
+        const plan = {
+            id: `plan_${Date.now()}`,
+            tests,
+            parallelGroups: [],
+            executionOrder: [],
+            estimatedTotalTime: 0,
+            resourceRequirements: {
+                agents: 1,
+                memory: '2GB',
+                timeout: 3600000
+            }
+        };
+        if (this.swarmCoordinated) {
+            // Create parallel execution groups
+            plan.parallelGroups = await this.createParallelGroups(tests);
+            // Calculate optimal agent count
+            plan.resourceRequirements.agents = this.calculateOptimalAgentCount(plan.parallelGroups);
+            // Optimize execution order within groups
+            for (const group of plan.parallelGroups){
+                const optimizedOrder = await this.optimizeExecutionOrder(group);
+                plan.executionOrder.push(...optimizedOrder.map((test)=>test.id));
+            }
+        } else {
+            // Sequential execution order
+            const orderedTests = await this.optimizeExecutionOrder(tests);
+            plan.executionOrder = orderedTests.map((test)=>test.id);
+            plan.parallelGroups = [
+                tests
+            ];
+        }
+        // Calculate estimated execution time
+        plan.estimatedTotalTime = this.calculatePlanExecutionTime(plan);
+        // Adjust resource requirements based on plan complexity
+        plan.resourceRequirements = this.calculateResourceRequirements(plan);
+        console.log(`✅ Execution plan created: ${plan.parallelGroups.length} groups, ${plan.resourceRequirements.agents} agents, ~${Math.round(plan.estimatedTotalTime / 1000)}s`);
+        return plan;
+    }
+    /**
+   * Execute regression tests with swarm coordination
+   */ async executeRegressionTests(plan) {
+        console.log(`🚀 Executing regression test plan: ${plan.id}`);
+        const executionResults = {
+            planId: plan.id,
+            startTime: new Date(),
+            endTime: null,
+            totalTests: plan.tests.length,
+            passed: 0,
+            failed: 0,
+            skipped: 0,
+            results: new Map(),
+            swarmMetrics: null,
+            performanceMetrics: null
+        };
+        try {
+            if (this.swarmCoordinated) {
+                // Execute with swarm coordination
+                await this.executeWithSwarmCoordination(plan, executionResults);
+            } else {
+                // Execute sequentially
+                await this.executeSequentially(plan, executionResults);
+            }
+            executionResults.endTime = new Date();
+            // Analyze results and update test registry
+            await this.analyzeExecutionResults(executionResults);
+            // Update execution history
+            await this.updateExecutionHistory(executionResults);
+            console.log(`✅ Regression tests completed: ${executionResults.passed}/${executionResults.totalTests} passed`);
+            return executionResults;
+        } catch (error) {
+            console.error('❌ Regression test execution failed:', error);
+            executionResults.endTime = new Date();
+            throw error;
+        }
+    }
+    /**
+   * Analyze test failures and generate recommendations
+   */ async analyzeFailures(executionResults) {
+        console.log('🔍 Analyzing test failures');
+        const failureAnalysis = {
+            totalFailures: executionResults.failed,
+            failurePatterns: new Map(),
+            flakyTests: [],
+            newFailures: [],
+            regressionFailures: [],
+            recommendations: []
+        };
+        // Analyze failure patterns
+        for (const [testId, result] of executionResults.results.entries()){
+            if (!result.success) {
+                const test = this.testRegistry.get(testId);
+                if (!test) continue;
+                // Categorize failure type
+                const failureType = this.categorizeFailure(result.error);
+                const count = failureAnalysis.failurePatterns.get(failureType) || 0;
+                failureAnalysis.failurePatterns.set(failureType, count + 1);
+                // Check if test is flaky
+                if (await this.isTestFlaky(testId)) {
+                    failureAnalysis.flakyTests.push({
+                        testId,
+                        name: test.name,
+                        flakiness: test.flakiness,
+                        recentFailures: await this.getRecentFailures(testId)
+                    });
+                }
+                // Check if this is a new failure
+                if (await this.isNewFailure(testId)) {
+                    failureAnalysis.newFailures.push({
+                        testId,
+                        name: test.name,
+                        error: result.error,
+                        firstFailure: new Date()
+                    });
+                }
+            }
+        }
+        // Generate actionable recommendations
+        failureAnalysis.recommendations = await this.generateFailureRecommendations(failureAnalysis);
+        console.log(`📊 Failure analysis complete: ${failureAnalysis.totalFailures} failures, ${failureAnalysis.flakyTests.length} flaky tests`);
+        return failureAnalysis;
+    }
+    /**
+   * Generate smart retry strategy for failed tests
+   */ async generateRetryStrategy(failedTests) {
+        console.log(`🔄 Generating retry strategy for ${failedTests.length} failed tests`);
+        const retryStrategy = {
+            immediateRetries: [],
+            delayedRetries: [],
+            skipRetries: [],
+            retryConfiguration: new Map()
+        };
+        for (const testId of failedTests){
+            const test = this.testRegistry.get(testId);
+            if (!test) continue;
+            const retryConfig = await this.determineRetryConfig(testId);
+            if (retryConfig.shouldRetry) {
+                if (retryConfig.immediate) {
+                    retryStrategy.immediateRetries.push(testId);
+                } else {
+                    retryStrategy.delayedRetries.push(testId);
+                }
+                retryStrategy.retryConfiguration.set(testId, {
+                    maxRetries: retryConfig.maxRetries,
+                    delay: retryConfig.delay,
+                    isolation: retryConfig.isolation,
+                    timeout: retryConfig.timeout
+                });
+            } else {
+                retryStrategy.skipRetries.push(testId);
+            }
+        }
+        return retryStrategy;
+    }
+    // Private helper methods
+    async discoverTests() {
+        // Discover regression tests from various sources
+        const testSources = [
+            {
+                pattern: '**/*.test.ts',
+                category: 'unit'
+            },
+            {
+                pattern: '**/*.spec.ts',
+                category: 'integration'
+            },
+            {
+                pattern: 'tests/e2e/**/*.ts',
+                category: 'e2e'
+            },
+            {
+                pattern: 'tests/api/**/*.ts',
+                category: 'api'
+            }
+        ];
+        for (const source of testSources){
+            const tests = await this.scanTestFiles(source.pattern);
+            for (const testFile of tests){
+                const testInfo = await this.extractTestInfo(testFile);
+                const regressionTest = {
+                    id: `test_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
+                    name: testInfo.name,
+                    path: testFile,
+                    category: source.category,
+                    priority: testInfo.priority || 'medium',
+                    dependencies: testInfo.dependencies || [],
+                    affectedComponents: testInfo.components || [],
+                    estimatedDuration: testInfo.duration || 30000,
+                    lastRun: new Date(0),
+                    successRate: 100,
+                    flakiness: 0
+                };
+                this.testRegistry.set(regressionTest.id, regressionTest);
+            }
+        }
+    }
+    async scanTestFiles(pattern) {
+        // Implement test file scanning logic
+        // This would typically use glob or similar to find test files
+        return [];
+    }
+    async extractTestInfo(filePath) {
+        // Extract test metadata from file
+        return {
+            name: filePath.split('/').pop(),
+            priority: 'medium',
+            dependencies: [],
+            components: [],
+            duration: 30000
+        };
+    }
+    async loadExecutionHistory() {
+        // Load historical execution data for analysis
+        console.log('📚 Loading test execution history');
+    }
+    async buildDependencyGraph() {
+        // Build test dependency graph for optimal ordering
+        console.log('🔗 Building test dependency graph');
+    }
+    async identifyAffectedTests(filePath) {
+        const affectedTests = [];
+        // Simple implementation - in reality this would be more sophisticated
+        for (const test of this.testRegistry.values()){
+            if (test.affectedComponents.some((component)=>filePath.includes(component) || component.includes(filePath.split('/').pop() || ''))) {
+                affectedTests.push(test);
+            }
+        }
+        return affectedTests;
+    }
+    deduplicateTests(tests) {
+        const seen = new Set();
+        return tests.filter((test)=>{
+            if (seen.has(test.id)) return false;
+            seen.add(test.id);
+            return true;
+        });
+    }
+    calculateRiskLevel(changedFiles, affectedTests) {
+        // Risk calculation based on various factors
+        let riskScore = 0;
+        // Factor 1: Number of affected tests
+        riskScore += Math.min(affectedTests.length / 10, 3);
+        // Factor 2: Critical component changes
+        const criticalFiles = changedFiles.filter((file)=>file.includes('core') || file.includes('auth') || file.includes('api'));
+        riskScore += criticalFiles.length * 2;
+        // Factor 3: High priority tests affected
+        const highPriorityTests = affectedTests.filter((test)=>test.priority === 'high' || test.priority === 'critical');
+        riskScore += highPriorityTests.length * 1.5;
+        if (riskScore >= 8) return 'critical';
+        if (riskScore >= 5) return 'high';
+        if (riskScore >= 2) return 'medium';
+        return 'low';
+    }
+    async generateTestRecommendations(analysis) {
+        let recommendations = [
+            ...analysis.affectedTests
+        ];
+        if (this.riskBasedTesting) {
+            // Add additional tests based on risk level
+            if (analysis.riskLevel === 'high' || analysis.riskLevel === 'critical') {
+                // Include all high priority tests
+                const highPriorityTests = Array.from(this.testRegistry.values()).filter((test)=>test.priority === 'high' || test.priority === 'critical');
+                recommendations.push(...highPriorityTests);
+            }
+            // Add flaky tests that might be affected
+            const flakyTests = Array.from(this.testRegistry.values()).filter((test)=>test.flakiness > 0.1);
+            recommendations.push(...flakyTests.slice(0, 5)); // Limit to top 5 flaky tests
+        }
+        return this.deduplicateTests(recommendations);
+    }
+    calculateTotalExecutionTime(tests) {
+        return tests.reduce((total, test)=>total + test.estimatedDuration, 0);
+    }
+    async createParallelGroups(tests) {
+        // Create parallel execution groups considering dependencies
+        const groups = [];
+        const processed = new Set();
+        // Group by category and dependencies
+        const testsByCategory = new Map();
+        for (const test of tests){
+            if (!testsByCategory.has(test.category)) {
+                testsByCategory.set(test.category, []);
+            }
+            testsByCategory.get(test.category).push(test);
+        }
+        // Create groups ensuring no dependency conflicts
+        for (const [category, categoryTests] of testsByCategory){
+            const independentTests = categoryTests.filter((test)=>test.dependencies.length === 0 || test.dependencies.every((dep)=>!tests.some((t)=>t.id === dep)));
+            if (independentTests.length > 0) {
+                groups.push(independentTests);
+                independentTests.forEach((test)=>processed.add(test.id));
+            }
+        }
+        // Add remaining tests with dependencies to appropriate groups
+        const remainingTests = tests.filter((test)=>!processed.has(test.id));
+        if (remainingTests.length > 0) {
+            groups.push(remainingTests);
+        }
+        return groups;
+    }
+    calculateOptimalAgentCount(parallelGroups) {
+        // Calculate optimal number of agents based on test distribution
+        const maxGroupSize = Math.max(...parallelGroups.map((group)=>group.length));
+        const totalTests = parallelGroups.reduce((sum, group)=>sum + group.length, 0);
+        // Aim for 4-8 tests per agent, with minimum of 2 agents and maximum of 8
+        const optimalAgents = Math.max(2, Math.min(8, Math.ceil(totalTests / 6)));
+        return optimalAgents;
+    }
+    async optimizeExecutionOrder(tests) {
+        // Optimize test execution order based on duration, dependencies, and success rate
+        return tests.sort((a, b)=>{
+            // Priority: dependencies first, then by success rate, then by duration
+            const aDeps = a.dependencies.length;
+            const bDeps = b.dependencies.length;
+            if (aDeps !== bDeps) return aDeps - bDeps;
+            const aScore = a.successRate * 0.7 + 1 / Math.max(a.estimatedDuration, 1000) * 0.3;
+            const bScore = b.successRate * 0.7 + 1 / Math.max(b.estimatedDuration, 1000) * 0.3;
+            return bScore - aScore;
+        });
+    }
+    calculatePlanExecutionTime(plan) {
+        if (plan.parallelGroups.length <= 1) {
+            return this.calculateTotalExecutionTime(plan.tests);
+        }
+        // Calculate parallel execution time
+        const groupExecutionTimes = plan.parallelGroups.map((group)=>this.calculateTotalExecutionTime(group) / plan.resourceRequirements.agents);
+        return Math.max(...groupExecutionTimes);
+    }
+    calculateResourceRequirements(plan) {
+        const baseMemory = 2; // 2GB base
+        const memoryPerAgent = 1; // 1GB per additional agent
+        const totalMemory = baseMemory + (plan.resourceRequirements.agents - 1) * memoryPerAgent;
+        // Adjust timeout based on estimated execution time
+        const timeout = Math.max(600000, plan.estimatedTotalTime * 1.5); // At least 10 minutes
+        return {
+            agents: plan.resourceRequirements.agents,
+            memory: `${totalMemory}GB`,
+            timeout
+        };
+    }
+    async executeWithSwarmCoordination(plan, results) {
+        console.log('🤖 Executing tests with swarm coordination');
+        // Execute parallel groups
+        for (const group of plan.parallelGroups){
+            const groupPromises = group.map(async (test)=>{
+                const result = await this.executeTest(test);
+                results.results.set(test.id, result);
+                if (result.success) {
+                    results.passed++;
+                } else {
+                    results.failed++;
+                }
+            });
+            await Promise.all(groupPromises);
+        }
+    }
+    async executeSequentially(plan, results) {
+        console.log('📝 Executing tests sequentially');
+        for (const test of plan.tests){
+            const result = await this.executeTest(test);
+            results.results.set(test.id, result);
+            if (result.success) {
+                results.passed++;
+            } else {
+                results.failed++;
+            }
+        }
+    }
+    async executeTest(test) {
+        // Execute individual test
+        console.log(`  Running test: ${test.name}`);
+        const startTime = Date.now();
+        try {
+            // Simulate test execution
+            await new Promise((resolve)=>setTimeout(resolve, Math.min(test.estimatedDuration, 5000)));
+            const executionTime = Date.now() - startTime;
+            const success = Math.random() > test.flakiness / 100; // Simulate based on flakiness
+            return {
+                testId: test.id,
+                success,
+                executionTime,
+                error: success ? null : `Simulated test failure`,
+                timestamp: new Date()
+            };
+        } catch (error) {
+            return {
+                testId: test.id,
+                success: false,
+                executionTime: Date.now() - startTime,
+                error: error.message,
+                timestamp: new Date()
+            };
+        }
+    }
+    async analyzeExecutionResults(results) {
+        // Update test registry with execution results
+        for (const [testId, result] of results.results.entries()){
+            const test = this.testRegistry.get(testId);
+            if (test) {
+                test.lastRun = new Date();
+                // Update success rate
+                const historicalSuccesses = Math.round(test.successRate / 100 * 10); // Assume 10 historical runs
+                const newSuccesses = historicalSuccesses + (result.success ? 1 : 0);
+                test.successRate = newSuccesses / 11 * 100;
+                // Update flakiness based on recent performance
+                if (!result.success && test.successRate > 70) {
+                    test.flakiness = Math.min(test.flakiness + 0.1, 1.0);
+                }
+            }
+        }
+    }
+    async updateExecutionHistory(results) {
+        // Store execution results in history
+        const historyEntry = {
+            timestamp: results.startTime,
+            planId: results.planId,
+            totalTests: results.totalTests,
+            passed: results.passed,
+            failed: results.failed,
+            executionTime: results.endTime.getTime() - results.startTime.getTime()
+        };
+        const history = this.executionHistory.get('overall') || [];
+        history.push(historyEntry);
+        this.executionHistory.set('overall', history.slice(-50)); // Keep last 50 runs
+    }
+    categorizeFailure(error) {
+        // Categorize failure types for pattern analysis
+        if (error.includes('timeout')) return 'timeout';
+        if (error.includes('network')) return 'network';
+        if (error.includes('assertion')) return 'assertion';
+        if (error.includes('element not found')) return 'ui-element';
+        return 'unknown';
+    }
+    async isTestFlaky(testId) {
+        const test = this.testRegistry.get(testId);
+        return test ? test.flakiness > 0.2 : false;
+    }
+    async isNewFailure(testId) {
+        // Check if this is the first time this test failed recently
+        const history = this.executionHistory.get(testId) || [];
+        const recentRuns = history.slice(-5);
+        return recentRuns.length > 0 && recentRuns.every((run)=>run.success);
+    }
+    async getRecentFailures(testId) {
+        const history = this.executionHistory.get(testId) || [];
+        return history.filter((run)=>!run.success).slice(-10);
+    }
+    async generateFailureRecommendations(analysis) {
+        const recommendations = [];
+        if (analysis.flakyTests.length > 0) {
+            recommendations.push(`Consider investigating ${analysis.flakyTests.length} flaky tests for stability improvements`);
+        }
+        if (analysis.newFailures.length > 0) {
+            recommendations.push(`${analysis.newFailures.length} new test failures detected - review recent changes`);
+        }
+        const topFailurePattern = Array.from(analysis.failurePatterns.entries()).sort((a, b)=>b[1] - a[1])[0];
+        if (topFailurePattern) {
+            recommendations.push(`Most common failure type: ${topFailurePattern[0]} (${topFailurePattern[1]} occurrences)`);
+        }
+        return recommendations;
+    }
+    async determineRetryConfig(testId) {
+        const test = this.testRegistry.get(testId);
+        if (!test) return {
+            shouldRetry: false
+        };
+        // Determine retry strategy based on test characteristics
+        const config = {
+            shouldRetry: test.flakiness > 0.1 || test.successRate > 80,
+            immediate: test.flakiness > 0.3,
+            maxRetries: test.flakiness > 0.5 ? 3 : 2,
+            delay: test.flakiness > 0.3 ? 5000 : 1000,
+            isolation: test.category === 'e2e',
+            timeout: test.estimatedDuration * 1.5
+        };
+        return config;
+    }
+}
+
+//# sourceMappingURL=RegressionTestManager.js.map

package/dist/src/automation/test-pipeline/RegressionTestManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/automation/test-pipeline/RegressionTestManager.ts"],"names":["RegressionTestManager","testRegistry","Map","executionHistory","swarmCoordinated","impactAnalysisEnabled","riskBasedTesting","config","swarmCoordination","enabled","testSelection","impactAnalysis","initialize","console","log","discoverTests","loadExecutionHistory","buildDependencyGraph","size","error","performImpactAnalysis","changedFiles","length","analysis","affectedTests","riskLevel","recommendedTests","estimatedExecutionTime","Array","from","values","calculateTotalExecutionTime","file","identifyAffectedTests","push","deduplicateTests","calculateRiskLevel","generateTestRecommendations","createExecutionPlan","tests","plan","id","Date","now","parallelGroups","executionOrder","estimatedTotalTime","resourceRequirements","agents","memory","timeout","createParallelGroups","calculateOptimalAgentCount","group","optimizedOrder","optimizeExecutionOrder","map","test","orderedTests","calculatePlanExecutionTime","calculateResourceRequirements","Math","round","executeRegressionTests","executionResults","planId","startTime","endTime","totalTests","passed","failed","skipped","results","swarmMetrics","performanceMetrics","executeWithSwarmCoordination","executeSequentially","analyzeExecutionResults","updateExecutionHistory","analyzeFailures","failureAnalysis","totalFailures","failurePatterns","flakyTests","newFailures","regressionFailures","recommendations","testId","result","entries","success","get","failureType","categorizeFailure","count","set","isTestFlaky","name","flakiness","recentFailures","getRecentFailures","isNewFailure","firstFailure","generateFailureRecommendations","generateRetryStrategy","failedTests","retryStrategy","immediateRetries","delayedRetries","skipRetries","retryConfiguration","retryConfig","determineRetryConfig","shouldRetry","immediate","maxRetries","delay","isolation","testSources","pattern","category","source","scanTestFiles","testFile","testInfo","extractTestInfo","regressionTest","random","toString","substr","path","priority","dependencies","affectedComponents","components","estimatedDuration","duration","lastRun","successRate","filePath","split","pop","some","component","includes","seen","Set","filter","has","add","riskScore","min","criticalFiles","highPriorityTests","slice","reduce","total","groups","processed","testsByCategory","categoryTests","independentTests","every","dep","t","forEach","remainingTests","maxGroupSize","max","sum","optimalAgents","ceil","sort","a","b","aDeps","bDeps","aScore","bScore","groupExecutionTimes","baseMemory","memoryPerAgent","totalMemory","groupPromises","executeTest","Promise","all","resolve","setTimeout","executionTime","timestamp","message","historicalSuccesses","newSuccesses","historyEntry","getTime","history","recentRuns","run","topFailurePattern"],"mappings":"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"}