centaurus-cli 2.5.2 → 2.5.3

package/dist/tests/integration-tests.js

@@ -1,648 +0,0 @@
-/**
- * Integration Tests for UI Rendering Refactor
- *
- * Comprehensive tests for:
- * - Complete conversation flows
- * - Approval and modal flows
- * - Error scenarios
- * - Performance testing
- */
-import { CentaurusCLI } from '../cli-adapter.js';
-import * as fs from 'fs';
-import * as path from 'path';
-class IntegrationTestRunner {
-    results = [];
-    cli;
-    testDir;
-    conversationHistory = [];
-    streamingMessages = new Map();
-    toolExecutions = new Map();
-    duplicateDetector = new Map();
-    constructor() {
-        this.cli = new CentaurusCLI();
-        this.testDir = path.join(process.cwd(), 'test-integration-temp');
-    }
-    async setup() {
-        console.log('🔧 Setting up integration test environment...\n');
-        // Create test directory
-        if (!fs.existsSync(this.testDir)) {
-            fs.mkdirSync(this.testDir, { recursive: true });
-        }
-        // Initialize CLI
-        await this.cli.initialize();
-        // Setup callbacks to track messages and detect duplicates
-        this.setupCallbacks();
-        console.log('✅ Integration test environment ready\n');
-    }
-    setupCallbacks() {
-        // Track streaming messages
-        this.cli.setOnStreamStart((messageId) => {
-            this.streamingMessages.set(messageId, '');
-            this.trackMessage('stream-start', messageId);
-        });
-        this.cli.setOnStreamChunk((messageId, chunk) => {
-            const current = this.streamingMessages.get(messageId) || '';
-            this.streamingMessages.set(messageId, current + chunk);
-        });
-        this.cli.setOnStreamComplete((messageId) => {
-            const content = this.streamingMessages.get(messageId) || '';
-            this.conversationHistory.push({
-                role: 'assistant',
-                content
-            });
-            this.streamingMessages.delete(messageId);
-            this.trackMessage('stream-complete', messageId);
-        });
-        // Track tool executions
-        this.cli.setOnToolExecutionUpdate((update) => {
-            this.toolExecutions.set(update.id || update.toolName, update);
-            this.trackMessage('tool-execution', update.id || update.toolName);
-            if (update.status === 'completed' || update.status === 'error') {
-                this.conversationHistory.push({
-                    role: 'tool',
-                    content: update.result || update.error || '',
-                    toolExecution: update
-                });
-            }
-        });
-        // Track responses
-        this.cli.setOnResponseCallback((message) => {
-            this.conversationHistory.push({
-                role: 'system',
-                content: message
-            });
-            this.trackMessage('system-response', message.substring(0, 50));
-        });
-    }
-    trackMessage(type, identifier) {
-        const key = `${type}:${identifier}`;
-        const count = this.duplicateDetector.get(key) || 0;
-        this.duplicateDetector.set(key, count + 1);
-    }
-    checkForDuplicates() {
-        const duplicates = [];
-        this.duplicateDetector.forEach((count, key) => {
-            if (count > 1) {
-                duplicates.push(`${key} appeared ${count} times`);
-            }
-        });
-        return duplicates;
-    }
-    async cleanup() {
-        console.log('\n🧹 Cleaning up integration test environment...');
-        if (fs.existsSync(this.testDir)) {
-            fs.rmSync(this.testDir, { recursive: true, force: true });
-        }
-        console.log('✅ Cleanup complete\n');
-    }
-    async runTest(name, testFn) {
-        const startTime = Date.now();
-        // Reset duplicate detector for each test
-        this.duplicateDetector.clear();
-        try {
-            await testFn();
-            // Check for duplicates after test
-            const duplicates = this.checkForDuplicates();
-            if (duplicates.length > 0) {
-                throw new Error(`Duplicates detected: ${duplicates.join(', ')}`);
-            }
-            const duration = Date.now() - startTime;
-            this.results.push({ name, passed: true, duration });
-            console.log(`✅ ${name} (${duration}ms)`);
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            this.results.push({ name, passed: false, error: error.message, duration });
-            console.log(`❌ ${name} (${duration}ms)`);
-            console.log(`   Error: ${error.message}`);
-        }
-    }
-    printSummary() {
-        console.log('\n' + '='.repeat(70));
-        console.log('INTEGRATION TEST SUMMARY');
-        console.log('='.repeat(70) + '\n');
-        const passed = this.results.filter(r => r.passed).length;
-        const failed = this.results.filter(r => !r.passed).length;
-        const total = this.results.length;
-        const passRate = total > 0 ? ((passed / total) * 100).toFixed(1) : '0.0';
-        console.log(`Total Tests: ${total}`);
-        console.log(`Passed: ${passed}`);
-        console.log(`Failed: ${failed}`);
-        console.log(`Pass Rate: ${passRate}%\n`);
-        if (failed > 0) {
-            console.log('Failed Tests:');
-            this.results
-                .filter(r => !r.passed)
-                .forEach(r => {
-                console.log(`  - ${r.name}`);
-                console.log(`    ${r.error}`);
-            });
-        }
-        console.log('\n' + '='.repeat(70) + '\n');
-    }
-    // ========================================================================
-    // Task 12.1: Test complete conversation flows
-    // ========================================================================
-    async testUserMessageFlow() {
-        await this.runTest('12.1.1: User message appears exactly once', async () => {
-            const initialCount = this.conversationHistory.length;
-            // Simulate user message (without AI response to keep test simple)
-            this.conversationHistory.push({
-                role: 'user',
-                content: 'Test user message'
-            });
-            const finalCount = this.conversationHistory.length;
-            if (finalCount !== initialCount + 1) {
-                throw new Error(`Expected 1 new message, got ${finalCount - initialCount}`);
-            }
-        });
-    }
-    async testStreamingResponseFlow() {
-        await this.runTest('12.1.2: Streaming response displays without duplicates', async () => {
-            const messageId = `test-stream-${Date.now()}`;
-            // Simulate streaming
-            this.cli.setOnStreamStart((id) => {
-                this.streamingMessages.set(id, '');
-                this.trackMessage('stream-start', id);
-            });
-            // Simulate chunks
-            const chunks = ['Hello', ' ', 'world', '!'];
-            for (const chunk of chunks) {
-                const current = this.streamingMessages.get(messageId) || '';
-                this.streamingMessages.set(messageId, current + chunk);
-            }
-            // Complete stream
-            const finalContent = this.streamingMessages.get(messageId) || '';
-            this.conversationHistory.push({
-                role: 'assistant',
-                content: finalContent
-            });
-            this.streamingMessages.delete(messageId);
-            this.trackMessage('stream-complete', messageId);
-            // Verify no duplicates
-            const streamStarts = this.duplicateDetector.get(`stream-start:${messageId}`) || 0;
-            const streamCompletes = this.duplicateDetector.get(`stream-complete:${messageId}`) || 0;
-            if (streamStarts > 1) {
-                throw new Error(`Stream started ${streamStarts} times`);
-            }
-            if (streamCompletes > 1) {
-                throw new Error(`Stream completed ${streamCompletes} times`);
-            }
-            // Verify content is correct
-            if (finalContent !== 'Hello world!') {
-                throw new Error(`Expected 'Hello world!', got '${finalContent}'`);
-            }
-        });
-    }
-    async testToolExecutionFlow() {
-        await this.runTest('12.1.3: Tool execution displays without duplicates', async () => {
-            const toolId = `test-tool-${Date.now()}`;
-            // Clear duplicate detector for this specific test since tool execution
-            // legitimately updates twice (start and complete)
-            this.duplicateDetector.clear();
-            // Simulate tool execution start
-            const toolUpdate = {
-                id: toolId,
-                toolName: 'read_file',
-                status: 'executing',
-                arguments: { file_path: 'test.txt' }
-            };
-            this.toolExecutions.set(toolId, toolUpdate);
-            this.trackMessage('tool-execution-start', toolId);
-            // Simulate tool completion
-            toolUpdate.status = 'completed';
-            toolUpdate.result = 'File content here';
-            this.toolExecutions.set(toolId, toolUpdate);
-            this.trackMessage('tool-execution-complete', toolId);
-            this.conversationHistory.push({
-                role: 'tool',
-                content: toolUpdate.result,
-                toolExecution: toolUpdate
-            });
-            // Verify tool execution tracked correctly (start and complete are separate events)
-            const startCount = this.duplicateDetector.get(`tool-execution-start:${toolId}`) || 0;
-            const completeCount = this.duplicateDetector.get(`tool-execution-complete:${toolId}`) || 0;
-            if (startCount !== 1) {
-                throw new Error(`Tool execution start should occur once, got ${startCount}`);
-            }
-            if (completeCount !== 1) {
-                throw new Error(`Tool execution complete should occur once, got ${completeCount}`);
-            }
-        });
-    }
-    async testRapidMessageSending() {
-        await this.runTest('12.1.4: Rapid message sending without duplicates', async () => {
-            const messageCount = 10;
-            const startCount = this.conversationHistory.length;
-            // Simulate rapid messages
-            for (let i = 0; i < messageCount; i++) {
-                this.conversationHistory.push({
-                    role: 'user',
-                    content: `Rapid message ${i}`
-                });
-                // Small delay to simulate rapid but not instant
-                await new Promise(resolve => setTimeout(resolve, 10));
-            }
-            const endCount = this.conversationHistory.length;
-            if (endCount - startCount !== messageCount) {
-                throw new Error(`Expected ${messageCount} messages, got ${endCount - startCount}`);
-            }
-        });
-    }
-    async testLongConversation() {
-        await this.runTest('12.1.5: Long conversation (50+ messages) without duplicates', async () => {
-            const messageCount = 55;
-            const startCount = this.conversationHistory.length;
-            // Create a long conversation
-            for (let i = 0; i < messageCount; i++) {
-                const role = i % 2 === 0 ? 'user' : 'assistant';
-                this.conversationHistory.push({
-                    role: role,
-                    content: `Message ${i} in long conversation`
-                });
-            }
-            const endCount = this.conversationHistory.length;
-            if (endCount - startCount !== messageCount) {
-                throw new Error(`Expected ${messageCount} messages, got ${endCount - startCount}`);
-            }
-            // Verify all messages are unique
-            const contentSet = new Set(this.conversationHistory.slice(startCount).map(m => m.content));
-            if (contentSet.size !== messageCount) {
-                throw new Error(`Duplicate messages detected in conversation`);
-            }
-        });
-    }
-    async testCompleteConversationFlows() {
-        console.log('📋 Task 12.1: Testing complete conversation flows...\n');
-        await this.testUserMessageFlow();
-        await this.testStreamingResponseFlow();
-        await this.testToolExecutionFlow();
-        await this.testRapidMessageSending();
-        await this.testLongConversation();
-    }
-    // ========================================================================
-    // Task 12.2: Test approval and modal flows
-    // ========================================================================
-    async testApprovalPromptDisplay() {
-        await this.runTest('12.2.1: Approval prompt displays exactly once', async () => {
-            let approvalShown = false;
-            let approvalCount = 0;
-            this.cli.setOnToolApprovalRequest(async (request) => {
-                approvalShown = true;
-                approvalCount++;
-                this.trackMessage('approval-prompt', request.message);
-                return true; // Auto-approve
-            });
-            // Simulate approval request
-            const request = {
-                message: 'Approve file write?',
-                risky: true
-            };
-            // Trigger approval (simulated)
-            approvalShown = true;
-            approvalCount++;
-            this.trackMessage('approval-prompt', request.message);
-            if (!approvalShown) {
-                throw new Error('Approval prompt was not shown');
-            }
-            if (approvalCount > 1) {
-                throw new Error(`Approval prompt shown ${approvalCount} times`);
-            }
-        });
-    }
-    async testPreviewContentDisplay() {
-        await this.runTest('12.2.2: Preview content displays exactly once', async () => {
-            let previewShown = false;
-            let previewCount = 0;
-            const preview = {
-                type: 'code',
-                content: 'console.log("test");',
-                language: 'javascript'
-            };
-            // Simulate preview display
-            previewShown = true;
-            previewCount++;
-            this.trackMessage('preview-display', preview.content);
-            if (!previewShown) {
-                throw new Error('Preview was not shown');
-            }
-            if (previewCount > 1) {
-                throw new Error(`Preview shown ${previewCount} times`);
-            }
-        });
-    }
-    async testAutoAcceptModeBypass() {
-        await this.runTest('12.2.3: Auto-accept mode bypasses approval prompts', async () => {
-            let approvalShown = false;
-            // Enable auto-accept mode (simulated)
-            const autoAcceptEnabled = true;
-            this.cli.setOnToolApprovalRequest(async (request) => {
-                if (!autoAcceptEnabled) {
-                    approvalShown = true;
-                }
-                return true; // Auto-approve
-            });
-            // Simulate risky operation with auto-accept enabled
-            // Approval should not be shown
-            if (approvalShown) {
-                throw new Error('Approval prompt shown despite auto-accept mode');
-            }
-        });
-    }
-    async testPlanApprovalFlow() {
-        await this.runTest('12.2.4: Plan approval flow works correctly', async () => {
-            let planApprovalShown = false;
-            let planApprovalCount = 0;
-            this.cli.setOnPlanApprovalRequest(async (plan) => {
-                planApprovalShown = true;
-                planApprovalCount++;
-                this.trackMessage('plan-approval', JSON.stringify(plan).substring(0, 50));
-                return true; // Auto-approve
-            });
-            // Simulate plan approval request
-            const plan = {
-                tasks: ['Task 1', 'Task 2', 'Task 3'],
-                question: 'Approve this plan?'
-            };
-            planApprovalShown = true;
-            planApprovalCount++;
-            this.trackMessage('plan-approval', JSON.stringify(plan).substring(0, 50));
-            if (!planApprovalShown) {
-                throw new Error('Plan approval was not shown');
-            }
-            if (planApprovalCount > 1) {
-                throw new Error(`Plan approval shown ${planApprovalCount} times`);
-            }
-        });
-    }
-    async testApprovalAndModalFlows() {
-        console.log('\n📋 Task 12.2: Testing approval and modal flows...\n');
-        await this.testApprovalPromptDisplay();
-        await this.testPreviewContentDisplay();
-        await this.testAutoAcceptModeBypass();
-        await this.testPlanApprovalFlow();
-    }
-    // ========================================================================
-    // Task 12.3: Test error scenarios
-    // ========================================================================
-    async testStreamingInterruption() {
-        await this.runTest('12.3.1: Streaming interruption handled correctly', async () => {
-            const messageId = `test-stream-error-${Date.now()}`;
-            // Start streaming
-            this.streamingMessages.set(messageId, '');
-            this.trackMessage('stream-start', messageId);
-            // Add some chunks
-            this.streamingMessages.set(messageId, 'Partial content');
-            // Simulate interruption/error
-            try {
-                throw new Error('Stream interrupted');
-            }
-            catch (error) {
-                // Handle error - add error message to conversation
-                this.conversationHistory.push({
-                    role: 'system',
-                    content: `❌ Streaming error: ${error.message}`
-                });
-                // Clear streaming message
-                this.streamingMessages.delete(messageId);
-                this.trackMessage('stream-error', messageId);
-            }
-            // Verify error was handled
-            const lastMessage = this.conversationHistory[this.conversationHistory.length - 1];
-            if (!lastMessage.content.includes('Streaming error')) {
-                throw new Error('Error message not added to conversation');
-            }
-            // Verify streaming message was cleared
-            if (this.streamingMessages.has(messageId)) {
-                throw new Error('Streaming message not cleared after error');
-            }
-        });
-    }
-    async testToolExecutionFailure() {
-        await this.runTest('12.3.2: Tool execution failure handled correctly', async () => {
-            const toolId = `test-tool-error-${Date.now()}`;
-            // Clear duplicate detector for this specific test
-            this.duplicateDetector.clear();
-            // Simulate tool execution
-            const toolUpdate = {
-                id: toolId,
-                toolName: 'read_file',
-                status: 'executing',
-                arguments: { file_path: 'nonexistent.txt' }
-            };
-            this.toolExecutions.set(toolId, toolUpdate);
-            this.trackMessage('tool-execution-start', toolId);
-            // Simulate tool failure
-            toolUpdate.status = 'error';
-            toolUpdate.error = 'File not found';
-            this.toolExecutions.set(toolId, toolUpdate);
-            this.trackMessage('tool-execution-error', toolId);
-            // Add error to conversation
-            this.conversationHistory.push({
-                role: 'tool',
-                content: toolUpdate.error,
-                toolExecution: toolUpdate
-            });
-            // Verify error was tracked
-            const lastMessage = this.conversationHistory[this.conversationHistory.length - 1];
-            if (lastMessage.content !== 'File not found') {
-                throw new Error('Tool error not added to conversation');
-            }
-            // Verify no duplicates (start and error are separate events)
-            const startCount = this.duplicateDetector.get(`tool-execution-start:${toolId}`) || 0;
-            const errorCount = this.duplicateDetector.get(`tool-execution-error:${toolId}`) || 0;
-            if (startCount !== 1) {
-                throw new Error(`Tool execution start should occur once, got ${startCount}`);
-            }
-            if (errorCount !== 1) {
-                throw new Error(`Tool execution error should occur once, got ${errorCount}`);
-            }
-        });
-    }
-    async testNetworkError() {
-        await this.runTest('12.3.3: Network error handled correctly', async () => {
-            // Simulate network error during AI request
-            try {
-                throw new Error('Network timeout');
-            }
-            catch (error) {
-                // Handle error
-                this.conversationHistory.push({
-                    role: 'system',
-                    content: `❌ Network error: ${error.message}`
-                });
-                this.trackMessage('network-error', error.message);
-            }
-            // Verify error message added
-            const lastMessage = this.conversationHistory[this.conversationHistory.length - 1];
-            if (!lastMessage.content.includes('Network error')) {
-                throw new Error('Network error not added to conversation');
-            }
-        });
-    }
-    async testErrorMessageNoDuplication() {
-        await this.runTest('12.3.4: Error messages display without duplication', async () => {
-            const errorMessage = 'Test error message';
-            // Add error message once
-            this.conversationHistory.push({
-                role: 'system',
-                content: `❌ ${errorMessage}`
-            });
-            this.trackMessage('error-message', errorMessage);
-            // Verify it appears only once
-            const errorCount = this.conversationHistory.filter(m => m.content.includes(errorMessage)).length;
-            if (errorCount > 1) {
-                throw new Error(`Error message appeared ${errorCount} times`);
-            }
-        });
-    }
-    async testErrorScenarios() {
-        console.log('\n📋 Task 12.3: Testing error scenarios...\n');
-        await this.testStreamingInterruption();
-        await this.testToolExecutionFailure();
-        await this.testNetworkError();
-        await this.testErrorMessageNoDuplication();
-    }
-    // ========================================================================
-    // Task 12.4: Performance testing
-    // ========================================================================
-    async testLargeConversationPerformance() {
-        await this.runTest('12.4.1: 100+ message conversation performance', async () => {
-            const messageCount = 120;
-            const startTime = Date.now();
-            const startCount = this.conversationHistory.length;
-            // Create large conversation
-            for (let i = 0; i < messageCount; i++) {
-                const role = i % 3 === 0 ? 'user' : i % 3 === 1 ? 'assistant' : 'system';
-                this.conversationHistory.push({
-                    role: role,
-                    content: `Performance test message ${i} with some content to make it realistic`
-                });
-            }
-            const duration = Date.now() - startTime;
-            const endCount = this.conversationHistory.length;
-            // Verify all messages added
-            if (endCount - startCount !== messageCount) {
-                throw new Error(`Expected ${messageCount} messages, got ${endCount - startCount}`);
-            }
-            // Performance check - should complete in reasonable time (< 1 second for adding messages)
-            if (duration > 1000) {
-                throw new Error(`Performance issue: took ${duration}ms to add ${messageCount} messages`);
-            }
-            console.log(`   Added ${messageCount} messages in ${duration}ms`);
-        });
-    }
-    async testResponsiveInput() {
-        await this.runTest('12.4.2: Input remains responsive with large history', async () => {
-            // Ensure we have a large conversation
-            const currentSize = this.conversationHistory.length;
-            if (currentSize < 100) {
-                // Add more messages to reach 100+
-                const needed = 100 - currentSize;
-                for (let i = 0; i < needed; i++) {
-                    this.conversationHistory.push({
-                        role: 'user',
-                        content: `Filler message ${i}`
-                    });
-                }
-            }
-            // Simulate rapid input
-            const startTime = Date.now();
-            const testMessages = 10;
-            for (let i = 0; i < testMessages; i++) {
-                this.conversationHistory.push({
-                    role: 'user',
-                    content: `Responsive test ${i}`
-                });
-            }
-            const duration = Date.now() - startTime;
-            // Should be very fast (< 100ms for 10 messages)
-            if (duration > 100) {
-                throw new Error(`Input not responsive: took ${duration}ms for ${testMessages} messages`);
-            }
-            console.log(`   Added ${testMessages} messages in ${duration}ms with ${this.conversationHistory.length} total messages`);
-        });
-    }
-    async testMemoryUsage() {
-        await this.runTest('12.4.3: Memory usage reasonable over long session', async () => {
-            const initialMemory = process.memoryUsage().heapUsed;
-            // Create a very long conversation
-            const messageCount = 500;
-            for (let i = 0; i < messageCount; i++) {
-                this.conversationHistory.push({
-                    role: i % 2 === 0 ? 'user' : 'assistant',
-                    content: `Memory test message ${i} with some content to simulate real usage`
-                });
-            }
-            const finalMemory = process.memoryUsage().heapUsed;
-            const memoryIncrease = (finalMemory - initialMemory) / 1024 / 1024; // MB
-            console.log(`   Memory increase: ${memoryIncrease.toFixed(2)} MB for ${messageCount} messages`);
-            // Memory increase should be reasonable (< 50 MB for 500 messages)
-            if (memoryIncrease > 50) {
-                throw new Error(`Excessive memory usage: ${memoryIncrease.toFixed(2)} MB for ${messageCount} messages`);
-            }
-        });
-    }
-    async testRerenderFrequency() {
-        await this.runTest('12.4.4: Re-render frequency is optimized', async () => {
-            // This test verifies that adding messages doesn't cause excessive operations
-            const startTime = Date.now();
-            const iterations = 50;
-            for (let i = 0; i < iterations; i++) {
-                // Simulate message addition
-                this.conversationHistory.push({
-                    role: 'user',
-                    content: `Render test ${i}`
-                });
-                // Simulate checking for duplicates (like React would re-render)
-                const duplicates = this.checkForDuplicates();
-                if (duplicates.length > 0) {
-                    throw new Error(`Duplicates detected during render test: ${duplicates.join(', ')}`);
-                }
-            }
-            const duration = Date.now() - startTime;
-            const avgTime = duration / iterations;
-            console.log(`   Average time per message: ${avgTime.toFixed(2)}ms`);
-            // Should be very fast (< 5ms per message on average)
-            if (avgTime > 5) {
-                throw new Error(`Slow render performance: ${avgTime.toFixed(2)}ms per message`);
-            }
-        });
-    }
-    async testPerformance() {
-        console.log('\n📋 Task 12.4: Testing performance...\n');
-        await this.testLargeConversationPerformance();
-        await this.testResponsiveInput();
-        await this.testMemoryUsage();
-        await this.testRerenderFrequency();
-    }
-    // ========================================================================
-    // Main test runner
-    // ========================================================================
-    async runAllTests() {
-        console.log('🚀 Starting Integration Tests for UI Rendering Refactor\n');
-        console.log('='.repeat(70) + '\n');
-        await this.setup();
-        // Task 12.1: Complete conversation flows
-        await this.testCompleteConversationFlows();
-        // Task 12.2: Approval and modal flows
-        await this.testApprovalAndModalFlows();
-        // Task 12.3: Error scenarios
-        await this.testErrorScenarios();
-        // Task 12.4: Performance testing
-        await this.testPerformance();
-        await this.cleanup();
-        this.printSummary();
-        // Exit with appropriate code
-        const failed = this.results.filter(r => !r.passed).length;
-        process.exit(failed > 0 ? 1 : 0);
-    }
-}
-// Run tests if this file is executed directly
-const runner = new IntegrationTestRunner();
-runner.runAllTests().catch((error) => {
-    console.error('❌ Integration test runner failed:', error);
-    process.exit(1);
-});
-export { IntegrationTestRunner };
-//# sourceMappingURL=integration-tests.js.map