yamlgraph 0.1.1__py3-none-any.whl

tests/unit/test_agent_nodes.py

@@ -0,0 +1,200 @@
+"""Tests for agent nodes (type: agent).
+
+Agent nodes allow the LLM to autonomously decide which tools to call
+in a loop until it has enough information to respond.
+"""
+
+from unittest.mock import MagicMock, patch
+
+from yamlgraph.tools.agent import build_langchain_tool, create_agent_node
+from yamlgraph.tools.shell import ShellToolConfig
+
+
+class TestBuildLangchainTool:
+    """Tests for build_langchain_tool function."""
+
+    def test_creates_tool_with_name(self):
+        """Tool has correct name."""
+        config = ShellToolConfig(
+            command="echo test",
+            description="Test tool",
+        )
+        tool = build_langchain_tool("my_tool", config)
+        assert tool.name == "my_tool"
+
+    def test_creates_tool_with_description(self):
+        """Tool has correct description."""
+        config = ShellToolConfig(
+            command="echo test",
+            description="A helpful test tool",
+        )
+        tool = build_langchain_tool("test", config)
+        assert tool.description == "A helpful test tool"
+
+    def test_tool_executes_command(self):
+        """Tool invocation runs shell command."""
+        config = ShellToolConfig(
+            command="echo {message}",
+            description="Echo a message",
+        )
+        tool = build_langchain_tool("echo", config)
+        result = tool.invoke({"message": "hello"})
+        assert "hello" in result
+
+
+class TestCreateAgentNode:
+    """Tests for create_agent_node function."""
+
+    @patch("yamlgraph.tools.agent.create_llm")
+    def test_agent_completes_without_tools(self, mock_create_llm):
+        """Agent can finish with no tool calls."""
+        # Mock LLM that returns a direct answer (no tool calls)
+        mock_llm = MagicMock()
+        mock_response = MagicMock()
+        mock_response.tool_calls = []
+        mock_response.content = "The answer is 42"
+        mock_llm.bind_tools.return_value = mock_llm
+        mock_llm.invoke.return_value = mock_response
+        mock_create_llm.return_value = mock_llm
+
+        tools = {
+            "search": ShellToolConfig(command="echo search", description="Search"),
+        }
+        node_config = {
+            "prompt": "agent",
+            "tools": ["search"],
+            "max_iterations": 5,
+            "state_key": "result",
+        }
+
+        node_fn = create_agent_node("agent", node_config, tools)
+        result = node_fn({"input": "What is the meaning of life?"})
+
+        assert result["result"] == "The answer is 42"
+        assert result["_agent_iterations"] == 1
+
+    @patch("yamlgraph.tools.agent.create_llm")
+    def test_agent_calls_tool(self, mock_create_llm):
+        """LLM tool call executes shell command."""
+        # Mock LLM that first calls a tool, then returns answer
+        mock_llm = MagicMock()
+
+        # First response: call a tool
+        first_response = MagicMock()
+        first_response.tool_calls = [
+            {"id": "call1", "name": "echo", "args": {"message": "test"}}
+        ]
+        first_response.content = ""
+
+        # Second response: final answer
+        second_response = MagicMock()
+        second_response.tool_calls = []
+        second_response.content = "I echoed: test"
+
+        mock_llm.bind_tools.return_value = mock_llm
+        mock_llm.invoke.side_effect = [first_response, second_response]
+        mock_create_llm.return_value = mock_llm
+
+        tools = {
+            "echo": ShellToolConfig(command="echo {message}", description="Echo"),
+        }
+        node_config = {
+            "prompt": "agent",
+            "tools": ["echo"],
+            "max_iterations": 5,
+            "state_key": "result",
+        }
+
+        node_fn = create_agent_node("agent", node_config, tools)
+        result = node_fn({"input": "Echo something"})
+
+        assert result["result"] == "I echoed: test"
+        assert result["_agent_iterations"] == 2
+
+    @patch("yamlgraph.tools.agent.create_llm")
+    def test_max_iterations_enforced(self, mock_create_llm):
+        """Stops after max_iterations reached."""
+        # Mock LLM that always calls a tool (never finishes)
+        mock_llm = MagicMock()
+        mock_response = MagicMock()
+        mock_response.tool_calls = [
+            {"id": "call1", "name": "search", "args": {"query": "more"}}
+        ]
+        mock_response.content = "Still searching..."
+        mock_llm.bind_tools.return_value = mock_llm
+        mock_llm.invoke.return_value = mock_response
+        mock_create_llm.return_value = mock_llm
+
+        tools = {
+            "search": ShellToolConfig(command="echo searching", description="Search"),
+        }
+        node_config = {
+            "prompt": "agent",
+            "tools": ["search"],
+            "max_iterations": 3,
+            "state_key": "result",
+        }
+
+        node_fn = create_agent_node("agent", node_config, tools)
+        result = node_fn({"input": "Search forever"})
+
+        # Should stop at max_iterations
+        assert result["_agent_limit_reached"] is True
+        assert mock_llm.invoke.call_count == 3
+
+    @patch("yamlgraph.tools.agent.create_llm")
+    def test_tool_result_returned_to_llm(self, mock_create_llm):
+        """LLM sees tool output in next turn."""
+        mock_llm = MagicMock()
+
+        # First: call tool
+        first_response = MagicMock()
+        first_response.tool_calls = [
+            {"id": "call1", "name": "calc", "args": {"expr": "2+2"}}
+        ]
+        first_response.content = ""
+
+        # Second: answer based on tool result
+        second_response = MagicMock()
+        second_response.tool_calls = []
+        second_response.content = "The result is 4"
+
+        mock_llm.bind_tools.return_value = mock_llm
+        mock_llm.invoke.side_effect = [first_response, second_response]
+        mock_create_llm.return_value = mock_llm
+
+        tools = {
+            "calc": ShellToolConfig(
+                command="echo 4",  # Simulates python calc
+                description="Calculate",
+            ),
+        }
+        node_config = {
+            "prompt": "agent",
+            "tools": ["calc"],
+            "max_iterations": 5,
+            "state_key": "answer",
+        }
+
+        node_fn = create_agent_node("agent", node_config, tools)
+        node_fn({"input": "What is 2+2?"})
+
+        # Check that second invoke received messages with tool result
+        second_call_messages = mock_llm.invoke.call_args_list[1][0][0]
+        # Should have: system, user, ai (with tool call), tool result
+        assert len(second_call_messages) >= 4
+
+    def test_default_max_iterations(self):
+        """Default max_iterations is 5."""
+        tools = {
+            "test": ShellToolConfig(command="echo test", description="Test"),
+        }
+        node_config = {
+            "prompt": "agent",
+            "tools": ["test"],
+            # No max_iterations specified
+        }
+
+        # Just verify it doesn't fail - actual behavior tested above
+        node_fn = create_agent_node("agent", node_config, tools)
+        assert callable(node_fn)

