pygeai-orchestration 0.1.0b2__py3-none-any.whl

pygeai_orchestration/tests/test_exceptions.py

@@ -0,0 +1,327 @@
+"""
+Tests for custom exception classes.
+"""
+
+import unittest
+from pygeai_orchestration.core.exceptions import (
+    OrchestrationError,
+    PatternExecutionError,
+    PatternConfigurationError,
+    AgentError,
+    ToolExecutionError,
+    StateError,
+    ValidationError,
+)
+
+
+class TestExceptionHierarchy(unittest.TestCase):
+    """Test exception inheritance and base functionality."""
+
+    def test_orchestration_error_base(self):
+        """Test base OrchestrationError."""
+        error = OrchestrationError("Test error")
+        self.assertIsInstance(error, Exception)
+        self.assertEqual(str(error), "Test error")
+
+    def test_pattern_execution_error_inheritance(self):
+        """Test PatternExecutionError inherits from OrchestrationError."""
+        error = PatternExecutionError("Pattern failed")
+        self.assertIsInstance(error, OrchestrationError)
+        self.assertIsInstance(error, Exception)
+
+    def test_all_exceptions_inherit_from_base(self):
+        """Test all custom exceptions inherit from OrchestrationError."""
+        exceptions = [
+            PatternExecutionError("test"),
+            PatternConfigurationError("test"),
+            AgentError("test"),
+            ToolExecutionError("test"),
+            StateError("test"),
+            ValidationError("test"),
+        ]
+
+        for exc in exceptions:
+            self.assertIsInstance(exc, OrchestrationError)
+
+
+class TestPatternExecutionError(unittest.TestCase):
+    """Test PatternExecutionError functionality."""
+
+    def test_basic_error(self):
+        """Test basic error creation."""
+        error = PatternExecutionError("Execution failed")
+        self.assertEqual(str(error), "Execution failed")
+
+    def test_error_with_pattern_name(self):
+        """Test error with pattern name."""
+        error = PatternExecutionError(
+            "Execution failed",
+            pattern_name="reflection"
+        )
+        self.assertIn("reflection", str(error))
+        self.assertEqual(error.pattern_name, "reflection")
+
+    def test_error_with_iteration(self):
+        """Test error with iteration number."""
+        error = PatternExecutionError(
+            "Execution failed",
+            pattern_name="reflection",
+            iteration=5
+        )
+        self.assertIn("5", str(error))
+        self.assertEqual(error.iteration, 5)
+
+    def test_error_with_details(self):
+        """Test error with additional details."""
+        details = {"max_iterations": 3, "timeout": True}
+        error = PatternExecutionError(
+            "Execution failed",
+            pattern_name="reflection",
+            iteration=5,
+            details=details
+        )
+        self.assertEqual(error.details, details)
+        self.assertIn("max_iterations", str(error))
+
+    def test_error_string_formatting(self):
+        """Test formatted error message."""
+        error = PatternExecutionError(
+            "Pattern execution failed",
+            pattern_name="reflection",
+            iteration=3,
+            details={"error": "timeout"}
+        )
+        error_str = str(error)
+        self.assertIn("Pattern execution failed", error_str)
+        self.assertIn("Pattern: reflection", error_str)
+        self.assertIn("Iteration: 3", error_str)
+        self.assertIn("Details:", error_str)
+
+
+class TestPatternConfigurationError(unittest.TestCase):
+    """Test PatternConfigurationError functionality."""
+
+    def test_basic_error(self):
+        """Test basic configuration error."""
+        error = PatternConfigurationError("Invalid configuration")
+        self.assertEqual(str(error), "Invalid configuration")
+
+    def test_error_with_field(self):
+        """Test error with config field."""
+        error = PatternConfigurationError(
+            "Invalid value",
+            config_field="max_iterations"
+        )
+        self.assertIn("max_iterations", str(error))
+        self.assertEqual(error.config_field, "max_iterations")
+
+    def test_error_with_expected_received(self):
+        """Test error with expected and received values."""
+        error = PatternConfigurationError(
+            "Invalid max_iterations",
+            config_field="max_iterations",
+            expected="positive integer",
+            received=-1
+        )
+        self.assertIn("positive integer", str(error))
+        self.assertIn("-1", str(error))
+        self.assertEqual(error.expected, "positive integer")
+        self.assertEqual(error.received, -1)
+
+
+class TestAgentError(unittest.TestCase):
+    """Test AgentError functionality."""
+
+    def test_basic_error(self):
+        """Test basic agent error."""
+        error = AgentError("Agent failed")
+        self.assertEqual(str(error), "Agent failed")
+
+    def test_error_with_agent_name(self):
+        """Test error with agent name."""
+        error = AgentError(
+            "Generation failed",
+            agent_name="research-agent"
+        )
+        self.assertIn("research-agent", str(error))
+        self.assertEqual(error.agent_name, "research-agent")
+
+    def test_error_with_operation(self):
+        """Test error with operation name."""
+        error = AgentError(
+            "Operation failed",
+            agent_name="research-agent",
+            operation="generate"
+        )
+        self.assertIn("generate", str(error))
+        self.assertEqual(error.operation, "generate")
+
+    def test_error_with_details(self):
+        """Test error with additional details."""
+        details = {"timeout": True, "retry_count": 3}
+        error = AgentError(
+            "Agent failed",
+            agent_name="research-agent",
+            operation="generate",
+            details=details
+        )
+        self.assertEqual(error.details, details)
+
+
+class TestToolExecutionError(unittest.TestCase):
+    """Test ToolExecutionError functionality."""
+
+    def test_basic_error(self):
+        """Test basic tool error."""
+        error = ToolExecutionError("Tool failed")
+        self.assertEqual(str(error), "Tool failed")
+
+    def test_error_with_tool_name(self):
+        """Test error with tool name."""
+        error = ToolExecutionError(
+            "Execution failed",
+            tool_name="calculator"
+        )
+        self.assertIn("calculator", str(error))
+        self.assertEqual(error.tool_name, "calculator")
+
+    def test_error_with_input_data(self):
+        """Test error with input data."""
+        input_data = {"expression": "2 + + 2"}
+        error = ToolExecutionError(
+            "Invalid expression",
+            tool_name="calculator",
+            input_data=input_data
+        )
+        self.assertEqual(error.input_data, input_data)
+        self.assertIn("expression", str(error))
+
+    def test_error_with_details(self):
+        """Test error with additional details."""
+        details = {"error_type": "SyntaxError"}
+        error = ToolExecutionError(
+            "Execution failed",
+            tool_name="calculator",
+            details=details
+        )
+        self.assertEqual(error.details, details)
+
+
+class TestStateError(unittest.TestCase):
+    """Test StateError functionality."""
+
+    def test_basic_error(self):
+        """Test basic state error."""
+        error = StateError("State error")
+        self.assertEqual(str(error), "State error")
+
+    def test_error_with_states(self):
+        """Test error with state information."""
+        error = StateError(
+            "Invalid transition",
+            current_state="running",
+            attempted_state="completed"
+        )
+        self.assertIn("running", str(error))
+        self.assertIn("completed", str(error))
+        self.assertEqual(error.current_state, "running")
+        self.assertEqual(error.attempted_state, "completed")
+
+    def test_error_with_details(self):
+        """Test error with additional details."""
+        details = {"reason": "tasks pending"}
+        error = StateError(
+            "Cannot transition",
+            current_state="running",
+            attempted_state="completed",
+            details=details
+        )
+        self.assertEqual(error.details, details)
+
+
+class TestValidationError(unittest.TestCase):
+    """Test ValidationError functionality."""
+
+    def test_basic_error(self):
+        """Test basic validation error."""
+        error = ValidationError("Validation failed")
+        self.assertEqual(str(error), "Validation failed")
+
+    def test_error_with_field(self):
+        """Test error with field information."""
+        error = ValidationError(
+            "Invalid value",
+            field="task"
+        )
+        self.assertIn("task", str(error))
+        self.assertEqual(error.field, "task")
+
+    def test_error_with_expected_received(self):
+        """Test error with expected and received values."""
+        error = ValidationError(
+            "Invalid task",
+            field="task",
+            expected="non-empty string",
+            received=""
+        )
+        self.assertIn("non-empty string", str(error))
+        self.assertEqual(error.expected, "non-empty string")
+        self.assertEqual(error.received, "")
+
+    def test_error_with_example(self):
+        """Test error with example."""
+        error = ValidationError(
+            "Invalid input",
+            field="task",
+            expected="non-empty string",
+            received="",
+            example='task="Summarize this"'
+        )
+        self.assertIn("Summarize", str(error))
+        self.assertEqual(error.example, 'task="Summarize this"')
+
+    def test_error_string_formatting(self):
+        """Test complete formatted error message."""
+        error = ValidationError(
+            "Invalid task input",
+            field="task",
+            expected="non-empty string",
+            received="",
+            example='task="Summarize document"'
+        )
+        error_str = str(error)
+        self.assertIn("Invalid task input", error_str)
+        self.assertIn("Field: task", error_str)
+        self.assertIn("Expected: non-empty string", error_str)
+        self.assertIn("Received:", error_str)
+        self.assertIn("Example:", error_str)
+
+
+class TestExceptionCatching(unittest.TestCase):
+    """Test exception catching patterns."""
+
+    def test_catch_specific_exception(self):
+        """Test catching specific exception type."""
+        with self.assertRaises(PatternExecutionError):
+            raise PatternExecutionError("Test")
+
+    def test_catch_as_base_exception(self):
+        """Test catching any orchestration error."""
+        with self.assertRaises(OrchestrationError):
+            raise PatternExecutionError("Test")
+
+    def test_catch_all_orchestration_errors(self):
+        """Test catching different errors as base type."""
+        errors = [
+            PatternExecutionError("test"),
+            AgentError("test"),
+            ValidationError("test"),
+        ]
+
+        for error in errors:
+            with self.assertRaises(OrchestrationError):
+                raise error
+
+
+if __name__ == "__main__":
+    unittest.main()

