streamweave-attractor 0.3.0

Attractor pipeline as a StreamWeave graph
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

//! Tests for the AttractorGraph → StreamWeave compiler.

use crate::compiler::compile_attractor_graph;
use crate::dot_parser::parse_dot;
use crate::runner::run_streamweave_graph;
use crate::types::GraphPayload;
use std::collections::HashMap;

#[test]
fn compile_rejects_exec_without_command() {
  let dot = r#"
    digraph G {
      graph [goal="test"]
      start [shape=Mdiamond]
      run [label="Run", type=exec]
      exit [shape=Msquare]
      start -> run -> exit
    }
  "#;
  let ast = parse_dot(dot).unwrap();
  match compile_attractor_graph(&ast, None, None, None) {
    Ok(_) => panic!("expected compile to fail (exec without command)"),
    Err(e) => {
      assert!(e.to_lowercase().contains("exec"));
      assert!(e.to_lowercase().contains("command"));
    }
  }
}

#[test]
fn compile_with_conditional_routing() {
  let dot = r#"
    digraph G {
      graph [goal="test"]
      start [shape=Mdiamond]
      run [type=exec, command="true"]
      fix [label="Fix"]
      exit [shape=Msquare]
      start -> run
      run -> exit [condition="outcome=success"]
      run -> fix [condition="outcome=fail"]
      fix -> run
    }
  "#;
  let ast = parse_dot(dot).unwrap();
  let graph = compile_attractor_graph(&ast, None, None, None).unwrap();
  // Graph built with direct out/error ports for run
  assert!(graph.name().contains("compiled"));
}

#[test]
fn compile_trivial_start_exit() {
  let dot = r#"
    digraph G {
      graph [goal="test"]
      start [shape=Mdiamond]
      exit [shape=Msquare]
      start -> exit
    }
  "#;
  let ast = parse_dot(dot).unwrap();
  let graph = compile_attractor_graph(&ast, None, None, None).unwrap();
  // Trivial case may be built via graph! or builder
  assert!(graph.find_node_by_name("start").is_some());
  assert!(graph.find_node_by_name("exit").is_some());
}

#[tokio::test]
async fn run_streamweave_graph_trivial_start_exit() {
  let dot = r#"
    digraph G {
      graph [goal="test"]
      start [shape=Mdiamond]
      exit [shape=Msquare]
      start -> exit
    }
  "#;
  let ast = parse_dot(dot).unwrap();
  let graph = compile_attractor_graph(&ast, None, None, None).unwrap();
  let initial = GraphPayload::initial(HashMap::new(), "start");
  let out = run_streamweave_graph(graph, initial).await.unwrap();
  // Identity path: one trigger in → one item out
  assert!(out.is_some(), "expected one output from start→exit graph");
}

#[test]
fn compile_err_no_start() {
  let dot = r#"
    digraph G {
      graph [goal="test"]
      exit [shape=Msquare]
    }
  "#;
  let ast = parse_dot(dot).unwrap();
  match compile_attractor_graph(&ast, None, None, None) {
    Ok(_) => panic!("expected compile to fail (no start)"),
    Err(e) => assert!(e.to_lowercase().contains("start")),
  }
}

#[test]
fn compile_err_no_exit() {
  let dot = r#"
    digraph G {
      graph [goal="test"]
      start [shape=Mdiamond]
    }
  "#;
  let ast = parse_dot(dot).unwrap();
  match compile_attractor_graph(&ast, None, None, None) {
    Ok(_) => panic!("expected compile to fail (no exit)"),
    Err(e) => assert!(e.to_lowercase().contains("exit")),
  }
}

#[test]
fn compile_pre_push_dot() {
  let path =
    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/workflows/pre-push.dot");
  let dot = std::fs::read_to_string(&path).unwrap();
  let ast = parse_dot(&dot).unwrap();
  let graph = compile_attractor_graph(&ast, None, None, None).unwrap();
  assert!(graph.name().contains("compiled"));
}

#[test]
fn compile_rejects_invalid_entry_node_id() {
  let dot = r#"
    digraph G {
      graph [goal="test"]
      start [shape=Mdiamond]
      exit [shape=Msquare]
      start -> exit
    }
  "#;
  let ast = parse_dot(dot).unwrap();
  match compile_attractor_graph(&ast, Some("not_a_node"), None, None) {
    Ok(_) => panic!("expected compile to fail (invalid entry node id)"),
    Err(e) => {
      assert!(
        e.contains("not_a_node") && e.contains("not a node"),
        "error should mention invalid entry node: {}",
        e
      );
    }
  }
}

#[test]
fn compile_accepts_valid_entry_node_id_for_resume() {
  let dot = r#"
    digraph G {
      graph [goal="test"]
      start [shape=Mdiamond]
      exit [shape=Msquare]
      start -> exit
    }
  "#;
  let ast = parse_dot(dot).unwrap();
  let graph = compile_attractor_graph(&ast, Some("exit"), None, None).unwrap();
  assert!(graph.name().contains("compiled"));
  assert!(graph.find_node_by_name("start").is_some());
  assert!(graph.find_node_by_name("exit").is_some());
}