tests/unit/test_checkpointer.py

@@ -0,0 +1,212 @@
+"""Tests for native LangGraph checkpointer integration."""
+
+from pathlib import Path
+
+
+class TestGetCheckpointer:
+    """Tests for get_checkpointer() function."""
+
+    def test_returns_sqlite_saver_instance(self, tmp_path: Path):
+        """Should return a SqliteSaver instance."""
+        from langgraph.checkpoint.sqlite import SqliteSaver
+
+        from yamlgraph.storage.checkpointer import get_checkpointer
+
+        db_path = tmp_path / "test.db"
+        checkpointer = get_checkpointer(db_path)
+
+        assert isinstance(checkpointer, SqliteSaver)
+
+    def test_creates_database_file(self, tmp_path: Path):
+        """Should create the database file on first use."""
+        from yamlgraph.storage.checkpointer import get_checkpointer
+
+        db_path = tmp_path / "test.db"
+        assert not db_path.exists()
+
+        checkpointer = get_checkpointer(db_path)
+        # Access connection to trigger file creation
+        _ = checkpointer
+
+        # File created when connection is made
+        assert db_path.exists()
+
+    def test_uses_default_path_when_none(self, monkeypatch, tmp_path: Path):
+        """Should use DATABASE_PATH when db_path is None."""
+        from yamlgraph.storage.checkpointer import get_checkpointer
+
+        # Monkeypatch the default path
+        default_db = tmp_path / "default.db"
+        monkeypatch.setattr("yamlgraph.storage.checkpointer.DATABASE_PATH", default_db)
+
+        checkpointer = get_checkpointer(None)
+        assert checkpointer is not None
+
+    def test_accepts_string_path(self, tmp_path: Path):
+        """Should accept string path as well as Path."""
+        from yamlgraph.storage.checkpointer import get_checkpointer
+
+        db_path = str(tmp_path / "test.db")
+        checkpointer = get_checkpointer(db_path)
+
+        assert checkpointer is not None
+
+
+class TestCheckpointerWithGraph:
+    """Tests for using checkpointer with a LangGraph StateGraph."""
+
+    def test_graph_compiles_with_checkpointer(self, tmp_path: Path):
+        """Graph should compile when checkpointer is provided."""
+        from typing import TypedDict
+
+        from langgraph.graph import END, StateGraph
+
+        from yamlgraph.storage.checkpointer import get_checkpointer
+
+        class SimpleState(TypedDict, total=False):
+            value: str
+
+        def node_fn(state: SimpleState) -> dict:
+            return {"value": "updated"}
+
+        workflow = StateGraph(SimpleState)
+        workflow.add_node("test", node_fn)
+        workflow.set_entry_point("test")
+        workflow.add_edge("test", END)
+
+        checkpointer = get_checkpointer(tmp_path / "test.db")
+        graph = workflow.compile(checkpointer=checkpointer)
+
+        assert graph is not None
+
+    def test_state_persists_with_thread_id(self, tmp_path: Path):
+        """State should persist when using thread_id in config."""
+        from typing import TypedDict
+
+        from langgraph.graph import END, StateGraph
+
+        from yamlgraph.storage.checkpointer import get_checkpointer
+
+        class CounterState(TypedDict, total=False):
+            count: int
+
+        def increment(state: CounterState) -> dict:
+            return {"count": state.get("count", 0) + 1}
+
+        workflow = StateGraph(CounterState)
+        workflow.add_node("increment", increment)
+        workflow.set_entry_point("increment")
+        workflow.add_edge("increment", END)
+
+        checkpointer = get_checkpointer(tmp_path / "test.db")
+        graph = workflow.compile(checkpointer=checkpointer)
+
+        config = {"configurable": {"thread_id": "test-thread-1"}}
+
+        # First invocation
+        result1 = graph.invoke({"count": 0}, config)
+        assert result1["count"] == 1
+
+        # State should be retrievable
+        state = graph.get_state(config)
+        assert state.values["count"] == 1
+
+    def test_get_state_history_returns_checkpoints(self, tmp_path: Path):
+        """get_state_history() should return checkpoint history."""
+        from typing import TypedDict
+
+        from langgraph.graph import END, StateGraph
+
+        from yamlgraph.storage.checkpointer import get_checkpointer
+
+        class StepState(TypedDict, total=False):
+            step: int
+
+        def step1(state: StepState) -> dict:
+            return {"step": 1}
+
+        def step2(state: StepState) -> dict:
+            return {"step": 2}
+
+        workflow = StateGraph(StepState)
+        workflow.add_node("step1", step1)
+        workflow.add_node("step2", step2)
+        workflow.set_entry_point("step1")
+        workflow.add_edge("step1", "step2")
+        workflow.add_edge("step2", END)
+
+        checkpointer = get_checkpointer(tmp_path / "test.db")
+        graph = workflow.compile(checkpointer=checkpointer)
+
+        config = {"configurable": {"thread_id": "history-test"}}
+        graph.invoke({}, config)
+
+        # Get history
+        history = list(graph.get_state_history(config))
+
+        # Should have multiple checkpoints (one per step + initial)
+        assert len(history) >= 2
+
+        # Most recent first
+        assert history[0].values["step"] == 2
+
+
+class TestGetStateHistory:
+    """Tests for get_state_history helper function."""
+
+    def test_returns_list_of_snapshots(self, tmp_path: Path):
+        """get_state_history should return list of StateSnapshot."""
+        from typing import TypedDict
+
+        from langgraph.graph import END, StateGraph
+
+        from yamlgraph.storage.checkpointer import get_checkpointer, get_state_history
+
+        class TestState(TypedDict, total=False):
+            data: str
+
+        def node(state: TestState) -> dict:
+            return {"data": "done"}
+
+        workflow = StateGraph(TestState)
+        workflow.add_node("test", node)
+        workflow.set_entry_point("test")
+        workflow.add_edge("test", END)
+
+        checkpointer = get_checkpointer(tmp_path / "test.db")
+        graph = workflow.compile(checkpointer=checkpointer)
+
+        thread_id = "history-helper-test"
+        config = {"configurable": {"thread_id": thread_id}}
+        graph.invoke({}, config)
+
+        history = get_state_history(graph, thread_id)
+
+        assert isinstance(history, list)
+        assert len(history) >= 1
+
+    def test_empty_history_for_unknown_thread(self, tmp_path: Path):
+        """Should return empty list for non-existent thread."""
+        from typing import TypedDict
+
+        from langgraph.graph import END, StateGraph
+
+        from yamlgraph.storage.checkpointer import get_checkpointer, get_state_history
+
+        class TestState(TypedDict, total=False):
+            data: str
+
+        def node(state: TestState) -> dict:
+            return {"data": "done"}
+
+        workflow = StateGraph(TestState)
+        workflow.add_node("test", node)
+        workflow.set_entry_point("test")
+        workflow.add_edge("test", END)
+
+        checkpointer = get_checkpointer(tmp_path / "test.db")
+        graph = workflow.compile(checkpointer=checkpointer)
+
+        history = get_state_history(graph, "non-existent-thread")
+
+        assert history == []

