yamlgraph 0.1.1__py3-none-any.whl

tests/unit/test_compile_graph_map.py

@@ -0,0 +1,132 @@
+"""Integration tests for compile_graph with map nodes."""
+
+from unittest.mock import MagicMock, patch
+
+from yamlgraph.graph_loader import GraphConfig, compile_graph
+
+
+def make_graph_config(nodes: dict, edges: list) -> GraphConfig:
+    """Helper to create GraphConfig from nodes and edges."""
+    config_dict = {
+        "name": "test-map",
+        "version": "0.1",
+        "nodes": nodes,
+        "edges": edges,
+    }
+    return GraphConfig(config_dict)
+
+
+def make_map_node_config(collect: str = "results") -> dict:
+    """Helper to create a valid map node config."""
+    return {
+        "type": "map",
+        "over": "{state.items}",
+        "as": "item",
+        "node": {"prompt": "process", "state_key": "result"},
+        "collect": collect,
+    }
+
+
+class TestCompileGraphMap:
+    """Tests for compile_graph handling type: map nodes."""
+
+    def test_map_node_compiled_to_graph(self) -> None:
+        """Map node is correctly added to graph."""
+        config = make_graph_config(
+            nodes={
+                "start_node": {"prompt": "generate", "state_key": "items"},
+                "process_items": make_map_node_config(),
+            },
+            edges=[
+                {"from": "START", "to": "start_node"},
+                {"from": "start_node", "to": "process_items"},
+                {"from": "process_items", "to": "END"},
+            ],
+        )
+
+        with patch("yamlgraph.graph_loader.compile_map_node") as mock_compile_map:
+            # Setup mock return value
+            mock_map_edge_fn = MagicMock()
+            mock_compile_map.return_value = (mock_map_edge_fn, "_map_process_items_sub")
+
+            compile_graph(config)
+
+            # verify compile_map_node was called with map node config
+            mock_compile_map.assert_called_once()
+            call_args = mock_compile_map.call_args
+            assert call_args[0][0] == "process_items"  # name
+            assert call_args[0][1]["type"] == "map"  # config
+
+    def test_map_node_sub_node_added(self) -> None:
+        """Map node's wrapped sub_node is added to graph."""
+        config = make_graph_config(
+            nodes={
+                "start_node": {"prompt": "generate", "state_key": "items"},
+                "map_node": make_map_node_config(),
+            },
+            edges=[
+                {"from": "START", "to": "start_node"},
+                {"from": "start_node", "to": "map_node"},
+                {"from": "map_node", "to": "END"},
+            ],
+        )
+
+        with patch("yamlgraph.graph_loader.compile_map_node") as mock_compile_map:
+            mock_map_edge_fn = MagicMock()
+            mock_compile_map.return_value = (mock_map_edge_fn, "_map_map_node_sub")
+
+            compile_graph(config)
+
+            # Check sub node was added by compile_map_node
+            # (the mocked compile_map_node adds it via the builder)
+            # In the real implementation, compile_map_node adds the node
+
+    def test_map_node_conditional_edge_wired(self) -> None:
+        """Map node predecessor gets conditional edge with Send function."""
+        config = make_graph_config(
+            nodes={
+                "start_node": {"prompt": "generate", "state_key": "items"},
+                "map_node": make_map_node_config(),
+                "final_node": {"prompt": "summarize", "state_key": "summary"},
+            },
+            edges=[
+                {"from": "START", "to": "start_node"},
+                {"from": "start_node", "to": "map_node"},
+                {"from": "map_node", "to": "final_node"},
+                {"from": "final_node", "to": "END"},
+            ],
+        )
+
+        with patch("yamlgraph.graph_loader.compile_map_node") as mock_compile_map:
+            mock_map_edge_fn = MagicMock()
+            mock_compile_map.return_value = (mock_map_edge_fn, "_map_map_node_sub")
+
+            # For fan-in, we need to verify sub_node -> next_node edge is created
+            compile_graph(config)
+
+            # The graph should have conditional edge from start_node using map_edge_fn
+
+    def test_map_node_fanin_edge_wired(self) -> None:
+        """Map sub_node has edge to next node for fan-in."""
+        config = make_graph_config(
+            nodes={
+                "start_node": {"prompt": "generate", "state_key": "items"},
+                "map_node": make_map_node_config(),
+                "final_node": {"prompt": "summarize", "state_key": "summary"},
+            },
+            edges=[
+                {"from": "START", "to": "start_node"},
+                {"from": "start_node", "to": "map_node"},
+                {"from": "map_node", "to": "final_node"},
+                {"from": "final_node", "to": "END"},
+            ],
+        )
+
+        with patch("yamlgraph.graph_loader.compile_map_node") as mock_compile_map:
+            mock_map_edge_fn = MagicMock()
+            mock_compile_map.return_value = (mock_map_edge_fn, "_map_map_node_sub")
+
+            # For fan-in, we need to verify sub_node -> next_node edge is created
+            compile_graph(config)
+
+            # We'll verify by examining the graph's edges

