yamlgraph 0.3.9__py3-none-any.whl

tests/unit/test_interrupt_node.py

@@ -0,0 +1,182 @@
+"""Unit tests for interrupt node functionality.
+
+TDD tests for 001: Interrupt Node feature.
+Tests create_interrupt_node() and interrupt YAML handling.
+"""
+
+from unittest.mock import patch
+
+from yamlgraph.constants import NodeType
+from yamlgraph.node_factory import create_interrupt_node
+
+
+class TestNodeTypeInterrupt:
+    """Test NodeType.INTERRUPT constant exists."""
+
+    def test_interrupt_constant_exists(self):
+        """NodeType should have INTERRUPT constant."""
+        assert hasattr(NodeType, "INTERRUPT")
+        assert NodeType.INTERRUPT == "interrupt"
+
+    def test_interrupt_not_requires_prompt(self):
+        """Interrupt nodes don't require prompt (can use message)."""
+        assert not NodeType.requires_prompt("interrupt")
+
+
+class TestCreateInterruptNode:
+    """Test create_interrupt_node() factory function."""
+
+    def test_create_interrupt_node_with_static_message(self):
+        """Interrupt node with static message should work."""
+        config = {
+            "message": "What is your name?",
+            "resume_key": "user_name",
+        }
+        node_fn = create_interrupt_node("ask_name", config)
+        assert callable(node_fn)
+
+    def test_create_interrupt_node_with_prompt(self):
+        """Interrupt node with prompt should work."""
+        config = {
+            "prompt": "dialogue/generate_question",
+            "state_key": "pending_question",
+            "resume_key": "user_response",
+        }
+        node_fn = create_interrupt_node("ask_dynamic", config)
+        assert callable(node_fn)
+
+    @patch("langgraph.types.interrupt")
+    def test_interrupt_node_calls_native_interrupt(self, mock_interrupt):
+        """Node should call LangGraph's native interrupt()."""
+        mock_interrupt.return_value = "Alice"  # Simulates resume value
+
+        config = {"message": "What is your name?"}
+        node_fn = create_interrupt_node("ask_name", config)
+
+        state = {}
+        result = node_fn(state)
+
+        mock_interrupt.assert_called_once_with("What is your name?")
+        assert result["user_input"] == "Alice"
+
+    @patch("langgraph.types.interrupt")
+    def test_interrupt_node_stores_payload_in_state_key(self, mock_interrupt):
+        """Payload should be stored in state_key for idempotency."""
+        mock_interrupt.return_value = "blue"
+
+        config = {
+            "message": "What is your favorite color?",
+            "state_key": "pending_question",
+            "resume_key": "color_choice",
+        }
+        node_fn = create_interrupt_node("ask_color", config)
+
+        state = {}
+        result = node_fn(state)
+
+        assert result["pending_question"] == "What is your favorite color?"
+        assert result["color_choice"] == "blue"
+
+    @patch("langgraph.types.interrupt")
+    def test_interrupt_node_idempotency_skips_prompt_on_resume(self, mock_interrupt):
+        """When state_key exists, should not re-execute prompt."""
+        mock_interrupt.return_value = "resumed_value"
+
+        config = {
+            "prompt": "expensive/llm_call",
+            "state_key": "pending_question",
+            "resume_key": "user_response",
+        }
+        node_fn = create_interrupt_node("ask_dynamic", config)
+
+        # Simulate resume: state already has the payload
+        state = {"pending_question": "Previously generated question"}
+
+        with patch("yamlgraph.node_factory.execute_prompt") as mock_prompt:
+            result = node_fn(state)
+
+            # execute_prompt should NOT be called (idempotency)
+            mock_prompt.assert_not_called()
+
+            # Should use existing payload
+            mock_interrupt.assert_called_once_with("Previously generated question")
+            assert result["user_response"] == "resumed_value"
+
+    @patch("langgraph.types.interrupt")
+    @patch("yamlgraph.node_factory.execute_prompt")
+    def test_interrupt_node_with_prompt_calls_execute_prompt(
+        self, mock_execute_prompt, mock_interrupt
+    ):
+        """First execution with prompt should call execute_prompt."""
+        mock_execute_prompt.return_value = "Generated question from LLM"
+        mock_interrupt.return_value = "user answer"
+
+        config = {
+            "prompt": "dialogue/generate_question",
+            "state_key": "pending_question",
+            "resume_key": "user_response",
+        }
+        node_fn = create_interrupt_node("ask_dynamic", config)
+
+        state = {"context": "some context"}
+        result = node_fn(state)
+
+        mock_execute_prompt.assert_called_once()
+        mock_interrupt.assert_called_once_with("Generated question from LLM")
+        assert result["pending_question"] == "Generated question from LLM"
+        assert result["user_response"] == "user answer"
+
+    @patch("langgraph.types.interrupt")
+    def test_interrupt_node_sets_current_step(self, mock_interrupt):
+        """Result should include current_step for tracking."""
+        mock_interrupt.return_value = "answer"
+
+        config = {"message": "Question?"}
+        node_fn = create_interrupt_node("my_node", config)
+
+        result = node_fn({})
+
+        assert result["current_step"] == "my_node"
+
+    def test_interrupt_node_default_keys(self):
+        """Default state_key and resume_key should be used if not specified."""
+        config = {"message": "Question?"}
+        node_fn = create_interrupt_node("ask", config)
+
+        # Just verify it creates without error
+        assert callable(node_fn)
+
+
+class TestInterruptNodeEdgeCases:
+    """Edge cases for interrupt node handling."""
+
+    @patch("langgraph.types.interrupt")
+    def test_interrupt_with_dict_payload(self, mock_interrupt):
+        """Interrupt should support dict payloads for structured questions."""
+        mock_interrupt.return_value = {"choice": "A", "reason": "because"}
+
+        config = {
+            "message": {"question": "Pick A or B", "options": ["A", "B"]},
+            "resume_key": "user_choice",
+        }
+        node_fn = create_interrupt_node("multi_choice", config)
+
+        result = node_fn({})
+
+        mock_interrupt.assert_called_once_with(
+            {"question": "Pick A or B", "options": ["A", "B"]}
+        )
+        assert result["user_choice"] == {"choice": "A", "reason": "because"}
+
+    @patch("langgraph.types.interrupt")
+    def test_interrupt_node_no_message_uses_node_name(self, mock_interrupt):
+        """If no message or prompt, use node name as fallback payload."""
+        mock_interrupt.return_value = "answer"
+
+        config = {}  # No message, no prompt
+        node_fn = create_interrupt_node("approval_gate", config)
+
+        _result = node_fn({})
+
+        # Should use {"node": "approval_gate"} as fallback
+        mock_interrupt.assert_called_once_with({"node": "approval_gate"})

