chore: import upstream snapshot with attribution

python/packages/durabletask/tests/test_models.py

@@ -0,0 +1,309 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+"""Unit tests for data models (RunRequest)."""
+
+import pytest
+from pydantic import BaseModel
+
+from agent_framework_durabletask._models import RunRequest
+
+
+class ModuleStructuredResponse(BaseModel):
+    value: int
+
+
+class TestRunRequest:
+    """Test suite for RunRequest."""
+
+    def test_init_with_defaults(self) -> None:
+        """Test RunRequest initialization with defaults."""
+        request = RunRequest(message="Hello", correlation_id="corr-001")
+
+        assert request.message == "Hello"
+        assert request.correlation_id == "corr-001"
+        assert request.role == "user"
+        assert request.response_format is None
+        assert request.enable_tool_calls is True
+        assert request.wait_for_response is True
+
+    def test_init_with_all_fields(self) -> None:
+        """Test RunRequest initialization with all fields."""
+        schema = ModuleStructuredResponse
+        request = RunRequest(
+            message="Hello",
+            correlation_id="corr-002",
+            role="system",
+            response_format=schema,
+            enable_tool_calls=False,
+            wait_for_response=False,
+        )
+
+        assert request.message == "Hello"
+        assert request.correlation_id == "corr-002"
+        assert request.role == "system"
+        assert request.response_format is schema
+        assert request.enable_tool_calls is False
+        assert request.wait_for_response is False
+
+    def test_init_coerces_string_role(self) -> None:
+        """Ensure string role values are coerced into Role instances."""
+        request = RunRequest(message="Hello", correlation_id="corr-003", role="system")  # type: ignore[arg-type]
+
+        assert request.role == "system"
+
+    def test_to_dict_with_defaults(self) -> None:
+        """Test to_dict with default values."""
+        request = RunRequest(message="Test message", correlation_id="corr-004")
+        data = request.to_dict()
+
+        assert data["message"] == "Test message"
+        assert data["enable_tool_calls"] is True
+        assert data["wait_for_response"] is True
+        assert data["role"] == "user"
+        assert data["correlationId"] == "corr-004"
+        assert "response_format" not in data or data["response_format"] is None
+        assert "thread_id" not in data
+
+    def test_to_dict_with_all_fields(self) -> None:
+        """Test to_dict with all fields."""
+        schema = ModuleStructuredResponse
+        request = RunRequest(
+            message="Hello",
+            correlation_id="corr-005",
+            role="assistant",
+            response_format=schema,
+            enable_tool_calls=False,
+            wait_for_response=False,
+        )
+        data = request.to_dict()
+
+        assert data["message"] == "Hello"
+        assert data["correlationId"] == "corr-005"
+        assert data["role"] == "assistant"
+        assert data["response_format"]["__response_schema_type__"] == "pydantic_model"
+        assert data["response_format"]["module"] == schema.__module__
+        assert data["response_format"]["qualname"] == schema.__qualname__
+        assert data["enable_tool_calls"] is False
+        assert data["wait_for_response"] is False
+        assert "thread_id" not in data
+
+    def test_from_dict_with_defaults(self) -> None:
+        """Test from_dict with minimal data."""
+        data = {"message": "Hello", "correlationId": "corr-006"}
+        request = RunRequest.from_dict(data)
+
+        assert request.message == "Hello"
+        assert request.correlation_id == "corr-006"
+        assert request.role == "user"
+        assert request.enable_tool_calls is True
+        assert request.wait_for_response is True
+
+    def test_from_dict_ignores_thread_id_field(self) -> None:
+        """Ensure legacy thread_id input does not break RunRequest parsing."""
+        request = RunRequest.from_dict({"message": "Hello", "correlationId": "corr-007", "thread_id": "ignored"})
+
+        assert request.message == "Hello"
+
+    def test_from_dict_with_all_fields(self) -> None:
+        """Test from_dict with all fields."""
+        data = {
+            "message": "Test",
+            "correlationId": "corr-008",
+            "role": "system",
+            "response_format": {
+                "__response_schema_type__": "pydantic_model",
+                "module": ModuleStructuredResponse.__module__,
+                "qualname": ModuleStructuredResponse.__qualname__,
+            },
+            "enable_tool_calls": False,
+        }
+        request = RunRequest.from_dict(data)
+
+        assert request.message == "Test"
+        assert request.correlation_id == "corr-008"
+        assert request.role == "system"
+        assert request.response_format is ModuleStructuredResponse
+        assert request.enable_tool_calls is False
+
+    def test_from_dict_unknown_role_preserves_value(self) -> None:
+        """Test from_dict keeps custom roles intact."""
+        data = {"message": "Test", "correlationId": "corr-009", "role": "reviewer"}
+        request = RunRequest.from_dict(data)
+
+        assert request.role == "reviewer"
+        assert request.role != "user"
+
+    def test_from_dict_empty_message(self) -> None:
+        """Test from_dict with empty message."""
+        request = RunRequest.from_dict({"correlationId": "corr-010"})
+
+        assert request.message == ""
+        assert request.correlation_id == "corr-010"
+        assert request.role == "user"
+
+    def test_from_dict_missing_correlation_id_raises(self) -> None:
+        """Test from_dict raises when correlationId is missing."""
+        with pytest.raises(ValueError, match="correlationId is required"):
+            RunRequest.from_dict({"message": "Test"})
+
+    def test_round_trip_dict_conversion(self) -> None:
+        """Test round-trip to_dict and from_dict."""
+        original = RunRequest(
+            message="Test message",
+            correlation_id="corr-011",
+            role="system",
+            response_format=ModuleStructuredResponse,
+            enable_tool_calls=False,
+        )
+
+        data = original.to_dict()
+        restored = RunRequest.from_dict(data)
+
+        assert restored.message == original.message
+        assert restored.correlation_id == original.correlation_id
+        assert restored.role == original.role
+        assert restored.response_format is ModuleStructuredResponse
+        assert restored.enable_tool_calls == original.enable_tool_calls
+
+    def test_round_trip_with_pydantic_response_format(self) -> None:
+        """Ensure Pydantic response formats serialize and deserialize properly."""
+        original = RunRequest(
+            message="Structured",
+            correlation_id="corr-012",
+            response_format=ModuleStructuredResponse,
+        )
+
+        data = original.to_dict()
+
+        assert data["response_format"]["__response_schema_type__"] == "pydantic_model"
+        assert data["response_format"]["module"] == ModuleStructuredResponse.__module__
+        assert data["response_format"]["qualname"] == ModuleStructuredResponse.__qualname__
+
+        restored = RunRequest.from_dict(data)
+        assert restored.response_format is ModuleStructuredResponse
+
+    def test_round_trip_with_options(self) -> None:
+        """Ensure options are preserved and response_format is deserialized."""
+        original = RunRequest(
+            message="Test",
+            correlation_id="corr-opts-1",
+            response_format=ModuleStructuredResponse,
+            enable_tool_calls=False,
+            options={
+                "response_format": ModuleStructuredResponse,
+                "enable_tool_calls": False,
+                "custom": "value",
+            },
+        )
+
+        data = original.to_dict()
+        assert data["options"]["custom"] == "value"
+
+        restored = RunRequest.from_dict(data)
+        assert restored.options is not None
+        assert restored.options["custom"] == "value"
+        assert restored.options["response_format"] is ModuleStructuredResponse
+
+    def test_init_with_correlationId(self) -> None:
+        """Test RunRequest initialization with correlationId."""
+        request = RunRequest(message="Test message", correlation_id="corr-123")
+
+        assert request.message == "Test message"
+        assert request.correlation_id == "corr-123"
+
+    def test_to_dict_with_correlationId(self) -> None:
+        """Test to_dict includes correlationId."""
+        request = RunRequest(message="Test", correlation_id="corr-456")
+        data = request.to_dict()
+
+        assert data["message"] == "Test"
+        assert data["correlationId"] == "corr-456"
+
+    def test_from_dict_with_correlationId(self) -> None:
+        """Test from_dict with correlationId."""
+        data = {"message": "Test", "correlationId": "corr-789"}
+        request = RunRequest.from_dict(data)
+
+        assert request.message == "Test"
+        assert request.correlation_id == "corr-789"
+
+    def test_round_trip_with_correlationId(self) -> None:
+        """Test round-trip to_dict and from_dict with correlationId."""
+        original = RunRequest(
+            message="Test message",
+            role="system",
+            correlation_id="corr-124",
+        )
+
+        data = original.to_dict()
+        restored = RunRequest.from_dict(data)
+
+        assert restored.message == original.message
+        assert restored.role == original.role
+        assert restored.correlation_id == original.correlation_id
+
+    def test_init_with_orchestration_id(self) -> None:
+        """Test RunRequest initialization with orchestration_id."""
+        request = RunRequest(
+            message="Test message",
+            correlation_id="corr-125",
+            orchestration_id="orch-123",
+        )
+
+        assert request.message == "Test message"
+        assert request.orchestration_id == "orch-123"
+
+    def test_to_dict_with_orchestration_id(self) -> None:
+        """Test to_dict includes orchestrationId."""
+        request = RunRequest(
+            message="Test",
+            correlation_id="corr-126",
+            orchestration_id="orch-456",
+        )
+        data = request.to_dict()
+
+        assert data["message"] == "Test"
+        assert data["orchestrationId"] == "orch-456"
+
+    def test_to_dict_excludes_orchestration_id_when_none(self) -> None:
+        """Test to_dict excludes orchestrationId when not set."""
+        request = RunRequest(
+            message="Test",
+            correlation_id="corr-127",
+        )
+        data = request.to_dict()
+
+        assert "orchestrationId" not in data
+
+    def test_from_dict_with_orchestration_id(self) -> None:
+        """Test from_dict with orchestrationId."""
+        data = {
+            "message": "Test",
+            "correlationId": "corr-128",
+            "orchestrationId": "orch-789",
+        }
+        request = RunRequest.from_dict(data)
+
+        assert request.message == "Test"
+        assert request.orchestration_id == "orch-789"
+
+    def test_round_trip_with_orchestration_id(self) -> None:
+        """Test round-trip to_dict and from_dict with orchestration_id."""
+        original = RunRequest(
+            message="Test message",
+            role="system",
+            correlation_id="corr-129",
+            orchestration_id="orch-123",
+        )
+
+        data = original.to_dict()
+        restored = RunRequest.from_dict(data)
+
+        assert restored.message == original.message
+        assert restored.role == original.role
+        assert restored.correlation_id == original.correlation_id
+        assert restored.orchestration_id == original.orchestration_id
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "--tb=short"])