langgraph-dev-testing-agentic-systems

Testing Agentic Systems

Testing LLM-based systems requires different approaches than traditional software: mock LLMs for determinism, use evaluation metrics instead of assertions.

Test Pyramid for Agentic Systems

E2E Tests (Real LLM, expensive, slow)
  ↓
Integration Tests (Mocked LLM, medium cost)
  ↓
Node Unit Tests (Fully mocked, fast)
  ↓
State/Schema Tests (No LLM, instant)

State Schema Tests (Instant)

from typing import TypedDict
from pydantic import BaseModel

# Option 1: TypedDict (lightweight, dict-like access)
class AgentStateDict(TypedDict):
    """Define state schema for the agent graph."""
    messages: list[str]
    intent: str
    confidence: float

# Option 2: Pydantic (recommended - validation, defaults, IDE support)
class AgentState(BaseModel):
    """Define state schema for the agent graph with validation."""
    messages: list[str]
    intent: str = ""
    confidence: float = 0.0

def test_state_structure_typeddict():
    """Verify TypedDict state accepts valid data."""
    state: AgentStateDict = {
        "messages": ["Hello"],
        "intent": "greeting",
        "confidence": 0.95
    }
    assert state["messages"] == ["Hello"]
    assert 0 <= state["confidence"] <= 1

def test_state_structure_pydantic():
    """Verify Pydantic state accepts valid data and validates."""
    state = AgentState(messages=["Hello"], intent="greeting", confidence=0.95)
    assert state.messages == ["Hello"]
    assert 0 <= state.confidence <= 1

    # Note: Pydantic BaseModel uses attribute access (state.messages)
    # LangGraph nodes receive Pydantic instances but graph output may be dict
    # For dict conversion: state.model_dump()

Node Unit Tests (Mocked LLM)

Node unit tests call the Python node function directly, bypassing graph compilation. This isolates node logic for fast, focused testing with mocked dependencies.

import pytest
from typing import TypedDict
from langchain_core.language_models import FakeListChatModel
from src.nodes import classify_node  # Import the node being tested

# Use TypedDict for type safety (same pattern as State Schema Tests)
class AgentStateDict(TypedDict):
    messages: list[str]
    intent: str
    confidence: float

@pytest.fixture
def mock_llm(monkeypatch):
    """Mock LLM using LangChain's FakeListChatModel.

    The fixture handles patching internally - test functions just use the fixture.
    """
    fake_llm = FakeListChatModel(responses=["greeting"])
    monkeypatch.setattr('src.nodes.llm', fake_llm)
    return fake_llm

def test_classify_node(mock_llm):
    """Test node function directly with mocked LLM (bypasses graph compilation)."""
    # Use TypedDict for type safety (defined above, matches State Schema Tests)
    state: AgentStateDict = {"messages": ["Test input"], "intent": "", "confidence": 0.0}
    result = classify_node(state)

    assert result["intent"] == "greeting"