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

autocoder/common/shell_commands/tests/test_error_recovery.py

@@ -0,0 +1,305 @@
+"""
+Tests for error recovery functionality.
+
+This module tests the error recovery mechanisms used in shell command execution.
+"""
+
+import pytest
+import time
+from unittest.mock import Mock, patch
+
+from autocoder.common.shell_commands.error_recovery import (
+    ErrorRecoveryManager,
+    RetryConfig,
+    create_default_error_recovery_manager,
+    retry_with_backoff
+)
+from autocoder.common.shell_commands.exceptions import (
+    CommandExecutionError,
+    CommandTimeoutError,
+    ErrorRecoveryFailedError
+)
+
+
+class TestRetryConfig:
+    """Test cases for RetryConfig class."""
+    
+    def test_initialization_defaults(self):
+        """Test RetryConfig initialization with default values."""
+        config = RetryConfig()
+        assert config.max_attempts == 3
+        assert config.base_delay == 1.0
+        assert config.max_delay == 60.0
+        assert config.backoff_factor == 2.0
+        assert config.retry_on_timeout is True
+        assert config.retry_on_cleanup_error is True
+    
+    def test_initialization_custom(self):
+        """Test RetryConfig initialization with custom values."""
+        config = RetryConfig(
+            max_attempts=5,
+            base_delay=2.0,
+            max_delay=120.0,
+            backoff_factor=3.0,
+            retry_on_timeout=False,
+            retry_on_cleanup_error=False
+        )
+        assert config.max_attempts == 5
+        assert config.base_delay == 2.0
+        assert config.max_delay == 120.0
+        assert config.backoff_factor == 3.0
+        assert config.retry_on_timeout is False
+        assert config.retry_on_cleanup_error is False
+    
+    def test_get_delay_exponential_backoff(self):
+        """Test exponential backoff delay calculation."""
+        config = RetryConfig(base_delay=1.0, backoff_factor=2.0, max_delay=10.0, jitter=False)
+        
+        assert config.get_delay(0) == 1.0  # base_delay * 2^0
+        assert config.get_delay(1) == 2.0  # base_delay * 2^1
+        assert config.get_delay(2) == 4.0  # base_delay * 2^2
+    
+    def test_get_delay_max_limit(self):
+        """Test that delay calculation respects maximum limit."""
+        config = RetryConfig(base_delay=1.0, backoff_factor=2.0, max_delay=5.0, jitter=False)
+        
+        # Even with exponential backoff, delay should not exceed max_delay
+        delay_high = config.get_delay(10)  # Very high attempt number
+        assert delay_high <= 5.0
+    
+    def test_should_retry_timeout_error(self):
+        """Test retry decision for timeout errors."""
+        config = RetryConfig(retry_on_timeout=True)
+        timeout_error = CommandTimeoutError("test", 5.0, 123)
+        assert config.should_retry(timeout_error, 0)
+        assert config.should_retry(timeout_error, 1)
+        assert config.should_retry(timeout_error, 2)
+        assert not config.should_retry(timeout_error, 3)  # Max attempts reached
+    
+    def test_should_retry_timeout_disabled(self):
+        """Test retry decision when timeout retry is disabled."""
+        config = RetryConfig(retry_on_timeout=False)
+        timeout_error = CommandTimeoutError("test", 5.0, 123)
+        assert not config.should_retry(timeout_error, 0)
+    
+    def test_should_retry_generic_error(self):
+        """Test retry decision for generic errors."""
+        config = RetryConfig()
+        generic_error = Exception("Generic error")
+        assert not config.should_retry(generic_error, 0)
+
+
+class TestErrorRecoveryManager:
+    """Test cases for ErrorRecoveryManager class."""
+    
+    def test_initialization_defaults(self):
+        """Test manager initialization with default values."""
+        manager = ErrorRecoveryManager()
+        assert manager.max_recovery_attempts == 3
+        assert len(manager.recovery_strategies) > 0
+    
+    def test_initialization_custom(self):
+        """Test manager initialization with custom values."""
+        manager = ErrorRecoveryManager(max_recovery_attempts=5)
+        assert manager.max_recovery_attempts == 5
+    
+    def test_register_recovery_strategy(self):
+        """Test registering custom recovery strategies."""
+        manager = ErrorRecoveryManager()
+        
+        def custom_strategy(error, context, retry_count):
+            return True
+        
+        manager.register_recovery_strategy(ValueError, custom_strategy)
+        assert ValueError in manager.recovery_strategies
+    
+    def test_handle_error_success(self):
+        """Test successful error recovery."""
+        manager = ErrorRecoveryManager()
+        
+        # Mock a successful recovery
+        def mock_strategy(error, context, retry_count):
+            return True
+        
+        manager.register_recovery_strategy(ValueError, mock_strategy)
+        
+        error = ValueError("Test error")
+        result = manager.handle_error(error)
+        assert result is True
+    
+    def test_handle_error_failure(self):
+        """Test failed error recovery."""
+        manager = ErrorRecoveryManager(max_recovery_attempts=1)
+        
+        # Mock a failed recovery
+        def mock_strategy(error, context, retry_count):
+            return False
+        
+        manager.register_recovery_strategy(ValueError, mock_strategy)
+        
+        error = ValueError("Test error")
+        with pytest.raises(ErrorRecoveryFailedError):
+            manager.handle_error(error)
+    
+    def test_handle_error_no_strategy(self):
+        """Test error handling when no strategy is available."""
+        manager = ErrorRecoveryManager()
+        
+        # Use an error type that doesn't have a strategy
+        error = KeyError("Test error")
+        result = manager.handle_error(error)
+        assert result is False
+
+
+class TestRetryWithBackoff:
+    """Test cases for retry_with_backoff function."""
+    
+    def test_retry_success_on_first_try(self):
+        """Test successful execution on first try."""
+        call_count = 0
+        
+        def successful_func():
+            nonlocal call_count
+            call_count += 1
+            return "success"
+        
+        config = RetryConfig()
+        result = retry_with_backoff(successful_func, config)
+        
+        assert result == "success"
+        assert call_count == 1
+    
+    def test_retry_success_after_failures(self):
+        """Test successful execution after initial failures."""
+        call_count = 0
+        
+        def flaky_func():
+            nonlocal call_count
+            call_count += 1
+            if call_count < 3:
+                raise CommandTimeoutError("test", 5.0, 123)
+            return "success"
+        
+        config = RetryConfig(max_attempts=5, retry_on_timeout=True)
+        result = retry_with_backoff(flaky_func, config)
+        
+        assert result == "success"
+        assert call_count == 3
+    
+    def test_retry_max_attempts_exceeded(self):
+        """Test behavior when max attempts is exceeded."""
+        call_count = 0
+        
+        def always_fail_func():
+            nonlocal call_count
+            call_count += 1
+            raise CommandTimeoutError("test", 5.0, 123)
+        
+        config = RetryConfig(max_attempts=2, retry_on_timeout=True)
+        with pytest.raises(CommandTimeoutError):
+            retry_with_backoff(always_fail_func, config)
+        
+        assert call_count == 2
+    
+    def test_retry_non_retryable_error(self):
+        """Test behavior with non-retryable errors."""
+        call_count = 0
+        
+        def non_retryable_func():
+            nonlocal call_count
+            call_count += 1
+            raise ValueError("Not retryable")
+        
+        config = RetryConfig()
+        with pytest.raises(ValueError):
+            retry_with_backoff(non_retryable_func, config)
+        
+        assert call_count == 1
+    
+    @patch('time.sleep')
+    def test_retry_delay_timing(self, mock_sleep):
+        """Test that delays are applied correctly."""
+        call_count = 0
+        
+        def failing_func():
+            nonlocal call_count
+            call_count += 1
+            if call_count < 3:
+                raise CommandTimeoutError("test", 5.0, 123)
+            return "success"
+        
+        config = RetryConfig(base_delay=1.0, max_attempts=3, retry_on_timeout=True, jitter=False)
+        result = retry_with_backoff(failing_func, config)
+        
+        assert result == "success"
+        assert mock_sleep.call_count == 2  # Two retries, two delays
+        
+        # Check that delays follow expected pattern
+        expected_delays = [1.0, 2.0]  # Exponential backoff
+        actual_delays = [call.args[0] for call in mock_sleep.call_args_list]
+        assert actual_delays == expected_delays
+
+
+class TestDefaultErrorRecoveryManager:
+    """Test cases for default error recovery manager."""
+    
+    def test_create_default_manager(self):
+        """Test creating default error recovery manager."""
+        manager = create_default_error_recovery_manager()
+        assert isinstance(manager, ErrorRecoveryManager)
+        assert manager.max_recovery_attempts == 3
+        assert len(manager.recovery_strategies) > 0
+    
+    def test_default_timeout_error_handling(self):
+        """Test default handling of timeout errors."""
+        manager = create_default_error_recovery_manager()
+        
+        timeout_error = CommandTimeoutError("test", 5.0, 123)
+        context = {}
+        
+        # Should attempt recovery
+        result = manager.handle_error(timeout_error, context)
+        assert result is True  # Should succeed on first try with increased timeout
+        assert 'timeout' in context  # Context should be updated with new timeout
+
+
+class TestErrorRecoveryEdgeCases:
+    """Test cases for edge cases and error conditions."""
+    
+    def test_zero_max_attempts(self):
+        """Test behavior with zero max attempts."""
+        config = RetryConfig(max_attempts=0)
+        
+        def failing_func():
+            raise CommandTimeoutError("test", 5.0, 123)
+        
+        with pytest.raises(CommandTimeoutError):
+            retry_with_backoff(failing_func, config)
+    
+    def test_negative_delay_values(self):
+        """Test behavior with negative delay values."""
+        config = RetryConfig(base_delay=-1.0)
+        
+        # Should handle negative delays gracefully
+        delay = config.get_delay(1)
+        assert delay >= 0  # Should not return negative delays
+    
+    def test_function_with_side_effects(self):
+        """Test retry behavior with functions that have side effects."""
+        side_effects = []
+        
+        def side_effect_func():
+            side_effects.append("called")
+            if len(side_effects) < 2:
+                raise CommandTimeoutError("test", 5.0, 123)
+            return "success"
+        
+        config = RetryConfig(max_attempts=3, retry_on_timeout=True)
+        result = retry_with_backoff(side_effect_func, config)
+        
+        assert result == "success"
+        assert len(side_effects) == 2
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"]) 

