use langgraph4rust::{
AgentNode, AgentState, DefaultMemoryState, END_NODE, LangGraphError, START_NODE,
StateGraphBuilder, StreamEvent, StreamExt,
};
use serde::Serialize;
use std::collections::HashSet;
use std::sync::Arc;
use std::time::Duration;
#[derive(Debug, Clone)]
struct CounterNode;
#[langgraph4rust::async_trait]
impl AgentNode<DefaultMemoryState> for CounterNode {
async fn apply(&self, state: Arc<DefaultMemoryState>) -> Result<(), LangGraphError> {
let count: i32 = state.get("count").await?.unwrap_or(0);
state.set("count", count + 1).await?;
Ok(())
}
}
#[derive(Debug, Clone)]
struct FailingNode;
#[langgraph4rust::async_trait]
impl AgentNode<DefaultMemoryState> for FailingNode {
async fn apply(&self, _state: Arc<DefaultMemoryState>) -> Result<(), LangGraphError> {
Err(LangGraphError::NodeError("intentional failure".into()))
}
}
#[derive(Debug, Clone)]
struct SlowNode {
ms: u64,
}
#[langgraph4rust::async_trait]
impl AgentNode<DefaultMemoryState> for SlowNode {
async fn apply(&self, state: Arc<DefaultMemoryState>) -> Result<(), LangGraphError> {
tokio::time::sleep(Duration::from_millis(self.ms)).await;
state.set("slow_done", true).await?;
Ok(())
}
}
#[derive(Debug, Clone)]
struct RouterNode;
#[langgraph4rust::async_trait]
impl AgentNode<DefaultMemoryState> for RouterNode {
async fn apply(&self, state: Arc<DefaultMemoryState>) -> Result<(), LangGraphError> {
let _ = state.get::<i32>("route").await?;
Ok(())
}
}
async fn collect_events<S>(
graph: Arc<langgraph4rust::StateGraph<S>>,
state: Arc<S>,
) -> Vec<StreamEvent<S>>
where
S: AgentState + Send + Sync + 'static,
{
let mut rx = graph.stream(state);
let mut events = Vec::new();
while let Some(event) = rx.next().await {
events.push(event);
}
events
}
fn extract_error(events: &[StreamEvent<DefaultMemoryState>]) -> &LangGraphError {
match events.last() {
Some(StreamEvent::WorkflowError { error, .. }) => error,
_ => panic!("expected WorkflowError as last event"),
}
}
#[tokio::test]
async fn test_linear_event_sequence() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(graph, state.clone()).await;
assert!(matches!(events.first(), Some(StreamEvent::WorkflowStarted)));
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
assert_eq!(events.len(), 7, "expected 7 events, got {}", events.len());
assert!(matches!(
&events[1],
StreamEvent::RoutingDecision { step: 1, .. }
));
assert!(matches!(&events[2], StreamEvent::StepStarted { step: 2, nodes } if nodes == &["a"]));
assert!(matches!(&events[3], StreamEvent::NodeStarted { step: 2, name } if name == "a"));
assert!(matches!(&events[4], StreamEvent::NodeFinished { step: 2, name, .. } if name == "a"));
assert!(matches!(
&events[5],
StreamEvent::RoutingDecision { step: 2, .. }
));
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, 1);
Ok(())
}
#[tokio::test]
async fn test_step_index_consistency() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let mut step1_events = 0usize;
let mut step2_events = 0usize;
let mut step3_events = 0usize;
for e in &events {
match e {
StreamEvent::StepStarted { step, .. }
| StreamEvent::NodeStarted { step, .. }
| StreamEvent::NodeFinished { step, .. }
| StreamEvent::RoutingDecision { step, .. } => match *step {
1 => step1_events += 1,
2 => step2_events += 1,
3 => step3_events += 1,
_ => panic!("unexpected step index: {}", step),
},
_ => {}
}
}
assert_eq!(
step1_events, 1,
"step 1 should have 1 event (RoutingDecision)"
);
assert_eq!(step2_events, 4, "step 2 should have 4 events");
assert_eq!(step3_events, 4, "step 3 should have 4 events");
Ok(())
}
#[tokio::test]
async fn test_workflow_finished_metadata() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_node("c", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from(["c".to_string()]));
builder.add_edge("c", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
if let Some(StreamEvent::WorkflowFinished {
state: final_state,
total_steps,
elapsed,
}) = events.last()
{
assert_eq!(
*total_steps, 5,
"should execute 5 steps (start + 3 nodes + end)"
);
assert!(*elapsed > Duration::ZERO, "elapsed should be positive");
let count: i32 = final_state.get("count").await?.unwrap_or(0);
assert_eq!(count, 3);
} else {
panic!("last event should be WorkflowFinished");
}
Ok(())
}
#[tokio::test]
async fn test_parallel_nodes_concurrent_timing() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("slow_a", Box::new(SlowNode { ms: 50 }));
builder.add_node("slow_b", Box::new(SlowNode { ms: 50 }));
builder.add_edge(
START_NODE,
HashSet::from(["slow_a".to_string(), "slow_b".to_string()]),
);
builder.add_edge("slow_a", HashSet::from([END_NODE.to_string()]));
builder.add_edge("slow_b", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let elapsed_values: Vec<Duration> = events
.iter()
.filter_map(|e| match e {
StreamEvent::NodeFinished { elapsed, .. } => Some(*elapsed),
_ => None,
})
.collect();
assert_eq!(elapsed_values.len(), 2, "should have 2 NodeFinished events");
for d in &elapsed_values {
assert!(
*d >= Duration::from_millis(45),
"node elapsed {:?} should be ~50ms",
d
);
}
if let Some(StreamEvent::WorkflowFinished { elapsed, .. }) = events.last() {
assert!(
*elapsed < Duration::from_millis(150),
"total elapsed {:?} suggests sequential execution",
elapsed
);
}
Ok(())
}
#[tokio::test]
async fn test_parallel_step_started_contains_all_nodes() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("x", Box::new(CounterNode));
builder.add_node("y", Box::new(CounterNode));
builder.add_node("z", Box::new(CounterNode));
builder.add_edge(
START_NODE,
HashSet::from(["x".to_string(), "y".to_string(), "z".to_string()]),
);
builder.add_edge("x", HashSet::from([END_NODE.to_string()]));
builder.add_edge("y", HashSet::from([END_NODE.to_string()]));
builder.add_edge("z", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let step_started = events
.iter()
.find(|e| matches!(e, StreamEvent::StepStarted { .. }));
if let Some(StreamEvent::StepStarted { step, nodes }) = step_started {
assert_eq!(*step, 2, "real nodes start at step 2");
assert_eq!(nodes.len(), 3);
let set: HashSet<&String> = nodes.iter().collect();
assert!(set.contains(&&"x".to_string()));
assert!(set.contains(&&"y".to_string()));
assert!(set.contains(&&"z".to_string()));
} else {
panic!("should have StepStarted event");
}
Ok(())
}
#[tokio::test]
async fn test_conditional_routing_decision() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("router", Box::new(RouterNode));
builder.add_node("left", Box::new(CounterNode));
builder.add_node("right", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["router".to_string()]));
builder.add_conditional_edge(
"router",
vec![Box::new(|state: &DefaultMemoryState| {
let _ = state;
"left".to_string()
})],
);
builder.add_edge("left", HashSet::from([END_NODE.to_string()]));
builder.add_edge("right", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let routing = events.iter().find(|e| matches!(
e,
StreamEvent::RoutingDecision { from_nodes, .. } if from_nodes.contains(&"router".to_string())
));
assert!(routing.is_some(), "should have RoutingDecision from router");
if let Some(StreamEvent::RoutingDecision {
from_nodes,
to_nodes,
..
}) = routing
{
assert!(from_nodes.contains(&"router".to_string()));
assert!(to_nodes.contains(&"left".to_string()));
}
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
Ok(())
}
#[tokio::test]
async fn test_node_failure_emits_workflow_error() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("ok", Box::new(CounterNode));
builder.add_node("fail", Box::new(FailingNode));
builder.add_edge(START_NODE, HashSet::from(["ok".to_string()]));
builder.add_edge("ok", HashSet::from(["fail".to_string()]));
builder.add_edge("fail", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert!(matches!(events.first(), Some(StreamEvent::WorkflowStarted)));
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowError { .. })
));
assert!(
!events
.iter()
.any(|e| matches!(e, StreamEvent::WorkflowFinished { .. }))
);
if let Some(StreamEvent::WorkflowError { step, error, .. }) = events.last() {
assert_eq!(*step, 3, "error should occur at step 3");
assert!(matches!(error, LangGraphError::NodeError(_)));
}
Ok(())
}
#[tokio::test]
async fn test_parallel_node_failure() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("good", Box::new(CounterNode));
builder.add_node("bad", Box::new(FailingNode));
builder.add_edge(
START_NODE,
HashSet::from(["good".to_string(), "bad".to_string()]),
);
builder.add_edge("good", HashSet::from([END_NODE.to_string()]));
builder.add_edge("bad", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowError { .. })
));
let started_count = events
.iter()
.filter(|e| matches!(e, StreamEvent::NodeStarted { .. }))
.count();
assert_eq!(started_count, 2, "both nodes should start");
Ok(())
}
#[tokio::test]
async fn test_max_steps_exhaustion_emits_error() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.set_max_steps(4);
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from(["a".to_string()])); let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
if let Some(StreamEvent::WorkflowError { step, error, .. }) = events.last() {
assert_eq!(*step, 4, "should stop at max_steps");
let msg = error.to_string();
assert!(
msg.contains("max_steps"),
"error should mention max_steps, got: {}",
msg
);
} else {
panic!("last event should be WorkflowError");
}
assert!(
!events
.iter()
.any(|e| matches!(e, StreamEvent::WorkflowFinished { .. }))
);
let count: i32 = state.get("count").await?.unwrap_or(0);
assert!(count > 0, "some steps should have executed");
Ok(())
}
#[tokio::test]
async fn test_receiver_drop_terminates_driver() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
for name in ["n1", "n2", "n3", "n4", "n5"] {
builder.add_node(name, Box::new(SlowNode { ms: 20 }));
}
builder.add_edge(START_NODE, HashSet::from(["n1".to_string()]));
builder.add_edge("n1", HashSet::from(["n2".to_string()]));
builder.add_edge("n2", HashSet::from(["n3".to_string()]));
builder.add_edge("n3", HashSet::from(["n4".to_string()]));
builder.add_edge("n4", HashSet::from(["n5".to_string()]));
builder.add_edge("n5", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let mut rx = graph.stream(Arc::new(DefaultMemoryState::new()));
let first = rx.next().await;
assert!(matches!(first, Some(StreamEvent::WorkflowStarted)));
drop(rx);
tokio::time::sleep(Duration::from_millis(50)).await;
Ok(())
}
#[tokio::test]
async fn test_state_accumulates_across_steps() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
for name in ["s1", "s2", "s3", "s4"] {
builder.add_node(name, Box::new(CounterNode));
}
builder.add_edge(START_NODE, HashSet::from(["s1".to_string()]));
builder.add_edge("s1", HashSet::from(["s2".to_string()]));
builder.add_edge("s2", HashSet::from(["s3".to_string()]));
builder.add_edge("s3", HashSet::from(["s4".to_string()]));
builder.add_edge("s4", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, 4, "4 nodes should increment count 4 times");
Ok(())
}
#[tokio::test]
async fn test_node_finished_elapsed_accuracy() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("slow", Box::new(SlowNode { ms: 80 }));
builder.add_edge(START_NODE, HashSet::from(["slow".to_string()]));
builder.add_edge("slow", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let node_finished = events
.iter()
.find(|e| matches!(e, StreamEvent::NodeFinished { name, .. } if name == "slow"));
if let Some(StreamEvent::NodeFinished { elapsed, .. }) = node_finished {
assert!(
*elapsed >= Duration::from_millis(75),
"elapsed {:?} should be >= ~80ms",
elapsed
);
} else {
panic!("should have NodeFinished for 'slow'");
}
Ok(())
}
#[tokio::test]
async fn test_routing_decision_from_to_nodes() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("alpha", Box::new(CounterNode));
builder.add_node("beta", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["alpha".to_string()]));
builder.add_edge("alpha", HashSet::from(["beta".to_string()]));
builder.add_edge("beta", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let routings: Vec<_> = events
.iter()
.filter(|e| matches!(e, StreamEvent::RoutingDecision { .. }))
.collect();
assert_eq!(routings.len(), 3, "should have 3 routing decisions");
if let StreamEvent::RoutingDecision {
step,
from_nodes,
to_nodes,
} = routings[0]
{
assert_eq!(*step, 1);
assert!(from_nodes.contains(&"__start__".to_string()));
assert!(to_nodes.contains(&"alpha".to_string()));
}
if let StreamEvent::RoutingDecision {
step,
from_nodes,
to_nodes,
} = routings[1]
{
assert_eq!(*step, 2);
assert!(from_nodes.contains(&"alpha".to_string()));
assert!(to_nodes.contains(&"beta".to_string()));
}
if let StreamEvent::RoutingDecision {
step,
from_nodes,
to_nodes,
} = routings[2]
{
assert_eq!(*step, 3);
assert!(from_nodes.contains(&"beta".to_string()));
assert!(to_nodes.contains(&"__end__".to_string()));
}
Ok(())
}
#[tokio::test]
async fn test_event_count_formula() -> Result<(), LangGraphError> {
for n in 1..=6 {
let mut builder = StateGraphBuilder::new();
let names: Vec<String> = (0..n).map(|i| format!("node_{}", i)).collect();
for name in &names {
builder.add_node(name, Box::new(CounterNode));
}
builder.add_edge(START_NODE, HashSet::from([names[0].clone()]));
for i in 0..n - 1 {
builder.add_edge(&names[i], HashSet::from([names[i + 1].clone()]));
}
builder.add_edge(&names[n - 1], HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let expected = 3 + 4 * n;
assert_eq!(
events.len(),
expected,
"n={}: expected {} events, got {}",
n,
expected,
events.len()
);
}
Ok(())
}
#[tokio::test]
async fn test_workflow_started_always_first() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert!(matches!(events[0], StreamEvent::WorkflowStarted));
let mut builder = StateGraphBuilder::new();
builder.add_node("f", Box::new(FailingNode));
builder.add_edge(START_NODE, HashSet::from(["f".to_string()]));
builder.add_edge("f", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert!(matches!(events[0], StreamEvent::WorkflowStarted));
Ok(())
}
#[tokio::test]
async fn test_workflow_error_is_terminal() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("fail", Box::new(FailingNode));
builder.add_node("unreachable", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["fail".to_string()]));
builder.add_edge("fail", HashSet::from(["unreachable".to_string()]));
builder.add_edge("unreachable", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowError { .. })
));
assert!(!events.iter().any(|e| matches!(
e,
StreamEvent::NodeStarted { name, .. } if name == "unreachable"
)));
Ok(())
}
#[tokio::test]
async fn test_diamond_fan_out_fan_in() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_node("merge", Box::new(CounterNode));
builder.add_edge(
START_NODE,
HashSet::from(["a".to_string(), "b".to_string()]),
);
builder.add_edge("a", HashSet::from(["merge".to_string()]));
builder.add_edge("b", HashSet::from(["merge".to_string()]));
builder.add_edge("merge", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, 3, "a + b + merge should run 3 times");
let merge_starts = events
.iter()
.filter(|e| matches!(e, StreamEvent::NodeStarted { name, .. } if name == "merge"))
.count();
assert_eq!(merge_starts, 1, "merge should run exactly once");
Ok(())
}
#[tokio::test]
async fn test_parallel_all_nodes_finish_successfully() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_node("c", Box::new(CounterNode));
builder.add_edge(
START_NODE,
HashSet::from(["a".to_string(), "b".to_string(), "c".to_string()]),
);
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
builder.add_edge("b", HashSet::from([END_NODE.to_string()]));
builder.add_edge("c", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let finished = events
.iter()
.filter(|e| matches!(e, StreamEvent::NodeFinished { .. }))
.count();
assert_eq!(finished, 3, "all 3 nodes should finish");
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, 3);
Ok(())
}
#[tokio::test]
async fn test_workflow_error_carries_state_snapshot() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("ok", Box::new(CounterNode));
builder.add_node("fail", Box::new(FailingNode));
builder.add_edge(START_NODE, HashSet::from(["ok".to_string()]));
builder.add_edge("ok", HashSet::from(["fail".to_string()]));
builder.add_edge("fail", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
if let Some(StreamEvent::WorkflowError { state, .. }) = events.last() {
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, 1, "error snapshot should keep partial update");
} else {
panic!("last event should be WorkflowError");
}
Ok(())
}
#[tokio::test]
async fn test_workflow_finished_state_is_same_arc() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(graph, Arc::clone(&state)).await;
if let Some(StreamEvent::WorkflowFinished {
state: final_state, ..
}) = events.last()
{
assert!(
Arc::ptr_eq(&state, final_state),
"finished state should be the same Arc as input"
);
} else {
panic!("last event should be WorkflowFinished");
}
Ok(())
}
#[tokio::test]
async fn test_graph_reuse_sequential_streams() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
for _ in 0..2 {
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, 1, "each run starts from fresh state");
}
Ok(())
}
#[tokio::test]
async fn test_concurrent_streams_same_graph() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let (e1, e2, e3) = tokio::join!(
collect_events(Arc::clone(&graph), Arc::new(DefaultMemoryState::new())),
collect_events(Arc::clone(&graph), Arc::new(DefaultMemoryState::new())),
collect_events(Arc::clone(&graph), Arc::new(DefaultMemoryState::new())),
);
for events in [&e1, &e2, &e3] {
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
}
Ok(())
}
#[tokio::test]
async fn test_multiple_conditional_routers_merge() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("split", Box::new(CounterNode));
builder.add_node("t1", Box::new(CounterNode));
builder.add_node("t2", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["split".to_string()]));
builder.add_conditional_edge(
"split",
vec![
Box::new(|_state: &DefaultMemoryState| "t1".to_string()),
Box::new(|_state: &DefaultMemoryState| "t2".to_string()),
],
);
builder.add_edge("t1", HashSet::from([END_NODE.to_string()]));
builder.add_edge("t2", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
let routing = events.iter().find(|e| matches!(
e,
StreamEvent::RoutingDecision { from_nodes, .. } if from_nodes.contains(&"split".to_string())
));
if let Some(StreamEvent::RoutingDecision { to_nodes, .. }) = routing {
assert!(to_nodes.contains(&"t1".to_string()), "missing t1");
assert!(to_nodes.contains(&"t2".to_string()), "missing t2");
} else {
panic!("should have RoutingDecision from split");
}
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, 3);
Ok(())
}
#[test]
fn test_node_cannot_have_both_static_and_conditional_edges() {
let mut builder = StateGraphBuilder::new();
builder.add_node("split", Box::new(CounterNode));
builder.add_node("t", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["split".to_string()]));
builder.add_edge("split", HashSet::from(["t".to_string()]));
builder.add_conditional_edge(
"split",
vec![Box::new(|_state: &DefaultMemoryState| "t".to_string())],
);
builder.add_edge("t", HashSet::from([END_NODE.to_string()]));
let result = builder.compile();
assert!(
result.is_err(),
"compile should reject mixed static + conditional edges"
);
let err = result.err().unwrap();
assert!(matches!(err, LangGraphError::GraphError(_)));
assert!(
err.to_string()
.contains("both static edges and conditional edges")
);
}
#[tokio::test]
async fn test_conditional_edge_directly_to_end() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("router", Box::new(RouterNode));
builder.add_edge(START_NODE, HashSet::from(["router".to_string()]));
builder.add_conditional_edge(
"router",
vec![Box::new(|_state: &DefaultMemoryState| END_NODE.to_string())],
);
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let started = events
.iter()
.filter(|e| matches!(e, StreamEvent::NodeStarted { .. }))
.count();
assert_eq!(started, 1, "only router should start");
Ok(())
}
#[tokio::test]
async fn test_large_fan_out_backpressure() -> Result<(), LangGraphError> {
const N: usize = 20;
let mut builder = StateGraphBuilder::new();
let names: Vec<String> = (0..N).map(|i| format!("p{}", i)).collect();
for name in &names {
builder.add_node(name, Box::new(CounterNode));
}
builder.add_edge(START_NODE, names.iter().cloned().collect());
for name in &names {
builder.add_edge(name, HashSet::from([END_NODE.to_string()]));
}
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let finished = events
.iter()
.filter(|e| matches!(e, StreamEvent::NodeFinished { .. }))
.count();
assert_eq!(finished, N, "all {} nodes should finish", N);
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, N as i32);
Ok(())
}
#[tokio::test]
async fn test_self_loop_max_steps() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.set_max_steps(3);
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["a".to_string()])); let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
if let Some(StreamEvent::WorkflowError { error, .. }) = events.last() {
assert!(
error.to_string().contains("max_steps"),
"should report max_steps"
);
} else {
panic!("last event should be WorkflowError");
}
assert!(
!events
.iter()
.any(|e| matches!(e, StreamEvent::WorkflowFinished { .. }))
);
Ok(())
}
#[tokio::test]
async fn test_failing_node_still_emits_node_finished() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("fail", Box::new(FailingNode));
builder.add_edge(START_NODE, HashSet::from(["fail".to_string()]));
builder.add_edge("fail", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert!(events.iter().any(|e| matches!(
e,
StreamEvent::NodeStarted { name, .. } if name == "fail"
)));
assert!(
events.iter().any(|e| matches!(
e,
StreamEvent::NodeFinished { name, .. } if name == "fail"
)),
"failing node should still emit NodeFinished"
);
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowError { .. })
));
Ok(())
}
#[derive(Clone)]
struct SyncRouteState {
data: Arc<std::sync::Mutex<std::collections::HashMap<String, serde_json::Value>>>,
}
impl SyncRouteState {
fn new() -> Self {
Self {
data: Arc::new(std::sync::Mutex::new(std::collections::HashMap::new())),
}
}
fn get_sync(&self, key: &str) -> Option<String> {
self.data
.lock()
.unwrap()
.get(key)
.and_then(|v| v.as_str().map(|s| s.to_string()))
}
}
#[langgraph4rust::async_trait]
impl AgentState for SyncRouteState {
async fn get<T: serde::de::DeserializeOwned + Send + Sync>(
&self,
key: &str,
) -> Result<Option<T>, LangGraphError> {
let guard = self.data.lock().unwrap();
Ok(guard
.get(key)
.and_then(|v| serde_json::from_value(v.clone()).ok()))
}
async fn set<T: serde::Serialize + Send + Sync>(
&self,
key: &str,
value: T,
) -> Result<bool, LangGraphError> {
let v =
serde_json::to_value(value).map_err(|e| LangGraphError::StateError(e.to_string()))?;
self.data.lock().unwrap().insert(key.to_string(), v);
Ok(true)
}
async fn snapshot(&self, step: usize, node_keys: Vec<String>) -> Result<(), ()> {
Ok(())
}
}
#[derive(Clone)]
struct SetRouteNode {
target: String,
}
#[langgraph4rust::async_trait]
impl AgentNode<SyncRouteState> for SetRouteNode {
async fn apply(&self, state: Arc<SyncRouteState>) -> Result<(), LangGraphError> {
state.set("route", self.target.clone()).await?;
Ok(())
}
}
#[derive(Clone)]
struct MarkNode {
key: String,
}
#[langgraph4rust::async_trait]
impl AgentNode<SyncRouteState> for MarkNode {
async fn apply(&self, state: Arc<SyncRouteState>) -> Result<(), LangGraphError> {
state.set(&self.key, true).await?;
Ok(())
}
}
#[tokio::test]
async fn test_state_dependent_conditional_routing() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::<SyncRouteState>::new();
builder.add_node(
"decide",
Box::new(SetRouteNode {
target: "right".to_string(),
}),
);
builder.add_node(
"left",
Box::new(MarkNode {
key: "left_visited".to_string(),
}),
);
builder.add_node(
"right",
Box::new(MarkNode {
key: "right_visited".to_string(),
}),
);
builder.add_edge(START_NODE, HashSet::from(["decide".to_string()]));
builder.add_conditional_edge(
"decide",
vec![Box::new(|state: &SyncRouteState| {
state
.get_sync("route")
.unwrap_or_else(|| "left".to_string())
})],
);
builder.add_edge("left", HashSet::from([END_NODE.to_string()]));
builder.add_edge("right", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(SyncRouteState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let right: Option<bool> = state.get("right_visited").await?;
let left: Option<bool> = state.get("left_visited").await?;
assert_eq!(right, Some(true), "right branch should be visited");
assert_eq!(left, None, "left branch should NOT be visited");
Ok(())
}
#[derive(Debug, Clone)]
struct SetIntNode {
key: String,
value: i32,
}
#[langgraph4rust::async_trait]
impl AgentNode<DefaultMemoryState> for SetIntNode {
async fn apply(&self, state: Arc<DefaultMemoryState>) -> Result<(), LangGraphError> {
state.set(&self.key, self.value).await?;
Ok(())
}
}
#[derive(Debug, Clone)]
struct DoubleNode {
read_key: String,
write_key: String,
}
#[langgraph4rust::async_trait]
impl AgentNode<DefaultMemoryState> for DoubleNode {
async fn apply(&self, state: Arc<DefaultMemoryState>) -> Result<(), LangGraphError> {
let v: i32 = state.get(&self.read_key).await?.unwrap_or(0);
state.set(&self.write_key, v * 2).await?;
Ok(())
}
}
#[tokio::test]
async fn test_node_started_finished_pairing() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let started: HashSet<(usize, String)> = events
.iter()
.filter_map(|e| match e {
StreamEvent::NodeStarted { step, name } => Some((*step, name.clone())),
_ => None,
})
.collect();
let finished: HashSet<(usize, String)> = events
.iter()
.filter_map(|e| match e {
StreamEvent::NodeFinished { step, name, .. } => Some((*step, name.clone())),
_ => None,
})
.collect();
assert_eq!(
started, finished,
"every NodeStarted must pair with a NodeFinished"
);
assert_eq!(started.len(), 2, "two real nodes should run");
Ok(())
}
#[tokio::test]
async fn test_node_started_precedes_its_finished() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("slow", Box::new(SlowNode { ms: 20 }));
builder.add_edge(START_NODE, HashSet::from(["slow".to_string()]));
builder.add_edge("slow", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let started_pos = events
.iter()
.position(|e| matches!(e, StreamEvent::NodeStarted { name, .. } if name == "slow"));
let finished_pos = events
.iter()
.position(|e| matches!(e, StreamEvent::NodeFinished { name, .. } if name == "slow"));
match (started_pos, finished_pos) {
(Some(s), Some(f)) => assert!(s < f, "NodeStarted must come before NodeFinished"),
_ => panic!("both NodeStarted and NodeFinished should exist"),
}
Ok(())
}
#[tokio::test]
async fn test_step_started_precedes_node_started() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let step_pos = events
.iter()
.position(|e| matches!(e, StreamEvent::StepStarted { step: 2, .. }));
let node_pos = events
.iter()
.position(|e| matches!(e, StreamEvent::NodeStarted { step: 2, .. }));
match (step_pos, node_pos) {
(Some(sp), Some(np)) => assert!(sp < np, "StepStarted must precede NodeStarted"),
_ => panic!("both StepStarted and NodeStarted for step 2 should exist"),
}
Ok(())
}
#[tokio::test]
async fn test_no_step_started_for_start_step() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert!(
!events
.iter()
.any(|e| matches!(e, StreamEvent::StepStarted { step: 1, .. })),
"__start__ step (1) must not emit StepStarted"
);
Ok(())
}
#[tokio::test]
async fn test_max_steps_exact_boundary() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.set_max_steps(3);
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
match events.last() {
Some(StreamEvent::WorkflowFinished { total_steps, .. }) => {
assert_eq!(*total_steps, 3, "should finish exactly at max_steps");
}
other => panic!(
"expected WorkflowFinished, got {:?}",
std::mem::discriminant(other.unwrap())
),
}
let mut builder = StateGraphBuilder::new();
builder.set_max_steps(2);
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert!(
matches!(events.last(), Some(StreamEvent::WorkflowError { .. })),
"one step short of max_steps should error"
);
Ok(())
}
#[tokio::test]
async fn test_conditional_router_unknown_target_errors() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("router", Box::new(RouterNode));
builder.add_edge(START_NODE, HashSet::from(["router".to_string()]));
builder.add_conditional_edge(
"router",
vec![Box::new(|_state: &DefaultMemoryState| "ghost".to_string())],
);
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
match events.last() {
Some(StreamEvent::WorkflowError { error, .. }) => {
assert!(
matches!(error, LangGraphError::GraphError(_)),
"unknown router target should yield GraphError"
);
}
_ => panic!("expected WorkflowError for unknown router target"),
}
Ok(())
}
#[tokio::test]
async fn test_data_dependency_across_steps() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node(
"init",
Box::new(SetIntNode {
key: "n".to_string(),
value: 5,
}),
);
builder.add_node(
"double",
Box::new(DoubleNode {
read_key: "n".to_string(),
write_key: "n2".to_string(),
}),
);
builder.add_edge(START_NODE, HashSet::from(["init".to_string()]));
builder.add_edge("init", HashSet::from(["double".to_string()]));
builder.add_edge("double", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let n2: i32 = state.get("n2").await?.unwrap_or(0);
assert_eq!(n2, 10, "downstream node should see upstream write");
Ok(())
}
#[tokio::test]
async fn test_workflow_finished_elapsed_lower_bound() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("fast", Box::new(SlowNode { ms: 30 }));
builder.add_node("slow", Box::new(SlowNode { ms: 60 }));
builder.add_edge(
START_NODE,
HashSet::from(["fast".to_string(), "slow".to_string()]),
);
builder.add_edge("fast", HashSet::from([END_NODE.to_string()]));
builder.add_edge("slow", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let max_node_elapsed = events
.iter()
.filter_map(|e| match e {
StreamEvent::NodeFinished { elapsed, .. } => Some(*elapsed),
_ => None,
})
.max()
.unwrap_or(Duration::ZERO);
if let Some(StreamEvent::WorkflowFinished { elapsed, .. }) = events.last() {
assert!(
*elapsed >= max_node_elapsed,
"workflow elapsed {:?} must encompass slowest node {:?}",
elapsed,
max_node_elapsed
);
} else {
panic!("last event should be WorkflowFinished");
}
Ok(())
}
#[tokio::test]
async fn test_exactly_one_terminal_event() -> Result<(), LangGraphError> {
let count_terminal = |events: &Vec<StreamEvent<DefaultMemoryState>>| {
events
.iter()
.filter(|e| {
matches!(
e,
StreamEvent::WorkflowFinished { .. } | StreamEvent::WorkflowError { .. }
)
})
.count()
};
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert_eq!(count_terminal(&events), 1, "success: exactly one terminal");
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let mut builder = StateGraphBuilder::new();
builder.add_node("f", Box::new(FailingNode));
builder.add_edge(START_NODE, HashSet::from(["f".to_string()]));
builder.add_edge("f", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert_eq!(count_terminal(&events), 1, "failure: exactly one terminal");
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowError { .. })
));
Ok(())
}
#[derive(Debug, Clone, Copy)]
enum ErrKind {
Timeout,
State,
Retry,
}
#[derive(Debug, Clone)]
struct ErrorNode {
kind: ErrKind,
}
#[langgraph4rust::async_trait]
impl AgentNode<DefaultMemoryState> for ErrorNode {
async fn apply(&self, _state: Arc<DefaultMemoryState>) -> Result<(), LangGraphError> {
Err(match self.kind {
ErrKind::Timeout => LangGraphError::Timeout("timed out".into()),
ErrKind::State => LangGraphError::StateError("state corrupted".into()),
ErrKind::Retry => LangGraphError::RetryExhausted("retries exhausted".into()),
})
}
}
#[derive(Debug, Clone)]
struct MultiKeyNode;
#[langgraph4rust::async_trait]
impl AgentNode<DefaultMemoryState> for MultiKeyNode {
async fn apply(&self, state: Arc<DefaultMemoryState>) -> Result<(), LangGraphError> {
state.set("k1", 1i32).await?;
state.set("k2", 2i32).await?;
state.set("k3", 3i32).await?;
Ok(())
}
}
#[tokio::test]
async fn test_workflow_started_emitted_exactly_once() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let started_count = events
.iter()
.filter(|e| matches!(e, StreamEvent::WorkflowStarted))
.count();
assert_eq!(
started_count, 1,
"WorkflowStarted must be emitted exactly once"
);
Ok(())
}
#[tokio::test]
async fn test_error_variant_fidelity() -> Result<(), LangGraphError> {
let run = |kind: ErrKind| async move {
let mut builder = StateGraphBuilder::new();
builder.add_node("boom", Box::new(ErrorNode { kind }));
builder.add_edge(START_NODE, HashSet::from(["boom".to_string()]));
builder.add_edge("boom", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile().unwrap());
collect_events(graph, Arc::new(DefaultMemoryState::new())).await
};
let e_timeout = run(ErrKind::Timeout).await;
assert!(matches!(
extract_error(&e_timeout),
LangGraphError::Timeout(_)
));
let e_state = run(ErrKind::State).await;
assert!(matches!(
extract_error(&e_state),
LangGraphError::StateError(_)
));
let e_retry = run(ErrKind::Retry).await;
assert!(matches!(
extract_error(&e_retry),
LangGraphError::RetryExhausted(_)
));
Ok(())
}
#[tokio::test]
async fn test_concurrent_streams_state_isolation() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let s1 = Arc::new(DefaultMemoryState::new());
let s2 = Arc::new(DefaultMemoryState::new());
let (e1, e2) = tokio::join!(
collect_events(Arc::clone(&graph), Arc::clone(&s1)),
collect_events(Arc::clone(&graph), Arc::clone(&s2)),
);
assert!(matches!(
e1.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
assert!(matches!(
e2.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let c1: i32 = s1.get("count").await?.unwrap_or(0);
let c2: i32 = s2.get("count").await?.unwrap_or(0);
assert_eq!(c1, 1, "stream 1 state must not be contaminated");
assert_eq!(c2, 1, "stream 2 state must not be contaminated");
Ok(())
}
#[tokio::test]
async fn test_stream_termination_is_idempotent() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let mut rx = graph.stream(Arc::new(DefaultMemoryState::new()));
while rx.next().await.is_some() {}
assert!(rx.next().await.is_none());
assert!(rx.next().await.is_none());
assert!(rx.next().await.is_none());
Ok(())
}
#[tokio::test]
async fn test_parallel_nodes_share_step_index() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_edge(
START_NODE,
HashSet::from(["a".to_string(), "b".to_string()]),
);
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
builder.add_edge("b", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let started_steps: HashSet<usize> = events
.iter()
.filter_map(|e| match e {
StreamEvent::NodeStarted { step, .. } => Some(*step),
_ => None,
})
.collect();
let finished_steps: HashSet<usize> = events
.iter()
.filter_map(|e| match e {
StreamEvent::NodeFinished { step, .. } => Some(*step),
_ => None,
})
.collect();
assert_eq!(
started_steps,
HashSet::from([2]),
"parallel nodes share one step"
);
assert_eq!(finished_steps, HashSet::from([2]));
Ok(())
}
#[tokio::test]
async fn test_node_writes_multiple_keys() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("multi", Box::new(MultiKeyNode));
builder.add_edge(START_NODE, HashSet::from(["multi".to_string()]));
builder.add_edge("multi", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let k1: i32 = state.get("k1").await?.unwrap_or(0);
let k2: i32 = state.get("k2").await?.unwrap_or(0);
let k3: i32 = state.get("k3").await?.unwrap_or(0);
assert_eq!((k1, k2, k3), (1, 2, 3), "all keys must be persisted");
Ok(())
}
#[tokio::test]
async fn test_event_count_deterministic_across_runs() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_node("c", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from(["c".to_string()]));
builder.add_edge("c", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let expected = 3 + 4 * 3;
for _ in 0..5 {
let events = collect_events(Arc::clone(&graph), Arc::new(DefaultMemoryState::new())).await;
assert_eq!(events.len(), expected, "event count must be deterministic");
}
Ok(())
}
#[tokio::test]
async fn test_routing_decision_count_linear() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let routing_count = events
.iter()
.filter(|e| matches!(e, StreamEvent::RoutingDecision { .. }))
.count();
assert_eq!(
routing_count, 3,
"linear N=2 graph should have N+1 routing decisions"
);
Ok(())
}
#[tokio::test]
async fn test_diamond_total_steps() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_node("merge", Box::new(CounterNode));
builder.add_edge(
START_NODE,
HashSet::from(["a".to_string(), "b".to_string()]),
);
builder.add_edge("a", HashSet::from(["merge".to_string()]));
builder.add_edge("b", HashSet::from(["merge".to_string()]));
builder.add_edge("merge", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
match events.last() {
Some(StreamEvent::WorkflowFinished { total_steps, .. }) => {
assert_eq!(*total_steps, 4, "diamond graph should take 4 steps");
}
_ => panic!("expected WorkflowFinished"),
}
Ok(())
}
#[tokio::test]
async fn test_slow_consumer_no_event_loss() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_node("c", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from(["c".to_string()]));
builder.add_edge("c", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let mut rx = graph.stream(Arc::new(DefaultMemoryState::new()));
let mut events = Vec::new();
while let Some(e) = rx.next().await {
events.push(e);
tokio::time::sleep(Duration::from_millis(3)).await;
}
assert_eq!(events.len(), 15, "slow consumer must not lose events");
assert!(matches!(events.first(), Some(StreamEvent::WorkflowStarted)));
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
Ok(())
}
#[tokio::test]
async fn test_deep_linear_chain_stress() -> Result<(), LangGraphError> {
const N: usize = 50;
let mut builder = StateGraphBuilder::new();
let names: Vec<String> = (0..N).map(|i| format!("n{i}")).collect();
for name in &names {
builder.add_node(name, Box::new(CounterNode));
}
builder.add_edge(START_NODE, HashSet::from([names[0].clone()]));
for w in names.windows(2) {
builder.add_edge(&w[0], HashSet::from([w[1].clone()]));
}
builder.add_edge(&names[N - 1], HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert_eq!(
events.len(),
3 + 4 * N,
"event count formula must hold for deep chain"
);
if let Some(StreamEvent::WorkflowFinished { total_steps, .. }) = events.last() {
assert_eq!(*total_steps, N + 2);
} else {
panic!("expected WorkflowFinished");
}
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, N as i32, "every node should have incremented count");
Ok(())
}
#[tokio::test]
async fn test_parallel_nodes_write_distinct_keys() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node(
"wx",
Box::new(SetIntNode {
key: "x".to_string(),
value: 100,
}),
);
builder.add_node(
"wy",
Box::new(SetIntNode {
key: "y".to_string(),
value: 200,
}),
);
builder.add_edge(
START_NODE,
HashSet::from(["wx".to_string(), "wy".to_string()]),
);
builder.add_edge("wx", HashSet::from([END_NODE.to_string()]));
builder.add_edge("wy", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let x: i32 = state.get("x").await?.unwrap_or(0);
let y: i32 = state.get("y").await?.unwrap_or(0);
assert_eq!((x, y), (100, 200), "both parallel writes must be visible");
Ok(())
}
#[tokio::test]
async fn test_graph_reuse_with_different_initial_state() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let s1 = Arc::new(DefaultMemoryState::new());
s1.set("count", 10i32).await?;
let _ = collect_events(Arc::clone(&graph), Arc::clone(&s1)).await;
let c1: i32 = s1.get("count").await?.unwrap_or(0);
assert_eq!(c1, 11);
let s2 = Arc::new(DefaultMemoryState::new());
let _ = collect_events(Arc::clone(&graph), Arc::clone(&s2)).await;
let c2: i32 = s2.get("count").await?.unwrap_or(0);
assert_eq!(c2, 1);
Ok(())
}
#[tokio::test]
async fn test_concurrent_streams_mixed_success_failure() -> Result<(), LangGraphError> {
let mut ok_builder = StateGraphBuilder::new();
ok_builder.add_node("a", Box::new(CounterNode));
ok_builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
ok_builder.add_edge("a", HashSet::from([END_NODE.to_string()]));
let ok_graph = Arc::new(ok_builder.compile()?);
let mut fail_builder = StateGraphBuilder::new();
fail_builder.add_node("f", Box::new(FailingNode));
fail_builder.add_edge(START_NODE, HashSet::from(["f".to_string()]));
fail_builder.add_edge("f", HashSet::from([END_NODE.to_string()]));
let fail_graph = Arc::new(fail_builder.compile()?);
let (ok_events, fail_events) = tokio::join!(
collect_events(Arc::clone(&ok_graph), Arc::new(DefaultMemoryState::new())),
collect_events(Arc::clone(&fail_graph), Arc::new(DefaultMemoryState::new())),
);
assert!(matches!(
ok_events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
assert!(matches!(
fail_events.last(),
Some(StreamEvent::WorkflowError { .. })
));
Ok(())
}
#[tokio::test]
async fn test_cross_step_event_ordering() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["a".to_string()]));
builder.add_edge("a", HashSet::from(["b".to_string()]));
builder.add_edge("b", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let route2 = events
.iter()
.position(|e| matches!(e, StreamEvent::RoutingDecision { step: 2, .. }));
let step3 = events
.iter()
.position(|e| matches!(e, StreamEvent::StepStarted { step: 3, .. }));
match (route2, step3) {
(Some(r), Some(s)) => assert!(
r < s,
"routing of step N must precede StepStarted of step N+1"
),
_ => panic!("both events should exist"),
}
Ok(())
}
#[tokio::test]
async fn test_conditional_chain_multiple_steps() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("r1", Box::new(RouterNode));
builder.add_node("r2", Box::new(RouterNode));
builder.add_edge(START_NODE, HashSet::from(["r1".to_string()]));
builder.add_conditional_edge(
"r1",
vec![Box::new(|_s: &DefaultMemoryState| "r2".to_string())],
);
builder.add_conditional_edge(
"r2",
vec![Box::new(|_s: &DefaultMemoryState| END_NODE.to_string())],
);
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
assert!(
events
.iter()
.any(|e| matches!(e, StreamEvent::NodeStarted { name, .. } if name == "r1"))
);
assert!(
events
.iter()
.any(|e| matches!(e, StreamEvent::NodeStarted { name, .. } if name == "r2"))
);
let routing_count = events
.iter()
.filter(|e| matches!(e, StreamEvent::RoutingDecision { .. }))
.count();
assert_eq!(routing_count, 3);
Ok(())
}
#[tokio::test]
async fn test_abandoned_stream_does_not_poison_graph() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("s1", Box::new(SlowNode { ms: 150 }));
builder.add_node("s2", Box::new(SlowNode { ms: 150 }));
builder.add_edge(
START_NODE,
HashSet::from(["s1".to_string(), "s2".to_string()]),
);
builder.add_edge("s1", HashSet::from([END_NODE.to_string()]));
builder.add_edge("s2", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let mut rx = Arc::clone(&graph).stream(Arc::new(DefaultMemoryState::new()));
let _ = rx.next().await; drop(rx);
tokio::time::sleep(Duration::from_millis(30)).await;
let events = collect_events(Arc::clone(&graph), Arc::new(DefaultMemoryState::new())).await;
assert!(
matches!(events.last(), Some(StreamEvent::WorkflowFinished { .. })),
"graph must remain usable after an abandoned stream"
);
Ok(())
}
#[tokio::test]
async fn test_node_finished_elapsed_lower_bound() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("slow", Box::new(SlowNode { ms: 60 }));
builder.add_edge(START_NODE, HashSet::from(["slow".to_string()]));
builder.add_edge("slow", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
let elapsed = events.iter().find_map(|e| match e {
StreamEvent::NodeFinished { name, elapsed, .. } if name == "slow" => Some(*elapsed),
_ => None,
});
match elapsed {
Some(d) => assert!(
d >= Duration::from_millis(55),
"elapsed {:?} should reflect the 60ms sleep",
d
),
None => panic!("NodeFinished for slow node should exist"),
}
Ok(())
}
#[tokio::test]
async fn test_failure_at_first_real_node_step() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("f", Box::new(FailingNode));
builder.add_edge(START_NODE, HashSet::from(["f".to_string()]));
builder.add_edge("f", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
match events.last() {
Some(StreamEvent::WorkflowError { step, .. }) => {
assert_eq!(*step, 2, "first real node fails at step 2");
}
_ => panic!("expected WorkflowError"),
}
Ok(())
}
#[tokio::test]
async fn test_stream_multi_start_nodes() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("a", Box::new(CounterNode));
builder.add_node("b", Box::new(CounterNode));
builder.add_node("merge", Box::new(CounterNode));
builder.set_start_node("a");
builder.add_start_node("b");
builder.add_edge("a", HashSet::from(["merge".to_string()]));
builder.add_edge("b", HashSet::from(["merge".to_string()]));
builder.add_edge("merge", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, 3, "a, b, merge should all execute");
let step_started = events.iter().find(|e| {
matches!(
e,
StreamEvent::StepStarted { nodes, .. } if nodes.len() == 2
)
});
assert!(
step_started.is_some(),
"should have a step with 2 parallel nodes"
);
Ok(())
}
#[tokio::test]
async fn test_stream_custom_end_node() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.set_end_node("finish");
builder.add_node("step", Box::new(CounterNode));
builder.add_edge(START_NODE, HashSet::from(["step".to_string()]));
builder.add_edge("step", HashSet::from(["finish".to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(DefaultMemoryState::new());
let events = collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
let count: i32 = state.get("count").await?.unwrap_or(0);
assert_eq!(count, 1, "single step should execute");
let routing = events.iter().find(|e| matches!(
e,
StreamEvent::RoutingDecision { to_nodes, .. } if to_nodes.contains(&"finish".to_string())
));
assert!(
routing.is_some(),
"should have routing decision to custom end node 'finish'"
);
Ok(())
}
#[derive(Debug, Clone)]
struct DebugState;
#[langgraph4rust::async_trait]
impl AgentState for DebugState {
async fn get<T: serde::de::DeserializeOwned + Send + Sync>(
&self,
_key: &str,
) -> Result<Option<T>, LangGraphError> {
Ok(None)
}
async fn set<T: serde::Serialize + Send + Sync>(
&self,
_key: &str,
_value: T,
) -> Result<bool, LangGraphError> {
Ok(true)
}
async fn snapshot(&self, step: usize, node_keys: Vec<String>) -> Result<(), ()> {
Ok(())
}
}
#[test]
fn test_stream_event_debug_format() {
let events: Vec<StreamEvent<DebugState>> = vec![
StreamEvent::WorkflowStarted,
StreamEvent::StepStarted {
step: 1,
nodes: vec!["a".to_string()],
},
StreamEvent::NodeStarted {
step: 1,
name: "a".to_string(),
},
StreamEvent::NodeFinished {
step: 1,
name: "a".to_string(),
elapsed: std::time::Duration::from_millis(10),
},
StreamEvent::RoutingDecision {
step: 1,
from_nodes: vec!["a".to_string()],
to_nodes: vec!["b".to_string()],
},
StreamEvent::WorkflowFinished {
state: Arc::new(DebugState),
total_steps: 3,
elapsed: std::time::Duration::from_millis(50),
},
StreamEvent::WorkflowError {
state: Arc::new(DebugState),
step: 2,
error: LangGraphError::NodeError("test".into()),
},
];
for event in &events {
let debug = format!("{:?}", event);
assert!(
!debug.is_empty(),
"Debug output should not be empty for event variant"
);
}
assert!(format!("{:?}", &events[0]).contains("WorkflowStarted"));
assert!(format!("{:?}", &events[1]).contains("StepStarted"));
assert!(format!("{:?}", &events[2]).contains("NodeStarted"));
assert!(format!("{:?}", &events[3]).contains("NodeFinished"));
assert!(format!("{:?}", &events[4]).contains("RoutingDecision"));
assert!(format!("{:?}", &events[5]).contains("WorkflowFinished"));
assert!(format!("{:?}", &events[6]).contains("WorkflowError"));
}
#[tokio::test]
async fn test_stream_node_lookup_failure() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::new();
builder.add_node("router", Box::new(RouterNode));
builder.add_edge(START_NODE, HashSet::from(["router".to_string()]));
builder.add_conditional_edge(
"router",
vec![Box::new(|_state: &DefaultMemoryState| "ghost".to_string())],
);
let graph = Arc::new(builder.compile()?);
let events = collect_events(graph, Arc::new(DefaultMemoryState::new())).await;
match events.last() {
Some(StreamEvent::WorkflowError { error, .. }) => {
let msg = error.to_string();
assert!(
msg.contains("Reached max_steps") || msg.contains("ghost"),
"error should indicate graph issue, got: {}",
msg
);
}
other => {
panic!("expected WorkflowError, got: {:?}", other.map(|_| ()));
}
}
Ok(())
}
#[derive(Debug, Clone)]
struct CounterState {
data: Arc<std::sync::Mutex<std::collections::HashMap<String, serde_json::Value>>>,
}
impl CounterState {
fn new() -> Self {
Self {
data: Arc::new(std::sync::Mutex::new(std::collections::HashMap::new())),
}
}
}
#[langgraph4rust::async_trait]
impl AgentState for CounterState {
async fn get<T: serde::de::DeserializeOwned + Send + Sync>(
&self,
key: &str,
) -> Result<Option<T>, LangGraphError> {
let guard = self.data.lock().unwrap();
Ok(guard
.get(key)
.and_then(|v| serde_json::from_value(v.clone()).ok()))
}
async fn set<T: serde::Serialize + Send + Sync>(
&self,
key: &str,
value: T,
) -> Result<bool, LangGraphError> {
let v =
serde_json::to_value(value).map_err(|e| LangGraphError::StateError(e.to_string()))?;
self.data.lock().unwrap().insert(key.to_string(), v);
Ok(true)
}
async fn snapshot(&self, step: usize, node_keys: Vec<String>) -> Result<(), ()> {
Ok(())
}
}
#[derive(Debug, Clone)]
struct SetValueNode {
key: String,
value: i32,
}
#[langgraph4rust::async_trait]
impl AgentNode<CounterState> for SetValueNode {
async fn apply(&self, state: Arc<CounterState>) -> Result<(), LangGraphError> {
state.set(&self.key, self.value).await?;
Ok(())
}
}
#[tokio::test]
async fn test_stream_with_custom_agent_state() -> Result<(), LangGraphError> {
let mut builder = StateGraphBuilder::<CounterState>::new();
builder.add_node(
"init",
Box::new(SetValueNode {
key: "n".to_string(),
value: 42,
}),
);
builder.add_node(
"double",
Box::new(SetValueNode {
key: "n2".to_string(),
value: 84,
}),
);
builder.add_edge(START_NODE, HashSet::from(["init".to_string()]));
builder.add_edge("init", HashSet::from(["double".to_string()]));
builder.add_edge("double", HashSet::from([END_NODE.to_string()]));
let graph = Arc::new(builder.compile()?);
let state = Arc::new(CounterState::new());
let events: Vec<StreamEvent<CounterState>> =
collect_events(Arc::clone(&graph), Arc::clone(&state)).await;
assert!(matches!(
events.last(),
Some(StreamEvent::WorkflowFinished { .. })
));
assert!(
events
.iter()
.any(|e| matches!(e, StreamEvent::WorkflowStarted))
);
assert!(
events
.iter()
.any(|e| matches!(e, StreamEvent::NodeStarted { name, .. } if name == "init"))
);
assert!(
events
.iter()
.any(|e| matches!(e, StreamEvent::NodeFinished { name, .. } if name == "init"))
);
let n: i32 = state.get("n").await?.unwrap_or(0);
let n2: i32 = state.get("n2").await?.unwrap_or(0);
assert_eq!(n, 42, "init node should write 42");
assert_eq!(n2, 84, "double node should write 84");
Ok(())
}