Add unit tests for chat history models and operation result classes

Co-authored-by: pontemonti <7850950+pontemonti@users.noreply.github.com>

Author: Copilot

tests/runtime/test_operation_error.py

@@ -0,0 +1,53 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+"""Unit tests for OperationError class."""
+
+import pytest
+from microsoft_agents_a365.runtime import OperationError
+
+
+class TestOperationError:
+    """Tests for OperationError class."""
+
+    def test_operation_error_can_be_instantiated(self):
+        """Test that OperationError can be instantiated with an exception."""
+        # Arrange
+        exception = Exception("Test error")
+
+        # Act
+        error = OperationError(exception)
+
+        # Assert
+        assert error is not None
+        assert error.exception == exception
+        assert error.message == "Test error"
+
+    def test_operation_error_requires_exception(self):
+        """Test that OperationError requires an exception."""
+        # Act & Assert
+        with pytest.raises(ValueError, match="exception cannot be None"):
+            OperationError(None)
+
+    def test_operation_error_string_representation(self):
+        """Test that OperationError has correct string representation."""
+        # Arrange
+        exception = Exception("Test error message")
+        error = OperationError(exception)
+
+        # Act
+        result = str(error)
+
+        # Assert
+        assert "Test error message" in result
+
+    def test_operation_error_with_different_exception_types(self):
+        """Test that OperationError works with different exception types."""
+        # Arrange & Act
+        value_error = OperationError(ValueError("Invalid value"))
+        type_error = OperationError(TypeError("Invalid type"))
+        runtime_error = OperationError(RuntimeError("Runtime issue"))
+
+        # Assert
+        assert value_error.message == "Invalid value"
+        assert type_error.message == "Invalid type"
+        assert runtime_error.message == "Runtime issue"

tests/runtime/test_operation_result.py

@@ -0,0 +1,102 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+"""Unit tests for OperationResult class."""
+
+from microsoft_agents_a365.runtime import OperationError, OperationResult
+
+
+class TestOperationResult:
+    """Tests for OperationResult class."""
+
+    def test_operation_result_success(self):
+        """Test that OperationResult.success() returns a successful result."""
+        # Act
+        result = OperationResult.success()
+
+        # Assert
+        assert result is not None
+        assert result.succeeded is True
+        assert len(result.errors) == 0
+
+    def test_operation_result_success_returns_singleton(self):
+        """Test that OperationResult.success() returns the same instance."""
+        # Act
+        result1 = OperationResult.success()
+        result2 = OperationResult.success()
+
+        # Assert
+        assert result1 is result2
+
+    def test_operation_result_failed_with_no_errors(self):
+        """Test that OperationResult.failed() without errors returns a failed result."""
+        # Act
+        result = OperationResult.failed()
+
+        # Assert
+        assert result is not None
+        assert result.succeeded is False
+        assert len(result.errors) == 0
+
+    def test_operation_result_failed_with_single_error(self):
+        """Test that OperationResult.failed() with a single error works correctly."""
+        # Arrange
+        exception = Exception("Test error")
+        error = OperationError(exception)
+
+        # Act
+        result = OperationResult.failed(error)
+
+        # Assert
+        assert result is not None
+        assert result.succeeded is False
+        assert len(result.errors) == 1
+        assert result.errors[0] == error
+
+    def test_operation_result_failed_with_multiple_errors(self):
+        """Test that OperationResult.failed() with multiple errors works correctly."""
+        # Arrange
+        error1 = OperationError(Exception("Error 1"))
+        error2 = OperationError(Exception("Error 2"))
+        error3 = OperationError(Exception("Error 3"))
+
+        # Act
+        result = OperationResult.failed(error1, error2, error3)
+
+        # Assert
+        assert result is not None
+        assert result.succeeded is False
+        assert len(result.errors) == 3
+        assert result.errors[0] == error1
+        assert result.errors[1] == error2
+        assert result.errors[2] == error3
+
+    def test_operation_result_success_string_representation(self):
+        """Test that successful OperationResult has correct string representation."""
+        # Act
+        result = OperationResult.success()
+
+        # Assert
+        assert str(result) == "Succeeded"
+
+    def test_operation_result_failed_string_representation_no_errors(self):
+        """Test that failed OperationResult without errors has correct string representation."""
+        # Act
+        result = OperationResult.failed()
+
+        # Assert
+        assert str(result) == "Failed : "
+
+    def test_operation_result_failed_string_representation_with_errors(self):
+        """Test that failed OperationResult with errors has correct string representation."""
+        # Arrange
+        error1 = OperationError(Exception("Error 1"))
+        error2 = OperationError(Exception("Error 2"))
+
+        # Act
+        result = OperationResult.failed(error1, error2)
+
+        # Assert
+        result_str = str(result)
+        assert "Failed" in result_str
+        assert "Error 1" in result_str
+        assert "Error 2" in result_str

