yamlgraph 0.3.9__py3-none-any.whl

tests/unit/test_template.py

@@ -0,0 +1,190 @@
+"""Tests for yamlgraph.utils.template module - Variable extraction and validation."""
+
+import pytest
+
+
+class TestExtractVariables:
+    """Tests for extract_variables function."""
+
+    def test_extract_simple_variables(self):
+        """Should extract {var} placeholders."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "Hello {name}, your style is {style}."
+        variables = extract_variables(template)
+        assert variables == {"name", "style"}
+
+    def test_extract_single_variable(self):
+        """Should extract a single variable."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "Welcome {user}!"
+        variables = extract_variables(template)
+        assert variables == {"user"}
+
+    def test_extract_no_variables(self):
+        """Should return empty set when no variables."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "No variables here"
+        variables = extract_variables(template)
+        assert variables == set()
+
+    def test_extract_duplicate_variables(self):
+        """Should deduplicate variables."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "{name} and {name} again"
+        variables = extract_variables(template)
+        assert variables == {"name"}
+
+    def test_extract_jinja2_variable(self):
+        """Should extract {{ var }} Jinja2 variables."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "Hello {{ name }}!"
+        variables = extract_variables(template)
+        assert "name" in variables
+
+    def test_extract_jinja2_variable_with_field_access(self):
+        """Should extract base variable from {{ var.field }}."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "User: {{ user.name }}"
+        variables = extract_variables(template)
+        assert "user" in variables
+
+    def test_extract_jinja2_loop_variable(self):
+        """Should extract iterable from {% for x in items %}."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "{% for item in items %}{{ item.name }}{% endfor %}"
+        variables = extract_variables(template)
+        assert "items" in variables
+        # 'item' is a loop variable, not a required input
+        assert "item" not in variables
+
+    def test_extract_jinja2_if_variable(self):
+        """Should extract variable from {% if condition %}."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "{% if show_details %}Details here{% endif %}"
+        variables = extract_variables(template)
+        assert "show_details" in variables
+
+    def test_exclude_state_variable(self):
+        """State is injected by framework, not a required input."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "{{ state.topic }}"
+        variables = extract_variables(template)
+        # state is excluded - it's injected by node_factory
+        assert "state" not in variables
+
+    def test_exclude_jinja2_builtins(self):
+        """Should exclude Jinja2 builtins like loop, range."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "{% for i in range(10) %}{{ loop.index }}{% endfor %}"
+        variables = extract_variables(template)
+        assert "range" not in variables
+        assert "loop" not in variables
+
+    def test_mixed_simple_and_jinja2(self):
+        """Should handle templates mixing {var} and {{ var }}."""
+        from yamlgraph.utils.template import extract_variables
+
+        template = "Simple {name} and Jinja2 {{ topic }}"
+        variables = extract_variables(template)
+        assert "name" in variables
+        assert "topic" in variables
+
+
+class TestValidateVariables:
+    """Tests for validate_variables function."""
+
+    def test_validate_all_provided(self):
+        """Should not raise when all variables provided."""
+        from yamlgraph.utils.template import validate_variables
+
+        template = "Hello {name}, style: {style}"
+        # Should not raise
+        validate_variables(template, {"name": "World", "style": "formal"}, "greet")
+
+    def test_validate_missing_single_variable(self):
+        """Should raise ValueError for single missing variable."""
+        from yamlgraph.utils.template import validate_variables
+
+        template = "Hello {name}, style: {style}"
+        with pytest.raises(ValueError, match="Missing required variable.*name"):
+            validate_variables(template, {"style": "formal"}, "greet")
+
+    def test_validate_missing_multiple_variables(self):
+        """Should list ALL missing variables in error."""
+        from yamlgraph.utils.template import validate_variables
+
+        template = "Hello {name}, style: {style}"
+        with pytest.raises(ValueError) as exc_info:
+            validate_variables(template, {}, "greet")
+        error_msg = str(exc_info.value)
+        assert "name" in error_msg
+        assert "style" in error_msg
+
+    def test_validate_extra_variables_ok(self):
+        """Should not raise when extra variables provided."""
+        from yamlgraph.utils.template import validate_variables
+
+        template = "Hello {name}"
+        # Should not raise - extra vars are fine
+        validate_variables(template, {"name": "World", "extra": "ignored"}, "greet")
+
+    def test_validate_prompt_name_in_error(self):
+        """Error message should include prompt name."""
+        from yamlgraph.utils.template import validate_variables
+
+        template = "Hello {name}"
+        with pytest.raises(ValueError, match="greet"):
+            validate_variables(template, {}, "greet")
+
+    def test_validate_empty_template(self):
+        """Should not raise for template without variables."""
+        from yamlgraph.utils.template import validate_variables
+
+        template = "No variables here"
+        # Should not raise
+        validate_variables(template, {}, "static")
+
+    def test_validate_jinja2_template(self):
+        """Should validate Jinja2 templates correctly."""
+        from yamlgraph.utils.template import validate_variables
+
+        template = "{% for item in items %}{{ item }}{% endfor %}"
+        with pytest.raises(ValueError, match="items"):
+            validate_variables(template, {}, "list_template")
+
+
+class TestExecutePromptValidation:
+    """Integration tests for validation in execute_prompt."""
+
+    def test_execute_prompt_raises_on_missing_variable(self):
+        """Should raise clear error when required variable is missing."""
+        from yamlgraph.executor import execute_prompt
+
+        with pytest.raises(ValueError, match="Missing required variable.*name"):
+            execute_prompt(
+                prompt_name="greet",
+                variables={"style": "formal"},  # Missing 'name'
+            )
+
+    def test_execute_prompt_lists_all_missing_variables(self):
+        """Error should list ALL missing variables, not just first."""
+        from yamlgraph.executor import execute_prompt
+
+        with pytest.raises(ValueError) as exc_info:
+            execute_prompt(
+                prompt_name="greet",
+                variables={},  # Missing both 'name' and 'style'
+            )
+        error_msg = str(exc_info.value)
+        assert "name" in error_msg
+        assert "style" in error_msg

