yamlgraph 0.3.9__py3-none-any.whl

tests/unit/test_graph_loader.py

@@ -0,0 +1,357 @@
+"""Tests for YAML graph loader.
+
+TDD: Write tests first, then implement graph_loader.py.
+
+Note: Node factory tests (resolve_class, resolve_template, create_node_function)
+have been moved to test_node_factory.py for better organization.
+"""
+
+from unittest.mock import patch
+
+import pytest
+
+from tests.conftest import FixtureGeneratedContent
+from yamlgraph.graph_loader import (
+    GraphConfig,
+    compile_graph,
+    load_and_compile,
+    load_graph_config,
+)
+
+# =============================================================================
+# Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def sample_yaml_content():
+    """Minimal valid YAML config."""
+    return """
+version: "1.0"
+name: test_graph
+description: Test pipeline
+
+defaults:
+  provider: mistral
+  temperature: 0.7
+
+nodes:
+  generate:
+    type: llm
+    prompt: generate
+    output_model: yamlgraph.models.GenericReport
+    temperature: 0.8
+    variables:
+      topic: "{state.topic}"
+    state_key: generated
+
+edges:
+  - from: START
+    to: generate
+  - from: generate
+    to: END
+"""
+
+
+@pytest.fixture
+def sample_yaml_file(tmp_path, sample_yaml_content):
+    """Create a temporary YAML file."""
+    yaml_file = tmp_path / "test_graph.yaml"
+    yaml_file.write_text(sample_yaml_content)
+    return yaml_file
+
+
+@pytest.fixture
+def sample_config(sample_yaml_file):
+    """Load sample config."""
+    return load_graph_config(sample_yaml_file)
+
+
+# =============================================================================
+# TestLoadGraphConfig
+# =============================================================================
+
+
+class TestLoadGraphConfig:
+    """Tests for loading YAML graph configs."""
+
+    def test_load_valid_yaml(self, sample_yaml_file):
+        """Load a valid graph YAML file."""
+        config = load_graph_config(sample_yaml_file)
+
+        assert isinstance(config, GraphConfig)
+        assert config.name == "test_graph"
+        assert config.version == "1.0"
+
+    def test_load_missing_file_raises(self, tmp_path):
+        """FileNotFoundError for missing file."""
+        missing = tmp_path / "nonexistent.yaml"
+
+        with pytest.raises(FileNotFoundError):
+            load_graph_config(missing)
+
+    def test_parse_nodes(self, sample_config):
+        """Nodes parsed with correct attributes."""
+        assert "generate" in sample_config.nodes
+
+        node = sample_config.nodes["generate"]
+        assert node["type"] == "llm"
+        assert node["prompt"] == "generate"
+        assert node["temperature"] == 0.8
+
+    def test_parse_edges(self, sample_config):
+        """Edges parsed correctly."""
+        assert len(sample_config.edges) == 2
+        assert sample_config.edges[0]["from"] == "START"
+        assert sample_config.edges[0]["to"] == "generate"
+
+    def test_parse_defaults(self, sample_config):
+        """Defaults parsed correctly."""
+        assert sample_config.defaults["provider"] == "mistral"
+        assert sample_config.defaults["temperature"] == 0.7
+
+    def test_parse_prompts_relative(self, tmp_path):
+        """Should parse prompts_relative from defaults."""
+        yaml_content = """
+version: "1.0"
+name: test_graph
+
+defaults:
+  prompts_relative: true
+
+nodes:
+  greet:
+    type: llm
+    prompt: prompts/greet
+    state_key: greeting
+
+edges:
+  - from: START
+    to: greet
+  - from: greet
+    to: END
+"""
+        yaml_file = tmp_path / "test.yaml"
+        yaml_file.write_text(yaml_content)
+
+        config = load_graph_config(yaml_file)
+
+        assert config.prompts_relative is True
+        assert config.prompts_dir is None
+
+    def test_parse_prompts_dir(self, tmp_path):
+        """Should parse prompts_dir from defaults."""
+        yaml_content = """
+version: "1.0"
+name: test_graph
+
+defaults:
+  prompts_dir: shared/prompts
+
+nodes:
+  greet:
+    type: llm
+    prompt: greet
+    state_key: greeting
+
+edges:
+  - from: START
+    to: greet
+  - from: greet
+    to: END
+"""
+        yaml_file = tmp_path / "test.yaml"
+        yaml_file.write_text(yaml_content)
+
+        config = load_graph_config(yaml_file)
+
+        assert config.prompts_dir == "shared/prompts"
+        assert config.prompts_relative is False
+
+    def test_parse_state_class(self, sample_config):
+        """State class defaults to empty (dynamic generation)."""
+        assert sample_config.state_class == ""
+
+
+# =============================================================================
+# TestCompileGraph
+# =============================================================================
+
+
+class TestCompileGraph:
+    """Tests for compiling config to LangGraph."""
+
+    def test_graph_has_all_nodes(self, sample_config):
+        """Compiled graph contains all defined nodes."""
+        graph = compile_graph(sample_config)
+
+        # Check node was added (nodes are stored in graph.nodes)
+        assert "generate" in graph.nodes
+
+    def test_entry_point_set(self, sample_config):
+        """START edge sets entry point correctly."""
+        graph = compile_graph(sample_config)
+
+        # Verify entry point by checking the graph compiles and
+        # the first node is reachable from START
+        compiled = graph.compile()
+        assert compiled is not None
+
+        # The 'generate' node should be in the graph
+        assert "generate" in graph.nodes
+
+    def test_edges_connected(self, sample_config):
+        """Edges create correct topology."""
+        graph = compile_graph(sample_config)
+
+        # Compile to check it works
+        compiled = graph.compile()
+        assert compiled is not None
+
+
+# =============================================================================
+# TestLoadAndCompile
+# =============================================================================
+
+
+class TestLoadAndCompile:
+    """Integration tests for full load-compile flow."""
+
+    def test_load_and_compile_yamlgraph(self):
+        """Load the actual yamlgraph.yaml and compile it."""
+        from yamlgraph.config import GRAPHS_DIR
+
+        yamlgraph_path = GRAPHS_DIR / "yamlgraph.yaml"
+        if not yamlgraph_path.exists():
+            pytest.skip("yamlgraph.yaml not created yet")
+
+        graph = load_and_compile(yamlgraph_path)
+        compiled = graph.compile()
+
+        assert compiled is not None
+
+    def test_compiled_graph_invocable(self, sample_yaml_file):
+        """Compiled graph can be invoked with initial state."""
+        mock_result = FixtureGeneratedContent(
+            title="Test",
+            content="Content",
+            word_count=100,
+            tags=[],
+        )
+
+        with patch("yamlgraph.node_factory.execute_prompt", return_value=mock_result):
+            graph = load_and_compile(sample_yaml_file)
+            compiled = graph.compile()
+
+            initial_state = {
+                "thread_id": "test",
+                "topic": "AI",
+                "style": "casual",
+                "word_count": 100,
+            }
+
+            result = compiled.invoke(initial_state)
+
+            assert result.get("generated") is not None
+            assert result["generated"].title == "Test"
+
+
+# =============================================================================
+# TestYAMLSchemaValidation
+# =============================================================================
+
+
+class TestYAMLSchemaValidation:
+    """Tests for YAML schema validation on load."""
+
+    def test_missing_nodes_raises_error(self, tmp_path):
+        """YAML without nodes should raise ValidationError."""
+        yaml_content = """
+version: "1.0"
+name: empty_graph
+edges:
+  - from: START
+    to: END
+"""
+        yaml_file = tmp_path / "no_nodes.yaml"
+        yaml_file.write_text(yaml_content)
+
+        with pytest.raises(ValueError, match="nodes"):
+            load_graph_config(yaml_file)
+
+    def test_missing_edges_raises_error(self, tmp_path):
+        """YAML without edges should raise ValidationError."""
+        yaml_content = """
+version: "1.0"
+name: no_edges
+nodes:
+  generate:
+    type: llm
+    prompt: generate
+"""
+        yaml_file = tmp_path / "no_edges.yaml"
+        yaml_file.write_text(yaml_content)
+
+        with pytest.raises(ValueError, match="edges"):
+            load_graph_config(yaml_file)
+
+    def test_node_missing_prompt_raises_error(self, tmp_path):
+        """Node without prompt should raise ValidationError."""
+        yaml_content = """
+version: "1.0"
+name: bad_node
+nodes:
+  generate:
+    type: llm
+    output_model: yamlgraph.models.GenericReport
+edges:
+  - from: START
+    to: generate
+"""
+        yaml_file = tmp_path / "no_prompt.yaml"
+        yaml_file.write_text(yaml_content)
+
+        with pytest.raises(ValueError, match="prompt"):
+            load_graph_config(yaml_file)
+
+    def test_edge_missing_from_raises_error(self, tmp_path):
+        """Edge without 'from' should raise ValidationError."""
+        yaml_content = """
+version: "1.0"
+name: bad_edge
+nodes:
+  generate:
+    type: llm
+    prompt: generate
+edges:
+  - to: generate
+"""
+        yaml_file = tmp_path / "no_from.yaml"
+        yaml_file.write_text(yaml_content)
+
+        with pytest.raises(ValueError, match="from"):
+            load_graph_config(yaml_file)
+
+    def test_edge_missing_to_raises_error(self, tmp_path):
+        """Edge without 'to' should raise ValidationError."""
+        yaml_content = """
+version: "1.0"
+name: bad_edge
+nodes:
+  generate:
+    type: llm
+    prompt: generate
+edges:
+  - from: START
+"""
+        yaml_file = tmp_path / "no_to.yaml"
+        yaml_file.write_text(yaml_content)
+
+        with pytest.raises(ValueError, match="to"):
+            load_graph_config(yaml_file)
+
+    def test_valid_yaml_passes_validation(self, sample_yaml_file):
+        """Valid YAML should load without errors."""
+        config = load_graph_config(sample_yaml_file)
+        assert config.name == "test_graph"
+        assert "generate" in config.nodes

