yamlgraph 0.1.1__py3-none-any.whl

tests/integration/test_memory_demo.py

@@ -0,0 +1,281 @@
+"""Tests for Memory Demo - Multi-turn conversation with persistence.
+
+Tests the memory features from Section 6 working together:
+- Checkpointer for state persistence
+- Message accumulation via dynamic state (Annotated reducers)
+- Tool results storage
+- Result export
+"""
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+
+
+class TestMemoryDemoGraphConfig:
+    """Tests for memory-demo.yaml graph configuration."""
+
+    def test_graph_config_exists(self):
+        """Graph config file exists."""
+        config_path = Path("graphs/memory-demo.yaml")
+        assert config_path.exists(), "graphs/memory-demo.yaml should exist"
+
+    def test_graph_config_loads(self):
+        """Graph config loads without errors."""
+        from yamlgraph.graph_loader import load_graph_config
+
+        config = load_graph_config("graphs/memory-demo.yaml")
+        assert config.name == "memory_demo"
+
+    def test_graph_has_agent_node(self):
+        """Graph includes an agent node."""
+        from yamlgraph.graph_loader import load_graph_config
+
+        config = load_graph_config("graphs/memory-demo.yaml")
+        assert "review" in config.nodes
+        assert config.nodes["review"]["type"] == "agent"
+
+    def test_graph_has_tools(self):
+        """Graph defines git tools."""
+        from yamlgraph.graph_loader import load_graph_config
+
+        config = load_graph_config("graphs/memory-demo.yaml")
+        tools = config.tools or {}
+        assert "git_log" in tools
+        assert "git_diff" in tools
+
+
+class TestCodeReviewPrompt:
+    """Tests for code_review.yaml prompt."""
+
+    def test_prompt_file_exists(self):
+        """Prompt file exists."""
+        prompt_path = Path("prompts/code_review.yaml")
+        assert prompt_path.exists(), "prompts/code_review.yaml should exist"
+
+    def test_prompt_loads(self):
+        """Prompt loads with system and user templates."""
+        from yamlgraph.executor import load_prompt
+
+        prompt = load_prompt("code_review")
+        assert "system" in prompt
+        assert "user" in prompt
+
+
+class TestCheckpointerIntegration:
+    """Tests for checkpointer integration with graph builder."""
+
+    def test_build_graph_accepts_checkpointer(self):
+        """build_graph accepts optional checkpointer parameter."""
+        import tempfile
+
+        from yamlgraph.builder import build_graph
+        from yamlgraph.storage.checkpointer import get_checkpointer
+
+        with tempfile.NamedTemporaryFile(suffix=".db") as f:
+            checkpointer = get_checkpointer(f.name)
+            # Should not raise
+            graph = build_graph(checkpointer=checkpointer)
+            assert graph is not None
+
+    def test_graph_with_checkpointer_accepts_thread_id(self):
+        """Graph with checkpointer can be invoked with thread_id."""
+        import tempfile
+
+        from yamlgraph.builder import build_graph
+        from yamlgraph.storage.checkpointer import get_checkpointer
+
+        with tempfile.NamedTemporaryFile(suffix=".db") as f:
+            checkpointer = get_checkpointer(f.name)
+            _graph = build_graph(checkpointer=checkpointer)  # noqa: F841
+
+            # Should accept configurable with thread_id
+            config = {"configurable": {"thread_id": "test-123"}}
+            # Just verify config structure is valid
+            assert "thread_id" in config["configurable"]
+
+
+class TestCLIThreadFlag:
+    """Tests for CLI --thread flag."""
+
+    def test_graph_run_cli_has_thread_argument(self):
+        """Graph run CLI accepts --thread argument."""
+        from yamlgraph.cli import create_parser
+
+        parser = create_parser()
+        # Parse with thread flag
+        args = parser.parse_args(
+            ["graph", "run", "graphs/yamlgraph.yaml", "--thread", "abc123"]
+        )
+        assert args.thread == "abc123"
+
+    def test_graph_run_thread_defaults_to_none(self):
+        """Thread defaults to None when not specified."""
+        from yamlgraph.cli import create_parser
+
+        parser = create_parser()
+        args = parser.parse_args(["graph", "run", "graphs/yamlgraph.yaml"])
+        assert args.thread is None
+
+
+class TestCLIExportFlag:
+    """Tests for CLI --export flag."""
+
+    def test_graph_run_cli_has_export_argument(self):
+        """Graph run CLI accepts --export flag."""
+        from yamlgraph.cli import create_parser
+
+        parser = create_parser()
+        args = parser.parse_args(["graph", "run", "graphs/yamlgraph.yaml", "--export"])
+        assert args.export is True
+
+    def test_graph_run_export_defaults_to_false(self):
+        """Export defaults to False when not specified."""
+        from yamlgraph.cli import create_parser
+
+        parser = create_parser()
+        args = parser.parse_args(["graph", "run", "graphs/yamlgraph.yaml"])
+        assert args.export is False
+
+
+class TestMemoryDemoEndToEnd:
+    """End-to-end tests for memory demo (mocked LLM)."""
+
+    def test_single_turn_returns_messages(self):
+        """Single turn execution returns messages in state."""
+        from yamlgraph.tools.agent import create_agent_node
+        from yamlgraph.tools.shell import ShellToolConfig
+
+        mock_response = AIMessage(content="Here are the recent commits...")
+
+        mock_llm = MagicMock()
+        mock_llm.bind_tools.return_value = mock_llm
+        mock_llm.invoke.return_value = mock_response
+
+        tool_config = ShellToolConfig(
+            command="git log --oneline -n {count}",
+            description="Get recent commits",
+        )
+
+        with patch("yamlgraph.tools.agent.create_llm", return_value=mock_llm):
+            node_fn = create_agent_node(
+                "review",
+                {
+                    "tools": ["git_log"],
+                    "state_key": "response",
+                    "tool_results_key": "_tool_results",
+                },
+                {"git_log": tool_config},
+            )
+            result = node_fn({"input": "Show recent commits"})
+
+        assert "messages" in result
+        assert "response" in result
+
+    def test_multi_turn_preserves_history(self):
+        """Multi-turn conversation preserves message history."""
+        from yamlgraph.tools.agent import create_agent_node
+
+        mock_response = AIMessage(content="Based on our previous discussion...")
+
+        mock_llm = MagicMock()
+        mock_llm.bind_tools.return_value = mock_llm
+        mock_llm.invoke.return_value = mock_response
+
+        # Simulate existing conversation
+        existing_messages = [
+            SystemMessage(content="You are a code review assistant."),
+            HumanMessage(content="Show commits"),
+            AIMessage(content="Here are 5 commits..."),
+        ]
+
+        with patch("yamlgraph.tools.agent.create_llm", return_value=mock_llm):
+            node_fn = create_agent_node(
+                "review",
+                {"tools": [], "state_key": "response"},
+                {},
+            )
+            result = node_fn(
+                {
+                    "input": "What about tests?",
+                    "messages": existing_messages,
+                }
+            )
+
+        # New messages should be returned
+        assert len(result["messages"]) >= 2  # At least human + AI
+
+    def test_tool_results_stored_in_state(self):
+        """Tool execution results are stored in state."""
+        from yamlgraph.tools.agent import create_agent_node
+        from yamlgraph.tools.shell import ShellToolConfig
+
+        tool_response = AIMessage(
+            content="",
+            tool_calls=[{"name": "git_log", "args": {"count": "5"}, "id": "call_1"}],
+        )
+        final_response = AIMessage(content="Found 5 commits")
+
+        mock_llm = MagicMock()
+        mock_llm.bind_tools.return_value = mock_llm
+        mock_llm.invoke.side_effect = [tool_response, final_response]
+
+        tool_config = ShellToolConfig(
+            command="git log --oneline -n {count}",
+            description="Get recent commits",
+        )
+
+        with patch("yamlgraph.tools.agent.create_llm", return_value=mock_llm):
+            with patch("yamlgraph.tools.agent.execute_shell_tool") as mock_exec:
+                mock_exec.return_value = MagicMock(
+                    success=True, output="abc123 First commit\ndef456 Second commit"
+                )
+
+                node_fn = create_agent_node(
+                    "review",
+                    {
+                        "tools": ["git_log"],
+                        "state_key": "response",
+                        "tool_results_key": "_tool_results",
+                    },
+                    {"git_log": tool_config},
+                )
+                result = node_fn({"input": "Show commits"})
+
+        assert "_tool_results" in result
+        assert len(result["_tool_results"]) == 1
+        assert result["_tool_results"][0]["tool"] == "git_log"
+
+    def test_export_creates_files(self, tmp_path: Path):
+        """Export flag creates output files."""
+        from yamlgraph.storage.export import export_result
+
+        state = {
+            "thread_id": "demo-123",
+            "response": "# Code Review Summary\n\nFound 5 commits.",
+            "_tool_results": [
+                {"tool": "git_log", "args": {"count": "5"}, "output": "..."}
+            ],
+        }
+
+        config = {
+            "response": {"format": "markdown", "filename": "review.md"},
+            "_tool_results": {"format": "json", "filename": "tool_outputs.json"},
+        }
+
+        paths = export_result(state, config, base_path=tmp_path)
+
+        assert len(paths) == 2
+
+        # Check markdown file
+        md_path = tmp_path / "demo-123" / "review.md"
+        assert md_path.exists()
+        assert "Code Review Summary" in md_path.read_text()
+
+        # Check JSON file
+        json_path = tmp_path / "demo-123" / "tool_outputs.json"
+        assert json_path.exists()
+        data = json.loads(json_path.read_text())
+        assert data[0]["tool"] == "git_log"