tests/unit/test_conditions_routing.py

@@ -0,0 +1,253 @@
+"""Unit tests for conditions and routing modules.
+
+Tests the expression evaluation and routing functions used for
+graph edge conditions.
+
+Note: resolve_value tests are in test_expressions.py (TestResolveStatePath)
+since resolve_value delegates to resolve_state_path.
+"""
+
+import pytest
+from pydantic import BaseModel
+
+from yamlgraph.routing import make_expr_router_fn, make_router_fn
+from yamlgraph.utils.conditions import (
+    evaluate_comparison,
+    evaluate_condition,
+    parse_literal,
+)
+
+
+class TestParseLiteral:
+    """Tests for parse_literal function."""
+
+    def test_integer(self):
+        """Should parse integer."""
+        assert parse_literal("42") == 42
+        assert parse_literal("-5") == -5
+
+    def test_float(self):
+        """Should parse float."""
+        assert parse_literal("0.8") == 0.8
+        assert parse_literal("-3.14") == -3.14
+
+    def test_boolean_true(self):
+        """Should parse boolean true (case insensitive)."""
+        assert parse_literal("true") is True
+        assert parse_literal("True") is True
+        assert parse_literal("TRUE") is True
+
+    def test_boolean_false(self):
+        """Should parse boolean false."""
+        assert parse_literal("false") is False
+        assert parse_literal("False") is False
+
+    def test_null_none(self):
+        """Should parse null/none."""
+        assert parse_literal("null") is None
+        assert parse_literal("None") is None
+
+    def test_quoted_string(self):
+        """Should parse quoted strings."""
+        assert parse_literal('"hello"') == "hello"
+        assert parse_literal("'world'") == "world"
+
+    def test_unquoted_string(self):
+        """Should return unquoted string as-is."""
+        assert parse_literal("hello") == "hello"
+
+
+class TestEvaluateComparison:
+    """Tests for evaluate_comparison function."""
+
+    def test_less_than(self):
+        """Should evaluate < operator."""
+        state = {"score": 0.5}
+        assert evaluate_comparison("score", "<", "0.8", state) is True
+        assert evaluate_comparison("score", "<", "0.3", state) is False
+
+    def test_greater_than(self):
+        """Should evaluate > operator."""
+        state = {"score": 0.9}
+        assert evaluate_comparison("score", ">", "0.5", state) is True
+        assert evaluate_comparison("score", ">", "1.0", state) is False
+
+    def test_less_than_or_equal(self):
+        """Should evaluate <= operator."""
+        state = {"value": 5}
+        assert evaluate_comparison("value", "<=", "5", state) is True
+        assert evaluate_comparison("value", "<=", "10", state) is True
+        assert evaluate_comparison("value", "<=", "3", state) is False
+
+    def test_greater_than_or_equal(self):
+        """Should evaluate >= operator."""
+        state = {"value": 5}
+        assert evaluate_comparison("value", ">=", "5", state) is True
+        assert evaluate_comparison("value", ">=", "3", state) is True
+        assert evaluate_comparison("value", ">=", "10", state) is False
+
+    def test_equal(self):
+        """Should evaluate == operator."""
+        state = {"status": "done", "count": 3}
+        assert evaluate_comparison("status", "==", '"done"', state) is True
+        assert evaluate_comparison("count", "==", "3", state) is True
+        assert evaluate_comparison("status", "==", '"pending"', state) is False
+
+    def test_not_equal(self):
+        """Should evaluate != operator."""
+        state = {"status": "done"}
+        assert evaluate_comparison("status", "!=", '"pending"', state) is True
+        assert evaluate_comparison("status", "!=", '"done"', state) is False
+
+    def test_missing_value_returns_false(self):
+        """Missing value should return False for comparison (except ==, !=)."""
+        state = {"a": 1}
+        assert evaluate_comparison("missing", "<", "5", state) is False
+        assert evaluate_comparison("missing", ">", "5", state) is False
+
+    def test_missing_value_equals_none(self):
+        """Missing value equals None."""
+        state = {"a": 1}
+        assert evaluate_comparison("missing", "==", "None", state) is True
+
+    def test_type_mismatch_returns_false(self):
+        """Type mismatch in comparison should return False."""
+        state = {"value": "not_a_number"}
+        assert evaluate_comparison("value", "<", "5", state) is False
+
+
+class TestEvaluateCondition:
+    """Tests for evaluate_condition function."""
+
+    def test_simple_comparison(self):
+        """Should evaluate simple comparison."""
+        assert evaluate_condition("score < 0.8", {"score": 0.5}) is True
+        assert evaluate_condition("score >= 0.8", {"score": 0.9}) is True
+
+    def test_nested_path(self):
+        """Should evaluate nested path comparison."""
+        state = {"critique": {"score": 0.7}}
+        assert evaluate_condition("critique.score < 0.8", state) is True
+        assert evaluate_condition("critique.score >= 0.8", state) is False
+
+    def test_compound_and(self):
+        """Should evaluate AND expression."""
+        state = {"a": 5, "b": 10}
+        assert evaluate_condition("a > 1 and b < 20", state) is True
+        assert evaluate_condition("a > 1 and b > 20", state) is False
+        assert evaluate_condition("a > 10 and b < 20", state) is False
+
+    def test_compound_or(self):
+        """Should evaluate OR expression."""
+        state = {"a": 5, "b": 10}
+        assert evaluate_condition("a > 10 or b < 20", state) is True
+        assert evaluate_condition("a > 1 or b > 100", state) is True
+        assert evaluate_condition("a > 10 or b > 100", state) is False
+
+    def test_mixed_and_or(self):
+        """Should handle mixed AND/OR (AND has higher precedence)."""
+        state = {"a": 5, "b": 10, "c": 15}
+        # a > 10 OR (b < 20 AND c > 10) -> False OR True -> True
+        assert evaluate_condition("a > 10 or b < 20 and c > 10", state) is True
+
+    def test_whitespace_handling(self):
+        """Should handle various whitespace."""
+        state = {"score": 0.5}
+        assert evaluate_condition("  score   <   0.8  ", state) is True
+        assert evaluate_condition("score<0.8", state) is True
+
+    def test_invalid_expression_raises(self):
+        """Should raise ValueError for invalid expression."""
+        with pytest.raises(ValueError, match="Invalid condition"):
+            evaluate_condition("not a valid expression !!!", {})
+
+    def test_pydantic_model_in_state(self):
+        """Should work with Pydantic models in state."""
+
+        class Critique(BaseModel):
+            score: float
+
+        state = {"critique": Critique(score=0.75)}
+        assert evaluate_condition("critique.score < 0.8", state) is True
+        assert evaluate_condition("critique.score >= 0.8", state) is False
+
+
+class TestMakeRouterFn:
+    """Tests for make_router_fn factory."""
+
+    def test_routes_to_matching_target(self):
+        """Should route to target matching _route."""
+        router = make_router_fn(["positive", "negative", "neutral"])
+        assert router({"_route": "positive"}) == "positive"
+        assert router({"_route": "negative"}) == "negative"
+
+    def test_defaults_to_first_target(self):
+        """Should default to first target when no match."""
+        router = make_router_fn(["a", "b", "c"])
+        assert router({"_route": "unknown"}) == "a"
+        assert router({}) == "a"
+
+    def test_ignores_invalid_route(self):
+        """Should ignore route not in targets."""
+        router = make_router_fn(["x", "y"])
+        assert router({"_route": "z"}) == "x"
+
+
+class TestMakeExprRouterFn:
+    """Tests for make_expr_router_fn factory."""
+
+    def test_routes_on_first_matching_condition(self):
+        """Should route to first matching condition."""
+        edges = [
+            ("score < 0.5", "refine"),
+            ("score >= 0.5", "done"),
+        ]
+        router = make_expr_router_fn(edges, "test_node")
+
+        assert router({"score": 0.3}) == "refine"
+        assert router({"score": 0.8}) == "done"
+
+    def test_loop_limit_takes_precedence(self):
+        """Should return END when loop limit reached."""
+        from langgraph.graph import END
+
+        edges = [("score < 0.8", "continue")]
+        router = make_expr_router_fn(edges, "test_node")
+
+        assert router({"_loop_limit_reached": True, "score": 0.5}) == END
+
+    def test_defaults_to_end_when_no_match(self):
+        """Should return END when no condition matches."""
+        from langgraph.graph import END
+
+        edges = [
+            ("score < 0.5", "a"),
+            ("score > 0.9", "b"),
+        ]
+        router = make_expr_router_fn(edges, "test_node")
+
+        # score = 0.7 doesn't match either
+        assert router({"score": 0.7}) == END
+
+    def test_handles_condition_error_gracefully(self):
+        """Should log warning and continue on condition error."""
+
+        edges = [
+            ("invalid!!! expression", "a"),  # This will fail
+            ("score >= 0.8", "done"),
+        ]
+        router = make_expr_router_fn(edges, "test_node")
+
+        # Should skip invalid and match second condition
+        assert router({"score": 0.9}) == "done"
+
+    def test_condition_order_matters(self):
+        """First matching condition wins."""
+        edges = [
+            ("score >= 0.5", "half"),
+            ("score >= 0.8", "high"),  # Never reached if first matches
+        ]
+        router = make_expr_router_fn(edges, "test_node")
+
+        # Both conditions true, but first wins
+        assert router({"score": 0.9}) == "half"