autocoder/common/shell_commands/tests/test_exceptions.py

@@ -0,0 +1,299 @@
+"""
+Tests for shell command exceptions.
+
+This module tests the custom exception classes used in the shell command system.
+"""
+
+import pytest
+
+from autocoder.common.shell_commands.exceptions import (
+    CommandExecutionError,
+    CommandTimeoutError,
+    ProcessCleanupError,
+    ProcessNotFoundError,
+    TimeoutConfigError,
+    ErrorRecoveryFailedError
+)
+
+
+class TestCommandExecutionError:
+    """Test cases for CommandExecutionError."""
+    
+    def test_basic_creation(self):
+        """Test basic exception creation."""
+        error = CommandExecutionError("Test error message")
+        assert str(error) == "Test error message"
+        assert isinstance(error, Exception)
+    
+    def test_inheritance(self):
+        """Test that CommandExecutionError inherits from Exception."""
+        error = CommandExecutionError("Test")
+        assert isinstance(error, Exception)
+    
+    def test_empty_message(self):
+        """Test exception with empty message."""
+        error = CommandExecutionError("")
+        assert str(error) == ""
+        assert isinstance(error, Exception)
+
+
+class TestCommandTimeoutError:
+    """Test cases for CommandTimeoutError."""
+    
+    def test_basic_creation(self):
+        """Test basic timeout error creation."""
+        error = CommandTimeoutError("sleep 10", 5.0, 12345)
+        assert "sleep 10" in str(error)
+        assert "5.0" in str(error)
+        assert "12345" in str(error)
+    
+    def test_attributes(self):
+        """Test timeout error attributes."""
+        error = CommandTimeoutError("test command", 3.0, 999)
+        assert error.command == "test command"
+        assert error.timeout == 3.0
+        assert error.pid == 999
+    
+    def test_without_pid(self):
+        """Test timeout error without PID."""
+        error = CommandTimeoutError("echo hello", 2.5)
+        assert error.command == "echo hello"
+        assert error.timeout == 2.5
+        assert error.pid is None
+        assert "echo hello" in str(error)
+        assert "2.5" in str(error)
+    
+    def test_string_representation(self):
+        """Test string representation of timeout error."""
+        error = CommandTimeoutError("echo hello", 2.5, 1234)
+        error_str = str(error)
+        assert "echo hello" in error_str
+        assert "2.5" in error_str
+        assert "1234" in error_str
+        assert "timed out" in error_str.lower()
+    
+    def test_repr(self):
+        """Test __repr__ method."""
+        error = CommandTimeoutError("test", 1.0, 123)
+        repr_str = repr(error)
+        assert "CommandTimeoutError" in repr_str
+        assert "test" in repr_str
+        assert "1.0" in repr_str
+        assert "123" in repr_str
+    
+    def test_inheritance(self):
+        """Test inheritance from CommandExecutionError."""
+        error = CommandTimeoutError("test", 1.0, 123)
+        assert isinstance(error, CommandExecutionError)
+        assert isinstance(error, Exception)
+
+
+class TestProcessCleanupError:
+    """Test cases for ProcessCleanupError."""
+    
+    def test_basic_creation(self):
+        """Test basic process cleanup error creation."""
+        error = ProcessCleanupError(1234, "Failed to cleanup process")
+        assert error.pid == 1234
+        assert error.original_message == "Failed to cleanup process"
+        assert "1234" in str(error)
+        assert "Failed to cleanup process" in str(error)
+    
+    def test_string_representation(self):
+        """Test string representation."""
+        error = ProcessCleanupError(5678, "Process is still running")
+        error_str = str(error)
+        assert "5678" in error_str
+        assert "Process is still running" in error_str
+        assert "Failed to cleanup process" in error_str
+    
+    def test_repr(self):
+        """Test __repr__ method."""
+        error = ProcessCleanupError(999, "Test message")
+        repr_str = repr(error)
+        assert "ProcessCleanupError" in repr_str
+        assert "999" in repr_str
+        assert "Test message" in repr_str
+    
+    def test_inheritance(self):
+        """Test inheritance from CommandExecutionError."""
+        error = ProcessCleanupError(123, "test")
+        assert isinstance(error, CommandExecutionError)
+        assert isinstance(error, Exception)
+
+
+class TestProcessNotFoundError:
+    """Test cases for ProcessNotFoundError."""
+    
+    def test_basic_creation(self):
+        """Test basic process not found error creation."""
+        error = ProcessNotFoundError(1234)
+        assert error.pid == 1234
+        assert "1234" in str(error)
+        assert "not found" in str(error).lower()
+    
+    def test_repr(self):
+        """Test __repr__ method."""
+        error = ProcessNotFoundError(999)
+        repr_str = repr(error)
+        assert "ProcessNotFoundError" in repr_str
+        assert "999" in repr_str
+    
+    def test_inheritance(self):
+        """Test inheritance from CommandExecutionError."""
+        error = ProcessNotFoundError(123)
+        assert isinstance(error, CommandExecutionError)
+        assert isinstance(error, Exception)
+
+
+class TestTimeoutConfigError:
+    """Test cases for TimeoutConfigError."""
+    
+    def test_basic_creation(self):
+        """Test basic timeout config error creation."""
+        error = TimeoutConfigError("default_timeout", -1, "Timeout must be positive")
+        assert error.config_field == "default_timeout"
+        assert error.value == -1
+        assert error.reason == "Timeout must be positive"
+    
+    def test_string_representation(self):
+        """Test string representation."""
+        error = TimeoutConfigError("max_timeout", "invalid", "Must be a number")
+        error_str = str(error)
+        assert "max_timeout" in error_str
+        assert "invalid" in error_str
+        assert "Must be a number" in error_str
+    
+    def test_repr(self):
+        """Test __repr__ method."""
+        error = TimeoutConfigError("test_field", 123, "test reason")
+        repr_str = repr(error)
+        assert "TimeoutConfigError" in repr_str
+        assert "test_field" in repr_str
+        assert "123" in repr_str
+        assert "test reason" in repr_str
+    
+    def test_inheritance(self):
+        """Test inheritance from CommandExecutionError."""
+        error = TimeoutConfigError("test", 1, "test")
+        assert isinstance(error, CommandExecutionError)
+        assert isinstance(error, Exception)
+
+
+class TestErrorRecoveryFailedError:
+    """Test cases for ErrorRecoveryFailedError."""
+    
+    def test_basic_creation(self):
+        """Test basic error recovery failed error creation."""
+        original_error = ValueError("Original error")
+        error = ErrorRecoveryFailedError(original_error, 3)
+        assert error.original_error is original_error
+        assert error.recovery_attempts == 3
+        assert "3 attempts" in str(error)
+        assert "Original error" in str(error)
+    
+    def test_with_different_original_error(self):
+        """Test with different types of original errors."""
+        original_error = CommandTimeoutError("test", 1.0, 123)
+        error = ErrorRecoveryFailedError(original_error, 5)
+        assert error.original_error is original_error
+        assert error.recovery_attempts == 5
+        assert "5 attempts" in str(error)
+    
+    def test_repr(self):
+        """Test __repr__ method."""
+        original_error = RuntimeError("Test error")
+        error = ErrorRecoveryFailedError(original_error, 2)
+        repr_str = repr(error)
+        assert "ErrorRecoveryFailedError" in repr_str
+        assert "2" in repr_str
+    
+    def test_inheritance(self):
+        """Test inheritance from CommandExecutionError."""
+        original_error = Exception("test")
+        error = ErrorRecoveryFailedError(original_error, 1)
+        assert isinstance(error, CommandExecutionError)
+        assert isinstance(error, Exception)
+
+
+class TestExceptionInteraction:
+    """Test cases for exception interaction and edge cases."""
+    
+    def test_exception_chaining(self):
+        """Test exception chaining scenarios."""
+        try:
+            raise CommandExecutionError("Original error")
+        except CommandExecutionError as e:
+            timeout_error = CommandTimeoutError("test", 1.0, 123)
+            timeout_error.__cause__ = e
+            assert timeout_error.__cause__ is e
+    
+    def test_multiple_exception_types(self):
+        """Test handling multiple exception types."""
+        exec_error = CommandExecutionError("Execution failed")
+        timeout_error = CommandTimeoutError("timeout test", 5.0, 456)
+        cleanup_error = ProcessCleanupError(789, "Cleanup failed")
+        
+        errors = [exec_error, timeout_error, cleanup_error]
+        
+        for error in errors:
+            assert isinstance(error, Exception)
+        
+        # Test that all errors inherit from CommandExecutionError
+        for error in errors:
+            assert isinstance(error, CommandExecutionError)
+    
+    def test_exception_with_none_values(self):
+        """Test exceptions with None values."""
+        # Test CommandTimeoutError with None PID
+        error = CommandTimeoutError("test", 5.0, None)
+        assert error.command == "test"
+        assert error.timeout == 5.0
+        assert error.pid is None
+        
+        # Should still be convertible to string
+        str_repr = str(error)
+        assert isinstance(str_repr, str)
+        assert "test" in str_repr
+    
+    def test_exception_pickling(self):
+        """Test that exceptions can be pickled (for multiprocessing)."""
+        import pickle
+        
+        # Test basic exception pickling
+        error1 = CommandExecutionError("Test execution error")
+        pickled1 = pickle.dumps(error1)
+        unpickled1 = pickle.loads(pickled1)
+        assert str(unpickled1) == str(error1)
+        
+        # Test that custom exceptions at least create proper string representations
+        timeout_error = CommandTimeoutError("test", 5.0, 123)
+        cleanup_error = ProcessCleanupError(456, "Test cleanup error")
+        
+        # These should at least have proper string representations
+        assert str(timeout_error)
+        assert str(cleanup_error)
+        assert repr(timeout_error)
+        assert repr(cleanup_error)
+        
+        # Note: Custom exceptions with complex __init__ may have pickling issues
+        # This is acceptable as they're primarily used for immediate error handling
+    
+    def test_all_exceptions_are_command_execution_errors(self):
+        """Test that all custom exceptions inherit from CommandExecutionError."""
+        exceptions = [
+            CommandExecutionError("test"),
+            CommandTimeoutError("test", 1.0, 123),
+            ProcessCleanupError(123, "test"),
+            ProcessNotFoundError(456),
+            TimeoutConfigError("test", "value", "reason"),
+            ErrorRecoveryFailedError(Exception("test"), 1)
+        ]
+        
+        for exc in exceptions:
+            assert isinstance(exc, CommandExecutionError)
+            assert isinstance(exc, Exception)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])