tests/unit/test_graph_schema.py

@@ -0,0 +1,193 @@
+"""Tests for graph configuration Pydantic schema validation."""
+
+import pytest
+from pydantic import ValidationError
+
+from yamlgraph.models.graph_schema import (
+    EdgeConfig,
+    NodeConfig,
+    validate_graph_schema,
+)
+
+
+class TestNodeConfig:
+    """Tests for NodeConfig validation."""
+
+    def test_default_node_type_is_llm(self):
+        """Default node type is llm."""
+        node = NodeConfig(prompt="test")
+        assert node.type == "llm"
+
+    def test_llm_node_requires_prompt(self):
+        """LLM node must have prompt."""
+        with pytest.raises(ValidationError, match="requires 'prompt'"):
+            NodeConfig(type="llm")
+
+    def test_router_requires_routes(self):
+        """Router node must have routes."""
+        with pytest.raises(ValidationError, match="requires 'routes'"):
+            NodeConfig(type="router", prompt="classify")
+
+    def test_router_with_routes_valid(self):
+        """Router with routes is valid."""
+        node = NodeConfig(
+            type="router",
+            prompt="classify",
+            routes={"positive": "happy", "negative": "sad"},
+        )
+        assert node.routes == {"positive": "happy", "negative": "sad"}
+
+    def test_map_requires_all_fields(self):
+        """Map node requires over, as, node, collect."""
+        # Missing 'as'
+        with pytest.raises(ValidationError, match="requires 'as'"):
+            NodeConfig(
+                type="map",
+                over="{state.items}",
+                node={"prompt": "process"},
+                collect="results",
+            )
+
+    def test_map_with_all_fields_valid(self):
+        """Map node with all fields is valid."""
+        node = NodeConfig.model_validate(
+            {
+                "type": "map",
+                "over": "{state.items}",
+                "as": "item",
+                "node": {"prompt": "process"},
+                "collect": "results",
+            }
+        )
+        assert node.item_var == "item"
+        assert node.collect == "results"
+
+    def test_invalid_on_error_rejected(self):
+        """Invalid on_error value is rejected."""
+        with pytest.raises(ValidationError, match="Invalid on_error"):
+            NodeConfig(prompt="test", on_error="invalid_handler")
+
+    def test_valid_on_error_accepted(self):
+        """Valid on_error values accepted."""
+        for handler in ["skip", "retry", "fail", "fallback"]:
+            node = NodeConfig(prompt="test", on_error=handler)
+            assert node.on_error == handler
+
+    def test_temperature_range(self):
+        """Temperature must be 0-2."""
+        NodeConfig(prompt="test", temperature=0.5)  # Valid
+
+        with pytest.raises(ValidationError):
+            NodeConfig(prompt="test", temperature=-0.1)
+
+        with pytest.raises(ValidationError):
+            NodeConfig(prompt="test", temperature=2.5)
+
+
+class TestEdgeConfig:
+    """Tests for EdgeConfig validation."""
+
+    def test_simple_edge(self):
+        """Simple from/to edge."""
+        edge = EdgeConfig.model_validate({"from": "a", "to": "b"})
+        assert edge.from_node == "a"
+        assert edge.to == "b"
+
+    def test_edge_with_condition(self):
+        """Edge with condition expression."""
+        edge = EdgeConfig.model_validate(
+            {
+                "from": "critique",
+                "to": "refine",
+                "condition": "score < 0.8",
+            }
+        )
+        assert edge.condition == "score < 0.8"
+
+    def test_edge_to_multiple_targets(self):
+        """Edge can have list of targets."""
+        edge = EdgeConfig.model_validate(
+            {
+                "from": "a",
+                "to": ["b", "c"],
+            }
+        )
+        assert edge.to == ["b", "c"]
+
+
+class TestGraphConfigSchema:
+    """Tests for full graph schema validation."""
+
+    def test_minimal_valid_graph(self):
+        """Minimal valid graph configuration."""
+        config = {
+            "nodes": {
+                "greet": {"prompt": "greet"},
+            },
+            "edges": [
+                {"from": "START", "to": "greet"},
+                {"from": "greet", "to": "END"},
+            ],
+        }
+        schema = validate_graph_schema(config)
+        assert schema.name == "unnamed"
+        assert "greet" in schema.nodes
+
+    def test_full_graph_config(self):
+        """Full graph with all optional fields."""
+        config = {
+            "version": "1.0",
+            "name": "test-graph",
+            "description": "A test graph",
+            "defaults": {"provider": "anthropic"},
+            "nodes": {
+                "generate": {"prompt": "generate", "temperature": 0.8},
+            },
+            "edges": [
+                {"from": "START", "to": "generate"},
+                {"from": "generate", "to": "END"},
+            ],
+            "loop_limits": {"refine": 3},
+        }
+        schema = validate_graph_schema(config)
+        assert schema.name == "test-graph"
+        assert schema.defaults == {"provider": "anthropic"}
+
+    def test_router_targets_validated(self):
+        """Router targets must exist as nodes."""
+        config = {
+            "nodes": {
+                "classify": {
+                    "type": "router",
+                    "prompt": "classify",
+                    "routes": {"a": "nonexistent"},
+                },
+            },
+            "edges": [{"from": "START", "to": "classify"}],
+        }
+        with pytest.raises(ValidationError, match="nonexistent"):
+            validate_graph_schema(config)
+
+    def test_edge_nodes_validated(self):
+        """Edge nodes must exist."""
+        config = {
+            "nodes": {"a": {"prompt": "test"}},
+            "edges": [
+                {"from": "START", "to": "a"},
+                {"from": "a", "to": "missing"},
+            ],
+        }
+        with pytest.raises(ValidationError, match="missing"):
+            validate_graph_schema(config)
+
+    def test_start_end_always_valid(self):
+        """START and END are always valid node references."""
+        config = {
+            "nodes": {"middle": {"prompt": "test"}},
+            "edges": [
+                {"from": "START", "to": "middle"},
+                {"from": "middle", "to": "END"},
+            ],
+        }
+        schema = validate_graph_schema(config)
+        assert len(schema.edges) == 2

