yamlgraph 0.3.9__py3-none-any.whl

tests/unit/test_langsmith_tools.py

@@ -0,0 +1,204 @@
+"""Tests for LangSmith tool wrappers.
+
+Tests for the agent-facing tool wrappers in yamlgraph.tools.langsmith_tools.
+"""
+
+from unittest.mock import patch
+
+# =============================================================================
+# get_run_details_tool tests
+# =============================================================================
+
+
+class TestGetRunDetailsTool:
+    """Tests for get_run_details_tool()."""
+
+    def test_returns_success_with_run_details(self):
+        """Returns run details with success flag."""
+        from yamlgraph.tools.langsmith_tools import get_run_details_tool
+
+        mock_details = {
+            "id": "run-123",
+            "name": "test_pipeline",
+            "status": "success",
+            "error": None,
+            "start_time": "2026-01-18T10:00:00",
+            "end_time": "2026-01-18T10:01:00",
+            "inputs": {"topic": "AI"},
+            "outputs": {"result": "done"},
+            "run_type": "chain",
+        }
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_run_details",
+            return_value=mock_details,
+        ):
+            result = get_run_details_tool("run-123")
+
+            assert result["success"] is True
+            assert result["id"] == "run-123"
+            assert result["status"] == "success"
+
+    def test_returns_error_when_no_details(self):
+        """Returns error dict when details not available."""
+        from yamlgraph.tools.langsmith_tools import get_run_details_tool
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_run_details",
+            return_value=None,
+        ):
+            result = get_run_details_tool("run-123")
+
+            assert result["success"] is False
+            assert "error" in result
+
+    def test_passes_run_id_to_underlying_function(self):
+        """Passes run_id parameter correctly."""
+        from yamlgraph.tools.langsmith_tools import get_run_details_tool
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_run_details",
+            return_value={"id": "test"},
+        ) as mock_get:
+            get_run_details_tool("specific-run-id")
+            mock_get.assert_called_once_with("specific-run-id")
+
+    def test_uses_latest_when_no_run_id(self):
+        """Uses latest run when no ID provided."""
+        from yamlgraph.tools.langsmith_tools import get_run_details_tool
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_run_details",
+            return_value={"id": "latest"},
+        ) as mock_get:
+            get_run_details_tool()
+            mock_get.assert_called_once_with(None)
+
+
+# =============================================================================
+# get_run_errors_tool tests
+# =============================================================================
+
+
+class TestGetRunErrorsTool:
+    """Tests for get_run_errors_tool()."""
+
+    def test_returns_errors_with_count(self):
+        """Returns errors with count and has_errors flag."""
+        from yamlgraph.tools.langsmith_tools import get_run_errors_tool
+
+        mock_errors = [
+            {"node": "generate", "error": "API failed", "run_type": "llm"},
+            {"node": "analyze", "error": "Timeout", "run_type": "llm"},
+        ]
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_run_errors",
+            return_value=mock_errors,
+        ):
+            result = get_run_errors_tool("run-123")
+
+            assert result["success"] is True
+            assert result["error_count"] == 2
+            assert result["has_errors"] is True
+            assert len(result["errors"]) == 2
+
+    def test_returns_empty_when_no_errors(self):
+        """Returns empty list when no errors."""
+        from yamlgraph.tools.langsmith_tools import get_run_errors_tool
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_run_errors",
+            return_value=[],
+        ):
+            result = get_run_errors_tool("run-123")
+
+            assert result["success"] is True
+            assert result["error_count"] == 0
+            assert result["has_errors"] is False
+            assert result["errors"] == []
+
+    def test_passes_run_id_to_underlying_function(self):
+        """Passes run_id parameter correctly."""
+        from yamlgraph.tools.langsmith_tools import get_run_errors_tool
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_run_errors",
+            return_value=[],
+        ) as mock_get:
+            get_run_errors_tool("specific-run-id")
+            mock_get.assert_called_once_with("specific-run-id")
+
+
+# =============================================================================
+# get_failed_runs_tool tests
+# =============================================================================
+
+
+class TestGetFailedRunsTool:
+    """Tests for get_failed_runs_tool()."""
+
+    def test_returns_failed_runs_with_count(self):
+        """Returns failed runs with count."""
+        from yamlgraph.tools.langsmith_tools import get_failed_runs_tool
+
+        mock_runs = [
+            {
+                "id": "run-1",
+                "name": "pipe1",
+                "error": "Err1",
+                "start_time": "2026-01-18T10:00:00",
+            },
+            {
+                "id": "run-2",
+                "name": "pipe2",
+                "error": "Err2",
+                "start_time": "2026-01-18T11:00:00",
+            },
+        ]
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_failed_runs",
+            return_value=mock_runs,
+        ):
+            result = get_failed_runs_tool(limit=5)
+
+            assert result["success"] is True
+            assert result["failed_count"] == 2
+            assert len(result["runs"]) == 2
+
+    def test_returns_empty_when_no_failures(self):
+        """Returns empty list when no failures."""
+        from yamlgraph.tools.langsmith_tools import get_failed_runs_tool
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_failed_runs",
+            return_value=[],
+        ):
+            result = get_failed_runs_tool()
+
+            assert result["success"] is True
+            assert result["failed_count"] == 0
+            assert result["runs"] == []
+
+    def test_passes_parameters_correctly(self):
+        """Passes limit and project_name to underlying function."""
+        from yamlgraph.tools.langsmith_tools import get_failed_runs_tool
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_failed_runs",
+            return_value=[],
+        ) as mock_get:
+            get_failed_runs_tool(limit=5, project_name="custom-project")
+            mock_get.assert_called_once_with(project_name="custom-project", limit=5)
+
+    def test_uses_defaults_when_no_params(self):
+        """Uses default limit when not provided."""
+        from yamlgraph.tools.langsmith_tools import get_failed_runs_tool
+
+        with patch(
+            "yamlgraph.tools.langsmith_tools.get_failed_runs",
+            return_value=[],
+        ) as mock_get:
+            get_failed_runs_tool()
+            mock_get.assert_called_once_with(project_name=None, limit=10)

