yamlgraph 0.3.9__py3-none-any.whl

tests/integration/test_memory_demo.py

@@ -0,0 +1,283 @@
+"""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),
+            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_npc_api/__init__.py

@@ -0,0 +1 @@
+"""Integration tests for NPC Web API."""

tests/integration/test_npc_api/test_routes.py

@@ -0,0 +1,357 @@
+"""Tests for NPC encounter API routes.
+
+Tests endpoint behavior, HTMX responses, and session handling.
+Uses mocking to avoid actual LLM calls.
+"""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+from httpx import ASGITransport, AsyncClient
+
+
+@pytest.fixture
+def mock_turn_result():
+    """Create mock TurnResult."""
+    from examples.npc.api.session import TurnResult
+
+    return TurnResult(
+        turn_number=1,
+        narrations=[{"npc": "Grok", "text": "Hello traveler!"}],
+        scene_image="/static/images/tavern.png",
+        turn_summary="The party enters the tavern.",
+        is_complete=False,
+    )
+
+
+class TestEncounterStart:
+    """Tests for POST /encounter/start endpoint."""
+
+    @pytest.mark.asyncio
+    async def test_start_requires_session_id(self):
+        """Start endpoint validates required session_id."""
+        from examples.npc.api.routes.encounter import router
+
+        app = FastAPI()
+        app.include_router(router)
+
+        transport = ASGITransport(app=app)
+        async with AsyncClient(transport=transport, base_url="http://test") as client:
+            response = await client.post(
+                "/encounter/start",
+                data={"location": "tavern"},  # Missing session_id
+            )
+
+        # FastAPI returns 422 for validation errors
+        assert response.status_code == 422
+
+    @pytest.mark.asyncio
+    async def test_start_accepts_valid_input(self, mock_turn_result):
+        """Start endpoint accepts valid form data."""
+        from examples.npc.api.routes import encounter
+
+        # Mock the dependencies
+        mock_session = AsyncMock()
+        mock_session.start = AsyncMock(return_value=mock_turn_result)
+
+        async def mock_get_session(session_id):
+            return mock_session
+
+        # Mock create_npcs_from_concepts to return simple NPCs
+        async def mock_create_npcs(concepts):
+            return [{"name": "Grok", "race": "dwarf"}]
+
+        # Patch the module-level functions
+        with (
+            patch.object(encounter, "_get_session", mock_get_session),
+            patch.object(encounter, "create_npcs_from_concepts", mock_create_npcs),
+            patch.object(encounter, "templates") as mock_tmpl,
+        ):
+            # Configure mock template to return proper Response
+            mock_tmpl.TemplateResponse.return_value = HTMLResponse(
+                content="<div>Started</div>",
+                headers={"HX-Trigger": "encounter-updated"},
+            )
+
+            app = FastAPI()
+            app.include_router(encounter.router)
+
+            transport = ASGITransport(app=app)
+            async with AsyncClient(
+                transport=transport, base_url="http://test"
+            ) as client:
+                response = await client.post(
+                    "/encounter/start",
+                    data={
+                        "session_id": "test-123",
+                        "location": "tavern",
+                        "npc_concepts": ["a gruff dwarf"],
+                    },
+                )
+
+            assert response.status_code == 200
+            assert mock_session.start.called
+
+    @pytest.mark.asyncio
+    async def test_start_creates_npcs_from_concepts(self, mock_turn_result):
+        """Start endpoint creates NPCs from concept strings."""
+        from examples.npc.api.routes import encounter
+
+        mock_session = AsyncMock()
+        mock_session.start = AsyncMock(return_value=mock_turn_result)
+
+        create_npcs_called_with = []
+
+        async def mock_create_npcs(concepts):
+            create_npcs_called_with.extend(concepts)
+            return [{"name": f"NPC-{i}", "race": "test"} for i in range(len(concepts))]
+
+        with (
+            patch.object(
+                encounter, "_get_session", AsyncMock(return_value=mock_session)
+            ),
+            patch.object(encounter, "create_npcs_from_concepts", mock_create_npcs),
+            patch.object(encounter, "templates") as mock_tmpl,
+        ):
+            mock_tmpl.TemplateResponse.return_value = HTMLResponse(
+                content="<div>OK</div>"
+            )
+
+            app = FastAPI()
+            app.include_router(encounter.router)
+
+            transport = ASGITransport(app=app)
+            async with AsyncClient(
+                transport=transport, base_url="http://test"
+            ) as client:
+                await client.post(
+                    "/encounter/start",
+                    data={
+                        "session_id": "test-123",
+                        "location": "tavern",
+                        "npc_concepts": ["a dwarf", "an elf"],
+                    },
+                )
+
+            # Should have called create_npcs with concept dicts
+            assert len(create_npcs_called_with) == 2
+            assert create_npcs_called_with[0]["concept"] == "a dwarf"
+
+
+class TestEncounterTurn:
+    """Tests for POST /encounter/turn endpoint."""
+
+    @pytest.mark.asyncio
+    async def test_turn_requires_dm_input(self):
+        """Turn endpoint validates required dm_input."""
+        from examples.npc.api.routes.encounter import router
+
+        app = FastAPI()
+        app.include_router(router)
+
+        transport = ASGITransport(app=app)
+        async with AsyncClient(transport=transport, base_url="http://test") as client:
+            response = await client.post(
+                "/encounter/turn",
+                data={"session_id": "test-123"},  # Missing dm_input
+            )
+
+        # FastAPI returns 422 for validation errors
+        assert response.status_code == 422
+
+    @pytest.mark.asyncio
+    async def test_turn_resumes_existing_session(self, mock_turn_result):
+        """Turn endpoint resumes existing session."""
+        from examples.npc.api.routes import encounter
+
+        mock_session = AsyncMock()
+        mock_session._is_resume = AsyncMock(return_value=True)  # Session exists
+        mock_session.turn = AsyncMock(return_value=mock_turn_result)
+
+        with (
+            patch.object(
+                encounter, "_get_session", AsyncMock(return_value=mock_session)
+            ),
+            patch.object(encounter, "templates") as mock_tmpl,
+        ):
+            mock_tmpl.TemplateResponse.return_value = HTMLResponse(
+                content="<div>Turn</div>"
+            )
+
+            app = FastAPI()
+            app.include_router(encounter.router)
+
+            transport = ASGITransport(app=app)
+            async with AsyncClient(
+                transport=transport, base_url="http://test"
+            ) as client:
+                response = await client.post(
+                    "/encounter/turn",
+                    data={
+                        "session_id": "test-123",
+                        "dm_input": "The party enters the tavern",
+                    },
+                )
+
+            assert response.status_code == 200
+            assert mock_session.turn.called
+            mock_session.turn.assert_called_once_with("The party enters the tavern")
+
+    @pytest.mark.asyncio
+    async def test_turn_handles_no_session(self, mock_turn_result):
+        """Turn on non-existent session returns error."""
+        from examples.npc.api.routes import encounter
+
+        mock_session = AsyncMock()
+        mock_session._is_resume = AsyncMock(return_value=False)  # Session doesn't exist
+
+        with (
+            patch.object(
+                encounter, "_get_session", AsyncMock(return_value=mock_session)
+            ),
+            patch.object(encounter, "templates") as mock_tmpl,
+        ):
+            mock_tmpl.TemplateResponse.return_value = HTMLResponse(
+                content="<div>Error</div>",
+                status_code=400,
+            )
+
+            app = FastAPI()
+            app.include_router(encounter.router)
+
+            transport = ASGITransport(app=app)
+            async with AsyncClient(
+                transport=transport, base_url="http://test"
+            ) as client:
+                response = await client.post(
+                    "/encounter/turn",
+                    data={
+                        "session_id": "nonexistent",
+                        "dm_input": "Hello",
+                    },
+                )
+
+            # Should return 400 error
+            assert response.status_code == 400
+
+
+class TestEncounterState:
+    """Tests for GET /encounter/{session_id} endpoint."""
+
+    @pytest.mark.asyncio
+    async def test_get_nonexistent_session_returns_404(self):
+        """GET non-existent session returns 404."""
+        from examples.npc.api.routes import encounter
+
+        mock_session = AsyncMock()
+        mock_session._is_resume = AsyncMock(return_value=False)
+
+        with patch.object(
+            encounter, "_get_session", AsyncMock(return_value=mock_session)
+        ):
+            app = FastAPI()
+            app.include_router(encounter.router)
+
+            transport = ASGITransport(app=app)
+            async with AsyncClient(
+                transport=transport, base_url="http://test"
+            ) as client:
+                response = await client.get("/encounter/nonexistent")
+
+            assert response.status_code == 404
+
+    @pytest.mark.asyncio
+    async def test_get_state_returns_current_state(self):
+        """GET state endpoint returns current session state."""
+        from examples.npc.api.routes import encounter
+
+        mock_session = AsyncMock()
+        mock_session._is_resume = AsyncMock(return_value=True)
+
+        # Mock the graph for aget_state
+        mock_graph = AsyncMock()
+        mock_graph.aget_state = AsyncMock(
+            return_value=AsyncMock(
+                values={
+                    "turn_number": 2,
+                    "narrations": [],
+                    "npcs": [],
+                    "location": "tavern",
+                }
+            )
+        )
+
+        with (
+            patch.object(
+                encounter, "_get_session", AsyncMock(return_value=mock_session)
+            ),
+            patch.object(
+                encounter, "get_encounter_graph", AsyncMock(return_value=mock_graph)
+            ),
+            patch.object(encounter, "templates") as mock_tmpl,
+        ):
+            mock_tmpl.TemplateResponse.return_value = HTMLResponse(
+                content="<div>State</div>"
+            )
+
+            app = FastAPI()
+            app.include_router(encounter.router)
+
+            transport = ASGITransport(app=app)
+            async with AsyncClient(
+                transport=transport, base_url="http://test"
+            ) as client:
+                response = await client.get("/encounter/test-123")
+
+            assert response.status_code == 200
+
+
+class TestHtmxIntegration:
+    """Tests for HTMX-specific behavior."""
+
+    @pytest.mark.asyncio
+    async def test_response_has_hx_trigger_header(self, mock_turn_result):
+        """Responses include HX-Trigger for client-side updates."""
+        from examples.npc.api.routes import encounter
+
+        mock_session = AsyncMock()
+        mock_session.start = AsyncMock(return_value=mock_turn_result)
+
+        with (
+            patch.object(
+                encounter, "_get_session", AsyncMock(return_value=mock_session)
+            ),
+            patch.object(
+                encounter,
+                "create_npcs_from_concepts",
+                AsyncMock(return_value=[{"name": "Grok"}]),
+            ),
+            patch.object(encounter, "templates") as mock_tmpl,
+        ):
+            # Return response with HX-Trigger header
+            mock_tmpl.TemplateResponse.return_value = HTMLResponse(
+                content="<div>Response</div>",
+                headers={"HX-Trigger": "encounter-updated"},
+            )
+
+            app = FastAPI()
+            app.include_router(encounter.router)
+
+            transport = ASGITransport(app=app)
+            async with AsyncClient(
+                transport=transport, base_url="http://test"
+            ) as client:
+                response = await client.post(
+                    "/encounter/start",
+                    data={
+                        "session_id": "test-123",
+                        "location": "tavern",
+                        "npc_concepts": ["a dwarf"],
+                    },
+                )
+
+            assert response.status_code == 200
+            assert "HX-Trigger" in response.headers
+            assert response.headers["HX-Trigger"] == "encounter-updated"