auto-coder 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/shell_commands/tests/test_monitoring.py

@@ -0,0 +1,546 @@
+"""
+Tests for monitoring functionality.
+
+This module tests the monitoring capabilities used in shell command execution.
+"""
+
+import pytest
+import time
+from datetime import datetime
+from unittest.mock import Mock, patch
+
+from autocoder.common.shell_commands.monitoring import (
+    CommandExecutionLogger,
+    PerformanceMonitor,
+    CommandExecutionMetrics,
+    get_logger,
+    get_global_monitor,
+    reset_global_instances
+)
+from autocoder.common.shell_commands.exceptions import (
+    CommandExecutionError,
+    CommandTimeoutError
+)
+
+
+class TestCommandExecutionMetrics:
+    """Test cases for CommandExecutionMetrics class."""
+    
+    def test_initialization(self):
+        """Test metrics initialization."""
+        command = "echo hello"
+        start_time = datetime.now()
+        
+        metrics = CommandExecutionMetrics(command, start_time)
+        
+        assert metrics.command == command
+        assert metrics.start_time == start_time
+        assert metrics.end_time is None
+        assert metrics.duration is None
+        assert metrics.exit_code is None
+        assert metrics.timeout is None
+        assert metrics.timed_out is False
+        assert metrics.pid is None
+        assert metrics.output_length == 0
+        assert metrics.error_count == 0
+        assert metrics.recovery_attempts == 0
+    
+    def test_finalize_with_default_end_time(self):
+        """Test metrics finalization with default end time."""
+        command = "echo hello"
+        start_time = datetime.now()
+        
+        metrics = CommandExecutionMetrics(command, start_time)
+        
+        # Wait a bit to ensure duration is measurable
+        time.sleep(0.001)
+        
+        metrics.finalize()
+        
+        assert metrics.end_time is not None
+        assert metrics.duration is not None
+        assert metrics.duration > 0
+        assert metrics.end_time > start_time
+    
+    def test_finalize_with_custom_end_time(self):
+        """Test metrics finalization with custom end time."""
+        command = "echo hello"
+        start_time = datetime.now()
+        end_time = datetime.now()
+        
+        metrics = CommandExecutionMetrics(command, start_time)
+        metrics.finalize(end_time)
+        
+        assert metrics.end_time == end_time
+        assert metrics.duration is not None
+        assert metrics.duration >= 0
+    
+    def test_string_representation(self):
+        """Test string representation of metrics."""
+        command = "echo hello"
+        start_time = datetime.now()
+        
+        metrics = CommandExecutionMetrics(command, start_time)
+        metrics.exit_code = 0
+        metrics.duration = 1.5
+        
+        str_repr = str(metrics)
+        assert command in str_repr
+        assert "0" in str_repr  # exit code
+        assert "1.5" in str_repr  # duration
+    
+    def test_metrics_with_timeout(self):
+        """Test metrics with timeout information."""
+        command = "sleep 10"
+        start_time = datetime.now()
+        
+        metrics = CommandExecutionMetrics(command, start_time)
+        metrics.timeout = 5.0
+        metrics.timed_out = True
+        metrics.pid = 1234
+        
+        assert metrics.timeout == 5.0
+        assert metrics.timed_out is True
+        assert metrics.pid == 1234
+    
+    def test_metrics_with_error_tracking(self):
+        """Test metrics with error tracking."""
+        command = "failing_command"
+        start_time = datetime.now()
+        
+        metrics = CommandExecutionMetrics(command, start_time)
+        metrics.error_count = 2
+        metrics.recovery_attempts = 3
+        
+        assert metrics.error_count == 2
+        assert metrics.recovery_attempts == 3
+
+
+class TestCommandExecutionLogger:
+    """Test cases for CommandExecutionLogger class."""
+    
+    def test_initialization(self):
+        """Test logger initialization."""
+        logger = CommandExecutionLogger(verbose=True)
+        assert logger.verbose is True
+    
+    def test_log_command_start(self):
+        """Test logging command start."""
+        logger = CommandExecutionLogger(verbose=False)
+        
+        metrics = logger.log_command_start("echo hello", 5.0, 1234, "/tmp")
+        
+        assert metrics.command == "echo hello"
+        assert metrics.timeout == 5.0
+        assert metrics.pid == 1234
+        assert metrics.start_time is not None
+    
+    def test_log_command_start_without_optional_params(self):
+        """Test logging command start without optional parameters."""
+        logger = CommandExecutionLogger()
+        
+        metrics = logger.log_command_start("test command")
+        
+        assert metrics.command == "test command"
+        assert metrics.timeout is None
+        assert metrics.pid is None
+    
+    def test_log_command_complete_success(self):
+        """Test logging successful command completion."""
+        logger = CommandExecutionLogger()
+        
+        metrics = CommandExecutionMetrics("test command", datetime.now())
+        metrics.pid = 1234
+        
+        logger.log_command_complete(metrics, 0, "output text")
+        
+        assert metrics.exit_code == 0
+        assert metrics.output_length == len("output text")
+        assert metrics.end_time is not None
+        assert metrics.duration is not None
+    
+    def test_log_command_complete_failure(self):
+        """Test logging failed command completion."""
+        logger = CommandExecutionLogger()
+        
+        metrics = CommandExecutionMetrics("test command", datetime.now())
+        metrics.pid = 1234
+        
+        error = CommandExecutionError("Command failed")
+        logger.log_command_complete(metrics, 1, "", error)
+        
+        assert metrics.exit_code == 1
+        assert metrics.output_length == 0
+        assert metrics.error_count == 1
+        assert metrics.end_time is not None
+    
+    def test_log_command_complete_timeout(self):
+        """Test logging command timeout."""
+        logger = CommandExecutionLogger()
+        
+        metrics = CommandExecutionMetrics("sleep 10", datetime.now())
+        metrics.pid = 1234
+        metrics.timeout = 5.0
+        
+        timeout_error = CommandTimeoutError("sleep 10", 5.0, 1234)
+        logger.log_command_complete(metrics, -1, "", timeout_error)
+        
+        assert metrics.exit_code == -1
+        assert metrics.timed_out is True
+        assert metrics.error_count == 1
+    
+    def test_get_execution_history(self):
+        """Test getting command execution history."""
+        logger = CommandExecutionLogger()
+        
+        # Log a few commands
+        metrics1 = logger.log_command_start("echo 1")
+        logger.log_command_complete(metrics1, 0, "output1")
+        
+        metrics2 = logger.log_command_start("echo 2")
+        logger.log_command_complete(metrics2, 0, "output2")
+        
+        history = logger.get_execution_history()
+        
+        assert len(history) == 2
+        assert history[0].command == "echo 1"
+        assert history[1].command == "echo 2"
+    
+    def test_get_summary_stats(self):
+        """Test getting summary statistics."""
+        logger = CommandExecutionLogger()
+        
+        # Log successful command
+        metrics1 = logger.log_command_start("echo success")
+        logger.log_command_complete(metrics1, 0, "output")
+        
+        # Log failed command
+        metrics2 = logger.log_command_start("false")
+        logger.log_command_complete(metrics2, 1, "")
+        
+        # Log timeout command
+        metrics3 = logger.log_command_start("sleep 10")
+        metrics3.timeout = 5.0
+        timeout_error = CommandTimeoutError("sleep 10", 5.0, 1234)
+        logger.log_command_complete(metrics3, -1, "", timeout_error)
+        
+        stats = logger.get_summary_stats()
+        
+        assert stats['total_commands'] == 3
+        assert stats['completed_commands'] == 3
+        assert stats['successful_commands'] == 1
+        assert stats['failed_commands'] == 1
+        assert stats['timed_out_commands'] == 1
+        assert stats['success_rate'] == 1/3
+        assert stats['timeout_rate'] == 1/3
+
+
+class TestPerformanceMonitor:
+    """Test cases for PerformanceMonitor class."""
+    
+    def test_initialization(self):
+        """Test monitor initialization."""
+        monitor = PerformanceMonitor()
+        assert len(monitor.metrics_history) == 0
+        assert len(monitor.performance_alerts) == 0
+    
+    def test_record_execution(self):
+        """Test recording command execution."""
+        monitor = PerformanceMonitor()
+        
+        metrics = CommandExecutionMetrics("echo test", datetime.now())
+        metrics.exit_code = 0
+        metrics.duration = 1.5
+        
+        monitor.record_execution(metrics)
+        
+        recent_metrics = monitor.get_recent_metrics(1)
+        assert len(recent_metrics) == 1
+        assert recent_metrics[0].command == "echo test"
+        assert recent_metrics[0].duration == 1.5
+    
+    def test_record_execution_performance_alert(self):
+        """Test recording execution that triggers performance alert."""
+        monitor = PerformanceMonitor()
+        
+        # Create a slow command
+        metrics = CommandExecutionMetrics("slow_command", datetime.now())
+        metrics.duration = 30.0  # Very slow command
+        metrics.exit_code = 0
+        
+        monitor.record_execution(metrics)
+        
+        alerts = monitor.get_alerts(1)
+        assert len(alerts) >= 0  # May or may not trigger alert depending on implementation
+    
+    def test_record_execution_timeout_alert(self):
+        """Test recording execution that triggers timeout alert."""
+        monitor = PerformanceMonitor()
+        
+        metrics = CommandExecutionMetrics("timeout_command", datetime.now())
+        metrics.timed_out = True
+        metrics.timeout = 5.0
+        
+        monitor.record_execution(metrics)
+        
+        alerts = monitor.get_alerts(1)
+        assert len(alerts) >= 0  # May or may not trigger alert depending on implementation
+    
+    def test_record_execution_error_alert(self):
+        """Test recording execution that triggers error alert."""
+        monitor = PerformanceMonitor()
+        
+        metrics = CommandExecutionMetrics("error_command", datetime.now())
+        metrics.exit_code = 1
+        metrics.error_count = 1
+        
+        monitor.record_execution(metrics)
+        
+        alerts = monitor.get_alerts(1)
+        assert len(alerts) >= 0  # May or may not trigger alert depending on implementation
+    
+    def test_get_recent_metrics(self):
+        """Test getting recent metrics."""
+        monitor = PerformanceMonitor()
+        
+        # Record multiple executions
+        for i in range(5):
+            metrics = CommandExecutionMetrics(f"echo {i}", datetime.now())
+            metrics.exit_code = 0
+            monitor.record_execution(metrics)
+        
+        recent = monitor.get_recent_metrics(3)
+        assert len(recent) == 3
+        # Check that we get some of the recent commands
+        assert any(f"echo {i}" in m.command for m in recent for i in range(2, 5))
+    
+    def test_get_command_stats(self):
+        """Test getting command statistics."""
+        monitor = PerformanceMonitor()
+        
+        # Record multiple echo commands
+        for i in range(3):
+            metrics = CommandExecutionMetrics(f"echo {i}", datetime.now())
+            metrics.exit_code = 0
+            metrics.duration = 1.0 + i * 0.5
+            monitor.record_execution(metrics)
+        
+        # Record a different command
+        metrics = CommandExecutionMetrics("ls", datetime.now())
+        metrics.exit_code = 0
+        metrics.duration = 0.5
+        monitor.record_execution(metrics)
+        
+        echo_stats = monitor.get_command_stats("echo")
+        assert echo_stats['total_executions'] == 3
+        assert echo_stats['completed_executions'] == 3
+        assert echo_stats['successful_executions'] == 3
+        assert echo_stats['success_rate'] == 1.0
+        assert echo_stats['average_duration'] == 1.5  # (1.0 + 1.5 + 2.0) / 3
+    
+    def test_get_performance_summary(self):
+        """Test getting performance summary."""
+        monitor = PerformanceMonitor()
+        
+        # Record some commands
+        for i in range(5):
+            metrics = CommandExecutionMetrics(f"echo {i}", datetime.now())
+            metrics.exit_code = 0 if i < 3 else 1
+            metrics.duration = 1.0
+            monitor.record_execution(metrics)
+        
+        summary = monitor.get_performance_summary()
+        
+        assert summary['total_commands'] == 5
+        assert summary['recent_commands'] == 5
+        assert summary['success_rate'] == 0.6  # 3/5
+        assert summary['timeout_rate'] == 0.0
+        assert summary['average_duration'] == 1.0
+
+
+class TestGlobalMonitoringInstances:
+    """Test cases for global monitoring instances."""
+    
+    def test_get_global_logger(self):
+        """Test getting global logger instance."""
+        logger1 = get_logger()
+        logger2 = get_logger()
+        
+        assert logger1 is logger2  # Should be the same instance
+        assert isinstance(logger1, CommandExecutionLogger)
+    
+    def test_get_global_monitor(self):
+        """Test getting global monitor instance."""
+        monitor1 = get_global_monitor()
+        monitor2 = get_global_monitor()
+        
+        assert monitor1 is monitor2  # Should be the same instance
+        assert isinstance(monitor1, PerformanceMonitor)
+    
+    def test_reset_global_instances(self):
+        """Test resetting global instances."""
+        logger1 = get_logger()
+        monitor1 = get_global_monitor()
+        
+        reset_global_instances()
+        
+        logger2 = get_logger()
+        monitor2 = get_global_monitor()
+        
+        assert logger1 is not logger2  # Should be different instances
+        assert monitor1 is not monitor2
+    
+    def test_global_logger_with_verbose_flag(self):
+        """Test global logger with verbose flag."""
+        logger = get_logger(verbose=True)
+        assert logger.verbose is True
+        
+        # Reset and test with verbose=False
+        reset_global_instances()
+        logger = get_logger(verbose=False)
+        assert logger.verbose is False
+
+
+class TestMonitoringIntegration:
+    """Test cases for monitoring integration scenarios."""
+    
+    def test_logger_monitor_integration(self):
+        """Test integration between logger and monitor."""
+        logger = CommandExecutionLogger()
+        monitor = PerformanceMonitor()
+        
+        # Log command execution
+        metrics = logger.log_command_start("echo test", 5.0, 1234)
+        logger.log_command_complete(metrics, 0, "output")
+        
+        # Record in monitor
+        monitor.record_execution(metrics)
+        
+        # Verify both have the execution recorded
+        history = logger.get_execution_history()
+        recent = monitor.get_recent_metrics(1)
+        
+        assert len(history) == 1
+        assert len(recent) == 1
+        assert history[0].command == recent[0].command
+    
+    def test_monitoring_with_errors(self):
+        """Test monitoring with error conditions."""
+        logger = CommandExecutionLogger()
+        monitor = PerformanceMonitor()
+        
+        # Log failed command
+        metrics = logger.log_command_start("false")
+        error = CommandExecutionError("Command failed")
+        logger.log_command_complete(metrics, 1, "", error)
+        
+        monitor.record_execution(metrics)
+        
+        # Check statistics
+        stats = logger.get_summary_stats()
+        alerts = monitor.get_alerts(1)
+        
+        assert stats['failed_commands'] == 1
+        assert len(alerts) >= 0  # May or may not trigger alert
+    
+    def test_monitoring_with_timeout(self):
+        """Test monitoring with timeout conditions."""
+        logger = CommandExecutionLogger()
+        monitor = PerformanceMonitor()
+        
+        # Log timeout command
+        metrics = logger.log_command_start("sleep 10")
+        metrics.timeout = 5.0
+        timeout_error = CommandTimeoutError("sleep 10", 5.0, 1234)
+        logger.log_command_complete(metrics, -1, "", timeout_error)
+        
+        monitor.record_execution(metrics)
+        
+        # Check statistics
+        stats = logger.get_summary_stats()
+        alerts = monitor.get_alerts(1)
+        
+        assert stats['timed_out_commands'] == 1
+        assert len(alerts) >= 0  # May or may not trigger alert
+
+
+class TestMonitoringEdgeCases:
+    """Test cases for monitoring edge cases."""
+    
+    def test_empty_command_logging(self):
+        """Test logging with empty command."""
+        logger = CommandExecutionLogger()
+        
+        metrics = logger.log_command_start("")
+        logger.log_command_complete(metrics, 0, "")
+        
+        assert metrics.command == ""
+        assert metrics.exit_code == 0
+    
+    def test_very_long_command_logging(self):
+        """Test logging with very long command."""
+        logger = CommandExecutionLogger()
+        
+        long_command = "echo " + "a" * 1000
+        metrics = logger.log_command_start(long_command)
+        logger.log_command_complete(metrics, 0, "output")
+        
+        assert metrics.command == long_command
+        assert len(metrics.command) > 1000
+    
+    def test_negative_duration_handling(self):
+        """Test handling of negative duration."""
+        monitor = PerformanceMonitor()
+        
+        metrics = CommandExecutionMetrics("echo test", datetime.now())
+        metrics.duration = -1.0  # Invalid duration
+        
+        # Should handle gracefully
+        monitor.record_execution(metrics)
+        
+        recent = monitor.get_recent_metrics(1)
+        assert len(recent) == 1
+    
+    def test_error_values_handling(self):
+        """Test handling of error values in metrics."""
+        logger = CommandExecutionLogger()
+        
+        metrics = logger.log_command_start("echo test")
+        # Set valid exit code and output
+        logger.log_command_complete(metrics, 0, "output")
+        
+        assert metrics.exit_code == 0
+        assert metrics.output_length == len("output")
+    
+    def test_concurrent_monitoring(self):
+        """Test concurrent access to monitoring instances."""
+        import threading
+        
+        logger = get_logger()
+        monitor = get_global_monitor()
+        
+        results = []
+        
+        def log_command(i):
+            metrics = logger.log_command_start(f"echo {i}")
+            logger.log_command_complete(metrics, 0, f"output {i}")
+            monitor.record_execution(metrics)
+            results.append(i)
+        
+        threads = []
+        for i in range(5):
+            thread = threading.Thread(target=log_command, args=(i,))
+            threads.append(thread)
+            thread.start()
+        
+        for thread in threads:
+            thread.join()
+        
+        # All commands should be logged
+        assert len(results) == 5
+        assert len(logger.get_execution_history()) == 5
+        assert len(monitor.get_recent_metrics(5)) == 5
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])