tests/unit/test_llm_factory.py

@@ -0,0 +1,109 @@
+"""Unit tests for LLM factory module."""
+
+import os
+from unittest.mock import patch
+
+import pytest
+from langchain_anthropic import ChatAnthropic
+
+from yamlgraph.utils.llm_factory import clear_cache, create_llm
+
+
+class TestCreateLLM:
+    """Test the create_llm factory function."""
+
+    def setup_method(self):
+        """Clear cache and environment before each test."""
+        clear_cache()
+
+    def test_default_provider_is_anthropic(self):
+        """Should use Anthropic by default."""
+        # Clear PROVIDER from environment to ensure default behavior
+        with patch.dict(os.environ, {"PROVIDER": ""}, clear=False):
+            llm = create_llm(temperature=0.7)
+            assert isinstance(llm, ChatAnthropic)
+            assert llm.temperature == 0.7
+
+    def test_explicit_anthropic_provider(self):
+        """Should create Anthropic LLM when provider='anthropic'."""
+        llm = create_llm(provider="anthropic", temperature=0.5)
+        assert isinstance(llm, ChatAnthropic)
+        assert llm.temperature == 0.5
+
+    def test_mistral_provider(self):
+        """Should create Mistral LLM when provider='mistral'."""
+        with patch.dict(os.environ, {"MISTRAL_API_KEY": "test-key"}):
+            llm = create_llm(provider="mistral", temperature=0.8)
+            # Check it's the right class (will import on first call)
+            assert llm.__class__.__name__ == "ChatMistralAI"
+            assert llm.temperature == 0.8
+
+    def test_openai_provider(self):
+        """Should create OpenAI LLM when provider='openai'."""
+        with patch.dict(os.environ, {"OPENAI_API_KEY": "test-key"}):
+            llm = create_llm(provider="openai", temperature=0.6)
+            assert llm.__class__.__name__ == "ChatOpenAI"
+            assert llm.temperature == 0.6
+
+    def test_provider_from_environment(self):
+        """Should use PROVIDER env var when no provider specified."""
+        with patch.dict(
+            os.environ, {"PROVIDER": "mistral", "MISTRAL_API_KEY": "test-key"}
+        ):
+            llm = create_llm(temperature=0.7)
+            assert llm.__class__.__name__ == "ChatMistralAI"
+
+    def test_custom_model(self):
+        """Should use custom model when specified."""
+        with patch.dict(os.environ, {"PROVIDER": ""}, clear=False):
+            llm = create_llm(model="claude-opus-4", temperature=0.5)
+            assert isinstance(llm, ChatAnthropic)
+            assert llm.model == "claude-opus-4"
+
+    def test_model_override_parameter(self):
+        """Should prefer model parameter over default."""
+        llm = create_llm(provider="anthropic", model="claude-sonnet-4", temperature=0.7)
+        assert llm.model == "claude-sonnet-4"
+
+    def test_default_models(self):
+        """Should use correct default models for each provider."""
+        # Anthropic default
+        llm_anthropic = create_llm(provider="anthropic", temperature=0.7)
+        assert llm_anthropic.model == "claude-haiku-4-5"
+
+        # Mistral default
+        with patch.dict(os.environ, {"MISTRAL_API_KEY": "test-key"}):
+            llm_mistral = create_llm(provider="mistral", temperature=0.7)
+            assert llm_mistral.model == "mistral-large-latest"
+
+        # OpenAI default (uses model_name attribute)
+        with patch.dict(os.environ, {"OPENAI_API_KEY": "test-key"}):
+            llm_openai = create_llm(provider="openai", temperature=0.7)
+            assert llm_openai.model_name == "gpt-4o"
+
+    def test_invalid_provider(self):
+        """Should raise error for invalid provider."""
+        with pytest.raises((ValueError, KeyError)):
+            create_llm(provider="invalid-provider", temperature=0.7)
+
+    def test_caching(self):
+        """Should cache LLM instances for same parameters."""
+        llm1 = create_llm(provider="anthropic", temperature=0.7)
+        llm2 = create_llm(provider="anthropic", temperature=0.7)
+        assert llm1 is llm2
+
+        # Different temperature = different instance
+        llm3 = create_llm(provider="anthropic", temperature=0.5)
+        assert llm1 is not llm3
+
+    def test_cache_key_includes_all_params(self):
+        """Cache should differentiate on provider, model, temperature."""
+        llm1 = create_llm(
+            provider="anthropic", model="claude-haiku-4-5", temperature=0.7
+        )
+        llm2 = create_llm(provider="anthropic", model="claude-opus-4", temperature=0.7)
+        assert llm1 is not llm2
+
+        with patch.dict(os.environ, {"MISTRAL_API_KEY": "test-key"}):
+            llm3 = create_llm(provider="mistral", temperature=0.7)
+            assert llm1 is not llm3