tests/integration/test_pipeline_flow.py

@@ -0,0 +1,105 @@
+"""Integration tests for the complete pipeline flow."""
+
+from unittest.mock import patch
+
+import pytest
+
+from tests.conftest import FixtureAnalysis, FixtureGeneratedContent
+from yamlgraph.builder import build_graph, build_resume_graph, run_pipeline
+
+
+class TestBuildGraph:
+    """Tests for build_graph function."""
+
+    def test_graph_compiles(self):
+        """Graph should compile without errors."""
+        graph = build_graph()
+        compiled = graph.compile()
+        assert compiled is not None
+
+    def test_graph_has_expected_nodes(self):
+        """Graph should have generate, analyze, summarize nodes."""
+        graph = build_graph()
+        # StateGraph stores nodes internally
+        assert "generate" in graph.nodes
+        assert "analyze" in graph.nodes
+        assert "summarize" in graph.nodes
+
+
+class TestBuildResumeGraph:
+    """Tests for build_resume_graph function.
+
+    Resume works via skip_if_exists: nodes skip LLM calls if output exists in state.
+    """
+
+    def test_resume_graph_loads_full_pipeline(self):
+        """Resume graph loads the full pipeline (same as main graph)."""
+        graph = build_resume_graph()
+        # All nodes present - skip_if_exists handles resume logic
+        assert "generate" in graph.nodes
+        assert "analyze" in graph.nodes
+        assert "summarize" in graph.nodes
+
+    def test_resume_graph_same_as_main(self):
+        """Resume graph is identical to main graph."""
+        main_graph = build_graph()
+        resume_graph = build_resume_graph()
+
+        assert set(main_graph.nodes.keys()) == set(resume_graph.nodes.keys())
+
+
+class TestRunPipeline:
+    """Tests for run_pipeline function with mocked LLM."""
+
+    @patch("yamlgraph.node_factory.execute_prompt")
+    def test_full_pipeline_success(self, mock_execute):
+        """Full pipeline should execute all steps."""
+        # Setup mock returns for each call
+        mock_generated = FixtureGeneratedContent(
+            title="Test Title",
+            content="Test content " * 50,
+            word_count=100,
+            tags=["test"],
+        )
+        mock_analysis = FixtureAnalysis(
+            summary="Test summary",
+            key_points=["Point 1"],
+            sentiment="positive",
+            confidence=0.9,
+        )
+        mock_summary = "Final test summary"
+
+        mock_execute.side_effect = [mock_generated, mock_analysis, mock_summary]
+
+        result = run_pipeline(topic="test", style="informative", word_count=100)
+
+        assert result["generated"] == mock_generated
+        assert result["analysis"] == mock_analysis
+        assert result["final_summary"] == mock_summary
+        assert mock_execute.call_count == 3
+
+    @patch("yamlgraph.node_factory.execute_prompt")
+    def test_pipeline_stops_on_generate_error(self, mock_execute):
+        """Pipeline should stop and raise exception on generate failure."""
+        mock_execute.side_effect = Exception("API Error")
+
+        with pytest.raises(Exception) as exc_info:
+            run_pipeline(topic="test")
+
+        assert "API Error" in str(exc_info.value)
+
+    @patch("yamlgraph.node_factory.execute_prompt")
+    def test_pipeline_state_progression(self, mock_execute):
+        """Pipeline should update current_step as it progresses."""
+        mock_generated = FixtureGeneratedContent(
+            title="Test", content="Content", word_count=1, tags=[]
+        )
+        mock_analysis = FixtureAnalysis(
+            summary="Summary", key_points=[], sentiment="neutral", confidence=0.5
+        )
+        mock_execute.side_effect = [mock_generated, mock_analysis, "Summary"]
+
+        result = run_pipeline(topic="test")
+
+        # Final step should be summarize
+        assert result["current_step"] == "summarize"