tests/unit/test_tool_call_integration.py

@@ -0,0 +1,164 @@
+"""Tests for type: tool_call integration in graph_loader.
+
+TDD Phase 3b: Wire tool_call node into graph compilation.
+"""
+
+import pytest
+from langgraph.graph import StateGraph
+
+from yamlgraph.graph_loader import GraphConfig, _compile_node
+from yamlgraph.map_compiler import compile_map_node
+
+
+# Sample tools for testing
+def sample_search(path: str) -> dict:
+    """Sample search tool."""
+    return {"path": path, "matches": ["line1", "line2"]}
+
+
+def sample_read(file: str, start: int = 1, end: int = 10) -> dict:
+    """Sample read tool."""
+    return {"file": file, "lines": list(range(start, end + 1))}
+
+
+@pytest.fixture
+def tools_registry() -> dict:
+    """Combined tools registry for tool_call nodes."""
+    return {
+        "search_file": sample_search,
+        "read_lines": sample_read,
+    }
+
+
+@pytest.fixture
+def minimal_config() -> GraphConfig:
+    """Minimal graph config with tools."""
+    config_dict = {
+        "version": "1.0",
+        "name": "test",
+        "nodes": {
+            "dummy": {
+                "prompt": "test",
+                "state_key": "result",
+            }
+        },
+        "edges": [
+            {"from": "START", "to": "dummy"},
+            {"from": "dummy", "to": "END"},
+        ],
+        "tools": {
+            "search_file": {
+                "type": "python",
+                "module": "tests.unit.test_tool_call_integration",
+                "function": "sample_search",
+            },
+            "read_lines": {
+                "type": "python",
+                "module": "tests.unit.test_tool_call_integration",
+                "function": "sample_read",
+            },
+        },
+    }
+    return GraphConfig(config_dict)
+
+
+class TestCompileToolCallNode:
+    """Test _compile_node with type: tool_call."""
+
+    def test_compiles_tool_call_node(self, minimal_config, tools_registry):
+        """Should compile tool_call node and add to graph."""
+        from operator import add
+        from typing import Annotated
+
+        # Create state class with reducer for discovery_findings
+        class TestState:
+            discovery_findings: Annotated[list, add] = []
+
+        graph = StateGraph(TestState)
+
+        node_config = {
+            "type": "tool_call",
+            "tool": "{state.task.tool}",
+            "args": "{state.task.args}",
+            "state_key": "result",
+        }
+
+        result = _compile_node(
+            "test_tool_call",
+            node_config,
+            graph,
+            minimal_config,
+            tools={},
+            python_tools={},
+            websearch_tools={},
+            callable_registry=tools_registry,  # tool_call uses callable_registry
+        )
+
+        # Should not return map info
+        assert result is None
+        # Node should be in graph
+        assert "test_tool_call" in graph.nodes
+
+    def test_tool_call_node_executes(self, tools_registry):
+        """Tool call node should execute tool from state."""
+        from yamlgraph.node_factory import create_tool_call_node
+
+        node_config = {
+            "tool": "{state.task.tool}",
+            "args": "{state.task.args}",
+            "state_key": "result",
+        }
+        node_fn = create_tool_call_node("exec_tool", node_config, tools_registry)
+
+        state = {
+            "task": {
+                "id": 1,
+                "tool": "search_file",
+                "args": {"path": "foo.py"},
+            }
+        }
+        result = node_fn(state)
+
+        assert result["result"]["success"] is True
+        assert result["result"]["result"]["path"] == "foo.py"
+
+
+class TestMapWithToolCall:
+    """Test map node with tool_call sub-node."""
+
+    def test_map_with_tool_call_sub_node(self, tools_registry):
+        """Map node should support type: tool_call in sub-node."""
+        from operator import add
+        from typing import Annotated
+
+        class TestState:
+            discovery_plan: dict = {}
+            discovery_findings: Annotated[list, add] = []
+
+        graph = StateGraph(TestState)
+
+        map_config = {
+            "type": "map",
+            "over": "{state.discovery_plan.tasks}",
+            "as": "task",
+            "node": {
+                "type": "tool_call",
+                "tool": "{state.task.tool}",
+                "args": "{state.task.args}",
+                "state_key": "discovery_result",
+            },
+            "collect": "discovery_findings",
+        }
+
+        # This should work - map_compiler needs to handle tool_call sub-nodes
+        map_edge_fn, sub_node_name = compile_map_node(
+            "execute_discovery",
+            map_config,
+            graph,
+            defaults={},
+            tools_registry=tools_registry,  # New parameter for tool_call
+        )
+
+        assert callable(map_edge_fn)
+        assert sub_node_name == "_map_execute_discovery_sub"
+        assert sub_node_name in graph.nodes

