yamlgraph 0.1.1__py3-none-any.whl

tests/unit/test_no_backward_compat.py

@@ -0,0 +1,56 @@
+"""Test that 'backward compatibility' markers are cleaned up in source code.
+
+Per project guidelines (.github/copilot-instructions.md):
+"Term 'backward compatibility' is a key indicator for a refactoring need."
+
+This test fails if any Python source files contain backward compatibility markers,
+ensuring deprecated code gets cleaned up rather than accumulating.
+"""
+
+import subprocess
+from pathlib import Path
+
+
+class TestNoBackwardCompatibilityMarkers:
+    """Ensure no backward compatibility markers exist in source code."""
+
+    def test_no_backward_compat_in_yamlgraph_source(self):
+        """Source files should not contain 'backward compatibility' markers.
+
+        Allowed exceptions:
+        - deprecation.py: Documents the DeprecationError pattern
+        - Tests in this file
+        """
+        project_root = Path(__file__).parent.parent.parent
+        yamlgraph_dir = project_root / "yamlgraph"
+
+        result = subprocess.run(
+            [
+                "grep",
+                "-rn",
+                "-i",
+                "backward compatib",
+                str(yamlgraph_dir),
+                "--include=*.py",
+            ],
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode == 0:  # Found matches
+            lines = result.stdout.strip().split("\n")
+            # Filter out allowed files
+            violations = [
+                line
+                for line in lines
+                if "deprecation.py" not in line  # Pattern documentation
+            ]
+
+            if violations:
+                msg = (
+                    "Found 'backward compatibility' markers in source code.\n"
+                    "Per guidelines, this signals refactoring need.\n"
+                    "Clean up deprecated code or move to deprecation.py.\n\n"
+                    "Violations:\n" + "\n".join(f"  {v}" for v in violations)
+                )
+                raise AssertionError(msg)

tests/unit/test_node_factory.py

@@ -0,0 +1,225 @@
+"""Tests for node factory - class resolution, template resolution, and node creation.
+
+Split from test_graph_loader.py for better organization and file size management.
+"""
+
+from unittest.mock import patch
+
+import pytest
+
+from tests.conftest import FixtureGeneratedContent
+from yamlgraph.node_factory import (
+    create_node_function,
+    resolve_class,
+    resolve_template,
+)
+
+# =============================================================================
+# Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def sample_state():
+    """Sample pipeline state."""
+    return {
+        "thread_id": "test-123",
+        "topic": "machine learning",
+        "style": "informative",
+        "word_count": 300,
+        "generated": None,
+        "analysis": None,
+        "final_summary": None,
+        "current_step": "init",
+        "error": None,
+        "errors": [],
+    }
+
+
+@pytest.fixture
+def state_with_generated(sample_state):
+    """State with generated content."""
+    state = dict(sample_state)
+    state["generated"] = FixtureGeneratedContent(
+        title="Test Title",
+        content="Test content about ML.",
+        word_count=50,
+        tags=["test"],
+    )
+    return state
+
+
+# =============================================================================
+# TestResolveClass
+# =============================================================================
+
+
+class TestResolveClass:
+    """Tests for dynamic class importing."""
+
+    def test_resolve_existing_class(self):
+        """Import a real class from dotted path."""
+        cls = resolve_class("yamlgraph.models.GenericReport")
+        # Just verify it resolves to a class with expected attributes
+        assert cls is not None
+        assert hasattr(cls, "model_fields")  # Pydantic model check
+
+    def test_resolve_state_class(self):
+        """Dynamic state class can be built."""
+        from yamlgraph.models.state_builder import build_state_class
+
+        cls = build_state_class({"nodes": {}})
+        # Dynamic state is a TypedDict
+        assert cls is not None
+        assert hasattr(cls, "__annotations__")
+
+    def test_resolve_invalid_module_raises(self):
+        """Invalid module raises ImportError."""
+        with pytest.raises((ImportError, ModuleNotFoundError)):
+            resolve_class("nonexistent.module.Class")
+
+    def test_resolve_invalid_class_raises(self):
+        """Invalid class name raises AttributeError."""
+        with pytest.raises(AttributeError):
+            resolve_class("yamlgraph.models.NonexistentClass")
+
+
+# =============================================================================
+# TestResolveTemplate
+# =============================================================================
+
+
+class TestResolveTemplate:
+    """Tests for template resolution against state."""
+
+    def test_simple_state_access(self, sample_state):
+        """'{state.topic}' resolves to state['topic']."""
+        result = resolve_template("{state.topic}", sample_state)
+        assert result == "machine learning"
+
+    def test_nested_state_access(self, state_with_generated):
+        """'{state.generated.content}' resolves nested attrs."""
+        result = resolve_template("{state.generated.content}", state_with_generated)
+        assert result == "Test content about ML."
+
+    def test_missing_state_returns_none(self, sample_state):
+        """Missing state key returns None."""
+        result = resolve_template("{state.generated.content}", sample_state)
+        assert result is None
+
+    def test_literal_string_unchanged(self, sample_state):
+        """Non-template strings returned as-is."""
+        result = resolve_template("literal value", sample_state)
+        assert result == "literal value"
+
+    def test_int_access(self, sample_state):
+        """Integer values resolved correctly."""
+        result = resolve_template("{state.word_count}", sample_state)
+        assert result == 300
+
+    def test_list_access(self, state_with_generated):
+        """List values resolved correctly."""
+        result = resolve_template("{state.generated.tags}", state_with_generated)
+        assert result == ["test"]
+
+
+# =============================================================================
+# TestCreateNodeFunction
+# =============================================================================
+
+
+class TestCreateNodeFunction:
+    """Tests for node function factory."""
+
+    def test_node_calls_execute_prompt(self, sample_state):
+        """Generated node calls execute_prompt with config."""
+        node_config = {
+            "type": "llm",
+            "prompt": "generate",
+            "output_model": "yamlgraph.models.GenericReport",
+            "temperature": 0.8,
+            "variables": {"topic": "{state.topic}"},
+            "state_key": "generated",
+        }
+
+        mock_result = FixtureGeneratedContent(
+            title="Test",
+            content="Content",
+            word_count=100,
+            tags=[],
+        )
+
+        with patch(
+            "yamlgraph.node_factory.execute_prompt", return_value=mock_result
+        ) as mock:
+            node_fn = create_node_function(
+                "generate", node_config, {"provider": "mistral"}
+            )
+            result = node_fn(sample_state)
+
+            mock.assert_called_once()
+            call_kwargs = mock.call_args
+            assert call_kwargs[1]["prompt_name"] == "generate"
+            assert call_kwargs[1]["temperature"] == 0.8
+            assert call_kwargs[1]["variables"]["topic"] == "machine learning"
+
+        assert result["generated"] == mock_result
+        assert result["current_step"] == "generate"
+
+    def test_node_checks_requirements(self, sample_state):
+        """Node returns error if requires not met."""
+        node_config = {
+            "type": "llm",
+            "prompt": "analyze",
+            "variables": {},
+            "state_key": "analysis",
+            "requires": ["generated"],  # generated is None in sample_state
+        }
+
+        node_fn = create_node_function("analyze", node_config, {})
+        result = node_fn(sample_state)
+
+        assert result.get("errors")
+        assert "generated" in result["errors"][0].message
+
+    def test_node_handles_exception(self, sample_state):
+        """Exceptions become PipelineError."""
+        node_config = {
+            "type": "llm",
+            "prompt": "generate",
+            "variables": {"topic": "{state.topic}"},
+            "state_key": "generated",
+        }
+
+        with patch(
+            "yamlgraph.node_factory.execute_prompt", side_effect=ValueError("API Error")
+        ):
+            node_fn = create_node_function("generate", node_config, {})
+            result = node_fn(sample_state)
+
+        assert result.get("errors")
+        assert "API Error" in result["errors"][0].message
+
+    def test_node_uses_defaults(self, sample_state):
+        """Node uses default provider/temperature from config."""
+        node_config = {
+            "type": "llm",
+            "prompt": "generate",
+            "variables": {},
+            "state_key": "generated",
+            # No temperature specified - should use default
+        }
+        defaults = {"provider": "anthropic", "temperature": 0.5}
+
+        mock_result = FixtureGeneratedContent(
+            title="T", content="C", word_count=1, tags=[]
+        )
+
+        with patch(
+            "yamlgraph.node_factory.execute_prompt", return_value=mock_result
+        ) as mock:
+            node_fn = create_node_function("generate", node_config, defaults)
+            node_fn(sample_state)
+
+            assert mock.call_args[1]["temperature"] == 0.5
+            assert mock.call_args[1]["provider"] == "anthropic"

tests/unit/test_prompts.py

@@ -0,0 +1,166 @@
+"""Tests for yamlgraph.utils.prompts module.
+
+TDD: Red phase - write tests before implementation.
+"""
+
+from pathlib import Path
+
+import pytest
+
+
+class TestResolvePromptPath:
+    """Tests for resolve_prompt_path function."""
+
+    def test_resolve_standard_prompt(self, tmp_path: Path):
+        """Should resolve prompt in standard prompts/ directory."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # Create temp prompt file
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+        prompt_file = prompts_dir / "greet.yaml"
+        prompt_file.write_text("system: Hello\nuser: Hi {name}")
+
+        result = resolve_prompt_path("greet", prompts_dir=prompts_dir)
+
+        assert result == prompt_file
+        assert result.exists()
+
+    def test_resolve_nested_prompt(self, tmp_path: Path):
+        """Should resolve nested prompt like map-demo/generate_ideas."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # Create nested prompt structure
+        prompts_dir = tmp_path / "prompts"
+        nested_dir = prompts_dir / "map-demo"
+        nested_dir.mkdir(parents=True)
+        prompt_file = nested_dir / "generate_ideas.yaml"
+        prompt_file.write_text("system: Generate\nuser: {topic}")
+
+        result = resolve_prompt_path("map-demo/generate_ideas", prompts_dir=prompts_dir)
+
+        assert result == prompt_file
+
+    def test_resolve_external_example_prompt(self, tmp_path: Path, monkeypatch):
+        """Should resolve external example like examples/storyboard/expand_story."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # Create external example structure: {parent}/prompts/{basename}.yaml
+        example_dir = tmp_path / "examples" / "storyboard"
+        prompts_subdir = example_dir / "prompts"
+        prompts_subdir.mkdir(parents=True)
+        prompt_file = prompts_subdir / "expand_story.yaml"
+        prompt_file.write_text("system: Expand\nuser: {story}")
+
+        # Change to tmp_path so relative paths resolve correctly
+        monkeypatch.chdir(tmp_path)
+
+        # Standard prompts dir doesn't have it, should fall back to external
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir(exist_ok=True)
+
+        result = resolve_prompt_path(
+            "examples/storyboard/expand_story",
+            prompts_dir=prompts_dir,
+        )
+
+        assert result.resolve() == prompt_file.resolve()
+
+    def test_resolve_nonexistent_raises(self, tmp_path: Path):
+        """Should raise FileNotFoundError for missing prompt."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+
+        with pytest.raises(FileNotFoundError, match="Prompt not found"):
+            resolve_prompt_path("nonexistent", prompts_dir=prompts_dir)
+
+    def test_resolve_uses_default_prompts_dir(self):
+        """Should use PROMPTS_DIR from config when not specified."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # This should find the real greet.yaml in prompts/
+        result = resolve_prompt_path("greet")
+
+        assert result.exists()
+        assert result.name == "greet.yaml"
+
+
+class TestLoadPrompt:
+    """Tests for load_prompt function."""
+
+    def test_load_existing_prompt(self, tmp_path: Path):
+        """Should load and parse YAML prompt file."""
+        from yamlgraph.utils.prompts import load_prompt
+
+        # Create temp prompt file
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+        prompt_file = prompts_dir / "test.yaml"
+        prompt_file.write_text("system: You are helpful\nuser: Hello {name}")
+
+        result = load_prompt("test", prompts_dir=prompts_dir)
+
+        assert result["system"] == "You are helpful"
+        assert result["user"] == "Hello {name}"
+
+    def test_load_prompt_with_schema(self, tmp_path: Path):
+        """Should load prompt with inline schema section."""
+        from yamlgraph.utils.prompts import load_prompt
+
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+        prompt_file = prompts_dir / "structured.yaml"
+        prompt_file.write_text("""
+system: Analyze content
+user: "{content}"
+schema:
+  name: Analysis
+  fields:
+    summary:
+      type: str
+      description: Brief summary
+""")
+
+        result = load_prompt("structured", prompts_dir=prompts_dir)
+
+        assert "schema" in result
+        assert result["schema"]["name"] == "Analysis"
+
+    def test_load_nonexistent_raises(self, tmp_path: Path):
+        """Should raise FileNotFoundError for missing prompt."""
+        from yamlgraph.utils.prompts import load_prompt
+
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+
+        with pytest.raises(FileNotFoundError):
+            load_prompt("missing", prompts_dir=prompts_dir)
+
+    def test_load_real_generate_prompt(self):
+        """Should load the real generate.yaml from prompts/."""
+        from yamlgraph.utils.prompts import load_prompt
+
+        result = load_prompt("generate")
+
+        assert "system" in result
+        assert "user" in result
+
+
+class TestLoadPromptPath:
+    """Tests for load_prompt_path (returns Path + parsed content)."""
+
+    def test_load_prompt_path_returns_both(self, tmp_path: Path):
+        """Should return both path and parsed content."""
+        from yamlgraph.utils.prompts import load_prompt_path
+
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+        prompt_file = prompts_dir / "dual.yaml"
+        prompt_file.write_text("system: Test\nuser: Hello")
+
+        path, content = load_prompt_path("dual", prompts_dir=prompts_dir)
+
+        assert path == prompt_file
+        assert content["system"] == "Test"

tests/unit/test_python_nodes.py

@@ -0,0 +1,198 @@
+"""Tests for Python tool nodes (type: python)."""
+
+import pytest
+
+from yamlgraph.tools.python_tool import (
+    PythonToolConfig,
+    create_python_node,
+    load_python_function,
+    parse_python_tools,
+)
+
+
+class TestPythonToolConfig:
+    """Tests for PythonToolConfig dataclass."""
+
+    def test_basic_config(self):
+        """Can create config with required fields."""
+        config = PythonToolConfig(
+            module="os.path",
+            function="join",
+        )
+        assert config.module == "os.path"
+        assert config.function == "join"
+        assert config.description == ""
+
+    def test_config_with_description(self):
+        """Can create config with description."""
+        config = PythonToolConfig(
+            module="json",
+            function="dumps",
+            description="Serialize to JSON",
+        )
+        assert config.description == "Serialize to JSON"
+
+
+class TestLoadPythonFunction:
+    """Tests for load_python_function."""
+
+    def test_loads_stdlib_function(self):
+        """Can load function from stdlib."""
+        config = PythonToolConfig(module="os.path", function="join")
+        func = load_python_function(config)
+        assert callable(func)
+        assert func("a", "b") == "a/b"
+
+    def test_loads_json_dumps(self):
+        """Can load json.dumps."""
+        config = PythonToolConfig(module="json", function="dumps")
+        func = load_python_function(config)
+        assert func({"a": 1}) == '{"a": 1}'
+
+    def test_raises_on_invalid_module(self):
+        """Raises ImportError for non-existent module."""
+        config = PythonToolConfig(module="nonexistent.module", function="foo")
+        with pytest.raises(ImportError, match="Cannot import module"):
+            load_python_function(config)
+
+    def test_raises_on_invalid_function(self):
+        """Raises AttributeError for non-existent function."""
+        config = PythonToolConfig(module="os.path", function="nonexistent_func")
+        with pytest.raises(AttributeError, match="not found in module"):
+            load_python_function(config)
+
+    def test_raises_on_non_callable(self):
+        """Raises TypeError if attribute is not callable."""
+        config = PythonToolConfig(module="os", function="name")
+        with pytest.raises(TypeError, match="not callable"):
+            load_python_function(config)
+
+
+class TestParsePythonTools:
+    """Tests for parse_python_tools."""
+
+    def test_parses_python_tools(self):
+        """Extracts only type: python tools."""
+        tools_config = {
+            "shell_tool": {"command": "echo hello"},
+            "python_tool": {
+                "type": "python",
+                "module": "json",
+                "function": "dumps",
+            },
+        }
+        result = parse_python_tools(tools_config)
+
+        assert len(result) == 1
+        assert "python_tool" in result
+        assert result["python_tool"].module == "json"
+        assert result["python_tool"].function == "dumps"
+
+    def test_skips_shell_tools(self):
+        """Does not include shell tools."""
+        tools_config = {
+            "git_log": {
+                "type": "shell",
+                "command": "git log",
+            },
+        }
+        result = parse_python_tools(tools_config)
+        assert len(result) == 0
+
+    def test_skips_incomplete_python_tools(self):
+        """Skips Python tools missing module or function."""
+        tools_config = {
+            "missing_module": {"type": "python", "function": "foo"},
+            "missing_function": {"type": "python", "module": "json"},
+        }
+        result = parse_python_tools(tools_config)
+        assert len(result) == 0
+
+    def test_includes_description(self):
+        """Parses description field."""
+        tools_config = {
+            "my_tool": {
+                "type": "python",
+                "module": "json",
+                "function": "loads",
+                "description": "Parse JSON",
+            },
+        }
+        result = parse_python_tools(tools_config)
+        assert result["my_tool"].description == "Parse JSON"
+
+
+class TestCreatePythonNode:
+    """Tests for create_python_node."""
+
+    def test_creates_node_function(self):
+        """Creates callable node function."""
+        python_tools = {
+            "my_tool": PythonToolConfig(
+                module="tests.unit.test_python_nodes",
+                function="sample_node_function",
+            ),
+        }
+        node_config = {"tool": "my_tool", "state_key": "result"}
+
+        node_fn = create_python_node("test_node", node_config, python_tools)
+        assert callable(node_fn)
+
+    def test_raises_on_missing_tool(self):
+        """Raises if tool not in registry."""
+        python_tools = {}
+        node_config = {"tool": "nonexistent"}
+
+        with pytest.raises(KeyError, match="not found"):
+            create_python_node("test_node", node_config, python_tools)
+
+    def test_raises_on_missing_tool_key(self):
+        """Raises if node config missing tool key."""
+        python_tools = {}
+        node_config = {}
+
+        with pytest.raises(ValueError, match="must specify"):
+            create_python_node("test_node", node_config, python_tools)
+
+    def test_node_returns_dict_from_function(self):
+        """Node returns function's dict result with current_step."""
+        python_tools = {
+            "dict_tool": PythonToolConfig(
+                module="tests.unit.test_python_nodes",
+                function="sample_node_function",
+            ),
+        }
+        node_config = {"tool": "dict_tool"}
+
+        node_fn = create_python_node("test_node", node_config, python_tools)
+        result = node_fn({"input": "hello"})
+
+        assert result["current_step"] == "test_node"
+        assert "output" in result
+
+    def test_node_wraps_non_dict_return(self):
+        """Node wraps non-dict return in state_key."""
+        python_tools = {
+            "scalar_tool": PythonToolConfig(
+                module="tests.unit.test_python_nodes",
+                function="scalar_return_function",
+            ),
+        }
+        node_config = {"tool": "scalar_tool", "state_key": "my_value"}
+
+        node_fn = create_python_node("test_node", node_config, python_tools)
+        result = node_fn({})
+
+        assert result["my_value"] == 42
+        assert result["current_step"] == "test_node"
+
+
+# Sample functions for testing
+def sample_node_function(state: dict) -> dict:
+    """Sample node function that returns a dict."""
+    return {"output": f"processed: {state.get('input', 'none')}"}
+
+
+def scalar_return_function(state: dict) -> int:
+    """Sample function that returns a scalar."""
+    return 42