1. 1#![allow(
2. 2 unused_imports,
3. 3 unused_variables,
4. 4 clippy::unwrap_used,
5. 5 clippy::expect_used,
6. 6 clippy::panic,
7. 7 clippy::indexing_slicing,
8. 8 clippy::redundant_closure,
9. 9 clippy::useless_conversion,
10. 10 clippy::bool_assert_comparison,
11. 11 clippy::collapsible_if,
12. 12 clippy::len_zero,
13. 13 clippy::needless_borrow,
14. 14 clippy::redundant_locals,
15. 15 clippy::too_many_lines,
16. 16 clippy::needless_pass_by_value,
17. 17 suspicious_double_ref_op
18. 18)]
19. 19
20. 20//! Final-output deep verification: 10,000 scenarios (5,000 red-team content
21. 21//! verification + 5,000 blue-team structural verification).
22. 22//! Each input is rendered through all six surfaces and assertions check the
23. 23//! actual output content — fallback preservation, coverage integrity,
24. 24//! payload types, serialization round-trip, schema correctness, and
25. 25//! surface-specific formatting.
26. 26
27. 27use std::collections::BTreeSet;
28. 28use vak_delivery::AnswerDraft;
29. 29use vak_delivery::DELIVERY_SCHEMA_VERSION;
30. 30use vak_delivery::DeliveryContent;
31. 31use vak_delivery::DeliveryJob;
32. 32use vak_delivery::DeliveryKind;
33. 33use vak_delivery::DeliveryPacket;
34. 34use vak_delivery::DeliveryPayload;
35. 35use vak_delivery::DeliveryPosture;
36. 36use vak_delivery::DeliveryProfile;
37. 37use vak_delivery::Markup;
38. 38use vak_delivery::render;
39. 39
40. 40type Scenario = (String, Box<dyn FnOnce()>);
41. 41
42. 42fn tc<F: FnOnce() + 'static>(name: &str, f: F) -> Scenario {
43. 43 (name.to_string(), Box::new(f))
44. 44}
45. 45
46. 46fn run_fn(label: &str, scenarios: Vec<Scenario>) {
47. 47 let total = scenarios.len();
48. 48 let mut passed = 0usize;
49. 49 let mut failures: Vec<String> = Vec::new();
50. 50 for (name, test) in scenarios {
51. 51 match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| test())) {
52. 52 Ok(()) => passed += 1,
53. 53 Err(_) => failures.push(name),
54. 54 }
55. 55 }
56. 56 assert_eq!(
57. 57 passed, total,
58. 58 "{label}: {passed}/{total} passed — failures: {failures:?}"
59. 59 );
60. 60 println!(" ✓ {label}: {total} scenarios passed");
61. 61}
62. 62
63. 63fn make_job(source: &str, markup: Markup, surface: &str) -> DeliveryJob {
64. 64 DeliveryJob {
65. 65 job_id: "test-job".into(),
66. 66 target: format!("{surface}:one"),
67. 67 kind: DeliveryKind::Assistant,
68. 68 content: DeliveryContent::Answer(AnswerDraft::from_markdown(source)),
69. 69 profile: DeliveryProfile {
70. 70 surface: surface.into(),
71. 71 markup,
72. 72 max_chars: None,
73. 73 supports_tables: true,
74. 74 supports_code_blocks: true,
75. 75 supports_links: true,
76. 76 supports_actions: false,
77. 77 template: None,
78. 78 posture: DeliveryPosture::default(),
79. 79 },
80. 80 skill_registry: None,
81. 81 }
82. 82}
83. 83
84. 84fn pt(packet: &DeliveryPacket) -> String {
85. 85 match &packet.payload {
86. 86 DeliveryPayload::Text(s) => s.clone(),
87. 87 DeliveryPayload::Structured(_) => packet.fallback_markdown.clone(),
88. 88 }
89. 89}
90. 90
91. 91const SURFACES: &[(&str, Markup)] = &[
92. 92 ("telegram", Markup::TelegramHtml),
93. 93 ("discord", Markup::DiscordMarkdown),
94. 94 ("slack", Markup::SlackMrkdwn),
95. 95 ("desktop", Markup::Markdown),
96. 96 ("terminal", Markup::Plain),
97. 97 ("admin", Markup::Plain),
98. 98];
99. 99
100. 100fn src_idx(base: &str, i: usize) -> String {
101. 101 format!("{}\n\n<!-- variant {} -->", base, i)
102. 102}
103. 103
104. 104fn render_all(source: &str) -> Vec<(DeliveryPacket, &'static str)> {
105. 105 let mut results = Vec::new();
106. 106 for (surface, markup) in SURFACES {
107. 107 let job = make_job(source, *markup, surface);
108. 108 let packet = render(&job).expect("render");
109. 109 results.push((packet, *surface));
110. 110 }
111. 111 results
112. 112}
113. 113
114. 114fn is_h1(template: &str) -> bool {
115. 115 template.starts_with("# ") && !template.starts_with("## ")
116. 116}
117. 117
118. 118#[test]
119. 119fn content_headings_output() {
120. 120 let mut scenarios: Vec<Scenario> = vec![];
121. 121 let templates: &[&str] = &[
122. 122 "# Title",
123. 123 "## Subtitle",
124. 124 "###### H6",
125. 125 "# T\n## S\n### H",
126. 126 "# Title with **bold**",
127. 127 "# Multiple\n\n# Another",
128. 128 "# H\n\nSome text.",
129. 129 ];
130. 130 for i in 0..500 {
131. 131 let t = templates[i % templates.len()];
132. 132 let source = src_idx(t, i);
133. 133 let i = i;
134. 134 scenarios.push(tc(&format!("heading_{i}"), move || {
135. 135 for (packet, surface) in render_all(&source) {
136. 136 let text = pt(&packet);
137. 137 let src = source.as_str();
138. 138 match surface {
139. 139 "telegram" => {
140. 140 assert!(text.contains("<b>"), "telegram heading missing <b>: {src}");
141. 141 }
142. 142 "discord" => {
143. 143 if is_h1(t) {
144. 144 assert!(text.contains("<b>"), "discord H1 missing <b>: {src}");
145. 145 } else {
146. 146 assert!(!text.is_empty(), "discord H2+ empty: {src}");
147. 147 }
148. 148 }
149. 149 "desktop" | "admin" => {
150. 150 assert!(
151. 151 text.contains("Title")
152. 152 || text.contains("Subtitle")
153. 153 || text.contains("H")
154. 154 || src.contains('#'),
155. 155 "desktop heading text missing: {src}"
156. 156 );
157. 157 }
158. 158 _ => {}
159. 159 }
160. 160 }
161. 161 }));
162. 162 }
163. 163 run_fn("content_headings_output", scenarios);
164. 164}
165. 165
166. 166#[test]
167. 167fn content_code_blocks_output() {
168. 168 let mut scenarios: Vec<Scenario> = vec![];
169. 169 let templates: &[&str] = &[
170. 170 "```rust\nfn main() {}\n```",
171. 171 "```python\nprint('hello')\n```",
172. 172 "```\nplain code\n```",
173. 173 "```diff\n- removed\n+ added\n```",
174. 174 "```\n```\n```",
175. 175 r#"```
176. 176fn hello() {
177. 177 println!("hi");
178. 178}
179. 179```"#,
180. 180 ];
181. 181 for i in 0..500 {
182. 182 let t = templates[i % templates.len()];
183. 183 let source = src_idx(t, i);
184. 184 let i = i;
185. 185 scenarios.push(tc(&format!("code_{i}"), move || {
186. 186 for (packet, surface) in render_all(&source) {
187. 187 let text = pt(&packet);
188. 188 let src = source.as_str();
189. 189 match surface {
190. 190 "telegram" => {
191. 191 assert!(
192. 192 text.contains("<pre>") || text.contains("<code>"),
193. 193 "telegram code missing <pre>/<code>: {src}"
194. 194 );
195. 195 }
196. 196 "desktop" | "discord" | "slack" => {
197. 197 assert!(
198. 198 text.contains("```")
199. 199 || text.contains("code")
200. 200 || text.contains("fn")
201. 201 || text.contains("removed")
202. 202 || text.contains("print"),
203. 203 "surface code missing content: {surface}: {src}"
204. 204 );
205. 205 }
206. 206 _ => {
207. 207 // Plain surfaces strip code fences; empty code blocks yield empty text
208. 208 if t.contains("fn")
209. 209 || t.contains("removed")
210. 210 || t.contains("print")
211. 211 || t.contains("hello")
212. 212 {
213. 213 assert!(
214. 214 !text.is_empty()
215. 215 && (text.contains("code")
216. 216 || text.contains("fn")
217. 217 || text.contains("removed")
218. 218 || text.contains("print")
219. 219 || text.contains("hello")),
220. 220 "plain code missing content: {surface}: {src}"
221. 221 );
222. 222 }
223. 223 }
224. 224 }
225. 225 }
226. 226 }));
227. 227 }
228. 228 run_fn("content_code_blocks_output", scenarios);
229. 229}
230. 230
231. 231#[test]
232. 232fn content_lists_output() {
233. 233 let mut scenarios: Vec<Scenario> = vec![];
234. 234 let templates: &[&str] = &[
235. 235 "- a\n- b\n- c",
236. 236 "1. first\n2. second\n3. third",
237. 237 "- [ ] todo\n- [x] done",
238. 238 "1. one\n 1. nested",
239. 239 "* star list\n* second",
240. 240 "+ plus list\n+ second",
241. 241 ];
242. 242 for i in 0..500 {
243. 243 let t = templates[i % templates.len()];
244. 244 let source = src_idx(t, i);
245. 245 let i = i;
246. 246 scenarios.push(tc(&format!("list_{i}"), move || {
247. 247 for (packet, surface) in render_all(&source) {
248. 248 let text = pt(&packet);
249. 249 let src = source.as_str();
250. 250 assert!(
251. 251 text.contains("a")
252. 252 || text.contains("first")
253. 253 || text.contains("todo")
254. 254 || text.contains("done"),
255. 255 "list content missing for {src}"
256. 256 );
257. 257 if src.contains("- [ ]") || src.contains("- [x]") {
258. 258 assert!(
259. 259 text.contains('☐')
260. 260 || text.contains("[ ]")
261. 261 || text.contains('☑')
262. 262 || text.contains("[x]"),
263. 263 "task list marker missing for {surface}: {src}"
264. 264 );
265. 265 }
266. 266 }
267. 267 }));
268. 268 }
269. 269 run_fn("content_lists_output", scenarios);
270. 270}
271. 271
272. 272#[test]
273. 273fn content_emphasis_output() {
274. 274 let mut scenarios: Vec<Scenario> = vec![];
275. 275 let templates: &[&str] = &[
276. 276 "**bold**",
277. 277 "*italic*",
278. 278 "~~strikethrough~~",
279. 279 "**a** *b* ~~c~~",
280. 280 "`inline code`",
281. 281 "**bold** and *italic* and ~~strike~~",
282. 282 ];
283. 283 for i in 0..500 {
284. 284 let t = templates[i % templates.len()];
285. 285 let source = src_idx(t, i);
286. 286 let i = i;
287. 287 scenarios.push(tc(&format!("emph_{i}"), move || {
288. 288 for (packet, surface) in render_all(&source) {
289. 289 let text = pt(&packet);
290. 290 let src = source.as_str();
291. 291 if src.contains("**bold**") {
292. 292 match surface {
293. 293 "telegram" => {
294. 294 assert!(text.contains("<b>"), "bold missing <b> for telegram: {src}");
295. 295 }
296. 296 _ => {
297. 297 assert!(!text.is_empty(), "bold empty: {src}");
298. 298 }
299. 299 }
300. 300 }
301. 301 if src.contains("~~strikethrough~~") {
302. 302 match surface {
303. 303 "telegram" => {
304. 304 assert!(
305. 305 text.contains("<s>"),
306. 306 "strike missing <s> for telegram: {src}"
307. 307 );
308. 308 }
309. 309 _ => {
310. 310 assert!(!text.is_empty(), "strike empty: {src}");
311. 311 }
312. 312 }
313. 313 }
314. 314 }
315. 315 }));
316. 316 }
317. 317 run_fn("content_emphasis_output", scenarios);
318. 318}
319. 319
320. 320#[test]
321. 321fn content_tables_output() {
322. 322 let mut scenarios: Vec<Scenario> = vec![];
323. 323 let templates: &[&str] = &[
324. 324 "| A | B |\n|---|---|\n| 1 | 2 |",
325. 325 "| a | b | c |\n|---|---|---|\n| 1 | 2 | 3 |",
326. 326 "| Col1 | Col2 |\n| --- | --- |\n| val1 | val2 |",
327. 327 "| single |\n|---|\n| val |",
328. 328 ];
329. 329 for i in 0..500 {
330. 330 let t = templates[i % templates.len()];
331. 331 let source = src_idx(t, i);
332. 332 let i = i;
333. 333 scenarios.push(tc(&format!("table_{i}"), move || {
334. 334 for (packet, surface) in render_all(&source) {
335. 335 let text = pt(&packet);
336. 336 let src = source.as_str();
337. 337 assert!(
338. 338 text.contains("1")
339. 339 || text.contains("val1")
340. 340 || text.contains("val")
341. 341 || text.contains("A"),
342. 342 "table data missing for {surface}: {src}"
343. 343 );
344. 344 }
345. 345 }));
346. 346 }
347. 347 run_fn("content_tables_output", scenarios);
348. 348}
349. 349
350. 350#[test]
351. 351fn content_links_output() {
352. 352 let mut scenarios: Vec<Scenario> = vec![];
353. 353 let templates: &[&str] = &[
354. 354 "[label](https://example.com)",
355. 355 "[text](https://x.com \"Title\")",
356. 356 "![alt](https://x.com/img.png)",
357. 357 "[a](https://a.com)\n\n[b](https://b.com)",
358. 358 ];
359. 359 for i in 0..500 {
360. 360 let t = templates[i % templates.len()];
361. 361 let source = src_idx(t, i);
362. 362 let i = i;
363. 363 scenarios.push(tc(&format!("link_{i}"), move || {
364. 364 for (packet, surface) in render_all(&source) {
365. 365 let text = pt(&packet);
366. 366 let src = source.as_str();
367. 367 assert!(
368. 368 text.contains("label")
369. 369 || text.contains("text")
370. 370 || text.contains("alt")
371. 371 || text.contains("https://")
372. 372 || text.contains("example.com")
373. 373 || text.contains("a.com"),
374. 374 "link text/url missing in {surface}: {src}"
375. 375 );
376. 376 }
377. 377 }));
378. 378 }
379. 379 run_fn("content_links_output", scenarios);
380. 380}
381. 381
382. 382#[test]
383. 383fn content_quotes_output() {
384. 384 let mut scenarios: Vec<Scenario> = vec![];
385. 385 let templates: &[&str] = &[
386. 386 "> quoted text",
387. 387 "> > nested quote",
388. 388 "> quote\n> second line",
389. 389 "# T\n\n> important",
390. 390 ];
391. 391 for i in 0..500 {
392. 392 let t = templates[i % templates.len()];
393. 393 let source = src_idx(t, i);
394. 394 let i = i;
395. 395 scenarios.push(tc(&format!("quote_{i}"), move || {
396. 396 for (packet, surface) in render_all(&source) {
397. 397 let text = pt(&packet);
398. 398 let src = source.as_str();
399. 399 if src.contains("quoted") || src.contains("important") {
400. 400 assert!(
401. 401 text.contains("quoted")
402. 402 || text.contains("important")
403. 403 || text.contains("<blockquote>"),
404. 404 "quote content missing for {surface}: {src}"
405. 405 );
406. 406 } else {
407. 407 assert!(!text.is_empty(), "quote empty for {surface}: {src}");
408. 408 }
409. 409 }
410. 410 }));
411. 411 }
412. 412 run_fn("content_quotes_output", scenarios);
413. 413}
414. 414
415. 415#[test]
416. 416fn content_html_escaping_output() {
417. 417 let mut scenarios: Vec<Scenario> = vec![];
418. 418 let templates: &[&str] = &[
419. 419 "<script>alert(1)</script>",
420. 420 "<b>bold</b>",
421. 421 "<img src=x onerror=alert(1)>",
422. 422 "Text < > & ",
423. 423 "<iframe src=javascript:alert(1)>",
424. 424 "<div onclick=alert(1)>x</div>",
425. 425 ];
426. 426 for i in 0..500 {
427. 427 let t = templates[i % templates.len()];
428. 428 let source = src_idx(t, i);
429. 429 let i = i;
430. 430 scenarios.push(tc(&format!("escape_{i}"), move || {
431. 431 let tg_packet =
432. 432 render(&make_job(&source, Markup::TelegramHtml, "telegram")).expect("render");
433. 433 let tg_text = pt(&tg_packet);
434. 434 assert!(
435. 435 !tg_text.contains("<script"),
436. 436 "script tag not escaped: {source}"
437. 437 );
438. 438 assert!(!tg_text.contains("<iframe"), "iframe not escaped: {source}");
439. 439 assert!(!tg_text.contains("<img"), "img not escaped: {source}");
440. 440 assert!(!tg_text.contains("<div"), "div not escaped: {source}");
441. 441 for (packet, _) in render_all(&source) {
442. 442 let _ = pt(&packet);
443. 443 }
444. 444 }));
445. 445 }
446. 446 run_fn("content_html_escaping_output", scenarios);
447. 447}
448. 448
449. 449#[test]
450. 450fn content_spoilers_output() {
451. 451 let mut scenarios: Vec<Scenario> = vec![];
452. 452 let templates: &[&str] = &[
453. 453 "||hidden||",
454. 454 "text ||spoiler|| more",
455. 455 "||multi\nline\nspoiler||",
456. 456 "# Title\n\n||spoiler||",
457. 457 "**bold** ||spoiler|| end",
458. 458 "||a|| ||b|| ||c||",
459. 459 ];
460. 460 for i in 0..500 {
461. 461 let t = templates[i % templates.len()];
462. 462 let source = src_idx(t, i);
463. 463 let i = i;
464. 464 scenarios.push(tc(&format!("spoiler_{i}"), move || {
465. 465 let tg = render(&make_job(&source, Markup::TelegramHtml, "telegram")).expect("render");
466. 466 let tg_text = pt(&tg);
467. 467 if !t.contains('\n') || t.lines().count() == 1 {
468. 468 assert!(
469. 469 tg_text.contains("<tg-spoiler>"),
470. 470 "telegram spoiler missing <tg-spoiler>: {source}"
471. 471 );
472. 472 }
473. 473 assert!(
474. 474 tg_text.contains("hidden")
475. 475 || tg_text.contains("spoiler")
476. 476 || tg_text.contains("tg-spoiler"),
477. 477 "spoiler content missing: {source}"
478. 478 );
479. 479 }));
480. 480 }
481. 481 run_fn("content_spoilers_output", scenarios);
482. 482}
483. 483
484. 484#[test]
485. 485fn content_mixed_structures_output() {
486. 486 let mut scenarios: Vec<Scenario> = vec![];
487. 487 let templates: &[&str] = &[
488. 488 "# Title\n\n**bold** *italic* ~~strike~~\n\n- item 1\n- item 2\n\n```rust\ncode\n```\n\n> quote\n\n| a | b |\n|---|---|\n| 1 | 2 |",
489. 489 "||spoiler||\n\ninline **bold** ||another|| end",
490. 490 "- [ ] todo\n- [x] done\n\n# H\n\n> **bold** quote",
491. 491 "",
492. 492 "plain text only",
493. 493 "| a | b | c |\n|---|---|---|\n| 1 | 2 | 3 |",
494. 494 "```python\nprint('hello')\n```\n\nMore text.",
495. 495 "# H1\n## H2\n### H3\n#### H4\n##### H5\n###### H6",
496. 496 "1. first\n2. second\n3. third\n\n- a\n - b\n - c",
497. 497 "Code `inline` and **bold** in same paragraph.",
498. 498 "# T\n\n- item 1\n- [x] done\n\n> quote\n\n| a | b |\n|---|---|\n| 1 | 2 |",
499. 499 r#"```
500. 500fn hello() {
501. 501 println!("hi");
502. 502}
503. 503```
504. 504
505. 505> **Important** quote with ||spoiler||"#,
506. 506 ];
507. 507 for i in 0..500 {
508. 508 let t = templates[i % templates.len()];
509. 509 let source = src_idx(t, i);
510. 510 let i = i;
511. 511 scenarios.push(tc(&format!("mixed_{i}"), move || {
512. 512 for (packet, surface) in render_all(&source) {
513. 513 let src = source.as_str();
514. 514 assert_eq!(
515. 515 packet.fallback_markdown, src,
516. 516 "fallback not preserved on {surface}: {src}"
517. 517 );
518. 518 assert_eq!(packet.schema_version, DELIVERY_SCHEMA_VERSION);
519. 519 let ids: BTreeSet<_> = packet.coverage.iter().map(|c| &c.block_id).collect();
520. 520 assert_eq!(
521. 521 ids.len(),
522. 522 packet.coverage.len(),
523. 523 "duplicate block IDs on {surface}: {src}"
524. 524 );
525. 525 }
526. 526 }));
527. 527 }
528. 528 run_fn("content_mixed_structures_output", scenarios);
529. 529}
530. 530
531. 531#[test]
532. 532fn content_special_characters_output() {
533. 533 let mut scenarios: Vec<Scenario> = vec![];
534. 534 let templates: &[&str] = &[
535. 535 "Emoji: 🎉🚀✅",
536. 536 "World: 世界の人々",
537. 537 "Math symbols: ∀∃∄∅∆∇∈∉∋∌∏∑−±∓",
538. 538 "RTL: \u{202E}hello\u{202C}",
539. 539 "Zero-width: \u{200B}joiner",
540. 540 "BOM: \u{FEFF}text",
541. 541 "Special: < > & ",
542. 542 "Tabs\tand\nnewlines",
543. 543 ];
544. 544 for i in 0..500 {
545. 545 let t = templates[i % templates.len()];
546. 546 let source = src_idx(t, i);
547. 547 let i = i;
548. 548 scenarios.push(tc(&format!("special_{i}"), move || {
549. 549 for (packet, surface) in render_all(&source) {
550. 550 let text = pt(&packet);
551. 551 if surface == "telegram" && source.contains('<') {
552. 552 assert!(!text.contains("<script"), "script leaked: {source}");
553. 553 }
554. 554 if !source.trim().is_empty() {
555. 555 assert!(
556. 556 !text.is_empty(),
557. 557 "empty output for non-empty input on {surface}: {source}"
558. 558 );
559. 559 }
560. 560 }
561. 561 }));
562. 562 }
563. 563 run_fn("content_special_characters_output", scenarios);
564. 564}
565. 565
566. 566#[test]
567. 567fn content_horizontal_rules_output() {
568. 568 let mut scenarios: Vec<Scenario> = vec![];
569. 569 let templates: &[&str] = &["Text before\n\n---\n\nText after", "---", "***", "___"];
570. 570 for i in 0..500 {
571. 571 let t = templates[i % templates.len()];
572. 572 let source = src_idx(t, i);
573. 573 let i = i;
574. 574 scenarios.push(tc(&format!("hr_{i}"), move || {
575. 575 for (packet, surface) in render_all(&source) {
576. 576 let text = pt(&packet);
577. 577 if source.contains("---") || source.contains("***") || source.contains("___") {
578. 578 match surface {
579. 579 "telegram" | "discord" | "slack" => {
580. 580 assert!(text.contains("─"), "HR missing on {surface}: {source}");
581. 581 }
582. 582 _ => {
583. 583 assert!(!text.is_empty(), "hr produced empty: {surface}: {source}");
584. 584 }
585. 585 }
586. 586 }
587. 587 assert_eq!(packet.fallback_markdown, source);
588. 588 }
589. 589 }));
590. 590 }
591. 591 run_fn("content_horizontal_rules_output", scenarios);
592. 592}
593. 593
594. 594#[test]
595. 595fn content_empty_and_whitespace_output() {
596. 596 let mut scenarios: Vec<Scenario> = vec![];
597. 597 let templates: &[&str] = &[
598. 598 "",
599. 599 " ",
600. 600 " ",
601. 601 "\n",
602. 602 "\n\n\n",
603. 603 "\t",
604. 604 " \n \t \n ",
605. 605 "\u{00A0}",
606. 606 "\u{200B}",
607. 607 ];
608. 608 for i in 0..500 {
609. 609 let t = templates[i % templates.len()];
610. 610 let source = t.to_string();
611. 611 let i = i;
612. 612 scenarios.push(tc(&format!("empty_{i}"), move || {
613. 613 for (packet, surface) in render_all(&source) {
614. 614 assert_eq!(
615. 615 packet.fallback_markdown, source,
616. 616 "fallback not preserved for empty input on {surface}"
617. 617 );
618. 618 if source.trim().is_empty() {
619. 619 assert!(
620. 620 packet.coverage.is_empty(),
621. 621 "non-empty coverage for empty input on {surface}"
622. 622 );
623. 623 }
624. 624 }
625. 625 }));
626. 626 }
627. 627 run_fn("content_empty_and_whitespace_output", scenarios);
628. 628}
629. 629
630. 630#[test]
631. 631fn content_paragraphs_and_linebreaks_output() {
632. 632 let mut scenarios: Vec<Scenario> = vec![];
633. 633 let templates: &[&str] = &[
634. 634 "Line 1\n\nLine 2",
635. 635 "Line 1\n\n\nLine 2",
636. 636 "Paragraph one.\n\nParagraph two.\n\nParagraph three.",
637. 637 "Single paragraph no newline",
638. 638 "Trailing newline\n",
639. 639 "Leading newline\n\nText",
640. 640 "Multiple\n\n\n\n\n\ngaps",
641. 641 ];
642. 642 for i in 0..500 {
643. 643 let t = templates[i % templates.len()];
644. 644 let source = src_idx(t, i);
645. 645 let i = i;
646. 646 scenarios.push(tc(&format!("para_{i}"), move || {
647. 647 for (packet, surface) in render_all(&source) {
648. 648 let text = pt(&packet);
649. 649 assert_eq!(packet.fallback_markdown, source);
650. 650 if text.contains("one") && text.contains("two") {
651. 651 assert!(
652. 652 text.contains("one") && text.contains("two"),
653. 653 "paragraph content lost on {surface}: {source}"
654. 654 );
655. 655 }
656. 656 }
657. 657 }));
658. 658 }
659. 659 run_fn("content_paragraphs_and_linebreaks_output", scenarios);
660. 660}
661. 661
662. 662#[test]
663. 663fn content_nested_constructs_output() {
664. 664 let mut scenarios: Vec<Scenario> = vec![];
665. 665 let templates: &[&str] = &[
666. 666 "**bold *italic* bold**",
667. 667 "*italic **bold** italic*",
668. 668 "~~strike **bold** strike~~",
669. 669 "`code with **bold** inside`",
670. 670 "> **bold** quote\n> *italic* quote",
671. 671 "| `code` | b |\n|---|---|\n| 1 | 2 |",
672. 672 "# **bold** heading",
673. 673 "**bold** `code` **bold**",
674. 674 "||**bold**||",
675. 675 "||`code`||",
676. 676 ];
677. 677 for i in 0..500 {
678. 678 let t = templates[i % templates.len()];
679. 679 let source = src_idx(t, i);
680. 680 let i = i;
681. 681 scenarios.push(tc(&format!("nested_{i}"), move || {
682. 682 for (packet, surface) in render_all(&source) {
683. 683 let text = pt(&packet);
684. 684 assert!(!text.is_empty(), "empty output for nested: {source}");
685. 685 assert_eq!(packet.fallback_markdown, source);
686. 686 }
687. 687 }));
688. 688 }
689. 689 run_fn("content_nested_constructs_output", scenarios);
690. 690}
691. 691
692. 692#[test]
693. 693fn structural_packet_fields() {
694. 694 let mut scenarios: Vec<Scenario> = vec![];
695. 695 let templates: &[&str] = &[
696. 696 "# Title\n\nBody.",
697. 697 "Plain text",
698. 698 "| A | B |\n|---|---|\n| 1 | 2 |",
699. 699 "```rust\nfn main() {}\n```",
700. 700 "- [ ] todo\n- [x] done",
701. 701 "||spoiler||",
702. 702 "",
703. 703 "**bold** *italic* ~~strike~~",
704. 704 "# H1\n## H2\n### H3",
705. 705 "Line 1\n\nLine 2\n\nLine 3",
706. 706 ];
707. 707 for i in 0..500 {
708. 708 let t = templates[i % templates.len()];
709. 709 let source = src_idx(t, i);
710. 710 let i = i;
711. 711 scenarios.push(tc(&format!("fields_{i}"), move || {
712. 712 for (surface, markup) in SURFACES {
713. 713 let job = make_job(&source, *markup, surface);
714. 714 let packet = render(&job).expect("render");
715. 715 assert_eq!(packet.schema_version, DELIVERY_SCHEMA_VERSION);
716. 716 assert_eq!(packet.job_id, "test-job");
717. 717 assert_eq!(packet.surface.as_str(), *surface);
718. 718 assert_eq!(packet.kind, DeliveryKind::Assistant);
719. 719 assert_eq!(packet.target.as_str(), &format!("{surface}:one"));
720. 720 }
721. 721 }));
722. 722 }
723. 723 run_fn("structural_packet_fields", scenarios);
724. 724}
725. 725
726. 726#[test]
727. 727fn structural_fallback_preservation() {
728. 728 let mut scenarios: Vec<Scenario> = vec![];
729. 729 let templates: &[&str] = &[
730. 730 "# Title\n\nBody.",
731. 731 "Plain text",
732. 732 "| A | B |\n|---|---|\n| 1 | 2 |",
733. 733 "```rust\nfn main() {}\n```",
734. 734 "- [ ] todo\n- [x] done",
735. 735 "||spoiler||",
736. 736 "**bold** *italic*",
737. 737 "# H1\n## H2\n### H3",
738. 738 "Line 1\n\nLine 2",
739. 739 "",
740. 740 "Complex: # T\n\n**b** *i*\n\n- a\n- b\n\n[link](url)",
741. 741 "> quote\n\n||spoiler||\n\n`code`",
742. 742 ];
743. 743 for i in 0..500 {
744. 744 let t = templates[i % templates.len()];
745. 745 let source = src_idx(t, i);
746. 746 let i = i;
747. 747 scenarios.push(tc(&format!("fb_{i}"), move || {
748. 748 for (surface, markup) in SURFACES {
749. 749 let job = make_job(&source, *markup, surface);
750. 750 let packet = render(&job).expect("render");
751. 751 assert_eq!(
752. 752 packet.fallback_markdown,
753. 753 source,
754. 754 "fallback mismatch on {surface}: expected {source:?}, got {actual:?}",
755. 755 actual = packet.fallback_markdown
756. 756 );
757. 757 }
758. 758 }));
759. 759 }
760. 760 run_fn("structural_fallback_preservation", scenarios);
761. 761}
762. 762
763. 763#[test]
764. 764fn structural_coverage_integrity() {
765. 765 let mut scenarios: Vec<Scenario> = vec![];
766. 766 let templates: &[&str] = &[
767. 767 "# Title\n\nBody.",
768. 768 "Plain text",
769. 769 "| A | B |\n|---|---|\n| 1 | 2 |",
770. 770 "```rust\nfn main() {}\n```",
771. 771 "- [ ] todo\n- [x] done",
772. 772 "||spoiler||",
773. 773 "**bold** *italic*",
774. 774 "# H1\n## H2\n### H3",
775. 775 "1. first\n2. second\n3. third",
776. 776 "> quoted",
777. 777 ];
778. 778 for i in 0..500 {
779. 779 let t = templates[i % templates.len()];
780. 780 let source = src_idx(t, i);
781. 781 let i = i;
782. 782 scenarios.push(tc(&format!("cov_{i}"), move || {
783. 783 for (surface, markup) in SURFACES {
784. 784 let job = make_job(&source, *markup, surface);
785. 785 let packet = render(&job).expect("render");
786. 786 let ids: BTreeSet<_> = packet.coverage.iter().map(|c| &c.block_id).collect();
787. 787 assert_eq!(
788. 788 ids.len(),
789. 789 packet.coverage.len(),
790. 790 "duplicate block IDs on {surface}: {source}"
791. 791 );
792. 792 for cov in &packet.coverage {
793. 793 assert!(!cov.block_id.is_empty(), "empty block_id on {surface}");
794. 794 }
795. 795 if !source.trim().is_empty() {
796. 796 assert!(
797. 797 !packet.coverage.is_empty(),
798. 798 "empty coverage for non-empty input on {surface}: {source}"
799. 799 );
800. 800 }
801. 801 }
802. 802 }));
803. 803 }
804. 804 run_fn("structural_coverage_integrity", scenarios);
805. 805}
806. 806
807. 807#[test]
808. 808fn structural_chunking_validity() {
809. 809 let mut scenarios: Vec<Scenario> = vec![];
810. 810 let templates: &[&str] = &[
811. 811 "# Title\n\nBody.",
812. 812 "Plain text",
813. 813 "| A | B |\n|---|---|\n| 1 | 2 |",
814. 814 "```rust\nfn main() {}\n```",
815. 815 "- [ ] todo\n- [x] done",
816. 816 "||spoiler||",
817. 817 "**bold** *italic*",
818. 818 "# H1\n## H2\n### H3",
819. 819 "Line 1\n\nLine 2\n\nLine 3",
820. 820 "Multiple\n\n\n\n\nparagraphs",
821. 821 ];
822. 822 for i in 0..500 {
823. 823 let t = templates[i % templates.len()];
824. 824 let source = src_idx(t, i);
825. 825 let i = i;
826. 826 scenarios.push(tc(&format!("chunk_{i}"), move || {
827. 827 for (surface, markup) in SURFACES {
828. 828 let job = make_job(&source, *markup, surface);
829. 829 let packet = render(&job).expect("render");
830. 830 for chunk in &packet.chunks {
831. 831 assert!(!chunk.is_empty(), "empty chunk on {surface}: {source}");
832. 832 }
833. 833 }
834. 834 }));
835. 835 }
836. 836 run_fn("structural_chunking_validity", scenarios);
837. 837}
838. 838
839. 839#[test]
840. 840fn structural_payload_types() {
841. 841 let mut scenarios: Vec<Scenario> = vec![];
842. 842 let templates: &[&str] = &[
843. 843 "# Title\n\nBody.",
844. 844 "Plain text",
845. 845 "| A | B |\n|---|---|\n| 1 | 2 |",
846. 846 "```rust\nfn main() {}\n```",
847. 847 "- [ ] todo\n- [x] done",
848. 848 "||spoiler||",
849. 849 "",
850. 850 "**bold** *italic*",
851. 851 "# H1\n## H2\n### H3",
852. 852 "Line 1\n\nLine 2",
853. 853 ];
854. 854 for i in 0..500 {
855. 855 let t = templates[i % templates.len()];
856. 856 let source = src_idx(t, i);
857. 857 let i = i;
858. 858 scenarios.push(tc(&format!("payload_{i}"), move || {
859. 859 for (surface, markup) in SURFACES {
860. 860 let job = make_job(&source, *markup, surface);
861. 861 let packet = render(&job).expect("render");
862. 862 match markup {
863. 863 Markup::Json => {
864. 864 assert!(
865. 865 matches!(packet.payload, DeliveryPayload::Structured(_)),
866. 866 "JSON markup should produce Structured payload on {surface}"
867. 867 );
868. 868 }
869. 869 _ => {
870. 870 assert!(
871. 871 matches!(packet.payload, DeliveryPayload::Text(_)),
872. 872 "non-JSON markup should produce Text payload on {surface}"
873. 873 );
874. 874 }
875. 875 }
876. 876 }
877. 877 }));
878. 878 }
879. 879 run_fn("structural_payload_types", scenarios);
880. 880}
881. 881
882. 882#[test]
883. 883fn structural_serialization_roundtrip() {
884. 884 let mut scenarios: Vec<Scenario> = vec![];
885. 885 let templates: &[&str] = &[
886. 886 "# Title\n\nBody.",
887. 887 "Plain text",
888. 888 "| A | B |\n|---|---|\n| 1 | 2 |",
889. 889 "```rust\nfn main() {}\n```",
890. 890 "- [ ] todo\n- [x] done",
891. 891 "||spoiler||",
892. 892 "**bold** *italic* ~~strike~~",
893. 893 "# H1\n## H2\n### H3",
894. 894 "Line 1\n\nLine 2\n\nLine 3",
895. 895 "Complex: # T\n\n**b** *i*\n\n- a\n- b\n\n[link](url)",
896. 896 ];
897. 897 for i in 0..500 {
898. 898 let t = templates[i % templates.len()];
899. 899 let source = src_idx(t, i);
900. 900 let i = i;
901. 901 scenarios.push(tc(&format!("ser_{i}"), move || {
902. 902 for (surface, markup) in SURFACES {
903. 903 let job = make_job(&source, *markup, surface);
904. 904 let packet = render(&job).expect("render");
905. 905 let json = serde_json::to_string(&packet).expect("serialize");
906. 906 let restored: DeliveryPacket = serde_json::from_str(&json).expect("deserialize");
907. 907 assert_eq!(packet.schema_version, restored.schema_version);
908. 908 assert_eq!(packet.job_id, restored.job_id);
909. 909 assert_eq!(packet.surface, restored.surface);
910. 910 assert_eq!(packet.kind, restored.kind);
911. 911 assert_eq!(packet.target, restored.target);
912. 912 assert_eq!(packet.payload, restored.payload);
913. 913 assert_eq!(packet.fallback_markdown, restored.fallback_markdown);
914. 914 assert_eq!(packet.chunks, restored.chunks);
915. 915 assert_eq!(packet.coverage, restored.coverage);
916. 916 assert_eq!(packet.actions, restored.actions);
917. 917 assert_eq!(packet.diagnostics, restored.diagnostics);
918. 918 }
919. 919 }));
920. 920 }
921. 921 run_fn("structural_serialization_roundtrip", scenarios);
922. 922}
923. 923
924. 924#[test]
925. 925fn structural_max_chars_truncation() {
926. 926 let mut scenarios: Vec<Scenario> = vec![];
927. 927 for i in 0..500 {
928. 928 let source = src_idx("# Heading\n\nBody text **bold** `code`\n\n- item", i);
929. 929 let i = i;
930. 930 scenarios.push(tc(&format!("maxchars_{i}"), move || {
931. 931 for (surface, markup) in SURFACES {
932. 932 let mut job = make_job(&source, *markup, surface);
933. 933 job.profile.max_chars = Some(100);
934. 934 let packet = render(&job).expect("render with max_chars");
935. 935 for chunk in &packet.chunks {
936. 936 assert!(!chunk.is_empty(), "empty chunk for {surface}");
937. 937 }
938. 938 }
939. 939 }));
940. 940 }
941. 941 run_fn("structural_max_chars_truncation", scenarios);
942. 942}
943. 943
944. 944#[test]
945. 945fn structural_cross_surface_consistency() {
946. 946 let mut scenarios: Vec<Scenario> = vec![];
947. 947 let templates: &[&str] = &[
948. 948 "# Title\n\nBody.",
949. 949 "Plain text",
950. 950 "| A | B |\n|---|---|\n| 1 | 2 |",
951. 951 "```rust\nfn main() {}\n```",
952. 952 "- [ ] todo\n- [x] done",
953. 953 "||spoiler||",
954. 954 "**bold** *italic* ~~strike~~",
955. 955 "# H1\n## H2\n### H3",
956. 956 "Line 1\n\nLine 2\n\nLine 3",
957. 957 "Complex: # T\n\n**b** *i*\n\n- a\n- b\n\n[link](url)",
958. 958 ];
959. 959 for i in 0..500 {
960. 960 let t = templates[i % templates.len()];
961. 961 let source = src_idx(t, i);
962. 962 let i = i;
963. 963 scenarios.push(tc(&format!("cross_{i}"), move || {
964. 964 let results = render_all(&source);
965. 965 for (packet, _) in &results {
966. 966 assert_eq!(packet.fallback_markdown, source);
967. 967 }
968. 968 let versions: BTreeSet<_> = results.iter().map(|(p, _)| p.schema_version).collect();
969. 969 assert_eq!(
970. 970 versions.len(),
971. 971 1,
972. 972 "inconsistent schema versions for {source}"
973. 973 );
974. 974 let first_kind = &results[0].0.kind;
975. 975 for (packet, _) in &results {
976. 976 assert_eq!(&packet.kind, first_kind, "inconsistent kinds for {source}");
977. 977 }
978. 978 assert!(results.iter().all(|(p, _)| p.job_id == "test-job"));
979. 979 }));
980. 980 }
981. 981 run_fn("structural_cross_surface_consistency", scenarios);
982. 982}
983. 983
984. 984#[test]
985. 985fn structural_content_kind_matching() {
986. 986 let mut scenarios: Vec<Scenario> = vec![];
987. 987 let templates: &[&str] = &[
988. 988 "# Title\n\nBody.",
989. 989 "Plain text",
990. 990 "| A | B |\n|---|---|\n| 1 | 2 |",
991. 991 "```rust\nfn main() {}\n```",
992. 992 "- [ ] todo\n- [x] done",
993. 993 "||spoiler||",
994. 994 "**bold** *italic*",
995. 995 "# H1\n## H2\n### H3",
996. 996 "Line 1\n\nLine 2",
997. 997 "Complex mixed content",
998. 998 ];
999. 999 for i in 0..500 {
1000. 1000 let t = templates[i % templates.len()];