1. 1#![allow(clippy::unwrap_used, clippy::expect_used)]
2. 2
3. 3use vak_config::load_with_trust;
4. 4
5. 5#[test]
6. 6fn project_layer_retry_keys_reach_effective_config() {
7. 7 // Regression: merge_into dropped run_retry_* when layering project over
8. 8 // user config, so the file value silently fell back to the default.
9. 9 let dir = tempfile::tempdir().unwrap();
10. 10 let project = dir.path().join(".vak");
11. 11 std::fs::create_dir_all(&project).unwrap();
12. 12 std::fs::write(
13. 13 project.join("config.toml"),
14. 14 "provider = \"opencode-zen\"\nmodel = \"x-preview-f-free\"\nrun_retry_attempts = 9\nrun_retry_base_backoff_ms = 1234\n",
15. 15 )
16. 16 .unwrap();
17. 17
18. 18 let cfg = load_with_trust(dir.path(), true).unwrap();
19. 19 assert_eq!(cfg.run_retry_attempts, 9);
20. 20 assert_eq!(cfg.run_retry_base_backoff_ms, 1234);
21. 21}
22. 22
23. 23#[test]
24. 24fn unknown_config_keys_warn_instead_of_failing() {
25. 25 let dir = tempfile::tempdir().unwrap();
26. 26 let project = dir.path().join(".vak");
27. 27 std::fs::create_dir_all(&project).unwrap();
28. 28 std::fs::write(
29. 29 project.join("config.toml"),
30. 30 "provider = \"opencode-zen\"\nmodel = \"m\"\nfuture_key = true\n",
31. 31 )
32. 32 .unwrap();
33. 33
34. 34 let cfg = load_with_trust(dir.path(), true).unwrap();
35. 35 assert!(
36. 36 cfg.warnings.iter().any(|w| w.contains("future_key")),
37. 37 "typo'd keys must be visible: {:?}",
38. 38 cfg.warnings
39. 39 );
40. 40}
41. 41
42. 42#[test]
43. 43fn ui_defaults_apply_when_section_absent() {
44. 44 let dir = tempfile::tempdir().unwrap();
45. 45 std::fs::create_dir_all(dir.path().join(".vak")).unwrap();
46. 46
47. 47 let cfg = load_with_trust(dir.path(), true).unwrap();
48. 48 assert_eq!(cfg.ui.theme, "dark");
49. 49 assert!(cfg.ui.bell);
50. 50 assert!(cfg.ui.keymap.is_empty());
51. 51}
52. 52
53. 53#[test]
54. 54fn ui_keymap_overrides_merge_project_over_user() {
55. 55 let dir = tempfile::tempdir().unwrap();
56. 56 let project = dir.path().join(".vak");
57. 57 std::fs::create_dir_all(&project).unwrap();
58. 58 std::fs::write(
59. 59 project.join("config.toml"),
60. 60 "[ui.keymap]\n\"Ctrl-P\" = \"exit\"\n",
61. 61 )
62. 62 .unwrap();
63. 63 let cfg = load_with_trust(dir.path(), true).unwrap();
64. 64 assert_eq!(
65. 65 cfg.ui.keymap.get("Ctrl-P").map(String::as_str),
66. 66 Some("exit")
67. 67 );
68. 68}
69. 69
70. 70#[test]
71. 71fn ui_layer_overrides_and_unknown_theme_normalizes_to_dark() {
72. 72 let dir = tempfile::tempdir().unwrap();
73. 73 let project = dir.path().join(".vak");
74. 74 std::fs::create_dir_all(&project).unwrap();
75. 75 std::fs::write(
76. 76 project.join("config.toml"),
77. 77 "[ui]\ntheme = \"light\"\nbell = false\n",
78. 78 )
79. 79 .unwrap();
80. 80 let cfg = load_with_trust(dir.path(), true).unwrap();
81. 81 assert_eq!(cfg.ui.theme, "light");
82. 82 assert!(!cfg.ui.bell);
83. 83
84. 84 std::fs::write(
85. 85 project.join("config.toml"),
86. 86 "[ui]\ntheme = \"neon\"\nbell = true\n",
87. 87 )
88. 88 .unwrap();
89. 89 let cfg = load_with_trust(dir.path(), true).unwrap();
90. 90 assert_eq!(cfg.ui.theme, "dark");
91. 91 assert!(cfg.ui.bell);
92. 92 assert!(
93. 93 cfg.warnings.iter().any(|w| w.contains("ui.theme")),
94. 94 "unknown theme must warn: {:?}",
95. 95 cfg.warnings
96. 96 );
97. 97}
98. 98
99. 99#[test]
100. 100fn designed_ui_themes_are_valid_config_values() {
101. 101 for theme in [
102. 102 "neo",
103. 103 "rich",
104. 104 "teenage",
105. 105 "plain",
106. 106 "midnight",
107. 107 "synthwave",
108. 108 "forest",
109. 109 ] {
110. 110 let dir = tempfile::tempdir().unwrap();
111. 111 let project = dir.path().join(".vak");
112. 112 std::fs::create_dir_all(&project).unwrap();
113. 113 std::fs::write(
114. 114 project.join("config.toml"),
115. 115 format!("[ui]\ntheme = \"{theme}\"\n"),
116. 116 )
117. 117 .unwrap();
118. 118 let cfg = load_with_trust(dir.path(), true).unwrap();
119. 119 assert_eq!(cfg.ui.theme, theme);
120. 120 }
121. 121}
122. 122
123. 123#[test]
124. 124fn custom_theme_names_resolve_without_warning() {
125. 125 let dir = tempfile::tempdir().unwrap();
126. 126 let project = dir.path().join(".vak");
127. 127 std::fs::create_dir_all(&project).unwrap();
128. 128 std::fs::write(
129. 129 project.join("config.toml"),
130. 130 "[ui]\ntheme = \"sunset\"\n[ui.themes.sunset]\naccent = \"#ff5500\"\ndim = \"grey\"\nbogus = 1\n",
131. 131 )
132. 132 .unwrap();
133. 133 let cfg = load_with_trust(dir.path(), true).unwrap();
134. 134 assert_eq!(cfg.ui.theme, "sunset");
135. 135 assert_eq!(
136. 136 cfg.ui.themes.get("sunset").and_then(|t| t.get("accent")),
137. 137 Some(&"#ff5500".to_string())
138. 138 );
139. 139 assert!(
140. 140 cfg.warnings
141. 141 .iter()
142. 142 .any(|w| w.contains("themes.sunset.bogus")),
143. 143 "unknown theme color must warn: {:?}",
144. 144 cfg.warnings
145. 145 );
146. 146}
147. 147
148. 148#[test]
149. 149fn composer_osc52_and_accessibility_layers_apply() {
150. 150 let dir = tempfile::tempdir().unwrap();
151. 151 let project = dir.path().join(".vak");
152. 152 std::fs::create_dir_all(&project).unwrap();
153. 153
154. 154 let cfg = load_with_trust(dir.path(), true).unwrap();
155. 155 assert_eq!(cfg.ui.composer, "emacs");
156. 156 assert!(!cfg.ui.osc52);
157. 157 assert!(!cfg.ui.accessibility.plain);
158. 158
159. 159 std::fs::write(
160. 160 project.join("config.toml"),
161. 161 "[ui]\ncomposer = \"vim\"\nosc52 = true\n[ui.accessibility]\nplain = true\nreduced_motion = true\nbogus = 1\n",
162. 162 )
163. 163 .unwrap();
164. 164 let cfg = load_with_trust(dir.path(), true).unwrap();
165. 165 assert_eq!(cfg.ui.composer, "vim");
166. 166 assert!(cfg.ui.osc52);
167. 167 assert!(cfg.ui.accessibility.plain);
168. 168 assert!(cfg.ui.accessibility.reduced_motion);
169. 169 assert!(!cfg.ui.accessibility.screen_reader);
170. 170 assert!(
171. 171 cfg.warnings
172. 172 .iter()
173. 173 .any(|w| w.contains("accessibility.bogus")),
174. 174 "unknown accessibility key must warn: {:?}",
175. 175 cfg.warnings
176. 176 );
177. 177
178. 178 std::fs::write(project.join("config.toml"), "[ui]\ncomposer = \"dvorak\"\n").unwrap();
179. 179 let cfg = load_with_trust(dir.path(), true).unwrap();
180. 180 assert_eq!(cfg.ui.composer, "emacs");
181. 181 assert!(cfg.warnings.iter().any(|w| w.contains("ui.composer")));
182. 182}
183. 183
184. 184#[test]
185. 185fn stop_policy_defaults_on_and_layer_overrides_apply() {
186. 186 let dir = tempfile::tempdir().unwrap();
187. 187 let cfg = load_with_trust(dir.path(), false).unwrap();
188. 188 assert!(cfg.stop_policy.enabled);
189. 189 assert_eq!(cfg.stop_policy.max_blocks, 2);
190. 190
191. 191 let project = dir.path().join(".vak");
192. 192 std::fs::create_dir_all(&project).unwrap();
193. 193 std::fs::write(
194. 194 project.join("config.toml"),
195. 195 "[stop_policy]\nenabled = true\nmax_blocks = 5\nbogus = 1\n",
196. 196 )
197. 197 .unwrap();
198. 198 let cfg = load_with_trust(dir.path(), true).unwrap();
199. 199 assert!(cfg.stop_policy.enabled);
200. 200 assert_eq!(cfg.stop_policy.max_blocks, 5);
201. 201 assert!(
202. 202 cfg.warnings.iter().any(|w| w.contains("stop_policy.bogus")),
203. 203 "unknown stop_policy key must warn: {:?}",
204. 204 cfg.warnings
205. 205 );
206. 206
207. 207 std::fs::write(
208. 208 project.join("config.toml"),
209. 209 "[stop_policy]\nenabled = false\n",
210. 210 )
211. 211 .unwrap();
212. 212 let cfg = load_with_trust(dir.path(), true).unwrap();
213. 213 assert!(!cfg.stop_policy.enabled);
214. 214}
215. 215
216. 216#[test]
217. 217fn finops_caps_and_overrides_layer_with_unknown_key_warning() {
218. 218 let dir = tempfile::tempdir().unwrap();
219. 219 let cfg = load_with_trust(dir.path(), false).unwrap();
220. 220 assert!(cfg.finops.max_run_usd.is_none());
221. 221 assert!(cfg.finops.price_overrides.is_empty());
222. 222
223. 223 let project = dir.path().join(".vak");
224. 224 std::fs::create_dir_all(&project).unwrap();
225. 225 std::fs::write(
226. 226 project.join("config.toml"),
227. 227 "[finops]\nmax_run_usd = 5.0\nmax_day_usd = 20.0\nbogus = 1\n\n[finops.price_overrides.custom-model]\ninput = 1.25\noutput = 6.0\n",
228. 228 )
229. 229 .unwrap();
230. 230 let cfg = load_with_trust(dir.path(), true).unwrap();
231. 231 assert_eq!(cfg.finops.max_run_usd, Some(5.0));
232. 232 assert_eq!(cfg.finops.max_day_usd, Some(20.0));
233. 233 let entry = cfg
234. 234 .finops
235. 235 .price_overrides
236. 236 .get("custom-model")
237. 237 .expect("override");
238. 238 assert_eq!((entry.input, entry.output), (1.25, 6.0));
239. 239 assert!(
240. 240 cfg.warnings.iter().any(|w| w.contains("finops.bogus")),
241. 241 "unknown finops key must warn: {:?}",
242. 242 cfg.warnings
243. 243 );
244. 244
245. 245 // Pricing resolution honors the override over the heuristic table.
246. 246 assert_eq!(
247. 247 vak_config::resolve_usd_per_mtok("custom-model", &cfg.finops.price_overrides),
248. 248 Some((1.25, 6.0))
249. 249 );
250. 250}
251. 251
252. 252/// An untrusted project must not be able to redirect the release feed: the
253. 253/// feed names the binary that replaces this one and supplies its own artifact
254. 254/// checksums, so whoever picks the URL picks the integrity check too.
255. 255#[test]
256. 256fn untrusted_project_cannot_redirect_the_updater() {
257. 257 let dir = tempfile::tempdir().unwrap();
258. 258 let project = dir.path().join(".vak");
259. 259 std::fs::create_dir_all(&project).unwrap();
260. 260 std::fs::write(
261. 261 project.join("config.toml"),
262. 262 "[update]\nurl = \"https://evil.invalid/feed.json\"\ninterval_hours = 1\n",
263. 263 )
264. 264 .unwrap();
265. 265
266. 266 let untrusted = load_with_trust(dir.path(), false).unwrap();
267. 267 assert_eq!(untrusted.update.url, None, "feed URL must be stripped");
268. 268 assert!(
269. 269 untrusted
270. 270 .warnings
271. 271 .iter()
272. 272 .any(|w| w.contains("not trusted") && w.contains("update")),
273. 273 "the strip must be announced: {:?}",
274. 274 untrusted.warnings
275. 275 );
276. 276
277. 277 let trusted = load_with_trust(dir.path(), true).unwrap();
278. 278 assert_eq!(
279. 279 trusted.update.url.as_deref(),
280. 280 Some("https://evil.invalid/feed.json"),
281. 281 "a trusted workspace keeps its own choice"
282. 282 );
283. 283}
284. 284
285. 285/// An untrusted project must not be able to switch on the feed pipeline: it is
286. 286/// an unattended runner (the scheduler fetches every tick) executing code with
287. 287/// network access, so a cloned repository that could set `feeds.enabled` would
288. 288/// be handing itself an unattended runner (invariant 15).
289. 289#[test]
290. 290fn untrusted_project_cannot_enable_the_feed_pipeline() {
291. 291 let dir = tempfile::tempdir().unwrap();
292. 292 let project = dir.path().join(".vak");
293. 293 std::fs::create_dir_all(&project).unwrap();
294. 294 std::fs::write(
295. 295 project.join("config.toml"),
296. 296 "[feeds]\nenabled = true\ndefault_check_interval = \"5m\"\n",
297. 297 )
298. 298 .unwrap();
299. 299
300. 300 let untrusted = load_with_trust(dir.path(), false).unwrap();
301. 301 assert!(
302. 302 !untrusted.feeds.enabled,
303. 303 "an untrusted project must not enable feeds"
304. 304 );
305. 305 assert!(
306. 306 untrusted
307. 307 .warnings
308. 308 .iter()
309. 309 .any(|w| w.contains("not trusted") && w.contains("feeds")),
310. 310 "the strip must be announced: {:?}",
311. 311 untrusted.warnings
312. 312 );
313. 313
314. 314 let trusted = load_with_trust(dir.path(), true).unwrap();
315. 315 assert!(
316. 316 trusted.feeds.enabled,
317. 317 "a trusted workspace keeps its own choice"
318. 318 );
319. 319}
320. 320
321. 321/// `inherit_* = false` clears the corresponding lower layer during merge, so
322. 322/// an untrusted project setting it would switch off the user's own hooks and
323. 323/// MCP servers. Disabling a protection is as privileged as adding capability.
324. 324#[test]
325. 325fn untrusted_project_cannot_disable_inherited_capabilities() {
326. 326 let dir = tempfile::tempdir().unwrap();
327. 327 let project = dir.path().join(".vak");
328. 328 std::fs::create_dir_all(&project).unwrap();
329. 329 std::fs::write(
330. 330 project.join("config.toml"),
331. 331 "[capabilities]\ninherit_hooks = false\ninherit_mcp = false\n\
332. 332 inherit_skills = false\ninherit_plugins = false\n",
333. 333 )
334. 334 .unwrap();
335. 335
336. 336 let cfg = load_with_trust(dir.path(), false).unwrap();
337. 337 assert!(
338. 338 cfg.capabilities.inherit_hooks,
339. 339 "global hooks stay inherited"
340. 340 );
341. 341 assert!(cfg.capabilities.inherit_mcp, "global MCP stays inherited");
342. 342 assert!(cfg.capabilities.inherit_skills);
343. 343 assert!(cfg.capabilities.inherit_plugins);
344. 344
345. 345 let trusted = load_with_trust(dir.path(), true).unwrap();
346. 346 assert!(
347. 347 !trusted.capabilities.inherit_hooks,
348. 348 "a trusted workspace may still isolate itself"
349. 349 );
350. 350}
351. 351