1. 1#![allow(
2. 2 clippy::unwrap_used,
3. 3 clippy::expect_used,
4. 4 clippy::panic,
5. 5 clippy::indexing_slicing
6. 6)]
7. 7
8. 8//! Deep audit harness for `vak-presentation`: 500+ scenarios covering spec
9. 9//! validation, binding paths, compilation, the `PresentationLibrary`
10. 10//! register/activate/select/revoke lifecycle, revision proposals, semantic
11. 11//! type inference, digest consistency, and the seed pack.
12. 12//!
13. 13//! Each scenario is a self-contained closure that panics on invariant
14. 14//! violation. The harness counts pass/fail so the test report proves breadth.
15. 15
16. 16use serde_json::json;
17. 17use std::collections::BTreeMap;
18. 18use vak_presentation::{
19. 19 AccessibilitySpec, Binding, CompileInput, CompiledPresentation, EmptyValue, FallbackKind,
20. 20 FallbackSpec, LibraryScope, MAX_DEPTH, MAX_EXPANSION_ITEMS, MAX_NODES, MAX_SPEC_BYTES,
21. 21 PresentationError, PresentationLibrary, PresentationOrigin, PresentationRevisionRequest,
22. 22 PresentationSpec, Primitive, SPEC_SCHEMA_VERSION, SpecNode, SpecValue, StoredPresentation,
23. 23 compile, digest, infer_semantic_type, parse_spec, propose_revision, seeds, validate_spec,
24. 24};
25. 25
26. 26type Scenario = (String, Box<dyn FnOnce()>);
27. 27
28. 28fn tc<F: FnOnce() + 'static>(name: &str, f: F) -> Scenario {
29. 29 (name.to_string(), Box::new(f))
30. 30}
31. 31
32. 32fn run(label: &str, scenarios: Vec<Scenario>) {
33. 33 let total = scenarios.len();
34. 34 let mut passed = 0usize;
35. 35 let mut failures: Vec<String> = Vec::new();
36. 36 for (name, test) in scenarios {
37. 37 match std::panic::catch_unwind(std::panic::AssertUnwindSafe(test)) {
38. 38 Ok(()) => passed += 1,
39. 39 Err(_) => failures.push(name),
40. 40 }
41. 41 }
42. 42 if !failures.is_empty() {
43. 43 for f in &failures {
44. 44 eprintln!("FAIL: {label} :: {f}");
45. 45 }
46. 46 }
47. 47 assert_eq!(
48. 48 passed, total,
49. 49 "{label}: {passed}/{total} passed — failures: {failures:?}"
50. 50 );
51. 51 println!(" ✓ {label}: {total} scenarios passed");
52. 52}
53. 53
54. 54// ── Data helpers ───────────────────────────────────────────────────
55. 55
56. 56fn spec_node(prim: Primitive) -> SpecNode {
57. 57 SpecNode {
58. 58 primitive: prim,
59. 59 props: BTreeMap::new(),
60. 60 children: vec![],
61. 61 each: None,
62. 62 item: None,
63. 63 }
64. 64}
65. 65
66. 66fn text_binding_node() -> SpecNode {
67. 67 SpecNode {
68. 68 primitive: Primitive::Text,
69. 69 props: BTreeMap::from([(
70. 70 "text".into(),
71. 71 SpecValue::Binding(Binding {
72. 72 path: "$.text".into(),
73. 73 required: false,
74. 74 empty: EmptyValue::EmptyText,
75. 75 }),
76. 76 )]),
77. 77 children: vec![],
78. 78 each: None,
79. 79 item: None,
80. 80 }
81. 81}
82. 82
83. 83fn section_with_title() -> SpecNode {
84. 84 SpecNode {
85. 85 primitive: Primitive::Section,
86. 86 props: BTreeMap::from([(
87. 87 "title".into(),
88. 88 SpecValue::Binding(Binding {
89. 89 path: "$.title".into(),
90. 90 required: false,
91. 91 empty: EmptyValue::EmptyText,
92. 92 }),
93. 93 )]),
94. 94 children: vec![text_binding_node()],
95. 95 each: None,
96. 96 item: None,
97. 97 }
98. 98}
99. 99
100. 100fn make_spec(id: &str, rev: u64, accepts: &[&str], root: SpecNode) -> PresentationSpec {
101. 101 PresentationSpec {
102. 102 schema_version: SPEC_SCHEMA_VERSION,
103. 103 id: id.into(),
104. 104 revision: rev,
105. 105 accepts: accepts.iter().map(|s| s.to_string()).collect(),
106. 106 root,
107. 107 fallback: FallbackSpec::default(),
108. 108 accessibility: AccessibilitySpec::default(),
109. 109 metadata: BTreeMap::new(),
110. 110 }
111. 111}
112. 112
113. 113fn binding_val(path: &str, required: bool) -> SpecValue {
114. 114 SpecValue::Binding(Binding {
115. 115 path: path.into(),
116. 116 required,
117. 117 empty: EmptyValue::Omit,
118. 118 })
119. 119}
120. 120
121. 121fn ci(sem: &str, payload: serde_json::Value, fb: &str) -> CompileInput {
122. 122 let payload = match payload {
123. 123 serde_json::Value::Object(mut map) => {
124. 124 if !map.contains_key("text") {
125. 125 map.insert("text".into(), serde_json::Value::String("hello".into()));
126. 126 }
127. 127 serde_json::Value::Object(map)
128. 128 }
129. 129 other => other,
130. 130 };
131. 131 CompileInput {
132. 132 semantic_type: sem.into(),
133. 133 payload,
134. 134 fallback_text: fb.into(),
135. 135 }
136. 136}
137. 137
138. 138fn stored_simple(
139. 139 id: &str,
140. 140 rev: u64,
141. 141 accepts: &[&str],
142. 142 root: SpecNode,
143. 143 owner: &str,
144. 144) -> StoredPresentation {
145. 145 let spec = make_spec(id, rev, accepts, root);
146. 146 let dg = digest(&spec).unwrap();
147. 147 StoredPresentation {
148. 148 spec,
149. 149 digest: dg,
150. 150 origin: PresentationOrigin {
151. 151 scope: LibraryScope::Workspace,
152. 152 owner: owner.into(),
153. 153 plugin_id: None,
154. 154 generation: Some("test-1".into()),
155. 155 },
156. 156 enabled: true,
157. 157 }
158. 158}
159. 159
160. 160fn stored_builtin(id: &str, rev: u64, accepts: &[&str], root: SpecNode) -> StoredPresentation {
161. 161 let spec = make_spec(id, rev, accepts, root);
162. 162 let dg = digest(&spec).unwrap();
163. 163 StoredPresentation {
164. 164 spec,
165. 165 digest: dg,
166. 166 origin: PresentationOrigin {
167. 167 scope: LibraryScope::Workspace,
168. 168 owner: "builtin".into(),
169. 169 plugin_id: None,
170. 170 generation: Some("seed-2".into()),
171. 171 },
172. 172 enabled: true,
173. 173 }
174. 174}
175. 175
176. 176fn stored_plugin(
177. 177 id: &str,
178. 178 rev: u64,
179. 179 accepts: &[&str],
180. 180 root: SpecNode,
181. 181 plugin_id: &str,
182. 182) -> StoredPresentation {
183. 183 let spec = make_spec(id, rev, accepts, root);
184. 184 let dg = digest(&spec).unwrap();
185. 185 StoredPresentation {
186. 186 spec,
187. 187 digest: dg,
188. 188 origin: PresentationOrigin {
189. 189 scope: LibraryScope::Workspace,
190. 190 owner: "plugin_owner".into(),
191. 191 plugin_id: Some(plugin_id.into()),
192. 192 generation: Some("gen-1".into()),
193. 193 },
194. 194 enabled: true,
195. 195 }
196. 196}
197. 197
198. 198const PRIMITIVES: &[Primitive] = &[
199. 199 Primitive::Stack,
200. 200 Primitive::Row,
201. 201 Primitive::Group,
202. 202 Primitive::Section,
203. 203 Primitive::Divider,
204. 204 Primitive::Title,
205. 205 Primitive::Text,
206. 206 Primitive::RichText,
207. 207 Primitive::Label,
208. 208 Primitive::Badge,
209. 209 Primitive::Callout,
210. 210 Primitive::Quote,
211. 211 Primitive::List,
212. 212 Primitive::Checklist,
213. 213 Primitive::Timeline,
214. 214 Primitive::Steps,
215. 215 Primitive::KeyValue,
216. 216 Primitive::Table,
217. 217 Primitive::Metric,
218. 218 Primitive::Progress,
219. 219 Primitive::Chart,
220. 220 Primitive::DataGrid,
221. 221 Primitive::Comparison,
222. 222 Primitive::Image,
223. 223 Primitive::Audio,
224. 224 Primitive::Video,
225. 225 Primitive::File,
226. 226 Primitive::LinkPreview,
227. 227 Primitive::Gallery,
228. 228 Primitive::Diff,
229. 229 Primitive::TestMatrix,
230. 230 Primitive::Terminal,
231. 231 Primitive::Artifact,
232. 232 Primitive::CitationList,
233. 233 Primitive::Disclosure,
234. 234 Primitive::Filter,
235. 235 Primitive::Sort,
236. 236 Primitive::Search,
237. 237 Primitive::Stepper,
238. 238 Primitive::Timer,
239. 239 Primitive::Loading,
240. 240 Primitive::Empty,
241. 241 Primitive::Partial,
242. 242 Primitive::Error,
243. 243 Primitive::Unavailable,
244. 244 Primitive::Stale,
245. 245];
246. 246
247. 247// ════════════════════════════════════════════════════════════════════
248. 248// 1. SPEC VALIDATION
249. 249// ════════════════════════════════════════════════════════════════════
250. 250
251. 251#[test]
252. 252fn audit_spec_validation() {
253. 253 let mut scenarios: Vec<Scenario> = vec![];
254. 254
255. 255 // 1a. Valid spec for each primitive (47 variants)
256. 256 for (i, prim) in PRIMITIVES.iter().enumerate() {
257. 257 let p = *prim;
258. 258 scenarios.push(tc(&format!("valid_spec_{i}_{p:?}"), move || {
259. 259 let s = make_spec(&format!("v{i}"), 1, &["detail"], spec_node(p));
260. 260 assert!(validate_spec(&s).is_ok(), "primitive {p:?} should validate");
261. 261 }));
262. 262 }
263. 263
264. 264 // 1b. Valid complex specs
265. 265 scenarios.push(tc("valid_section_node", || {
266. 266 let s = make_spec("cs1", 1, &["detail"], section_with_title());
267. 267 assert!(validate_spec(&s).is_ok());
268. 268 }));
269. 269
270. 270 scenarios.push(tc("valid_divider_node", || {
271. 271 let s = make_spec("cs2", 1, &["detail"], spec_node(Primitive::Divider));
272. 272 assert!(validate_spec(&s).is_ok());
273. 273 }));
274. 274
275. 275 scenarios.push(tc("valid_stale_node", || {
276. 276 let s = make_spec("cs3", 1, &["detail"], spec_node(Primitive::Stale));
277. 277 assert!(validate_spec(&s).is_ok());
278. 278 }));
279. 279
280. 280 scenarios.push(tc("valid_error_node", || {
281. 281 let s = make_spec("cs4", 1, &["detail"], spec_node(Primitive::Error));
282. 282 assert!(validate_spec(&s).is_ok());
283. 283 }));
284. 284
285. 285 scenarios.push(tc("valid_loading_node", || {
286. 286 let s = make_spec("cs5", 1, &["detail"], spec_node(Primitive::Loading));
287. 287 assert!(validate_spec(&s).is_ok());
288. 288 }));
289. 289
290. 290 scenarios.push(tc("valid_empty_node", || {
291. 291 let s = make_spec("cs6", 1, &["detail"], spec_node(Primitive::Empty));
292. 292 assert!(validate_spec(&s).is_ok());
293. 293 }));
294. 294
295. 295 scenarios.push(tc("valid_partial_node", || {
296. 296 let s = make_spec("cs7", 1, &["detail"], spec_node(Primitive::Partial));
297. 297 assert!(validate_spec(&s).is_ok());
298. 298 }));
299. 299
300. 300 scenarios.push(tc("valid_richtext_node", || {
301. 301 let s = make_spec("cs8", 1, &["detail"], spec_node(Primitive::RichText));
302. 302 assert!(validate_spec(&s).is_ok());
303. 303 }));
304. 304
305. 305 scenarios.push(tc("valid_nested_stack", || {
306. 306 let root = SpecNode {
307. 307 primitive: Primitive::Stack,
308. 308 props: BTreeMap::new(),
309. 309 children: vec![spec_node(Primitive::Text), spec_node(Primitive::Divider)],
310. 310 each: None,
311. 311 item: None,
312. 312 };
313. 313 let s = make_spec("cs9", 1, &["detail"], root);
314. 314 assert!(validate_spec(&s).is_ok());
315. 315 }));
316. 316
317. 317 scenarios.push(tc("valid_section_no_title", || {
318. 318 let root = SpecNode {
319. 319 primitive: Primitive::Section,
320. 320 props: BTreeMap::new(),
321. 321 children: vec![text_binding_node()],
322. 322 each: None,
323. 323 item: None,
324. 324 };
325. 325 let s = make_spec("cs10", 1, &["detail"], root);
326. 326 assert!(validate_spec(&s).is_ok());
327. 327 }));
328. 328
329. 329 // 1c. Invalid schema versions
330. 330 for bad_sv in [0u16, 2, 3, 65535] {
331. 331 scenarios.push(tc(&format!("invalid_schema_{bad_sv}"), move || {
332. 332 let mut s = make_spec("bad_sv", 1, &["detail"], text_binding_node());
333. 333 s.schema_version = bad_sv;
334. 334 assert!(matches!(validate_spec(&s), Err(PresentationError::UnsupportedSchema(v)) if v == bad_sv));
335. 335 }));
336. 336 }
337. 337
338. 338 // 1d. Empty / whitespace / too-long id
339. 339 scenarios.push(tc("empty_id_invalid", || {
340. 340 let s = make_spec("", 1, &["detail"], text_binding_node());
341. 341 assert!(matches!(
342. 342 validate_spec(&s),
343. 343 Err(PresentationError::InvalidSpec(_))
344. 344 ));
345. 345 }));
346. 346
347. 347 scenarios.push(tc("whitespace_id_invalid", || {
348. 348 let s = make_spec(" ", 1, &["detail"], text_binding_node());
349. 349 assert!(matches!(
350. 350 validate_spec(&s),
351. 351 Err(PresentationError::InvalidSpec(_))
352. 352 ));
353. 353 }));
354. 354
355. 355 scenarios.push(tc("too_long_id_invalid", || {
356. 356 let long_id = "x".repeat(257);
357. 357 let s = make_spec(&long_id, 1, &["detail"], text_binding_node());
358. 358 assert!(matches!(
359. 359 validate_spec(&s),
360. 360 Err(PresentationError::InvalidSpec(_))
361. 361 ));
362. 362 }));
363. 363
364. 364 // 1e. Zero revision
365. 365 scenarios.push(tc("zero_revision_invalid", || {
366. 366 let s = make_spec("zr", 0, &["detail"], text_binding_node());
367. 367 assert!(matches!(
368. 368 validate_spec(&s),
369. 369 Err(PresentationError::InvalidSpec(_))
370. 370 ));
371. 371 }));
372. 372
373. 373 // 1f. Empty accepts entries
374. 374 scenarios.push(tc("empty_accept_entry_invalid", || {
375. 375 let s = make_spec("bad_a", 1, &[""], text_binding_node());
376. 376 assert!(matches!(
377. 377 validate_spec(&s),
378. 378 Err(PresentationError::InvalidSpec(_))
379. 379 ));
380. 380 }));
381. 381
382. 382 scenarios.push(tc("whitespace_accept_entry_invalid", || {
383. 383 let s = make_spec("bad_a2", 1, &[" "], text_binding_node());
384. 384 assert!(matches!(
385. 385 validate_spec(&s),
386. 386 Err(PresentationError::InvalidSpec(_))
387. 387 ));
388. 388 }));
389. 389
390. 390 // 1g. Too many nodes
391. 391 for extra in [0usize, 1, 5, 50] {
392. 392 let target = MAX_NODES + extra;
393. 393 scenarios.push(tc(&format!("too_many_nodes_{target}"), move || {
394. 394 let mut children = Vec::new();
395. 395 for i in 0..target {
396. 396 children.push(SpecNode {
397. 397 primitive: Primitive::Text,
398. 398 props: BTreeMap::from([(
399. 399 "text".into(),
400. 400 SpecValue::Text {
401. 401 value: format!("n{i}"),
402. 402 },
403. 403 )]),
404. 404 children: vec![],
405. 405 each: None,
406. 406 item: None,
407. 407 });
408. 408 }
409. 409 let root = SpecNode {
410. 410 primitive: Primitive::Stack,
411. 411 props: BTreeMap::new(),
412. 412 children,
413. 413 each: None,
414. 414 item: None,
415. 415 };
416. 416 let s = make_spec("too_many", 1, &["detail"], root);
417. 417 assert!(matches!(
418. 418 validate_spec(&s),
419. 419 Err(PresentationError::Limit(_))
420. 420 ));
421. 421 }));
422. 422 }
423. 423
424. 424 // 1h. Too deep nesting
425. 425 for extra_depth in [0usize, 1, 5] {
426. 426 let depth = MAX_DEPTH + 1 + extra_depth;
427. 427 scenarios.push(tc(&format!("too_deep_{depth}"), move || {
428. 428 let mut node = text_binding_node();
429. 429 for _ in 0..depth {
430. 430 node = SpecNode {
431. 431 primitive: Primitive::Stack,
432. 432 props: BTreeMap::new(),
433. 433 children: vec![node],
434. 434 each: None,
435. 435 item: None,
436. 436 };
437. 437 }
438. 438 let s = make_spec("too_deep", 1, &["detail"], node);
439. 439 assert!(matches!(
440. 440 validate_spec(&s),
441. 441 Err(PresentationError::Limit(_))
442. 442 ));
443. 443 }));
444. 444 }
445. 445
446. 446 // 1i. Each without item
447. 447 scenarios.push(tc("each_without_item_invalid", || {
448. 448 let root = SpecNode {
449. 449 primitive: Primitive::Stack,
450. 450 props: BTreeMap::new(),
451. 451 children: vec![],
452. 452 each: Some(Binding {
453. 453 path: "$.items".into(),
454. 454 required: false,
455. 455 empty: EmptyValue::Omit,
456. 456 }),
457. 457 item: None,
458. 458 };
459. 459 let s = make_spec("no_item", 1, &["detail"], root);
460. 460 assert!(matches!(
461. 461 validate_spec(&s),
462. 462 Err(PresentationError::InvalidSpec(_))
463. 463 ));
464. 464 }));
465. 465
466. 466 // 1j. Each with item is valid
467. 467 scenarios.push(tc("each_with_item_valid", || {
468. 468 let root = SpecNode {
469. 469 primitive: Primitive::Stack,
470. 470 props: BTreeMap::new(),
471. 471 children: vec![],
472. 472 each: Some(Binding {
473. 473 path: "$.items".into(),
474. 474 required: false,
475. 475 empty: EmptyValue::Omit,
476. 476 }),
477. 477 item: Some(Box::new(text_binding_node())),
478. 478 };
479. 479 let s = make_spec("with_item", 1, &["detail"], root);
480. 480 assert!(validate_spec(&s).is_ok());
481. 481 }));
482. 482
483. 483 // 1k. Non-finite number (validation doesn't serialize, so should pass)
484. 484 for n_val in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
485. 485 let n = n_val;
486. 486 scenarios.push(tc(&format!("non_finite_number_{n:?}"), move || {
487. 487 let mut props = BTreeMap::new();
488. 488 props.insert("value".into(), SpecValue::Number { value: n });
489. 489 let root = SpecNode {
490. 490 primitive: Primitive::Metric,
491. 491 props,
492. 492 children: vec![],
493. 493 each: None,
494. 494 item: None,
495. 495 };
496. 496 let s = make_spec("non_finite", 1, &["metric"], root);
497. 497 let result = validate_spec(&s);
498. 498 // validate_spec doesn't serialize, but compile does (via digest)
499. 499 assert!(result.is_ok());
500. 500 }));
501. 501 }
502. 502
503. 503 run("spec_validation", scenarios);
504. 504}
505. 505
506. 506// ════════════════════════════════════════════════════════════════════
507. 507// 2. BINDING PATHS
508. 508// ════════════════════════════════════════════════════════════════════
509. 509
510. 510#[test]
511. 511fn audit_binding_paths() {
512. 512 let mut scenarios: Vec<Scenario> = vec![];
513. 513
514. 514 let valid_paths: &[&str] = &[
515. 515 "$",
516. 516 "$.title",
517. 517 "$.title.subtitle",
518. 518 "$.items[0]",
519. 519 "$.items[0].name",
520. 520 "$.items[10].name",
521. 521 "$.data[999]",
522. 522 "$.a.b.c.d.e.f.g",
523. 523 "$.a-b_c",
524. 524 "$.a1.b2.c3",
525. 525 "$[0]",
526. 526 "$[0][1]",
527. 527 "$.items[0][1]",
528. 528 "$.very.long.path.with.many.segments[0][1][2]",
529. 529 ];
530. 530
531. 531 for path in valid_paths {
532. 532 let p = path.to_string();
533. 533 scenarios.push(tc(&format!("valid_path_{p}"), move || {
534. 534 let root = SpecNode {
535. 535 primitive: Primitive::Text,
536. 536 props: BTreeMap::from([("text".into(), binding_val(&p, false))]),
537. 537 children: vec![],
538. 538 each: None,
539. 539 item: None,
540. 540 };
541. 541 let s = make_spec("vb", 1, &["detail"], root);
542. 542 assert!(validate_spec(&s).is_ok(), "path {p:?} should be valid");
543. 543 }));
544. 544 }
545. 545
546. 546 let invalid_paths: &[&str] = &[
547. 547 "title",
548. 548 "$.items[-1]",
549. 549 "$.items[abc]",
550. 550 "$.items[]",
551. 551 "$['title']",
552. 552 "$.items[",
553. 553 "$.items]",
554. 554 "$.items[0",
555. 555 "$..title",
556. 556 "$.title + 1",
557. 557 "$.items[0].",
558. 558 "$.items[0]..name",
559. 559 "./title",
560. 560 "$#comment",
561. 561 "$.items[1.5]",
562. 562 "$.items[0x]",
563. 563 "$.items[+1]",
564. 564 "$.a..b",
565. 565 "$.a.b.",
566. 566 "$.a[0]b",
567. 567 "$/.[0]",
568. 568 "$.[items]",
569. 569 "$/",
570. 570 "$.items[0]extra",
571. 571 "$.items]",
572. 572 "$a",
573. 573 ];
574. 574
575. 575 for path in invalid_paths {
576. 576 let p = path.to_string();
577. 577 scenarios.push(tc(&format!("invalid_path_{p:?}"), move || {
578. 578 let root = SpecNode {
579. 579 primitive: Primitive::Text,
580. 580 props: BTreeMap::from([("text".into(), binding_val(&p, false))]),
581. 581 children: vec![],
582. 582 each: None,
583. 583 item: None,
584. 584 };
585. 585 let s = make_spec("ib", 1, &["detail"], root);
586. 586 let result = validate_spec(&s);
587. 587 assert!(
588. 588 matches!(result, Err(PresentationError::InvalidBinding(_))),
589. 589 "path {p:?}: {result:?}"
590. 590 );
591. 591 }));
592. 592 }
593. 593
594. 594 // Path too long (>512 chars)
595. 595 scenarios.push(tc("path_513_chars_invalid", || {
596. 596 let long_path = format!("$.{}", "a.".repeat(300));
597. 597 let root = SpecNode {
598. 598 primitive: Primitive::Text,
599. 599 props: BTreeMap::from([("text".into(), binding_val(&long_path, false))]),
600. 600 children: vec![],
601. 601 each: None,
602. 602 item: None,
603. 603 };
604. 604 let s = make_spec("pl", 1, &["detail"], root);
605. 605 assert!(matches!(
606. 606 validate_spec(&s),
607. 607 Err(PresentationError::InvalidBinding(_))
608. 608 ));
609. 609 }));
610. 610
611. 611 // Empty path
612. 612 scenarios.push(tc("empty_binding_path_invalid", || {
613. 613 let root = SpecNode {
614. 614 primitive: Primitive::Text,
615. 615 props: BTreeMap::from([("text".into(), binding_val("", false))]),
616. 616 children: vec![],
617. 617 each: None,
618. 618 item: None,
619. 619 };
620. 620 let s = make_spec("ep", 1, &["detail"], root);
621. 621 assert!(matches!(
622. 622 validate_spec(&s),
623. 623 Err(PresentationError::InvalidBinding(_))
624. 624 ));
625. 625 }));
626. 626
627. 627 // Required binding absent → Fallback (via compile)
628. 628 scenarios.push(tc("required_binding_absent_fallback", || {
629. 629 let root = SpecNode {
630. 630 primitive: Primitive::Text,
631. 631 props: BTreeMap::from([("text".into(), binding_val("$.missing", true))]),
632. 632 children: vec![],
633. 633 each: None,
634. 634 item: None,
635. 635 };
636. 636 let s = make_spec("req_absent", 1, &["detail"], root);
637. 637 let result = compile(&s, &ci("detail", json!({}), "fb"));
638. 638 assert!(matches!(result, CompiledPresentation::Fallback { .. }));
639. 639 }));
640. 640
641. 641 // Optional binding absent with Omit → resolved as None, node still Rich
642. 642 scenarios.push(tc("optional_binding_missing_omit", || {
643. 643 let root = SpecNode {
644. 644 primitive: Primitive::Text,
645. 645 props: BTreeMap::from([(
646. 646 "text".into(),
647. 647 SpecValue::Binding(Binding {
648. 648 path: "$.missing".into(),
649. 649 required: false,
650. 650 empty: EmptyValue::Omit,
651. 651 }),
652. 652 )]),
653. 653 children: vec![],
654. 654 each: None,
655. 655 item: None,
656. 656 };
657. 657 let s = make_spec("opt_omit", 1, &["detail"], root);
658. 658 assert!(validate_spec(&s).is_ok());
659. 659 let result = compile(&s, &ci("detail", json!({}), "fb"));
660. 660 assert!(matches!(result, CompiledPresentation::Rich(_)));
661. 661 }));
662. 662
663. 663 // Optional binding absent with EmptyText → resolved as empty string
664. 664 scenarios.push(tc("optional_binding_missing_empty_text", || {
665. 665 let root = SpecNode {
666. 666 primitive: Primitive::Text,
667. 667 props: BTreeMap::from([(
668. 668 "text".into(),
669. 669 SpecValue::Binding(Binding {
670. 670 path: "$.missing".into(),
671. 671 required: false,
672. 672 empty: EmptyValue::EmptyText,
673. 673 }),
674. 674 )]),
675. 675 children: vec![],
676. 676 each: None,
677. 677 item: None,
678. 678 };
679. 679 let s = make_spec("opt_et", 1, &["detail"], root);
680. 680 assert!(validate_spec(&s).is_ok());
681. 681 }));
682. 682
683. 683 // Optional binding absent with EmptyList → resolves as empty array
684. 684 scenarios.push(tc("optional_binding_missing_empty_list", || {
685. 685 let root = SpecNode {
686. 686 primitive: Primitive::Stack,
687. 687 props: BTreeMap::new(),
688. 688 children: vec![],
689. 689 each: Some(Binding {
690. 690 path: "$.missing".into(),
691. 691 required: false,
692. 692 empty: EmptyValue::EmptyList,
693. 693 }),
694. 694 item: Some(Box::new(text_binding_node())),
695. 695 };
696. 696 let s = make_spec("opt_el", 1, &["detail"], root);
697. 697 assert!(validate_spec(&s).is_ok());
698. 698 }));
699. 699
700. 700 // Each with non-array data → Fallback
701. 701 scenarios.push(tc("each_non_array_fallback", || {
702. 702 let root = SpecNode {
703. 703 primitive: Primitive::Stack,
704. 704 props: BTreeMap::new(),
705. 705 children: vec![],
706. 706 each: Some(Binding {
707. 707 path: "$.items".into(),
708. 708 required: false,
709. 709 empty: EmptyValue::Omit,
710. 710 }),
711. 711 item: Some(Box::new(text_binding_node())),
712. 712 };
713. 713 let s = make_spec("each_na", 1, &["detail"], root);
714. 714 let result = compile(&s, &ci("detail", json!({"items": "not_an_array"}), "fb"));
715. 715 assert!(matches!(result, CompiledPresentation::Fallback { .. }));
716. 716 }));
717. 717
718. 718 // Each expansion exceeding MAX_EXPANSION_ITEMS
719. 719 scenarios.push(tc("each_exceeds_max_expansion_fallback", || {
720. 720 let root = SpecNode {
721. 721 primitive: Primitive::Stack,
722. 722 props: BTreeMap::new(),
723. 723 children: vec![],
724. 724 each: Some(Binding {
725. 725 path: "$.items".into(),
726. 726 required: false,
727. 727 empty: EmptyValue::Omit,
728. 728 }),
729. 729 item: Some(Box::new(text_binding_node())),
730. 730 };
731. 731 let s = make_spec("each_over", 1, &["detail"], root);
732. 732 let items: Vec<String> = (0..(MAX_EXPANSION_ITEMS + 10))
733. 733 .map(|i| format!("i{i}"))
734. 734 .collect();
735. 735 let result = compile(&s, &ci("detail", json!({"items": items}), "fb"));
736. 736 assert!(matches!(result, CompiledPresentation::Fallback { .. }));
737. 737 }));
738. 738
739. 739 // Nested each valid
740. 740 scenarios.push(tc("nested_each_valid", || {
741. 741 let inner = SpecNode {
742. 742 primitive: Primitive::Stack,
743. 743 props: BTreeMap::new(),
744. 744 children: vec![],
745. 745 each: Some(Binding {
746. 746 path: "$.items".into(),
747. 747 required: false,
748. 748 empty: EmptyValue::Omit,
749. 749 }),
750. 750 item: Some(Box::new(text_binding_node())),
751. 751 };
752. 752 let root = SpecNode {
753. 753 primitive: Primitive::Stack,
754. 754 props: BTreeMap::new(),
755. 755 children: vec![inner],
756. 756 each: None,
757. 757 item: None,
758. 758 };
759. 759 let s = make_spec("nested_each", 1, &["detail"], root);
760. 760 assert!(validate_spec(&s).is_ok());
761. 761 }));
762. 762
763. 763 run("binding_paths", scenarios);
764. 764}
765. 765
766. 766// ════════════════════════════════════════════════════════════════════
767. 767// 3. COMPILATION
768. 768// ════════════════════════════════════════════════════════════════════
769. 769
770. 770#[test]
771. 771fn audit_compilation() {
772. 772 let mut scenarios: Vec<Scenario> = vec![];
773. 773
774. 774 // 3a. Valid compilation for each primitive
775. 775 for (i, prim) in PRIMITIVES.iter().enumerate() {
776. 776 let p = *prim;
777. 777 scenarios.push(tc(&format!("compile_{i}_{p:?}"), move || {
778. 778 let s = make_spec(&format!("c{i}"), 1, &["detail"], spec_node(p));
779. 779 let result = compile(&s, &ci("detail", json!({"title":"T","items":[1]}), "fb"));
780. 780 assert!(
781. 781 matches!(result, CompiledPresentation::Rich(_)),
782. 782 "compile {prim:?}: {result:?}"
783. 783 );
784. 784 }));
785. 785 }
786. 786
787. 787 // 3b. Semantic type mismatch → Fallback
788. 788 for (i, prim) in PRIMITIVES.iter().enumerate() {
789. 789 let p = *prim;
790. 790 scenarios.push(tc(&format!("mismatch_{i}_{p:?}"), move || {
791. 791 let s = make_spec(&format!("m{i}"), 1, &["comparison"], spec_node(p));
792. 792 let result = compile(&s, &ci("detail", json!({}), "fb"));
793. 793 assert!(
794. 794 matches!(result, CompiledPresentation::Fallback { ref reason, .. } if reason.contains("does not match")),
795. 795 "mismatch {prim:?}: {result:?}"
796. 796 );
797. 797 }));
798. 798 }
799. 799
800. 800 // 3c. Each with collection expansion at various sizes
801. 801 for size in [0usize, 1, 2, 5, 10, 50, 100, 255, 256] {
802. 802 let sz = size;
803. 803 scenarios.push(tc(&format!("each_size_{sz}"), move || {
804. 804 let root = SpecNode {
805. 805 primitive: Primitive::Stack,
806. 806 props: BTreeMap::new(),
807. 807 children: vec![],
808. 808 each: Some(Binding {
809. 809 path: "$.items".into(),
810. 810 required: false,
811. 811 empty: EmptyValue::Omit,
812. 812 }),
813. 813 item: Some(Box::new(text_binding_node())),
814. 814 };
815. 815 let s = make_spec("each", 1, &["detail"], root);
816. 816 let payload =
817. 817 json!({"items": (0..sz).map(|j| json!(format!("i{j}"))).collect::<Vec<_>>()});
818. 818 let result = compile(&s, &ci("detail", payload, "fb"));
819. 819 assert!(
820. 820 matches!(result, CompiledPresentation::Rich(_)),
821. 821 "each size {sz}: {result:?}"
822. 822 );
823. 823 }));
824. 824 }
825. 825
826. 826 // 3d. FallbackKind Document vs Plain
827. 827 for (fk, label) in [
828. 828 (FallbackKind::Document, "doc"),
829. 829 (FallbackKind::Plain, "plain"),
830. 830 ] {
831. 831 let lf = label.to_string();
832. 832 let fk_val = fk;
833. 833 scenarios.push(tc(&format!("fallback_kind_{lf}"), move || {
834. 834 let root = SpecNode {
835. 835 primitive: Primitive::Title,
836. 836 props: BTreeMap::from([("title".into(), binding_val("$.missing", true))]),
837. 837 children: vec![],
838. 838 each: None,
839. 839 item: None,
840. 840 };
841. 841 let s = PresentationSpec {
842. 842 schema_version: SPEC_SCHEMA_VERSION,
843. 843 id: format!("fb_{lf}"),
844. 844 revision: 1,
845. 845 accepts: vec!["detail".into()],
846. 846 root,
847. 847 fallback: FallbackSpec { kind: fk_val },
848. 848 accessibility: AccessibilitySpec::default(),
849. 849 metadata: BTreeMap::new(),
850. 850 };
851. 851 let result = compile(&s, &ci("detail", json!({}), "fallback text"));
852. 852 assert!(matches!(result, CompiledPresentation::Fallback { .. }));
853. 853 }));
854. 854 }
855. 855
856. 856 // 3e. Deep nesting within MAX_DEPTH compiles
857. 857 scenarios.push(tc("deep_nesting_within_depth_compiles", || {
858. 858 let mut node = text_binding_node();
859. 859 for _ in 0..(MAX_DEPTH - 2) {
860. 860 node = SpecNode {
861. 861 primitive: Primitive::Stack,
862. 862 props: BTreeMap::new(),
863. 863 children: vec![node],
864. 864 each: None,
865. 865 item: None,
866. 866 };
867. 867 }
868. 868 let s = make_spec("deep_ok", 1, &["detail"], node);
869. 869 let result = compile(&s, &ci("detail", json!({}), "fb"));
870. 870 assert!(matches!(result, CompiledPresentation::Rich(_)));
871. 871 }));
872. 872
873. 873 // 3f. Deep nesting exceeding depth at compile → Fallback
874. 874 scenarios.push(tc("deep_nesting_exceeds_depth_fallback", || {
875. 875 let mut node = text_binding_node();
876. 876 for _ in 0..(MAX_DEPTH + 5) {
877. 877 node = SpecNode {
878. 878 primitive: Primitive::Stack,
879. 879 props: BTreeMap::new(),
880. 880 children: vec![node],
881. 881 each: None,
882. 882 item: None,
883. 883 };
884. 884 }
885. 885 let s = make_spec("deep_bad", 1, &["detail"], node);
886. 886 let result = compile(&s, &ci("detail", json!({}), "fb"));
887. 887 assert!(matches!(result, CompiledPresentation::Fallback { .. }));
888. 888 }));
889. 889
890. 890 // 3g. Accessibility summary resolved
891. 891 scenarios.push(tc("accessibility_summary_resolved", || {
892. 892 let root = section_with_title();
893. 893 let mut s = make_spec("acc1", 1, &["detail"], root);
894. 894 s.accessibility.summary = Some(Binding {
895. 895 path: "$.title".into(),
896. 896 required: false,
897. 897 empty: EmptyValue::EmptyText,
898. 898 });
899. 899 let result = compile(&s, &ci("detail", json!({"title": "Hello World"}), "fb"));
900. 900 assert!(matches!(result, CompiledPresentation::Rich(_)));
901. 901 }));
902. 902
903. 903 // 3h. Accessibility summary missing → ok
904. 904 scenarios.push(tc("accessibility_summary_missing_ok", || {
905. 905 let s = make_spec("acc2", 1, &["detail"], section_with_title());
906. 906 let result = compile(&s, &ci("detail", json!({}), "fb"));
907. 907 assert!(matches!(result, CompiledPresentation::Rich(_)));
908. 908 }));
909. 909
910. 910 // 3i. Edge payloads
911. 911 scenarios.push(tc("empty_payload_omits_optional_bindings", || {
912. 912 let root = SpecNode {
913. 913 primitive: Primitive::Text,
914. 914 props: BTreeMap::from([("text".into(), binding_val("$.missing", false))]),
915. 915 children: vec![],
916. 916 each: None,
917. 917 item: None,
918. 918 };
919. 919 let s = make_spec("empty", 1, &["detail"], root);
920. 920 let result = compile(&s, &ci("detail", json!({}), "fb"));
921. 921 assert!(matches!(result, CompiledPresentation::Rich(_)));
922. 922 }));
923. 923
924. 924 scenarios.push(tc("unicode_in_text", || {
925. 925 let root = SpecNode {
926. 926 primitive: Primitive::Section,
927. 927 props: BTreeMap::from([("title".into(), binding_val("$.title", false))]),
928. 928 children: vec![],
929. 929 each: None,
930. 930 item: None,
931. 931 };
932. 932 let s = make_spec("unicode", 1, &["detail"], root);
933. 933 let result = compile(&s, &ci("detail", json!({"title": "Hello 世界 🌍"}), "fb"));
934. 934 assert!(matches!(result, CompiledPresentation::Rich(_)));
935. 935 }));
936. 936
937. 937 scenarios.push(tc("special_chars_in_text", || {
938. 938 let root = SpecNode {
939. 939 primitive: Primitive::Section,
940. 940 props: BTreeMap::from([("title".into(), binding_val("$.title", false))]),
941. 941 children: vec![],
942. 942 each: None,
943. 943 item: None,
944. 944 };
945. 945 let s = make_spec("specialchars", 1, &["detail"], root);
946. 946 let result = compile(&s, &ci("detail", json!({"title": "<>&\"'`"}), "fb"));
947. 947 assert!(matches!(result, CompiledPresentation::Rich(_)));
948. 948 }));
949. 949
950. 950 scenarios.push(tc("hostile_massive_payload_no_panic", || {
951. 951 let big_array: Vec<String> = (0..10000).map(|i| format!("x{i}")).collect();
952. 952 let s = make_spec("huge", 1, &["detail"], section_with_title());
953. 953 let result = compile(
954. 954 &s,
955. 955 &ci("detail", json!({"title": "Huge", "items": big_array}), "fb"),
956. 956 );
957. 957 assert!(matches!(result, CompiledPresentation::Rich(_)));
958. 958 }));
959. 959
960. 960 scenarios.push(tc("hostile_deeply_nested_json_no_panic", || {
961. 961 let nested = serde_json::Value::Array((0..100).map(|i| json!({"v": i})).collect());
962. 962 let s = make_spec("deep_json", 1, &["detail"], section_with_title());
963. 963 let result = compile(
964. 964 &s,
965. 965 &ci("detail", json!({"title": "Deep", "items": nested}), "fb"),
966. 966 );
967. 967 assert!(matches!(result, CompiledPresentation::Rich(_)));
968. 968 }));
969. 969
970. 970 scenarios.push(tc("hostile_null_payload_fallback", || {
971. 971 let root = SpecNode {
972. 972 primitive: Primitive::Text,
973. 973 props: BTreeMap::from([("text".into(), binding_val("$.title", true))]),
974. 974 children: vec![],
975. 975 each: None,
976. 976 item: None,
977. 977 };
978. 978 let s = make_spec("null_pl", 1, &["detail"], root);
979. 979 let result = compile(&s, &ci("detail", serde_json::Value::Null, "fb"));
980. 980 assert!(matches!(result, CompiledPresentation::Fallback { .. }));
981. 981 }));
982. 982
983. 983 scenarios.push(tc("hostile_array_payload_fallback", || {
984. 984 let root = SpecNode {
985. 985 primitive: Primitive::Section,
986. 986 props: BTreeMap::from([("title".into(), binding_val("$.title", true))]),
987. 987 children: vec![],
988. 988 each: None,
989. 989 item: None,
990. 990 };
991. 991 let s = make_spec("arr_pl", 1, &["detail"], root);
992. 992 let result = compile(&s, &ci("detail", serde_json::Value::Array(vec![]), "fb"));
993. 993 assert!(matches!(result, CompiledPresentation::Fallback { .. }));
994. 994 }));
995. 995
996. 996 scenarios.push(tc("hostile_string_payload_fallback", || {
997. 997 let root = SpecNode {
998. 998 primitive: Primitive::Section,
999. 999 props: BTreeMap::from([("title".into(), binding_val("$.title", true))]),
1000. 1000 children: vec![],