tests/unit/test_tool_call_node.py

@@ -0,0 +1,178 @@
+"""Tests for type: tool_call node in node_factory.
+
+TDD Phase 3: Dynamic tool execution from state.
+"""
+
+import pytest
+
+from yamlgraph.constants import NodeType
+from yamlgraph.node_factory import create_tool_call_node
+
+
+# Sample tools for testing
+def sample_tool(path: str, pattern: str = ".*") -> dict:
+    """Sample tool that returns its args."""
+    return {"path": path, "pattern": pattern, "found": ["line1", "line2"]}
+
+
+def failing_tool(path: str) -> dict:
+    """Tool that always raises."""
+    raise ValueError(f"Cannot process: {path}")
+
+
+def simple_tool() -> str:
+    """Tool with no args."""
+    return "simple result"
+
+
+@pytest.fixture
+def tools_registry() -> dict:
+    """Sample tools registry."""
+    return {
+        "search_file": sample_tool,
+        "failing_tool": failing_tool,
+        "simple_tool": simple_tool,
+    }
+
+
+class TestNodeTypeConstant:
+    """Verify TOOL_CALL is added to NodeType enum."""
+
+    def test_tool_call_in_node_type(self):
+        """TOOL_CALL should be a valid node type."""
+        assert NodeType.TOOL_CALL == "tool_call"
+
+
+class TestCreateToolCallNode:
+    """Test create_tool_call_node factory function."""
+
+    def test_creates_callable(self, tools_registry):
+        """Should return a callable node function."""
+        config = {
+            "tool": "{state.task.tool}",
+            "args": "{state.task.args}",
+            "state_key": "result",
+        }
+        node_fn = create_tool_call_node("test_node", config, tools_registry)
+        assert callable(node_fn)
+
+    def test_resolves_tool_from_state(self, tools_registry):
+        """Should resolve tool name dynamically from state."""
+        config = {
+            "tool": "{state.task.tool}",
+            "args": "{state.task.args}",
+            "state_key": "result",
+        }
+        node_fn = create_tool_call_node("test_node", config, tools_registry)
+
+        state = {
+            "task": {
+                "id": 1,
+                "tool": "search_file",
+                "args": {"path": "foo.py", "pattern": "def"},
+            }
+        }
+        result = node_fn(state)
+
+        assert result["result"]["success"] is True
+        assert result["result"]["tool"] == "search_file"
+
+    def test_resolves_args_from_state(self, tools_registry):
+        """Should resolve args dynamically and pass to tool."""
+        config = {
+            "tool": "{state.task.tool}",
+            "args": "{state.task.args}",
+            "state_key": "result",
+        }
+        node_fn = create_tool_call_node("test_node", config, tools_registry)
+
+        state = {
+            "task": {
+                "id": 1,
+                "tool": "search_file",
+                "args": {"path": "bar.py", "pattern": "class"},
+            }
+        }
+        result = node_fn(state)
+
+        # Verify args were passed correctly
+        assert result["result"]["result"]["path"] == "bar.py"
+        assert result["result"]["result"]["pattern"] == "class"
+
+    def test_successful_execution(self, tools_registry):
+        """Should return success=True with result on success."""
+        config = {
+            "tool": "{state.task.tool}",
+            "args": "{state.task.args}",
+            "state_key": "result",
+        }
+        node_fn = create_tool_call_node("test_node", config, tools_registry)
+
+        state = {"task": {"id": 42, "tool": "search_file", "args": {"path": "x.py"}}}
+        result = node_fn(state)
+
+        assert result["result"]["success"] is True
+        assert result["result"]["task_id"] == 42
+        assert result["result"]["error"] is None
+        assert "found" in result["result"]["result"]
+
+    def test_unknown_tool_handling(self, tools_registry):
+        """Should return success=False for unknown tool."""
+        config = {
+            "tool": "{state.task.tool}",
+            "args": "{state.task.args}",
+            "state_key": "result",
+        }
+        node_fn = create_tool_call_node("test_node", config, tools_registry)
+
+        state = {"task": {"id": 1, "tool": "nonexistent_tool", "args": {}}}
+        result = node_fn(state)
+
+        assert result["result"]["success"] is False
+        assert "Unknown tool" in result["result"]["error"]
+        assert result["result"]["tool"] == "nonexistent_tool"
+
+    def test_tool_exception_handling(self, tools_registry):
+        """Should catch exceptions and return success=False."""
+        config = {
+            "tool": "{state.task.tool}",
+            "args": "{state.task.args}",
+            "state_key": "result",
+        }
+        node_fn = create_tool_call_node("test_node", config, tools_registry)
+
+        state = {"task": {"id": 5, "tool": "failing_tool", "args": {"path": "bad.py"}}}
+        result = node_fn(state)
+
+        assert result["result"]["success"] is False
+        assert "Cannot process: bad.py" in result["result"]["error"]
+        assert result["result"]["task_id"] == 5
+
+    def test_includes_current_step(self, tools_registry):
+        """Should include current_step in output for state tracking."""
+        config = {
+            "tool": "{state.task.tool}",
+            "args": "{state.task.args}",
+            "state_key": "result",
+        }
+        node_fn = create_tool_call_node("my_tool_call", config, tools_registry)
+
+        state = {"task": {"id": 1, "tool": "simple_tool", "args": {}}}
+        result = node_fn(state)
+
+        assert result["current_step"] == "my_tool_call"
+
+    def test_empty_args(self, tools_registry):
+        """Should work with tools that take no arguments."""
+        config = {
+            "tool": "{state.task.tool}",
+            "args": "{state.task.args}",
+            "state_key": "result",
+        }
+        node_fn = create_tool_call_node("test_node", config, tools_registry)
+
+        state = {"task": {"id": 1, "tool": "simple_tool", "args": {}}}
+        result = node_fn(state)
+
+        assert result["result"]["success"] is True
+        assert result["result"]["result"] == "simple result"