pygeai_orchestration/tests/test_handlers.py

@@ -0,0 +1,307 @@
+"""
+Tests for error and retry handlers.
+"""
+
+import unittest
+import logging
+from pygeai_orchestration.core.handlers import ErrorHandler, RetryHandler
+from pygeai_orchestration.core.exceptions import (
+    OrchestrationError,
+    PatternExecutionError,
+)
+
+
+class TestErrorHandlerDetection(unittest.TestCase):
+    """Test error detection functionality."""
+
+    def test_has_errors_with_error_key(self):
+        """Test detection of error key in dict."""
+        response = {"error": "Something went wrong"}
+        self.assertTrue(ErrorHandler.has_errors(response))
+
+    def test_has_errors_with_errors_key(self):
+        """Test detection of errors key in dict."""
+        response = {"errors": ["Error 1", "Error 2"]}
+        self.assertTrue(ErrorHandler.has_errors(response))
+
+    def test_has_errors_with_success_false(self):
+        """Test detection of success=False."""
+        response = {"success": False, "message": "Failed"}
+        self.assertTrue(ErrorHandler.has_errors(response))
+
+    def test_has_errors_with_error_status(self):
+        """Test detection of error status."""
+        self.assertTrue(ErrorHandler.has_errors({"status": "error"}))
+        self.assertTrue(ErrorHandler.has_errors({"status": "failed"}))
+        self.assertTrue(ErrorHandler.has_errors({"status": 500}))
+
+    def test_has_errors_with_error_code(self):
+        """Test detection of error codes."""
+        self.assertTrue(ErrorHandler.has_errors({"code": 400}))
+        self.assertTrue(ErrorHandler.has_errors({"code": 500}))
+        self.assertTrue(ErrorHandler.has_errors({"code": 404}))
+
+    def test_has_errors_with_exception(self):
+        """Test detection of Exception objects."""
+        error = Exception("Test error")
+        self.assertTrue(ErrorHandler.has_errors(error))
+
+    def test_has_no_errors_with_success_true(self):
+        """Test no error detection with success response."""
+        response = {"success": True, "data": "result"}
+        self.assertFalse(ErrorHandler.has_errors(response))
+
+    def test_has_no_errors_with_good_status(self):
+        """Test no error detection with 2xx status."""
+        response = {"status": 200}
+        self.assertFalse(ErrorHandler.has_errors(response))
+
+    def test_has_no_errors_with_none(self):
+        """Test no error detection with None."""
+        self.assertFalse(ErrorHandler.has_errors(None))
+
+    def test_has_no_errors_with_empty_dict(self):
+        """Test no error detection with empty dict."""
+        self.assertFalse(ErrorHandler.has_errors({}))
+
+
+class TestErrorHandlerExtraction(unittest.TestCase):
+    """Test error extraction functionality."""
+
+    def test_extract_error_from_dict_with_error_key(self):
+        """Test extracting error from dict with error key."""
+        response = {"error": "Connection failed"}
+        error = ErrorHandler.extract_error(response)
+        self.assertEqual(error, "Connection failed")
+
+    def test_extract_error_from_dict_with_nested_error(self):
+        """Test extracting from nested error object."""
+        response = {"error": {"message": "Invalid input", "code": 400}}
+        error = ErrorHandler.extract_error(response)
+        self.assertIn("Invalid input", error)
+
+    def test_extract_error_from_errors_list(self):
+        """Test extracting from errors list."""
+        response = {"errors": ["Error 1", "Error 2"]}
+        error = ErrorHandler.extract_error(response)
+        self.assertIn("Error 1", error)
+
+    def test_extract_error_from_message_key(self):
+        """Test extracting from message key."""
+        response = {"message": "Operation failed"}
+        error = ErrorHandler.extract_error(response)
+        self.assertEqual(error, "Operation failed")
+
+    def test_extract_error_from_status_code(self):
+        """Test extracting from status/code."""
+        response = {"status": 500, "code": "SERVER_ERROR"}
+        error = ErrorHandler.extract_error(response)
+        self.assertIn("500", error)
+        self.assertIn("SERVER_ERROR", error)
+
+    def test_extract_error_from_exception(self):
+        """Test extracting from Exception."""
+        exc = ValueError("Invalid value")
+        error = ErrorHandler.extract_error(exc)
+        self.assertEqual(error, "Invalid value")
+
+    def test_extract_error_from_string(self):
+        """Test extracting from string."""
+        error = ErrorHandler.extract_error("Simple error message")
+        self.assertEqual(error, "Simple error message")
+
+    def test_extract_error_from_none(self):
+        """Test extracting from None."""
+        error = ErrorHandler.extract_error(None)
+        self.assertIn("None", error)
+
+
+class TestErrorHandlerHandling(unittest.TestCase):
+    """Test error handling functionality."""
+
+    def test_handle_error_basic(self):
+        """Test basic error handling."""
+        error = {"error": "Test error"}
+        message = ErrorHandler.handle_error(error)
+        self.assertEqual(message, "Test error")
+
+    def test_handle_error_with_context(self):
+        """Test error handling with context."""
+        error = {"error": "Operation failed"}
+        message = ErrorHandler.handle_error(
+            error,
+            context={"operation": "generate", "attempt": 1}
+        )
+        self.assertIn("Operation failed", message)
+        self.assertIn("operation=generate", message)
+        self.assertIn("attempt=1", message)
+
+    def test_handle_error_with_log_level(self):
+        """Test error handling with different log levels."""
+        error = {"error": "Warning message"}
+        # Should not raise, just return message
+        message = ErrorHandler.handle_error(error, log_level=logging.WARNING)
+        self.assertEqual(message, "Warning message")
+
+
+class TestErrorHandlerWrap(unittest.TestCase):
+    """Test exception wrapping functionality."""
+
+    def test_wrap_exception_basic(self):
+        """Test basic exception wrapping."""
+        original = ValueError("Original error")
+        wrapped = ErrorHandler.wrap_exception(original)
+
+        self.assertIsInstance(wrapped, OrchestrationError)
+        self.assertIn("Original error", str(wrapped))
+        self.assertEqual(wrapped.__cause__, original)
+
+    def test_wrap_exception_with_custom_class(self):
+        """Test wrapping with custom exception class."""
+        original = ValueError("Original error")
+        wrapped = ErrorHandler.wrap_exception(
+            original,
+            exception_class=PatternExecutionError,
+            pattern_name="reflection"
+        )
+
+        self.assertIsInstance(wrapped, PatternExecutionError)
+        self.assertEqual(wrapped.pattern_name, "reflection")
+
+    def test_wrap_exception_with_prefix(self):
+        """Test wrapping with message prefix."""
+        original = ValueError("Original error")
+        wrapped = ErrorHandler.wrap_exception(
+            original,
+            message_prefix="Pattern failed"
+        )
+
+        self.assertIn("Pattern failed", str(wrapped))
+        self.assertIn("Original error", str(wrapped))
+
+
+class TestErrorHandlerRecoverable(unittest.TestCase):
+    """Test recoverable error detection."""
+
+    def test_is_recoverable_timeout(self):
+        """Test timeout errors are recoverable."""
+        self.assertTrue(ErrorHandler.is_recoverable({"code": 504}))
+        self.assertTrue(ErrorHandler.is_recoverable({"error": "Request timeout"}))
+
+    def test_is_recoverable_rate_limit(self):
+        """Test rate limit errors are recoverable."""
+        self.assertTrue(ErrorHandler.is_recoverable({"code": 429}))
+        self.assertTrue(ErrorHandler.is_recoverable({"error": "Rate limit exceeded"}))
+
+    def test_is_recoverable_service_unavailable(self):
+        """Test service unavailable is recoverable."""
+        self.assertTrue(ErrorHandler.is_recoverable({"code": 503}))
+        self.assertTrue(ErrorHandler.is_recoverable({"error": "Service unavailable"}))
+
+    def test_is_not_recoverable_bad_request(self):
+        """Test bad request is not recoverable."""
+        self.assertFalse(ErrorHandler.is_recoverable({"code": 400}))
+
+    def test_is_not_recoverable_not_found(self):
+        """Test not found is not recoverable."""
+        self.assertFalse(ErrorHandler.is_recoverable({"code": 404}))
+
+    def test_is_recoverable_exception(self):
+        """Test exception recoverability."""
+        timeout_exc = TimeoutError("Connection timeout")
+        self.assertTrue(ErrorHandler.is_recoverable(timeout_exc))
+
+        value_exc = ValueError("Invalid value")
+        self.assertFalse(ErrorHandler.is_recoverable(value_exc))
+
+
+class TestErrorHandlerFormat(unittest.TestCase):
+    """Test error response formatting."""
+
+    def test_format_error_response_basic(self):
+        """Test basic error formatting."""
+        error = ValueError("Test error")
+        response = ErrorHandler.format_error_response(error)
+
+        self.assertFalse(response['success'])
+        self.assertEqual(response['error'], "Test error")
+        self.assertEqual(response['error_type'], "ValueError")
+
+    def test_format_error_response_with_details(self):
+        """Test formatting with details."""
+        error = {"error": "Failed", "code": 500, "details": {"reason": "timeout"}}
+        response = ErrorHandler.format_error_response(error)
+
+        self.assertFalse(response['success'])
+        self.assertEqual(response['error'], "Failed")
+        self.assertEqual(response['code'], 500)
+        self.assertEqual(response['details'], {"reason": "timeout"})
+
+    def test_format_error_response_without_details(self):
+        """Test formatting without details."""
+        error = ValueError("Test error")
+        response = ErrorHandler.format_error_response(error, include_details=False)
+
+        self.assertFalse(response['success'])
+        self.assertEqual(response['error'], "Test error")
+        self.assertNotIn('error_type', response)
+
+    def test_format_error_response_with_cause(self):
+        """Test formatting with exception cause."""
+        original = ValueError("Original")
+        wrapped = ErrorHandler.wrap_exception(original, message_prefix="Wrapped")
+        response = ErrorHandler.format_error_response(wrapped)
+
+        self.assertEqual(response['original_error'], "Original")
+
+
+class TestRetryHandler(unittest.TestCase):
+    """Test retry handler functionality."""
+
+    def test_retry_handler_init(self):
+        """Test retry handler initialization."""
+        handler = RetryHandler(max_retries=5, delay=2.0)
+        self.assertEqual(handler.max_retries, 5)
+        self.assertEqual(handler.delay, 2.0)
+
+    def test_should_retry_within_limit(self):
+        """Test should retry when within limit."""
+        handler = RetryHandler(max_retries=3, recoverable_only=False)
+        self.assertTrue(handler.should_retry({"error": "test"}, attempt=0))
+        self.assertTrue(handler.should_retry({"error": "test"}, attempt=2))
+
+    def test_should_not_retry_at_limit(self):
+        """Test should not retry when at limit."""
+        handler = RetryHandler(max_retries=3, recoverable_only=False)
+        self.assertFalse(handler.should_retry({"error": "test"}, attempt=3))
+
+    def test_should_retry_recoverable_only(self):
+        """Test retry only recoverable errors."""
+        handler = RetryHandler(max_retries=3, recoverable_only=True)
+
+        # Recoverable error
+        self.assertTrue(handler.should_retry({"code": 504}, attempt=0))
+
+        # Non-recoverable error
+        self.assertFalse(handler.should_retry({"code": 400}, attempt=0))
+
+    def test_get_delay_exponential_backoff(self):
+        """Test exponential backoff delay calculation."""
+        handler = RetryHandler(delay=1.0, backoff_factor=2.0)
+
+        self.assertEqual(handler.get_delay(0), 1.0)
+        self.assertEqual(handler.get_delay(1), 2.0)
+        self.assertEqual(handler.get_delay(2), 4.0)
+        self.assertEqual(handler.get_delay(3), 8.0)
+
+    def test_get_delay_custom_backoff(self):
+        """Test custom backoff factor."""
+        handler = RetryHandler(delay=1.0, backoff_factor=3.0)
+
+        self.assertEqual(handler.get_delay(0), 1.0)
+        self.assertEqual(handler.get_delay(1), 3.0)
+        self.assertEqual(handler.get_delay(2), 9.0)
+
+
+if __name__ == "__main__":
+    unittest.main()