tests/integration/test_providers.py

@@ -0,0 +1,163 @@
+"""Integration tests for multi-provider LLM support."""
+
+import os
+from unittest.mock import patch
+
+import pytest
+from pydantic import BaseModel, Field
+
+from yamlgraph.executor import execute_prompt, load_prompt
+from yamlgraph.utils.llm_factory import clear_cache
+
+
+class ProviderTestContent(BaseModel):
+    """Test model for provider tests - replaces demo model dependency."""
+
+    title: str = Field(description="Title of the generated content")
+    content: str = Field(description="The main generated text")
+    word_count: int = Field(description="Approximate word count")
+    tags: list[str] = Field(default_factory=list, description="Relevant tags")
+
+
+class TestProviderIntegration:
+    """Test multi-provider functionality end-to-end."""
+
+    def setup_method(self):
+        """Clear LLM cache before each test."""
+        clear_cache()
+
+    def test_execute_prompt_with_anthropic_provider(self):
+        """Should execute prompt with explicit Anthropic provider."""
+        result = execute_prompt(
+            prompt_name="greet",
+            variables={"name": "Alice", "style": "formal"},
+            provider="anthropic",
+        )
+        assert isinstance(result, str)
+        assert len(result) > 0
+
+    @pytest.mark.skipif(
+        not os.getenv("MISTRAL_API_KEY"), reason="MISTRAL_API_KEY not set"
+    )
+    def test_execute_prompt_with_mistral_provider(self):
+        """Should execute prompt with Mistral provider."""
+        result = execute_prompt(
+            prompt_name="greet",
+            variables={"name": "Bob", "style": "casual"},
+            provider="mistral",
+        )
+        assert isinstance(result, str)
+        assert len(result) > 0
+
+    @pytest.mark.skipif(
+        not os.getenv("OPENAI_API_KEY"), reason="OPENAI_API_KEY not set"
+    )
+    def test_execute_prompt_with_openai_provider(self):
+        """Should execute prompt with OpenAI provider."""
+        result = execute_prompt(
+            prompt_name="greet",
+            variables={"name": "Charlie", "style": "friendly"},
+            provider="openai",
+        )
+        assert isinstance(result, str)
+        assert len(result) > 0
+
+    def test_provider_from_environment_variable(self):
+        """Should use provider from PROVIDER env var."""
+        with patch.dict(os.environ, {"PROVIDER": "anthropic"}):
+            result = execute_prompt(
+                prompt_name="greet",
+                variables={"name": "Dave", "style": "formal"},
+            )
+            assert isinstance(result, str)
+            assert len(result) > 0
+
+    def test_provider_in_yaml_metadata(self):
+        """Should extract provider from YAML metadata."""
+        # greet.yaml doesn't have provider metadata,
+        # so this just verifies the load works
+        _ = load_prompt("greet")
+
+        # Even though greet.yaml doesn't have provider,
+        # the executor should handle it gracefully
+        result = execute_prompt(
+            prompt_name="greet",
+            variables={"name": "Eve", "style": "casual"},
+        )
+        assert isinstance(result, str)
+
+    def test_structured_output_with_different_providers(self):
+        """Should work with structured outputs across providers."""
+        result = execute_prompt(
+            prompt_name="generate",
+            variables={
+                "topic": "Python testing",
+                "style": "technical",
+                "word_count": 50,
+            },
+            output_model=ProviderTestContent,
+            provider="anthropic",
+        )
+        assert isinstance(result, ProviderTestContent)
+        assert result.content
+        assert isinstance(result.tags, list)
+
+    def test_temperature_and_provider_together(self):
+        """Should handle both temperature and provider parameters."""
+        result = execute_prompt(
+            prompt_name="greet",
+            variables={"name": "Frank", "style": "formal"},
+            temperature=0.3,
+            provider="anthropic",
+        )
+        assert isinstance(result, str)
+        assert len(result) > 0
+
+    def test_invalid_provider_raises_error(self):
+        """Should raise error for invalid provider."""
+        with pytest.raises(ValueError, match="Invalid provider"):
+            execute_prompt(
+                prompt_name="greet",
+                variables={"name": "Greg", "style": "casual"},
+                provider="invalid-provider",
+            )
+
+    def test_caching_across_calls_with_same_provider(self):
+        """Should reuse LLM instances for same provider/temperature."""
+        # First call
+        result1 = execute_prompt(
+            prompt_name="greet",
+            variables={"name": "Harry", "style": "formal"},
+            temperature=0.7,
+            provider="anthropic",
+        )
+
+        # Second call with same params should use cached LLM
+        result2 = execute_prompt(
+            prompt_name="greet",
+            variables={"name": "Ivy", "style": "casual"},
+            temperature=0.7,
+            provider="anthropic",
+        )
+
+        # Both should succeed (testing cache doesn't break functionality)
+        assert isinstance(result1, str)
+        assert isinstance(result2, str)
+
+
+class TestJinja2WithProviders:
+    """Test Jinja2 templates work with different providers."""
+
+    def setup_method(self):
+        """Clear LLM cache before each test."""
+        clear_cache()
+
+    def test_simple_prompt_template_format(self):
+        """Should work with simple {variable} templates on any provider."""
+        result = execute_prompt(
+            prompt_name="greet",
+            variables={"name": "TestUser", "style": "formal"},
+            provider="anthropic",
+        )
+        assert isinstance(result, str)
+        assert len(result) > 0