tests/unit/test_issues.py

@@ -0,0 +1,164 @@
+"""Tests for issues that were identified and fixed.
+
+These tests verify the fixes for issues documented in docs/open-issues.md.
+"""
+
+from unittest.mock import patch
+
+import pytest
+
+from tests.conftest import FixtureAnalysis, FixtureGeneratedContent
+from yamlgraph.builder import build_resume_graph
+from yamlgraph.graph_loader import load_graph_config
+from yamlgraph.models import create_initial_state
+
+# =============================================================================
+# Issue 1: Resume Logic - FIXED: skip_if_exists behavior
+# =============================================================================
+
+
+class TestResumeStartFromParameter:
+    """Issue 1: Resume should skip nodes whose output already exists."""
+
+    @patch("yamlgraph.node_factory.execute_prompt")
+    def test_resume_from_analyze_skips_generate(self, mock_execute):
+        """When state has 'generated', generate node should be skipped.
+
+        Resume works via skip_if_exists: if output already in state, skip LLM call.
+        """
+        # State with generated content already present
+        state = create_initial_state(topic="test", thread_id="issue1")
+        state["generated"] = FixtureGeneratedContent(
+            title="Already Generated",
+            content="This was generated in a previous run",
+            word_count=10,
+            tags=[],
+        )
+
+        # Only mock analyze and summarize - generate should be skipped
+        mock_analysis = FixtureAnalysis(
+            summary="Analysis",
+            key_points=["Point"],
+            sentiment="neutral",
+            confidence=0.8,
+        )
+        mock_execute.side_effect = [mock_analysis, "Final summary"]
+
+        graph = build_resume_graph().compile()
+        result = graph.invoke(state)
+
+        # Expected: 2 calls (analyze, summarize) - generate skipped
+        assert mock_execute.call_count == 2, (
+            f"Expected 2 LLM calls (analyze, summarize), "
+            f"but got {mock_execute.call_count}. "
+            f"Generate should be skipped when 'generated' exists!"
+        )
+        # Original generated content should be preserved
+        assert result["generated"].title == "Already Generated"
+
+    @patch("yamlgraph.node_factory.execute_prompt")
+    def test_resume_from_summarize_skips_generate_and_analyze(self, mock_execute):
+        """When state has 'generated' and 'analysis', only summarize runs."""
+        state = create_initial_state(topic="test", thread_id="issue1b")
+        state["generated"] = FixtureGeneratedContent(
+            title="Done",
+            content="Content",
+            word_count=5,
+            tags=[],
+        )
+        state["analysis"] = FixtureAnalysis(
+            summary="Done",
+            key_points=["Point"],
+            sentiment="positive",
+            confidence=0.9,
+        )
+
+        mock_execute.return_value = "Final summary"
+
+        graph = build_resume_graph().compile()
+        result = graph.invoke(state)
+
+        # Expected: 1 call (summarize only)
+        assert mock_execute.call_count == 1, (
+            f"Expected 1 LLM call (summarize only), "
+            f"but got {mock_execute.call_count}. "
+            f"Generate and analyze should be skipped!"
+        )
+        # Original content should be preserved
+        assert result["generated"].title == "Done"
+        assert result["analysis"].summary == "Done"
+
+    def test_resume_preserves_existing_generated_content(self):
+        """Resuming should NOT overwrite already-generated content."""
+        # Covered by test_resume_from_analyze_skips_generate
+        pass
+
+
+# =============================================================================
+# Issue 2: Conditions Block is Dead Config
+# =============================================================================
+
+
+class TestConditionsFromYAML:
+    """Issue 2: Conditions block was dead config - now uses expression routing."""
+
+    def test_conditions_block_not_in_schema(self):
+        """GraphConfig no longer parses conditions block."""
+        from yamlgraph.config import DEFAULT_GRAPH
+
+        config = load_graph_config(DEFAULT_GRAPH)
+
+        # conditions attribute should not exist
+        assert not hasattr(
+            config, "conditions"
+        ), "GraphConfig should not have 'conditions' attribute - it's dead config"
+
+
+# =============================================================================
+# Issue 5: _entry_point hack
+# =============================================================================
+
+
+class TestEntryPointHack:
+    """Issue 5: Using private _entry_point is fragile."""
+
+    @pytest.fixture
+    def simple_yaml(self, tmp_path):
+        """Minimal YAML for testing."""
+        yaml_content = """
+version: "1.0"
+name: test
+nodes:
+  first:
+    type: llm
+    prompt: generate
+    output_model: yamlgraph.models.GenericReport
+    state_key: generated
+edges:
+  - from: START
+    to: first
+  - from: first
+    to: END
+"""
+        yaml_file = tmp_path / "test.yaml"
+        yaml_file.write_text(yaml_content)
+        return yaml_file
+
+    def test_entry_point_accessible_via_behavior(self, simple_yaml):
+        """Entry point should be testable via graph behavior, not private attrs.
+
+        Currently graph_loader.py sets graph._entry_point for testing.
+        This test shows how to test entry point via behavior instead.
+        """
+        from yamlgraph.graph_loader import load_and_compile
+
+        graph = load_and_compile(simple_yaml)
+        _ = graph.compile()  # Verify it compiles
+
+        # Get the graph structure - this is the proper way
+        # The first node after START should be 'first'
+        nodes = list(graph.nodes.keys())
+        assert "first" in nodes
+
+        # We can also check by looking at edges from __start__
+        # But testing via invocation is more robust