tests/unit/test_inline_schema.py

@@ -0,0 +1,151 @@
+"""Tests for YAML inline schema integration with node factory.
+
+TDD: RED phase - tests for loading output_model from prompt YAML schema block.
+"""
+
+import pytest
+
+
+class TestInlineSchemaIntegration:
+    """Test node factory uses inline schema from prompt YAML."""
+
+    def test_node_uses_inline_schema_from_prompt(self, tmp_path, monkeypatch):
+        """Node uses schema defined in prompt YAML instead of output_model."""
+        # Create a prompt file with inline schema
+        prompt_dir = tmp_path / "prompts" / "test"
+        prompt_dir.mkdir(parents=True)
+
+        prompt_file = prompt_dir / "classify.yaml"
+        prompt_file.write_text("""
+name: classify_tone
+version: "1.0"
+
+schema:
+  name: InlineClassification
+  fields:
+    result:
+      type: str
+      description: "Classification result"
+    score:
+      type: float
+      description: "Confidence score"
+      constraints:
+        ge: 0.0
+        le: 1.0
+
+system: You are a classifier.
+user: "Classify: {message}"
+""")
+
+        # Patch prompts directory
+        monkeypatch.setenv("PROMPTS_DIR", str(tmp_path / "prompts"))
+
+        # Create node without explicit output_model - should use inline schema
+        node_config = {
+            "type": "llm",
+            "prompt": "test/classify",
+            # No output_model specified - should load from YAML
+        }
+
+        # This should work and detect inline schema
+        from yamlgraph.node_factory import get_output_model_for_node
+
+        model = get_output_model_for_node(node_config, str(tmp_path / "prompts"))
+
+        assert model is not None
+        assert model.__name__ == "InlineClassification"
+
+        # Verify model works
+        instance = model(result="positive", score=0.95)
+        assert instance.result == "positive"
+        assert instance.score == 0.95
+
+    def test_explicit_output_model_overrides_inline_schema(self, tmp_path, monkeypatch):
+        """Explicit output_model in node config takes precedence."""
+        prompt_dir = tmp_path / "prompts" / "test"
+        prompt_dir.mkdir(parents=True)
+
+        prompt_file = prompt_dir / "with_schema.yaml"
+        prompt_file.write_text("""
+name: test_prompt
+schema:
+  name: InlineModel
+  fields:
+    value: {type: str}
+system: Test
+user: "{input}"
+""")
+
+        monkeypatch.setenv("PROMPTS_DIR", str(tmp_path / "prompts"))
+
+        # Node config has explicit output_model
+        node_config = {
+            "type": "llm",
+            "prompt": "test/with_schema",
+            "output_model": "yamlgraph.models.GenericReport",  # Explicit - takes precedence
+        }
+
+        from yamlgraph.node_factory import get_output_model_for_node
+
+        model = get_output_model_for_node(node_config, str(tmp_path / "prompts"))
+
+        # Should use explicit model, not inline
+        assert model.__name__ == "GenericReport"
+
+    def test_no_schema_returns_none(self, tmp_path, monkeypatch):
+        """Prompt without schema returns None for output_model."""
+        prompt_dir = tmp_path / "prompts" / "test"
+        prompt_dir.mkdir(parents=True)
+
+        prompt_file = prompt_dir / "plain.yaml"
+        prompt_file.write_text("""
+name: plain_prompt
+system: Test
+user: "{input}"
+""")
+
+        monkeypatch.setenv("PROMPTS_DIR", str(tmp_path / "prompts"))
+
+        node_config = {
+            "type": "llm",
+            "prompt": "test/plain",
+        }
+
+        from yamlgraph.node_factory import get_output_model_for_node
+
+        model = get_output_model_for_node(node_config, str(tmp_path / "prompts"))
+
+        assert model is None
+
+
+class TestResolvePromptPath:
+    """Test resolving prompt name to full file path."""
+
+    def test_resolve_prompt_path(self, tmp_path):
+        """Resolve prompt name to full YAML path."""
+        prompt_dir = tmp_path / "prompts"
+        prompt_dir.mkdir()
+
+        (prompt_dir / "simple.yaml").write_text("name: simple")
+        (prompt_dir / "nested").mkdir()
+        (prompt_dir / "nested" / "deep.yaml").write_text("name: deep")
+
+        from yamlgraph.node_factory import resolve_prompt_path
+
+        # Simple prompt - now returns Path object
+        path = resolve_prompt_path("simple", prompt_dir)
+        assert path.name == "simple.yaml"
+
+        # Nested prompt
+        path = resolve_prompt_path("nested/deep", prompt_dir)
+        assert path.name == "deep.yaml"
+
+    def test_resolve_missing_prompt_raises(self, tmp_path):
+        """Missing prompt file raises FileNotFoundError."""
+        prompt_dir = tmp_path / "prompts"
+        prompt_dir.mkdir()
+
+        from yamlgraph.node_factory import resolve_prompt_path
+
+        with pytest.raises(FileNotFoundError):
+            resolve_prompt_path("nonexistent", prompt_dir)