tests/integration/test_resume.py

@@ -0,0 +1,75 @@
+"""Integration tests for pipeline resume functionality."""
+
+from unittest.mock import patch
+
+from tests.conftest import FixtureAnalysis, FixtureGeneratedContent
+from yamlgraph.builder import build_resume_graph
+from yamlgraph.models import create_initial_state
+
+
+class TestResumeFromAnalyze:
+    """Tests for resuming pipeline with existing generated content."""
+
+    @patch("yamlgraph.node_factory.execute_prompt")
+    def test_resume_with_generated_skips_generate(self, mock_execute):
+        """Should skip generate when generated content exists."""
+        # Create state with generated content
+        state = create_initial_state(topic="test", thread_id="resume1")
+        state["generated"] = FixtureGeneratedContent(
+            title="Existing Title",
+            content="Existing content",
+            word_count=10,
+            tags=[],
+        )
+        state["current_step"] = "generate"
+
+        # Mock returns: analyze, summarize (generate is skipped)
+        mock_analysis = FixtureAnalysis(
+            summary="Resume summary",
+            key_points=["Point"],
+            sentiment="neutral",
+            confidence=0.7,
+        )
+        mock_execute.side_effect = [mock_analysis, "Final summary"]
+
+        graph = build_resume_graph().compile()
+        result = graph.invoke(state)
+
+        assert mock_execute.call_count == 2  # analyze + summarize only
+        assert result["analysis"] == mock_analysis
+        assert result["final_summary"] == "Final summary"
+        assert result["generated"].title == "Existing Title"  # Preserved
+
+
+class TestResumeFromSummarize:
+    """Tests for resuming pipeline with existing analysis."""
+
+    @patch("yamlgraph.node_factory.execute_prompt")
+    def test_resume_with_analysis_skips_generate_and_analyze(self, mock_execute):
+        """Should skip generate and analyze when both exist."""
+        # Create state with generated content and analysis
+        state = create_initial_state(topic="test", thread_id="resume2")
+        state["generated"] = FixtureGeneratedContent(
+            title="Title",
+            content="Content",
+            word_count=5,
+            tags=[],
+        )
+        state["analysis"] = FixtureAnalysis(
+            summary="Existing analysis",
+            key_points=["Point"],
+            sentiment="positive",
+            confidence=0.8,
+        )
+        state["current_step"] = "analyze"
+
+        # Mock returns: only summarize (generate and analyze skipped)
+        mock_execute.return_value = "Resumed final summary"
+
+        graph = build_resume_graph().compile()
+        result = graph.invoke(state)
+
+        assert mock_execute.call_count == 1  # summarize only
+        assert result["final_summary"] == "Resumed final summary"
+        assert result["generated"].title == "Title"  # Preserved
+        assert result["analysis"].summary == "Existing analysis"  # Preserved

tests/unit/__init__.py

@@ -0,0 +1 @@
+"""Unit tests for yamlgraph."""