tests/unit/test_jinja2_prompts.py

@@ -0,0 +1,85 @@
+"""Integration test for Jinja2 prompt templates."""
+
+from yamlgraph.executor import format_prompt, load_prompt
+
+
+def test_jinja2_analyze_list_prompt():
+    """Test the analyze_list prompt with Jinja2 features."""
+    prompt = load_prompt("analyze_list")
+
+    # Test data
+    variables = {
+        "items": [
+            {
+                "title": "Introduction to AI",
+                "topic": "Artificial Intelligence",
+                "word_count": 500,
+                "tags": ["AI", "machine learning", "technology"],
+                "content": "Artificial intelligence is transforming how we interact with technology...",
+            },
+            {
+                "title": "Machine Learning Basics",
+                "topic": "ML Fundamentals",
+                "word_count": 750,
+                "tags": ["ML", "algorithms", "data"],
+                "content": "Machine learning involves training models on data to make predictions...",
+            },
+        ],
+        "min_confidence": 0.8,
+    }
+
+    # Format the template field
+    result = format_prompt(prompt["template"], variables)
+
+    # Verify Jinja2 features are working
+    assert "2 items" in result  # {{ items|length }} filter
+    assert "1. Introduction to AI" in result  # {{ loop.index }}
+    assert "2. Machine Learning Basics" in result
+    assert "**Tags**: AI, machine learning, technology" in result  # join filter
+    assert "**Tags**: ML, algorithms, data" in result
+    assert "confidence >= 0.8" in result  # conditional rendering
+    assert "**Content**:" in result  # if/else conditional
+
+    # Verify loop counter
+    assert "### 1." in result
+    assert "### 2." in result
+
+
+def test_jinja2_prompt_with_empty_list():
+    """Test analyze_list prompt with empty items."""
+    prompt = load_prompt("analyze_list")
+
+    variables = {"items": [], "min_confidence": None}
+
+    result = format_prompt(prompt["template"], variables)
+
+    # Should handle empty list gracefully
+    assert "0 items" in result
+    assert "### 1." not in result  # No items to iterate
+
+
+def test_jinja2_prompt_without_optional_fields():
+    """Test analyze_list prompt without optional fields."""
+    prompt = load_prompt("analyze_list")
+
+    variables = {
+        "items": [
+            {
+                "title": "Short Content",
+                "topic": "Brief",
+                "word_count": 100,
+                "tags": [],  # Empty tags
+                "content": "Short content without tags",
+            },
+        ],
+    }
+
+    result = format_prompt(prompt["template"], variables)
+
+    # Should handle missing/empty optional fields
+    assert "1 items" in result
+    assert "Short Content" in result
+    # Should not show tags section if empty
+    assert "**Tags**:" not in result or "**Tags**: \n" in result
+    # Should not show min_confidence note if not provided
+    assert "confidence >=" not in result