tests/unit/test_cli.py

@@ -0,0 +1,121 @@
+"""Tests for yamlgraph.cli module."""
+
+import argparse
+
+from yamlgraph.cli.validators import validate_run_args
+from yamlgraph.config import MAX_TOPIC_LENGTH, MAX_WORD_COUNT, MIN_WORD_COUNT
+
+
+class TestValidateRunArgs:
+    """Tests for validate_run_args function."""
+
+    def _create_args(self, topic="test topic", word_count=300, style="informative"):
+        """Helper to create args namespace."""
+        return argparse.Namespace(
+            topic=topic,
+            word_count=word_count,
+            style=style,
+        )
+
+    def test_valid_args(self):
+        """Valid arguments should pass validation."""
+        args = self._create_args()
+        assert validate_run_args(args) is True
+
+    def test_empty_topic(self):
+        """Empty topic should fail validation."""
+        args = self._create_args(topic="")
+        assert validate_run_args(args) is False
+
+    def test_whitespace_only_topic(self):
+        """Whitespace-only topic should fail validation."""
+        args = self._create_args(topic="   ")
+        assert validate_run_args(args) is False
+
+    def test_topic_too_long(self):
+        """Topic exceeding max length should be truncated with warning."""
+        long_topic = "x" * (MAX_TOPIC_LENGTH + 100)
+        args = self._create_args(topic=long_topic)
+        # Should pass but truncate the topic
+        assert validate_run_args(args) is True
+        assert len(args.topic) == MAX_TOPIC_LENGTH
+
+    def test_topic_at_max_length(self):
+        """Topic at max length should pass validation."""
+        max_topic = "x" * MAX_TOPIC_LENGTH
+        args = self._create_args(topic=max_topic)
+        assert validate_run_args(args) is True
+
+    def test_word_count_too_low(self):
+        """Word count below minimum should fail validation."""
+        args = self._create_args(word_count=MIN_WORD_COUNT - 1)
+        assert validate_run_args(args) is False
+
+    def test_word_count_too_high(self):
+        """Word count above maximum should fail validation."""
+        args = self._create_args(word_count=MAX_WORD_COUNT + 1)
+        assert validate_run_args(args) is False
+
+    def test_word_count_at_min(self):
+        """Word count at minimum should pass validation."""
+        args = self._create_args(word_count=MIN_WORD_COUNT)
+        assert validate_run_args(args) is True
+
+    def test_word_count_at_max(self):
+        """Word count at maximum should pass validation."""
+        args = self._create_args(word_count=MAX_WORD_COUNT)
+        assert validate_run_args(args) is True
+
+
+class TestFormatResult:
+    """Tests for generic result formatting."""
+
+    def test_format_result_with_any_pydantic_model(self, capsys):
+        """CLI should format any Pydantic model, not just known ones."""
+        from pydantic import BaseModel
+
+        from yamlgraph.cli.commands import _format_result
+
+        class CustomResult(BaseModel):
+            title: str
+            score: float
+            items: list[str]
+
+        result = {
+            "current_step": "done",
+            "custom": CustomResult(title="Test Title", score=0.95, items=["a", "b"]),
+        }
+
+        _format_result(result)
+        captured = capsys.readouterr()
+        assert "Test Title" in captured.out
+        assert "0.95" in captured.out
+
+    def test_format_result_skips_internal_keys(self, capsys):
+        """Internal keys should be skipped."""
+        from yamlgraph.cli.commands import _format_result
+
+        result = {
+            "current_step": "done",
+            "_route": "positive",
+            "_loop_counts": {"draft": 2},
+            "response": "Hello!",
+        }
+
+        _format_result(result)
+        captured = capsys.readouterr()
+        assert "_route" not in captured.out
+        assert "_loop_counts" not in captured.out
+        assert "Hello!" in captured.out
+
+    def test_format_result_truncates_long_strings(self, capsys):
+        """Long strings should be truncated."""
+        from yamlgraph.cli.commands import _format_result
+
+        long_text = "x" * 500
+        result = {"summary": long_text}
+
+        _format_result(result)
+        captured = capsys.readouterr()
+        assert "..." in captured.out
+        assert len(captured.out) < 400  # Truncated