tests/tooling/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Microsoft. All rights reserved.

tests/tooling/models/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Microsoft. All rights reserved.

tests/tooling/models/test_chat_history_message.py

@@ -0,0 +1,95 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+"""Unit tests for ChatHistoryMessage class."""
+
+from datetime import datetime, timezone
+
+import pytest
+from microsoft_agents_a365.tooling.models import ChatHistoryMessage
+
+
+class TestChatHistoryMessage:
+    """Tests for ChatHistoryMessage class."""
+
+    def test_chat_history_message_can_be_instantiated(self):
+        """Test that ChatHistoryMessage can be instantiated with valid parameters."""
+        # Arrange & Act
+        timestamp = datetime.now(timezone.utc)
+        message = ChatHistoryMessage("msg-123", "user", "Hello, world!", timestamp)
+
+        # Assert
+        assert message is not None
+        assert message.id == "msg-123"
+        assert message.role == "user"
+        assert message.content == "Hello, world!"
+        assert message.timestamp == timestamp
+
+    def test_chat_history_message_to_dict(self):
+        """Test that ChatHistoryMessage converts to dictionary correctly."""
+        # Arrange
+        timestamp = datetime(2024, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
+        message = ChatHistoryMessage("msg-456", "assistant", "How can I help you?", timestamp)
+
+        # Act
+        result = message.to_dict()
+
+        # Assert
+        assert result["id"] == "msg-456"
+        assert result["role"] == "assistant"
+        assert result["content"] == "How can I help you?"
+        assert result["timestamp"] == "2024-01-15T10:30:00+00:00"
+
+    def test_chat_history_message_requires_non_empty_id(self):
+        """Test that ChatHistoryMessage requires a non-empty id."""
+        # Arrange
+        timestamp = datetime.now(timezone.utc)
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="id cannot be empty"):
+            ChatHistoryMessage("", "user", "Test content", timestamp)
+
+    def test_chat_history_message_requires_non_empty_role(self):
+        """Test that ChatHistoryMessage requires a non-empty role."""
+        # Arrange
+        timestamp = datetime.now(timezone.utc)
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="role cannot be empty"):
+            ChatHistoryMessage("msg-001", "", "Test content", timestamp)
+
+    def test_chat_history_message_requires_non_empty_content(self):
+        """Test that ChatHistoryMessage requires a non-empty content."""
+        # Arrange
+        timestamp = datetime.now(timezone.utc)
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="content cannot be empty"):
+            ChatHistoryMessage("msg-001", "user", "", timestamp)
+
+    def test_chat_history_message_requires_timestamp(self):
+        """Test that ChatHistoryMessage requires a timestamp."""
+        # Act & Assert
+        with pytest.raises(ValueError, match="timestamp cannot be empty"):
+            ChatHistoryMessage("msg-001", "user", "Test content", None)
+
+    def test_chat_history_message_supports_system_role(self):
+        """Test that ChatHistoryMessage supports system role."""
+        # Arrange & Act
+        timestamp = datetime.now(timezone.utc)
+        message = ChatHistoryMessage("sys-001", "system", "You are a helpful assistant.", timestamp)
+
+        # Assert
+        assert message.role == "system"
+
+    def test_chat_history_message_preserves_timestamp_precision(self):
+        """Test that ChatHistoryMessage preserves timestamp precision."""
+        # Arrange
+        timestamp = datetime(2024, 1, 15, 10, 30, 45, 123000, tzinfo=timezone.utc)
+        message = ChatHistoryMessage("msg-001", "user", "Test", timestamp)
+
+        # Act
+        message_dict = message.to_dict()
+
+        # Assert
+        assert message.timestamp == timestamp
+        assert "2024-01-15T10:30:45.123000" in message_dict["timestamp"]

tests/tooling/models/test_chat_message_request.py