tests/unit/test_config.py

@@ -0,0 +1,93 @@
+"""Tests for yamlgraph.config module."""
+
+from yamlgraph.config import (
+    DATABASE_PATH,
+    DEFAULT_MAX_TOKENS,
+    DEFAULT_MODELS,
+    DEFAULT_TEMPERATURE,
+    MAX_TOPIC_LENGTH,
+    MAX_WORD_COUNT,
+    MIN_WORD_COUNT,
+    OUTPUTS_DIR,
+    PACKAGE_ROOT,
+    PROMPTS_DIR,
+    VALID_STYLES,
+    WORKING_DIR,
+)
+
+
+class TestPaths:
+    """Tests for path configuration."""
+
+    def test_package_root_exists(self):
+        """Package root directory should exist."""
+        assert PACKAGE_ROOT.exists()
+        assert PACKAGE_ROOT.is_dir()
+
+    def test_working_dir_exists(self):
+        """Working directory should exist."""
+        assert WORKING_DIR.exists()
+        assert WORKING_DIR.is_dir()
+
+    def test_prompts_dir_exists(self):
+        """Prompts directory should exist."""
+        assert PROMPTS_DIR.exists()
+        assert PROMPTS_DIR.is_dir()
+
+    def test_prompts_dir_has_yaml_files(self):
+        """Prompts directory should contain YAML files."""
+        yaml_files = list(PROMPTS_DIR.glob("*.yaml"))
+        assert len(yaml_files) > 0
+
+    def test_outputs_dir_path(self):
+        """Outputs directory path should be under working dir."""
+        assert OUTPUTS_DIR.parent == WORKING_DIR
+
+    def test_database_path(self):
+        """Database path should be in outputs directory."""
+        assert DATABASE_PATH.parent == OUTPUTS_DIR
+        assert DATABASE_PATH.suffix == ".db"
+
+
+class TestLLMConfig:
+    """Tests for LLM configuration."""
+
+    def test_default_models_has_all_providers(self):
+        """Default models dict should have all supported providers."""
+        assert "anthropic" in DEFAULT_MODELS
+        assert "mistral" in DEFAULT_MODELS
+        assert "openai" in DEFAULT_MODELS
+
+    def test_default_models_are_strings(self):
+        """All default models should be non-empty strings."""
+        for provider, model in DEFAULT_MODELS.items():
+            assert isinstance(model, str), f"{provider} model should be string"
+            assert len(model) > 0, f"{provider} model should not be empty"
+
+    def test_default_temperature_range(self):
+        """Default temperature should be in valid range."""
+        assert 0.0 <= DEFAULT_TEMPERATURE <= 1.0
+
+    def test_default_max_tokens_positive(self):
+        """Max tokens should be positive."""
+        assert DEFAULT_MAX_TOKENS > 0
+
+
+class TestCLIConstraints:
+    """Tests for CLI validation constraints."""
+
+    def test_topic_length_constraint(self):
+        """Max topic length should be reasonable."""
+        assert MAX_TOPIC_LENGTH > 0
+        assert MAX_TOPIC_LENGTH <= 10000
+
+    def test_word_count_constraints(self):
+        """Word count constraints should be valid."""
+        assert MIN_WORD_COUNT > 0
+        assert MAX_WORD_COUNT > MIN_WORD_COUNT
+
+    def test_valid_styles(self):
+        """Valid styles should include expected options."""
+        assert "informative" in VALID_STYLES
+        assert "casual" in VALID_STYLES
+        assert "technical" in VALID_STYLES