tests/unit/test_tool_nodes.py

@@ -0,0 +1,129 @@
+"""Tests for tool nodes (type: tool)."""
+
+import pytest
+
+from yamlgraph.tools.nodes import create_tool_node
+from yamlgraph.tools.shell import ShellToolConfig
+
+
+class TestCreateToolNode:
+    """Tests for create_tool_node function."""
+
+    def test_executes_named_tool(self):
+        """Node runs correct tool from registry."""
+        tools = {
+            "echo_tool": ShellToolConfig(command="echo hello"),
+            "other_tool": ShellToolConfig(command="echo other"),
+        }
+        node_config = {"tool": "echo_tool"}
+
+        node_fn = create_tool_node("test_node", node_config, tools)
+        result = node_fn({})
+
+        assert result["test_node"].strip() == "hello"
+        assert result["current_step"] == "test_node"
+
+    def test_resolves_variables_from_state(self):
+        """State values passed to tool."""
+        tools = {
+            "greet": ShellToolConfig(command="echo Hello {name}"),
+        }
+        node_config = {
+            "tool": "greet",
+            "variables": {"name": "{state.user_name}"},
+        }
+
+        node_fn = create_tool_node("greet_node", node_config, tools)
+        result = node_fn({"user_name": "Alice"})
+
+        assert "Alice" in result["greet_node"]
+
+    def test_stores_result_in_state_key(self):
+        """Tool output saved to custom state_key."""
+        tools = {
+            "data_tool": ShellToolConfig(command="echo data_value"),
+        }
+        node_config = {
+            "tool": "data_tool",
+            "state_key": "my_data",
+        }
+
+        node_fn = create_tool_node("fetch_node", node_config, tools)
+        result = node_fn({})
+
+        assert "my_data" in result
+        assert result["my_data"].strip() == "data_value"
+
+    def test_on_error_skip(self):
+        """Failed tool skipped when on_error: skip."""
+        tools = {
+            "fail_tool": ShellToolConfig(command="exit 1"),
+        }
+        node_config = {
+            "tool": "fail_tool",
+            "on_error": "skip",
+        }
+
+        node_fn = create_tool_node("fail_node", node_config, tools)
+        result = node_fn({})
+
+        # Should not raise, should return with error info
+        assert result["current_step"] == "fail_node"
+        assert "errors" in result or result.get("fail_node") is None
+
+    def test_on_error_fail_raises(self):
+        """Failed tool raises when on_error: fail."""
+        tools = {
+            "fail_tool": ShellToolConfig(command="exit 1"),
+        }
+        node_config = {
+            "tool": "fail_tool",
+            "on_error": "fail",
+        }
+
+        node_fn = create_tool_node("fail_node", node_config, tools)
+
+        with pytest.raises(RuntimeError):
+            node_fn({})
+
+    def test_nested_state_variable(self):
+        """Nested state values like {state.location.lat} resolved."""
+        tools = {
+            "geo": ShellToolConfig(command="echo {lat},{lon}"),
+        }
+        node_config = {
+            "tool": "geo",
+            "variables": {
+                "lat": "{state.location.lat}",
+                "lon": "{state.location.lon}",
+            },
+        }
+
+        node_fn = create_tool_node("geo_node", node_config, tools)
+        result = node_fn({"location": {"lat": "37.7749", "lon": "-122.4194"}})
+
+        assert "37.7749" in result["geo_node"]
+        assert "-122.4194" in result["geo_node"]
+
+    def test_missing_tool_raises(self):
+        """Unknown tool name raises error."""
+        tools = {}
+        node_config = {"tool": "nonexistent"}
+
+        with pytest.raises(KeyError):
+            create_tool_node("bad_node", node_config, tools)
+
+    def test_json_parse_tool(self):
+        """Tool with parse: json returns dict."""
+        tools = {
+            "json_tool": ShellToolConfig(
+                command="echo '{{\"count\": 42}}'",
+                parse="json",
+            ),
+        }
+        node_config = {"tool": "json_tool"}
+
+        node_fn = create_tool_node("json_node", node_config, tools)
+        result = node_fn({})
+
+        assert result["json_node"] == {"count": 42}