@@ -0,0 +1,104 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+"""Unit tests for ChatMessageRequest class."""
+
+from datetime import datetime, timezone
+
+import pytest
+from microsoft_agents_a365.tooling.models import ChatHistoryMessage, ChatMessageRequest
+
+
+class TestChatMessageRequest:
+    """Tests for ChatMessageRequest class."""
+
+    def test_chat_message_request_can_be_instantiated(self):
+        """Test that ChatMessageRequest can be instantiated with valid parameters."""
+        # Arrange
+        timestamp = datetime.now(timezone.utc)
+        message1 = ChatHistoryMessage("msg-1", "user", "Hello", timestamp)
+        message2 = ChatHistoryMessage("msg-2", "assistant", "Hi there!", timestamp)
+        chat_history = [message1, message2]
+
+        # Act
+        request = ChatMessageRequest("conv-123", "msg-456", "How are you?", chat_history)
+
+        # Assert
+        assert request is not None
+        assert request.conversation_id == "conv-123"
+        assert request.message_id == "msg-456"
+        assert request.user_message == "How are you?"
+        assert request.chat_history == chat_history
+
+    def test_chat_message_request_to_dict(self):
+        """Test that ChatMessageRequest converts to dictionary correctly."""
+        # Arrange
+        timestamp = datetime(2024, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
+        message = ChatHistoryMessage("msg-1", "user", "Hello", timestamp)
+        request = ChatMessageRequest("conv-123", "msg-456", "How are you?", [message])
+
+        # Act
+        result = request.to_dict()
+
+        # Assert
+        assert result["conversationId"] == "conv-123"
+        assert result["messageId"] == "msg-456"
+        assert result["userMessage"] == "How are you?"
+        assert len(result["chatHistory"]) == 1
+        assert result["chatHistory"][0]["id"] == "msg-1"
+        assert result["chatHistory"][0]["role"] == "user"
+        assert result["chatHistory"][0]["content"] == "Hello"
+
+    def test_chat_message_request_requires_non_empty_conversation_id(self):
+        """Test that ChatMessageRequest requires a non-empty conversation_id."""
+        # Arrange
+        timestamp = datetime.now(timezone.utc)
+        message = ChatHistoryMessage("msg-1", "user", "Hello", timestamp)
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="conversation_id cannot be empty"):
+            ChatMessageRequest("", "msg-456", "How are you?", [message])
+
+    def test_chat_message_request_requires_non_empty_message_id(self):
+        """Test that ChatMessageRequest requires a non-empty message_id."""
+        # Arrange
+        timestamp = datetime.now(timezone.utc)
+        message = ChatHistoryMessage("msg-1", "user", "Hello", timestamp)
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="message_id cannot be empty"):
+            ChatMessageRequest("conv-123", "", "How are you?", [message])
+
+    def test_chat_message_request_requires_non_empty_user_message(self):
+        """Test that ChatMessageRequest requires a non-empty user_message."""
+        # Arrange
+        timestamp = datetime.now(timezone.utc)
+        message = ChatHistoryMessage("msg-1", "user", "Hello", timestamp)
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="user_message cannot be empty"):
+            ChatMessageRequest("conv-123", "msg-456", "", [message])
+
+    def test_chat_message_request_requires_non_empty_chat_history(self):
+        """Test that ChatMessageRequest requires a non-empty chat_history."""
+        # Act & Assert
+        with pytest.raises(ValueError, match="chat_history cannot be empty"):
+            ChatMessageRequest("conv-123", "msg-456", "How are you?", [])
+
+    def test_chat_message_request_with_multiple_messages(self):
+        """Test that ChatMessageRequest handles multiple messages correctly."""
+        # Arrange
+        timestamp = datetime(2024, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
+        message1 = ChatHistoryMessage("msg-1", "user", "Hello", timestamp)
+        message2 = ChatHistoryMessage("msg-2", "assistant", "Hi!", timestamp)
+        message3 = ChatHistoryMessage("msg-3", "user", "How are you?", timestamp)
+        chat_history = [message1, message2, message3]
+
+        # Act
+        request = ChatMessageRequest("conv-123", "msg-456", "What can you do?", chat_history)
+        result = request.to_dict()
+
+        # Assert
+        assert len(result["chatHistory"]) == 3
+        assert result["chatHistory"][0]["id"] == "msg-1"
+        assert result["chatHistory"][1]["id"] == "msg-2"
+        assert result["chatHistory"][2]["id"] == "msg-3"