tests/unit/test_llm_factory_async.py

@@ -0,0 +1,118 @@
+"""Unit tests for async LLM factory module."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from yamlgraph.utils.llm_factory_async import (
+    create_llm_async,
+    get_executor,
+    invoke_async,
+    shutdown_executor,
+)
+
+
+class TestGetExecutor:
+    """Tests for get_executor function."""
+
+    def teardown_method(self):
+        """Clean up executor after each test."""
+        shutdown_executor()
+
+    def test_creates_executor(self):
+        """Should create a ThreadPoolExecutor."""
+        executor = get_executor()
+        assert executor is not None
+
+    def test_returns_same_executor(self):
+        """Should return the same executor on subsequent calls."""
+        executor1 = get_executor()
+        executor2 = get_executor()
+        assert executor1 is executor2
+
+
+class TestShutdownExecutor:
+    """Tests for shutdown_executor function."""
+
+    def test_shutdown_cleans_up(self):
+        """Shutdown should clean up executor."""
+        # Create an executor
+        executor1 = get_executor()
+        assert executor1 is not None
+
+        # Shutdown
+        shutdown_executor()
+
+        # Next call should create a new executor
+        executor2 = get_executor()
+        assert executor2 is not executor1
+
+    def test_shutdown_when_none(self):
+        """Shutdown when no executor should not raise."""
+        shutdown_executor()  # Ensure clean state
+        shutdown_executor()  # Should not raise
+
+
+class TestCreateLLMAsync:
+    """Tests for create_llm_async function."""
+
+    def teardown_method(self):
+        """Clean up executor after each test."""
+        shutdown_executor()
+
+    @pytest.mark.asyncio
+    async def test_creates_llm(self):
+        """Should create an LLM instance."""
+        llm = await create_llm_async(provider="anthropic", temperature=0.5)
+        assert llm is not None
+        assert llm.temperature == 0.5
+
+    @pytest.mark.asyncio
+    async def test_uses_default_provider(self):
+        """Should use default provider when not specified."""
+        with patch.dict("os.environ", {"PROVIDER": ""}, clear=False):
+            llm = await create_llm_async(temperature=0.7)
+            # Default is anthropic
+            assert "anthropic" in llm.__class__.__name__.lower()
+
+
+class TestInvokeAsync:
+    """Tests for invoke_async function."""
+
+    def teardown_method(self):
+        """Clean up executor after each test."""
+        shutdown_executor()
+
+    @pytest.mark.asyncio
+    async def test_invoke_returns_string(self):
+        """Should return string content when no output model."""
+        mock_llm = MagicMock()
+        mock_response = MagicMock()
+        mock_response.content = "Hello, world!"
+        mock_llm.invoke.return_value = mock_response
+
+        messages = [MagicMock()]
+        result = await invoke_async(mock_llm, messages)
+
+        assert result == "Hello, world!"
+        mock_llm.invoke.assert_called_once_with(messages)
+
+    @pytest.mark.asyncio
+    async def test_invoke_with_output_model(self):
+        """Should use structured output when model provided."""
+        from pydantic import BaseModel
+
+        class TestOutput(BaseModel):
+            value: str
+
+        mock_llm = MagicMock()
+        mock_structured_llm = MagicMock()
+        mock_llm.with_structured_output.return_value = mock_structured_llm
+        mock_structured_llm.invoke.return_value = TestOutput(value="test")
+
+        messages = [MagicMock()]
+        result = await invoke_async(mock_llm, messages, output_model=TestOutput)
+
+        assert isinstance(result, TestOutput)
+        assert result.value == "test"
+        mock_llm.with_structured_output.assert_called_once_with(TestOutput)