yamlgraph 0.3.9__py3-none-any.whl

tests/integration/test_npc_api/test_session.py

@@ -0,0 +1,216 @@
+"""Tests for NPC session adapter.
+
+TDD: Red → Green → Refactor
+"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+
+class TestGetCheckpointer:
+    """Tests for checkpointer factory."""
+
+    def test_returns_memory_saver_by_default(self):
+        """Without REDIS_URL, should return MemorySaver."""
+        from examples.npc.api.session import _reset_checkpointer, get_checkpointer
+
+        _reset_checkpointer()
+
+        with patch.dict("os.environ", {}, clear=True):
+            checkpointer = get_checkpointer()
+            assert checkpointer is not None
+            # MemorySaver type check
+            assert "memory" in type(checkpointer).__module__.lower()
+
+    def test_caches_checkpointer(self):
+        """Should return same instance on repeated calls."""
+        from examples.npc.api.session import _reset_checkpointer, get_checkpointer
+
+        _reset_checkpointer()
+
+        cp1 = get_checkpointer()
+        cp2 = get_checkpointer()
+        assert cp1 is cp2
+
+
+class TestEncounterSession:
+    """Tests for EncounterSession class."""
+
+    @pytest.fixture
+    def mock_app(self):
+        """Create mock LangGraph app."""
+        app = MagicMock()
+        app.checkpointer = MagicMock()
+        app.checkpointer.aget = AsyncMock(return_value=None)
+        app.aget_state = AsyncMock(return_value=MagicMock(next=[], values={}))
+        return app
+
+    @pytest.mark.asyncio
+    async def test_is_resume_false_for_new_session(self, mock_app):
+        """New session should return False for _is_resume."""
+        from examples.npc.api.session import EncounterSession
+
+        mock_app.checkpointer.aget.return_value = None
+
+        session = EncounterSession(mock_app, "test-session-123")
+        result = await session._is_resume()
+
+        assert result is False
+        mock_app.checkpointer.aget.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_is_resume_true_for_existing_session(self, mock_app):
+        """Existing session should return True for _is_resume."""
+        from examples.npc.api.session import EncounterSession
+
+        mock_app.checkpointer.aget.return_value = {"some": "checkpoint"}
+
+        session = EncounterSession(mock_app, "test-session-123")
+        result = await session._is_resume()
+
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_start_creates_initial_state(self, mock_app):
+        """Start should invoke graph with initial state."""
+        from examples.npc.api.session import EncounterSession
+
+        mock_app.ainvoke = AsyncMock(
+            return_value={
+                "turn_number": 1,
+                "narrations": [],
+                "scene_image": None,
+            }
+        )
+        mock_app.aget_state.return_value = MagicMock(next=["await_dm"], values={})
+
+        session = EncounterSession(mock_app, "test-session-123")
+        npcs = [{"name": "Thorin", "race": "Dwarf"}]
+        result = await session.start(npcs, "The Red Dragon Inn")
+
+        assert result.turn_number == 1
+        assert result.is_complete is False  # Has next node
+        mock_app.ainvoke.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_turn_resumes_with_command(self, mock_app):
+        """Turn should resume graph with Command."""
+        from examples.npc.api.session import EncounterSession
+
+        mock_app.ainvoke = AsyncMock(
+            return_value={
+                "turn_number": 2,
+                "narrations": [{"npc": "Thorin", "text": "Hmm..."}],
+                "scene_image": None,
+            }
+        )
+        mock_app.aget_state.return_value = MagicMock(next=["await_dm"], values={})
+
+        session = EncounterSession(mock_app, "test-session-123")
+        result = await session.turn("A stranger enters the tavern")
+
+        assert result.turn_number == 2
+        assert len(result.narrations) == 1
+
+    @pytest.mark.asyncio
+    async def test_turn_catches_errors(self, mock_app):
+        """Turn should catch exceptions and return error."""
+        from examples.npc.api.session import EncounterSession
+
+        mock_app.ainvoke = AsyncMock(side_effect=Exception("LLM failed"))
+
+        session = EncounterSession(mock_app, "test-session-123")
+        result = await session.turn("A stranger enters")
+
+        assert result.error is not None
+        assert "LLM failed" in result.error
+
+
+class TestTurnResult:
+    """Tests for TurnResult dataclass."""
+
+    def test_creates_with_defaults(self):
+        """TurnResult should have sensible defaults."""
+        from examples.npc.api.session import TurnResult
+
+        result = TurnResult(
+            turn_number=1,
+            narrations=[],
+            scene_image=None,
+            turn_summary=None,
+            is_complete=False,
+        )
+
+        assert result.turn_number == 1
+        assert result.error is None
+
+    def test_error_field_optional(self):
+        """Error field should be optional."""
+        from examples.npc.api.session import TurnResult
+
+        result = TurnResult(
+            turn_number=1,
+            narrations=[],
+            scene_image=None,
+            turn_summary=None,
+            is_complete=False,
+            error="Something went wrong",
+        )
+
+        assert result.error == "Something went wrong"
+
+
+class TestCreateNpcsFromConcepts:
+    """Tests for NPC creation helper."""
+
+    @pytest.mark.asyncio
+    async def test_creates_npcs_from_concepts(self):
+        """Should create NPCs using npc-creation graph."""
+        from examples.npc.api.session import create_npcs_from_concepts
+
+        concepts = [
+            {"concept": "a gruff dwarven bartender", "race": "Dwarf"},
+        ]
+
+        with patch("examples.npc.api.session.get_npc_creation_graph") as mock_get:
+            mock_app = MagicMock()
+            mock_app.ainvoke = AsyncMock(
+                return_value={
+                    "identity": {
+                        "name": "Thorin Ironfoot",
+                        "race": "Dwarf",
+                        "character_class": "Commoner",
+                        "appearance": "Stocky with copper beard",
+                    },
+                    "personality": {"traits": ["Gruff", "Loyal"]},
+                    "behavior": {"goals": ["Run the tavern"]},
+                }
+            )
+            mock_get.return_value = mock_app
+
+            npcs = await create_npcs_from_concepts(concepts)
+
+            assert len(npcs) == 1
+            assert npcs[0]["name"] == "Thorin Ironfoot"
+            assert npcs[0]["race"] == "Dwarf"
+
+    @pytest.mark.asyncio
+    async def test_handles_creation_errors_gracefully(self):
+        """Should return fallback NPC on error."""
+        from examples.npc.api.session import create_npcs_from_concepts
+
+        concepts = [
+            {"concept": "a mysterious elf", "race": "Elf"},
+        ]
+
+        with patch("examples.npc.api.session.get_npc_creation_graph") as mock_get:
+            mock_app = MagicMock()
+            mock_app.ainvoke = AsyncMock(side_effect=Exception("Graph failed"))
+            mock_get.return_value = mock_app
+
+            npcs = await create_npcs_from_concepts(concepts)
+
+            assert len(npcs) == 1
+            assert "error" in npcs[0]
+            assert npcs[0]["race"] == "Elf"

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