1. 1#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
2. 2
3. 3use vak_flow::{ParseError, parse_flow};
4. 4
5. 5#[test]
6. 6fn valid_flow_parses_with_layers() {
7. 7 let toml = r#"
8. 8[flow]
9. 9name = "demo"
10. 10
11. 11[[nodes]]
12. 12id = "a"
13. 13type = "bash"
14. 14command = "echo a"
15. 15
16. 16[[nodes]]
17. 17id = "b"
18. 18type = "agent"
19. 19prompt = "use {{a}}"
20. 20
21. 21[[nodes]]
22. 22id = "c"
23. 23type = "merge"
24. 24deps = ["b"]
25. 25"#;
26. 26 let flow = parse_flow(toml).unwrap();
27. 27 assert_eq!(flow.nodes.len(), 3);
28. 28 let layers = vak_flow::parse::layers(&flow).unwrap();
29. 29 assert_eq!(layers.len(), 3);
30. 30 assert_eq!(layers[0], vec!["a"]);
31. 31 assert_eq!(layers[1], vec!["b"]);
32. 32 assert_eq!(layers[2], vec!["c"]);
33. 33}
34. 34
35. 35#[test]
36. 36fn independent_nodes_share_a_layer() {
37. 37 let toml = r#"
38. 38[flow]
39. 39name = "fan"
40. 40
41. 41[[nodes]]
42. 42id = "x"
43. 43type = "bash"
44. 44command = "echo x"
45. 45
46. 46[[nodes]]
47. 47id = "y"
48. 48type = "bash"
49. 49command = "echo y"
50. 50
51. 51[[nodes]]
52. 52id = "z"
53. 53type = "merge"
54. 54deps = ["x", "y"]
55. 55"#;
56. 56 let layers = vak_flow::parse::layers(&parse_flow(toml).unwrap()).unwrap();
57. 57 assert_eq!(layers.len(), 2);
58. 58 assert!(layers[0].contains(&"x".to_string()));
59. 59 assert!(layers[0].contains(&"y".to_string()));
60. 60}
61. 61
62. 62#[test]
63. 63fn cycle_is_rejected() {
64. 64 let toml = r#"
65. 65[flow]
66. 66name = "cycle"
67. 67
68. 68[[nodes]]
69. 69id = "a"
70. 70type = "bash"
71. 71command = "echo a"
72. 72deps = ["b"]
73. 73
74. 74[[nodes]]
75. 75id = "b"
76. 76type = "bash"
77. 77command = "echo b"
78. 78deps = ["a"]
79. 79"#;
80. 80 match parse_flow(toml) {
81. 81 Err(ParseError::Cycle(stuck)) => assert!(stuck.contains("a") && stuck.contains("b")),
82. 82 other => panic!("expected cycle, got {other:?}"),
83. 83 }
84. 84}
85. 85
86. 86#[test]
87. 87fn unknown_dep_and_self_dep_rejected() {
88. 88 let toml = r#"
89. 89[flow]
90. 90name = "bad"
91. 91
92. 92[[nodes]]
93. 93id = "a"
94. 94type = "bash"
95. 95command = "echo a"
96. 96deps = ["ghost"]
97. 97"#;
98. 98 assert!(matches!(
99. 99 parse_flow(toml),
100. 100 Err(ParseError::UnknownDep(node, dep)) if node == "a" && dep == "ghost"
101. 101 ));
102. 102
103. 103 let toml = r#"
104. 104[flow]
105. 105name = "bad"
106. 106
107. 107[[nodes]]
108. 108id = "a"
109. 109type = "bash"
110. 110command = "echo a"
111. 111deps = ["a"]
112. 112"#;
113. 113 assert!(matches!(parse_flow(toml), Err(ParseError::SelfDep(_))));
114. 114}
115. 115
116. 116#[test]
117. 117fn unknown_type_and_missing_fields_rejected() {
118. 118 let toml = r#"
119. 119[flow]
120. 120name = "bad"
121. 121
122. 122[[nodes]]
123. 123id = "a"
124. 124type = "quantum"
125. 125command = "echo a"
126. 126"#;
127. 127 assert!(matches!(
128. 128 parse_flow(toml),
129. 129 Err(ParseError::UnknownType(_, t)) if t == "quantum"
130. 130 ));
131. 131
132. 132 let toml = r#"
133. 133[flow]
134. 134name = "bad"
135. 135
136. 136[[nodes]]
137. 137id = "a"
138. 138type = "agent"
139. 139"#;
140. 140 assert!(matches!(
141. 141 parse_flow(toml),
142. 142 Err(ParseError::MissingField(id, _, field)) if id == "a" && field == "prompt"
143. 143 ));
144. 144}
145. 145
146. 146#[test]
147. 147fn duplicate_ids_rejected() {
148. 148 let toml = r#"
149. 149[flow]
150. 150name = "dup"
151. 151
152. 152[[nodes]]
153. 153id = "a"
154. 154type = "bash"
155. 155command = "echo 1"
156. 156
157. 157[[nodes]]
158. 158id = "a"
159. 159type = "bash"
160. 160command = "echo 2"
161. 161"#;
162. 162 assert!(matches!(parse_flow(toml), Err(ParseError::Duplicate(d)) if d == "a"));
163. 163}
164. 164
165. 165#[test]
166. 166fn accept_done_contract_parses_and_survives_validation() {
167. 167 let toml = r#"
168. 168[flow]
169. 169name = "accept-flow"
170. 170
171. 171[[nodes]]
172. 172id = "build"
173. 173type = "bash"
174. 174command = "cargo build"
175. 175accept = ["verify: test -f target", "exit 0"]
176. 176
177. 177[[nodes]]
178. 178id = "report"
179. 179type = "merge"
180. 180deps = ["build"]
181. 181"#;
182. 182 let flow = vak_flow::parse_flow(toml).expect("parse");
183. 183 let node = flow.nodes.iter().find(|n| n.id == "build").unwrap();
184. 184 assert_eq!(node.accept.len(), 2);
185. 185 assert_eq!(node.accept[0], "verify: test -f target");
186. 186}
187. 187