tests/unit/test_json_extract.py

@@ -0,0 +1,134 @@
+"""Tests for JSON extraction from LLM output (FR-B)."""
+
+
+from yamlgraph.utils.json_extract import extract_json
+
+
+class TestExtractJson:
+    """Tests for extract_json utility."""
+
+    def test_extract_raw_json_object(self):
+        """Should parse raw JSON object."""
+        text = '{"name": "test", "value": 42}'
+        result = extract_json(text)
+
+        assert result == {"name": "test", "value": 42}
+
+    def test_extract_raw_json_array(self):
+        """Should parse raw JSON array."""
+        text = '[1, 2, 3]'
+        result = extract_json(text)
+
+        assert result == [1, 2, 3]
+
+    def test_extract_json_codeblock(self):
+        """Should extract JSON from ```json ... ``` block."""
+        text = '''Here is the result:
+
+```json
+{"frequency": 3, "amount": null}
+```
+
+Reasoning: The user mentioned drinking 2-3 times per week.
+'''
+        result = extract_json(text)
+
+        assert result == {"frequency": 3, "amount": None}
+
+    def test_extract_any_codeblock(self):
+        """Should extract JSON from ``` ... ``` block without language."""
+        text = '''```
+{"status": "ok"}
+```'''
+        result = extract_json(text)
+
+        assert result == {"status": "ok"}
+
+    def test_extract_curly_pattern(self):
+        """Should extract JSON from {...} pattern in text."""
+        text = 'The extracted data is {"key": "value"} from the input.'
+        result = extract_json(text)
+
+        assert result == {"key": "value"}
+
+    def test_extract_array_pattern(self):
+        """Should extract JSON from [...] pattern in text."""
+        text = 'Items: ["a", "b", "c"] found.'
+        result = extract_json(text)
+
+        assert result == ["a", "b", "c"]
+
+    def test_returns_original_on_failure(self):
+        """Should return original text if no JSON found."""
+        text = "This is just plain text with no JSON."
+        result = extract_json(text)
+
+        assert result == text
+
+    def test_handles_nested_json(self):
+        """Should handle nested JSON structures."""
+        text = '''```json
+{
+  "person": {
+    "name": "Alice",
+    "scores": [95, 87, 92]
+  }
+}
+```'''
+        result = extract_json(text)
+
+        assert result == {"person": {"name": "Alice", "scores": [95, 87, 92]}}
+
+    def test_handles_whitespace(self):
+        """Should handle JSON with extra whitespace."""
+        text = '''   {
+  "key"  :  "value"
+}   '''
+        result = extract_json(text)
+
+        assert result == {"key": "value"}
+
+    def test_prefers_json_codeblock_over_raw(self):
+        """Should extract from codeblock even if other JSON present."""
+        text = '''Some intro {"wrong": true}
+
+```json
+{"correct": true}
+```
+'''
+        result = extract_json(text)
+
+        # Should find the codeblock, not the inline JSON
+        assert result == {"correct": True}
+
+    def test_invalid_json_in_codeblock_falls_through(self):
+        """Invalid JSON in codeblock should try next strategy."""
+        text = '''```json
+{not valid json}
+```
+
+The actual data is {"valid": true}.
+'''
+        result = extract_json(text)
+
+        # Should fall through to curly pattern
+        assert result == {"valid": True}
+
+    def test_empty_string(self):
+        """Should handle empty string."""
+        result = extract_json("")
+
+        assert result == ""
+
+    def test_multiline_json(self):
+        """Should handle multiline JSON in code block."""
+        text = '''```json
+{
+  "line1": "value1",
+  "line2": "value2",
+  "line3": "value3"
+}
+```'''
+        result = extract_json(text)
+
+        assert result == {"line1": "value1", "line2": "value2", "line3": "value3"}