yamlgraph 0.3.9__py3-none-any.whl

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_checkpointer_factory.py

@@ -0,0 +1,212 @@
+"""Unit tests for checkpointer factory.
+
+TDD tests for 002: Redis Checkpointer feature.
+Tests get_checkpointer() factory with env var expansion and async mode.
+"""
+
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from yamlgraph.storage.checkpointer_factory import (
+    expand_env_vars,
+    get_checkpointer,
+)
+
+
+class TestExpandEnvVars:
+    """Test environment variable expansion."""
+
+    def test_expand_single_var(self):
+        """Should expand ${VAR} pattern."""
+        with patch.dict(os.environ, {"REDIS_URL": "redis://localhost:6379"}):
+            result = expand_env_vars("${REDIS_URL}")
+            assert result == "redis://localhost:6379"
+
+    def test_expand_multiple_vars(self):
+        """Should expand multiple ${VAR} patterns."""
+        with patch.dict(os.environ, {"HOST": "localhost", "PORT": "6379"}):
+            result = expand_env_vars("redis://${HOST}:${PORT}/0")
+            assert result == "redis://localhost:6379/0"
+
+    def test_expand_missing_var_keeps_original(self):
+        """Missing env vars should keep original ${VAR} pattern."""
+        # Ensure NONEXISTENT is not set
+        os.environ.pop("NONEXISTENT", None)
+        result = expand_env_vars("${NONEXISTENT}")
+        assert result == "${NONEXISTENT}"
+
+    def test_expand_non_string_returns_unchanged(self):
+        """Non-string values should pass through unchanged."""
+        assert expand_env_vars(123) == 123
+        assert expand_env_vars(None) is None
+        assert expand_env_vars(["a", "b"]) == ["a", "b"]
+
+    def test_expand_no_vars_returns_original(self):
+        """String without ${} should return unchanged."""
+        result = expand_env_vars("redis://localhost:6379")
+        assert result == "redis://localhost:6379"
+
+    def test_expand_empty_string(self):
+        """Empty string should return empty string."""
+        assert expand_env_vars("") == ""
+
+
+class TestGetCheckpointerMemory:
+    """Test in-memory checkpointer (default)."""
+
+    def test_memory_checkpointer_default(self):
+        """Default type should be memory."""
+        config = {"type": "memory"}  # Empty config defaults to memory via get
+        saver = get_checkpointer(config)
+
+        from langgraph.checkpoint.memory import InMemorySaver
+
+        assert isinstance(saver, InMemorySaver)
+
+    def test_memory_checkpointer_explicit(self):
+        """Explicit type: memory should work."""
+        config = {"type": "memory"}
+        saver = get_checkpointer(config)
+
+        from langgraph.checkpoint.memory import InMemorySaver
+
+        assert isinstance(saver, InMemorySaver)
+
+    def test_none_config_returns_none(self):
+        """None config should return None."""
+        assert get_checkpointer(None) is None
+
+
+class TestGetCheckpointerSqlite:
+    """Test SQLite checkpointer."""
+
+    def test_sqlite_checkpointer_memory(self):
+        """SQLite with :memory: should work."""
+        config = {"type": "sqlite", "path": ":memory:"}
+        saver = get_checkpointer(config)
+
+        from langgraph.checkpoint.sqlite import SqliteSaver
+
+        assert isinstance(saver, SqliteSaver)
+
+    def test_sqlite_expands_env_var(self):
+        """SQLite path should expand env vars."""
+        with patch.dict(os.environ, {"DB_PATH": ":memory:"}):
+            config = {"type": "sqlite", "path": "${DB_PATH}"}
+            saver = get_checkpointer(config)
+
+            from langgraph.checkpoint.sqlite import SqliteSaver
+
+            assert isinstance(saver, SqliteSaver)
+
+
+class TestGetCheckpointerRedis:
+    """Test Redis checkpointer (mocked)."""
+
+    def test_redis_checkpointer_sync(self):
+        """Redis sync saver should be created."""
+        mock_saver = MagicMock()
+        mock_redis_module = MagicMock()
+        mock_redis_module.RedisSaver.from_conn_string.return_value = mock_saver
+
+        with patch.dict(
+            "sys.modules", {"langgraph.checkpoint.redis": mock_redis_module}
+        ):
+            # Re-import to pick up mocked module
+            import importlib
+
+            from yamlgraph.storage import checkpointer_factory
+
+            importlib.reload(checkpointer_factory)
+
+            with patch.dict(os.environ, {"REDIS_URL": "redis://localhost:6379"}):
+                config = {"type": "redis", "url": "${REDIS_URL}", "ttl": 120}
+                saver = checkpointer_factory.get_checkpointer(config)
+
+                mock_redis_module.RedisSaver.from_conn_string.assert_called_once_with(
+                    "redis://localhost:6379",
+                    ttl={"default_ttl": 120},
+                )
+                mock_saver.setup.assert_called_once()
+                assert saver is mock_saver
+
+    def test_redis_checkpointer_async(self):
+        """Redis async saver should be created with async_mode=True."""
+        mock_saver = MagicMock()
+        mock_aio_module = MagicMock()
+        mock_aio_module.AsyncRedisSaver.from_conn_string.return_value = mock_saver
+
+        with patch.dict(
+            "sys.modules", {"langgraph.checkpoint.redis.aio": mock_aio_module}
+        ):
+            import importlib
+
+            from yamlgraph.storage import checkpointer_factory
+
+            importlib.reload(checkpointer_factory)
+
+            config = {"type": "redis", "url": "redis://localhost:6379", "ttl": 60}
+            saver = checkpointer_factory.get_checkpointer(config, async_mode=True)
+
+            mock_aio_module.AsyncRedisSaver.from_conn_string.assert_called_once_with(
+                "redis://localhost:6379",
+                ttl={"default_ttl": 60},
+            )
+            # Async saver should NOT call setup() - caller must await asetup()
+            mock_saver.setup.assert_not_called()
+            assert saver is mock_saver
+
+    def test_redis_import_error_helpful_message(self):
+        """Missing redis package should give helpful error."""
+        # Clear any cached imports
+        import sys
+
+        for key in list(sys.modules.keys()):
+            if "langgraph.checkpoint.redis" in key:
+                del sys.modules[key]
+
+        # This test verifies the ImportError wrapping
+        config = {"type": "redis", "url": "redis://localhost:6379"}
+
+        with pytest.raises(ImportError) as exc_info:
+            get_checkpointer(config)
+
+        assert "pip install yamlgraph[redis]" in str(exc_info.value)
+
+    def test_redis_default_ttl(self):
+        """Redis should use default TTL of 60 if not specified."""
+        mock_saver = MagicMock()
+        mock_redis_module = MagicMock()
+        mock_redis_module.RedisSaver.from_conn_string.return_value = mock_saver
+
+        with patch.dict(
+            "sys.modules", {"langgraph.checkpoint.redis": mock_redis_module}
+        ):
+            import importlib
+
+            from yamlgraph.storage import checkpointer_factory
+
+            importlib.reload(checkpointer_factory)
+
+            config = {"type": "redis", "url": "redis://localhost:6379"}
+            checkpointer_factory.get_checkpointer(config)
+
+            mock_redis_module.RedisSaver.from_conn_string.assert_called_once_with(
+                "redis://localhost:6379",
+                ttl={"default_ttl": 60},
+            )
+
+
+class TestGetCheckpointerErrors:
+    """Test error handling."""
+
+    def test_unknown_type_raises_error(self):
+        """Unknown checkpointer type should raise ValueError."""
+        config = {"type": "unknown_db"}
+
+        with pytest.raises(ValueError) as exc_info:
+            get_checkpointer(config)
+
+        assert "Unknown checkpointer type: unknown_db" in str(exc_info.value)

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