tests/unit/test_cli_package.py

@@ -0,0 +1,81 @@
+"""Tests for CLI package structure (Phase 7.1).
+
+TDD tests for splitting cli.py into a cli/ package.
+"""
+
+import argparse
+
+# =============================================================================
+# Package Structure Tests
+# =============================================================================
+
+
+class TestCLIPackageStructure:
+    """Tests for CLI package imports."""
+
+    def test_cli_package_importable(self):
+        """yamlgraph.cli should be importable as package."""
+        import yamlgraph.cli
+
+        assert yamlgraph.cli is not None
+
+    def test_main_function_available(self):
+        """main() should be available from package."""
+        from yamlgraph.cli import main
+
+        assert callable(main)
+
+    def test_validators_submodule_exists(self):
+        """validators submodule should exist."""
+        from yamlgraph.cli import validators
+
+        assert validators is not None
+
+    def test_validate_run_args_in_validators(self):
+        """validate_run_args should be in validators module."""
+        from yamlgraph.cli.validators import validate_run_args
+
+        assert callable(validate_run_args)
+
+    def test_commands_submodule_exists(self):
+        """commands submodule should exist."""
+        from yamlgraph.cli import commands
+
+        assert commands is not None
+
+    def test_cmd_list_runs_in_commands(self):
+        """cmd_list_runs should be in commands module."""
+        from yamlgraph.cli.commands import cmd_list_runs
+
+        assert callable(cmd_list_runs)
+
+
+# =============================================================================
+# Validator Tests (moved from cli module)
+# =============================================================================
+
+
+class TestValidatorsModule:
+    """Tests for validators module functionality."""
+
+    def _create_run_args(self, topic="test topic", word_count=300, style="informative"):
+        """Helper to create run args namespace."""
+        return argparse.Namespace(
+            topic=topic,
+            word_count=word_count,
+            style=style,
+        )
+
+    def test_validate_run_args_valid(self):
+        """Valid run args pass validation."""
+        from yamlgraph.cli.validators import validate_run_args
+
+        args = self._create_run_args()
+        assert validate_run_args(args) is True
+
+    def test_validate_run_args_empty_topic(self):
+        """Empty topic fails validation."""
+        from yamlgraph.cli.validators import validate_run_args
+
+        args = self._create_run_args(topic="")
+        assert validate_run_args(args) is False