+5 -697

src/tests.rs src/tests/app.rs

reviewed

··· 1 1 - use crate::app::FileChange; 2 2 - use crate::markdown::{ 3 3 - hash_str, parse_markdown, parse_markdown_with_width, read_file_state, resolve_syntax, 4 4 - }; 5 5 - use crate::theme::{current_theme_preset, set_theme_preset, theme_preset_index}; 6 6 - use crate::update::TestAsset; 1 1 + use super::{test_assets, unique_temp_dir}; 2 2 + use crate::app::{App, AppConfig, FileChange}; 3 3 + use crate::cli::parse_cli; 4 4 + use crate::markdown::{hash_str, parse_markdown, parse_markdown_with_width, read_file_state}; 7 5 use crate::*; 8 6 use crossterm::event::KeyEventKind; 9 9 - use ratatui::backend::TestBackend; 10 10 - use ratatui::{text::Line, widgets::Paragraph, Terminal}; 11 7 use std::{ 12 8 fs, 13 13 - path::PathBuf, 14 14 - sync::{Mutex, MutexGuard}, 15 9 time::{SystemTime, UNIX_EPOCH}, 16 10 }; 17 17 - use syntect::{ 18 18 - highlighting::{Theme, ThemeSet}, 19 19 - parsing::SyntaxSet, 20 20 - }; 21 21 - 22 22 - static THEME_TEST_MUTEX: Mutex<()> = Mutex::new(()); 23 23 - 24 24 - fn test_assets() -> (SyntaxSet, Theme) { 25 25 - let ss = SyntaxSet::load_defaults_newlines(); 26 26 - let ts = ThemeSet::load_defaults(); 27 27 - let theme = ts.themes["base16-ocean.dark"].clone(); 28 28 - (ss, theme) 29 29 - } 30 30 - 31 31 - fn render_buffer(lines: &[Line<'static>]) -> ratatui::buffer::Buffer { 32 32 - let width = lines 33 33 - .iter() 34 34 - .map(|line| line.width()) 35 35 - .max() 36 36 - .unwrap_or(1) 37 37 - .max(1) as u16; 38 38 - let height = lines.len().max(1) as u16; 39 39 - let backend = TestBackend::new(width, height); 40 40 - let mut terminal = Terminal::new(backend).unwrap(); 41 41 - terminal 42 42 - .draw(|f| { 43 43 - f.render_widget(Paragraph::new(lines.to_vec()), f.area()); 44 44 - }) 45 45 - .unwrap(); 46 46 - terminal.backend().buffer().clone() 47 47 - } 48 48 - 49 49 - fn find_symbol(buffer: &ratatui::buffer::Buffer, symbol: &str) -> Option<(u16, u16)> { 50 50 - for y in 0..buffer.area.height { 51 51 - for x in 0..buffer.area.width { 52 52 - if buffer 53 53 - .cell((x, y)) 54 54 - .is_some_and(|cell| cell.symbol() == symbol) 55 55 - { 56 56 - return Some((x, y)); 57 57 - } 58 58 - } 59 59 - } 60 60 - None 61 61 - } 62 62 - 63 63 - fn rendered_non_empty_lines(lines: &[Line<'static>]) -> Vec<String> { 64 64 - lines 65 65 - .iter() 66 66 - .map(line_plain_text) 67 67 - .filter(|line| !line.is_empty()) 68 68 - .collect() 69 69 - } 70 70 - 71 71 - fn lock_theme_test_state() -> MutexGuard<'static, ()> { 72 72 - THEME_TEST_MUTEX.lock().unwrap() 73 73 - } 74 74 - 75 75 - fn unique_temp_dir(prefix: &str) -> PathBuf { 76 76 - let unique = SystemTime::now() 77 77 - .duration_since(UNIX_EPOCH) 78 78 - .unwrap() 79 79 - .as_nanos(); 80 80 - std::env::temp_dir().join(format!("{prefix}-{unique}")) 81 81 - } 11 11 + use syntect::highlighting::ThemeSet; 82 12 83 13 #[test] 84 14 fn search_matches_across_span_boundaries() { ··· 156 86 } 157 87 158 88 #[test] 159 159 - fn asset_name_matches_supported_release_targets() { 160 160 - assert_eq!( 161 161 - asset_name_for_target("macos", "x86_64"), 162 162 - Some("leaf-macos-x86_64") 163 163 - ); 164 164 - assert_eq!( 165 165 - asset_name_for_target("macos", "aarch64"), 166 166 - Some("leaf-macos-arm64") 167 167 - ); 168 168 - assert_eq!( 169 169 - asset_name_for_target("linux", "x86_64"), 170 170 - Some("leaf-linux-x86_64") 171 171 - ); 172 172 - assert_eq!( 173 173 - asset_name_for_target("linux", "aarch64"), 174 174 - Some("leaf-linux-arm64") 175 175 - ); 176 176 - assert_eq!( 177 177 - asset_name_for_target("android", "aarch64"), 178 178 - Some("leaf-android-arm64") 179 179 - ); 180 180 - assert_eq!( 181 181 - asset_name_for_target("windows", "x86_64"), 182 182 - Some("leaf-windows-x86_64.exe") 183 183 - ); 184 184 - assert_eq!(asset_name_for_target("linux", "arm"), None); 185 185 - } 186 186 - 187 187 - #[test] 188 188 - fn newer_version_comparison_accepts_optional_v_prefix() { 189 189 - assert!(is_newer_version("1.4.2", "v1.4.3").unwrap()); 190 190 - assert!(!is_newer_version("1.4.2", "1.4.2").unwrap()); 191 191 - assert!(!is_newer_version("1.4.2", "1.4.1").unwrap()); 192 192 - } 193 193 - 194 194 - #[test] 195 195 - fn expected_asset_download_url_selects_matching_asset() { 196 196 - let assets = vec![ 197 197 - TestAsset { 198 198 - name: "leaf-linux-x86_64", 199 199 - download_url: "https://example.test/linux", 200 200 - }, 201 201 - TestAsset { 202 202 - name: "leaf-windows-x86_64.exe", 203 203 - download_url: "https://example.test/windows", 204 204 - }, 205 205 - ]; 206 206 - 207 207 - let url = expected_asset_download_url("1.4.3", &assets, "leaf-linux-x86_64").unwrap(); 208 208 - assert_eq!(url, "https://example.test/linux"); 209 209 - } 210 210 - 211 211 - #[test] 212 212 - fn expected_asset_download_url_errors_when_asset_is_missing() { 213 213 - let assets = vec![TestAsset { 214 214 - name: "leaf-linux-x86_64", 215 215 - download_url: "https://example.test/linux", 216 216 - }]; 217 217 - 218 218 - let err = expected_asset_download_url("1.4.3", &assets, "leaf-macos-arm64").unwrap_err(); 219 219 - assert!(err.to_string().contains("does not contain asset")); 220 220 - } 221 221 - 222 222 - #[test] 223 223 - fn validate_download_size_accepts_matching_non_zero_sizes() { 224 224 - assert!(validate_download_size(Some(42), 42).is_ok()); 225 225 - assert!(validate_download_size(None, 42).is_ok()); 226 226 - } 227 227 - 228 228 - #[test] 229 229 - fn validate_download_size_rejects_zero_or_mismatched_sizes() { 230 230 - let empty_err = validate_download_size(None, 0).unwrap_err(); 231 231 - assert!(empty_err.to_string().contains("is empty")); 232 232 - 233 233 - let mismatch_err = validate_download_size(Some(42), 41).unwrap_err(); 234 234 - assert!(mismatch_err.to_string().contains("size mismatch")); 235 235 - } 236 236 - 237 237 - #[test] 238 238 - fn find_expected_checksum_extracts_matching_asset_checksum() { 239 239 - let checksums = "\ 240 240 - aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa leaf-linux-x86_64 241 241 - bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb leaf-windows-x86_64.exe 242 242 - "; 243 243 - 244 244 - let checksum = find_expected_checksum(checksums, "leaf-windows-x86_64.exe").unwrap(); 245 245 - assert_eq!( 246 246 - checksum, 247 247 - "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" 248 248 - ); 249 249 - } 250 250 - 251 251 - #[test] 252 252 - fn find_expected_checksum_rejects_missing_or_invalid_entries() { 253 253 - let missing = 254 254 - find_expected_checksum("abcd leaf-linux-x86_64\n", "leaf-macos-arm64").unwrap_err(); 255 255 - assert!(missing.to_string().contains("does not contain")); 256 256 - 257 257 - let invalid = 258 258 - find_expected_checksum("xyz leaf-linux-x86_64\n", "leaf-linux-x86_64").unwrap_err(); 259 259 - assert!(invalid 260 260 - .to_string() 261 261 - .contains("Invalid SHA256 checksum format")); 262 262 - } 263 263 - 264 264 - #[test] 265 265 - fn validate_sha256_hex_accepts_expected_format() { 266 266 - assert!(validate_sha256_hex( 267 267 - "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" 268 268 - ) 269 269 - .is_ok()); 270 270 - } 271 271 - 272 272 - #[test] 273 89 fn cancelling_search_clears_query_and_matches() { 274 90 let (ss, theme) = test_assets(); 275 91 let (lines, toc) = parse_markdown("alpha\nbeta\nalpha beta\n", &ss, &theme); ··· 398 214 let app = App::new(lines, toc, "stdin".to_string(), false, false, None, None); 399 215 400 216 assert_eq!(app.active_highlight_line(), None); 401 401 - } 402 402 - 403 403 - #[test] 404 404 - fn code_block_box_renders_right_border_in_one_column() { 405 405 - let (ss, theme) = test_assets(); 406 406 - let md = "```ts\nconst city = \"東京\";\n\tconsole.log(city)\n```"; 407 407 - let (lines, _) = parse_markdown(md, &ss, &theme); 408 408 - let buffer = render_buffer(&lines); 409 409 - 410 410 - let (right_x, start_y) = find_symbol(&buffer, "┐").unwrap(); 411 411 - let (_, end_y) = find_symbol(&buffer, "┘").unwrap(); 412 412 - 413 413 - for y in start_y + 1..end_y { 414 414 - assert_eq!( 415 415 - buffer.cell((right_x, y)).unwrap().symbol(), 416 416 - "│", 417 417 - "missing code block right border at row {y}" 418 418 - ); 419 419 - } 420 420 - } 421 421 - 422 422 - #[test] 423 423 - fn table_render_right_border_stays_aligned() { 424 424 - let (ss, theme) = test_assets(); 425 425 - let md = "| Name | Value |\n| --- | --- |\n| 東京 | 12 |\n| tab\tcell | ok |"; 426 426 - let (lines, _) = parse_markdown(md, &ss, &theme); 427 427 - let buffer = render_buffer(&lines); 428 428 - 429 429 - let (right_x, start_y) = find_symbol(&buffer, "┐").unwrap(); 430 430 - let (_, end_y) = find_symbol(&buffer, "┘").unwrap(); 431 431 - 432 432 - for y in start_y + 1..end_y { 433 433 - let symbol = buffer.cell((right_x, y)).unwrap().symbol(); 434 434 - assert!( 435 435 - matches!(symbol, "│" | "┤" | "╡"), 436 436 - "unexpected table edge symbol {symbol:?} at row {y}" 437 437 - ); 438 438 - } 439 439 - } 440 440 - 441 441 - #[test] 442 442 - fn table_render_right_border_stays_aligned_with_emoji_cells() { 443 443 - let (ss, theme) = test_assets(); 444 444 - let md = "| Critère | Note |\n| --- | --- |\n| Tests | ✅ Bonne couverture |\n| Sécurité | ⚠ Quelques points |\n"; 445 445 - let (lines, _) = parse_markdown(md, &ss, &theme); 446 446 - let buffer = render_buffer(&lines); 447 447 - 448 448 - let (right_x, start_y) = find_symbol(&buffer, "┐").unwrap(); 449 449 - let (_, end_y) = find_symbol(&buffer, "┘").unwrap(); 450 450 - 451 451 - for y in start_y + 1..end_y { 452 452 - let symbol = buffer.cell((right_x, y)).unwrap().symbol(); 453 453 - assert!( 454 454 - matches!(symbol, "│" | "┤" | "╡"), 455 455 - "unexpected emoji-table edge symbol {symbol:?} at row {y}" 456 456 - ); 457 457 - } 458 458 - } 459 459 - 460 460 - #[test] 461 461 - fn narrow_tables_fit_render_width_and_wrap_cells() { 462 462 - let (ss, theme) = test_assets(); 463 463 - let md = "| Column | Description | Value |\n| --- | --- | ---: |\n| Width | Terminal-dependent layout behavior | 80 |\n"; 464 464 - let (lines, _) = parse_markdown_with_width(md, &ss, &theme, 36); 465 465 - let rendered = rendered_non_empty_lines(&lines); 466 466 - 467 467 - assert!(rendered.len() >= 6); 468 468 - assert!(rendered.iter().all(|line| display_width(line) <= 36)); 469 469 - } 470 470 - 471 471 - #[test] 472 472 - fn h1_headings_render_double_rule_without_bottom_spacing() { 473 473 - let (ss, theme) = test_assets(); 474 474 - let (lines, _) = parse_markdown("# 東京\n", &ss, &theme); 475 475 - let rendered = rendered_non_empty_lines(&lines); 476 476 - 477 477 - assert_eq!(rendered[0], "東京"); 478 478 - assert_eq!(rendered[1], "═".repeat(display_width("東京"))); 479 479 - } 480 480 - 481 481 - #[test] 482 482 - fn loose_list_items_keep_their_markers() { 483 483 - let (ss, theme) = test_assets(); 484 484 - let (lines, _) = parse_markdown("- first\n\n- second\n", &ss, &theme); 485 485 - let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 486 486 - 487 487 - assert!(rendered.iter().any(|line| line.contains("• first"))); 488 488 - assert!(rendered.iter().any(|line| line.contains("• second"))); 489 489 - } 490 490 - 491 491 - #[test] 492 492 - fn ordered_lists_render_numeric_markers() { 493 493 - let (ss, theme) = test_assets(); 494 494 - let (lines, _) = parse_markdown("3. third\n4. fourth\n", &ss, &theme); 495 495 - let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 496 496 - 497 497 - assert!(rendered.iter().any(|line| line.contains("3. third"))); 498 498 - assert!(rendered.iter().any(|line| line.contains("4. fourth"))); 499 499 - } 500 500 - 501 501 - #[test] 502 502 - fn multiline_list_items_keep_marker_only_on_first_line() { 503 503 - let (ss, theme) = test_assets(); 504 504 - let (lines, _) = parse_markdown("- first line\n second line\n", &ss, &theme); 505 505 - let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 506 506 - 507 507 - let first = rendered 508 508 - .iter() 509 509 - .find(|line| line.contains("first line")) 510 510 - .unwrap(); 511 511 - let second = rendered 512 512 - .iter() 513 513 - .find(|line| line.contains("second line")) 514 514 - .unwrap(); 515 515 - 516 516 - assert!(first.contains("• first line")); 517 517 - assert!(!second.contains('•')); 518 518 - assert!(second.starts_with(" ")); 519 519 - } 520 520 - 521 521 - #[test] 522 522 - fn ordered_lists_preserve_non_default_start_numbers() { 523 523 - let (ss, theme) = test_assets(); 524 524 - let (lines, _) = parse_markdown("7. seven\n8. eight\n", &ss, &theme); 525 525 - let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 526 526 - 527 527 - assert!(rendered.iter().any(|line| line.contains("7. seven"))); 528 528 - assert!(rendered.iter().any(|line| line.contains("8. eight"))); 529 529 - } 530 530 - 531 531 - #[test] 532 532 - fn loose_list_items_render_expected_lines() { 533 533 - let (ss, theme) = test_assets(); 534 534 - let src = "- first loose item\n\n- second loose item after a blank line\n\n- third loose item\n\n continuation paragraph\n"; 535 535 - let (lines, _) = parse_markdown(src, &ss, &theme); 536 536 - let rendered = rendered_non_empty_lines(&lines); 537 537 - 538 538 - assert_eq!( 539 539 - rendered, 540 540 - vec![ 541 541 - "• first loose item", 542 542 - "• second loose item after a blank line", 543 543 - "• third loose item", 544 544 - " continuation paragraph", 545 545 - ] 546 546 - ); 547 547 - } 548 548 - 549 549 - #[test] 550 550 - fn ordered_loose_lists_render_expected_lines() { 551 551 - let (ss, theme) = test_assets(); 552 552 - let src = "7. seventh item\n\n8. eighth item\n\n continuation paragraph\n"; 553 553 - let (lines, _) = parse_markdown(src, &ss, &theme); 554 554 - let rendered = rendered_non_empty_lines(&lines); 555 555 - 556 556 - assert_eq!( 557 557 - rendered, 558 558 - vec![ 559 559 - "7. seventh item", 560 560 - "8. eighth item", 561 561 - " continuation paragraph", 562 562 - ] 563 563 - ); 564 564 - } 565 565 - 566 566 - #[test] 567 567 - fn ordered_lists_render_expected_lines() { 568 568 - let (ss, theme) = test_assets(); 569 569 - let (lines, _) = parse_markdown("3. third item\n4. fourth item\n", &ss, &theme); 570 570 - let rendered = rendered_non_empty_lines(&lines); 571 571 - 572 572 - assert_eq!(rendered, vec!["3. third item", "4. fourth item"]); 573 573 - } 574 574 - 575 575 - #[test] 576 576 - fn paragraph_and_following_list_have_no_blank_gap() { 577 577 - let (ss, theme) = test_assets(); 578 578 - let (lines, _) = parse_markdown("Intro paragraph\n\n- first\n- second\n", &ss, &theme); 579 579 - let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 580 580 - let intro_idx = rendered 581 581 - .iter() 582 582 - .position(|line| line == "Intro paragraph") 583 583 - .unwrap(); 584 584 - 585 585 - assert_eq!(rendered[intro_idx + 1], "• first"); 586 586 - } 587 587 - 588 588 - #[test] 589 589 - fn wrapped_list_items_align_continuation_under_text() { 590 590 - let (ss, theme) = test_assets(); 591 591 - let src = "- First item with enough text to wrap when the terminal is narrow and show continuation alignment.\n8. Eighth item with enough text to wrap and keep numeric alignment readable.\n"; 592 592 - let (lines, _) = parse_markdown_with_width(src, &ss, &theme, 36); 593 593 - let rendered = rendered_non_empty_lines(&lines); 594 594 - 595 595 - assert!(rendered.iter().any(|line| line.starts_with("• First item"))); 596 596 - assert!(rendered 597 597 - .iter() 598 598 - .any(|line| line.starts_with(" ") && line.contains("terminal is narrow"))); 599 599 - assert!(rendered 600 600 - .iter() 601 601 - .any(|line| line.starts_with("8. Eighth item"))); 602 602 - assert!(rendered 603 603 - .iter() 604 604 - .any(|line| line.starts_with(" ") && !line.starts_with("8. "))); 605 605 - } 606 606 - 607 607 - #[test] 608 608 - fn paragraph_and_following_code_block_have_no_blank_gap() { 609 609 - let (ss, theme) = test_assets(); 610 610 - let src = "Intro paragraph\n\n```rs\nfn main() {}\n```\n"; 611 611 - let (lines, _) = parse_markdown(src, &ss, &theme); 612 612 - let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 613 613 - let intro_idx = rendered 614 614 - .iter() 615 615 - .position(|line| line == "Intro paragraph") 616 616 - .unwrap(); 617 617 - 618 618 - assert!(rendered[intro_idx + 1].starts_with("┌─ rs ")); 619 619 - } 620 620 - 621 621 - #[test] 622 622 - fn nested_blockquotes_keep_quote_prefix_after_inner_quote_ends() { 623 623 - let (ss, theme) = test_assets(); 624 624 - let src = "> outer\n> > inner\n> outer again\n"; 625 625 - let (lines, _) = parse_markdown(src, &ss, &theme); 626 626 - let rendered = rendered_non_empty_lines(&lines); 627 627 - 628 628 - assert!(rendered.iter().any(|line| line == "▏ outer")); 629 629 - assert!(rendered.iter().any(|line| line == "▏ inner")); 630 630 - assert!(rendered.iter().any(|line| line == "▏ outer again")); 631 631 - } 632 632 - 633 633 - #[test] 634 634 - fn long_blockquotes_wrap_into_multiple_prefixed_lines() { 635 635 - let (ss, theme) = test_assets(); 636 636 - let src = "> This is a long blockquote line that should wrap into multiple quoted lines at narrow widths.\n"; 637 637 - let (lines, _) = parse_markdown_with_width(src, &ss, &theme, 28); 638 638 - let rendered = rendered_non_empty_lines(&lines); 639 639 - let quoted: Vec<_> = rendered 640 640 - .into_iter() 641 641 - .filter(|line| line.starts_with('▏')) 642 642 - .collect(); 643 643 - 644 644 - assert!(quoted.len() >= 2); 645 645 - assert!(quoted.iter().all(|line| line.starts_with("▏ "))); 646 646 - } 647 647 - 648 648 - #[test] 649 649 - fn toc_only_includes_first_two_heading_levels() { 650 650 - let (ss, theme) = test_assets(); 651 651 - let (_, toc) = parse_markdown("# One\n## Two\n### Three\n#### Four\n", &ss, &theme); 652 652 - 653 653 - assert_eq!(toc.len(), 3); 654 654 - assert_eq!(toc[0].level, 1); 655 655 - assert_eq!(toc[1].level, 2); 656 656 - assert_eq!(toc[2].level, 3); 657 657 - } 658 658 - 659 659 - #[test] 660 660 - fn frontmatter_is_ignored_in_preview_and_toc() { 661 661 - let (ss, theme) = test_assets(); 662 662 - let src = "---\ntitle: Demo\nowner: me\n---\n# Visible\nBody\n"; 663 663 - let (lines, toc) = parse_markdown(src, &ss, &theme); 664 664 - let rendered = rendered_non_empty_lines(&lines); 665 665 - 666 666 - assert!(!rendered.iter().any(|line| line.contains("title: Demo"))); 667 667 - assert!(rendered.iter().any(|line| line.contains("Visible"))); 668 668 - assert_eq!(toc.len(), 1); 669 669 - assert_eq!(toc[0].title, "Visible"); 670 670 - } 671 671 - 672 672 - #[test] 673 673 - fn h2_headings_are_underlined_and_compact() { 674 674 - let (ss, theme) = test_assets(); 675 675 - let (lines, _) = parse_markdown_with_width("Intro\n\n## Section\nBody\n", &ss, &theme, 40); 676 676 - let rendered = rendered_non_empty_lines(&lines); 677 677 - 678 678 - assert!(rendered.iter().any(|line| line.contains("Section"))); 679 679 - assert!(rendered.iter().any(|line| line.contains("────"))); 680 680 - } 681 681 - 682 682 - #[test] 683 683 - fn rules_use_render_width_without_extra_blank_after() { 684 684 - let (ss, theme) = test_assets(); 685 685 - let (lines, _) = parse_markdown_with_width("Alpha\n\n---\nBeta\n", &ss, &theme, 24); 686 686 - let rendered = rendered_non_empty_lines(&lines); 687 687 - let rule = rendered 688 688 - .iter() 689 689 - .find(|line| line.trim_start().starts_with('─')) 690 690 - .unwrap(); 691 691 - 692 692 - assert_eq!(display_width(rule.trim_start()), 24); 693 693 - let rule_idx = rendered.iter().position(|line| line == rule).unwrap(); 694 694 - assert_eq!(rendered[rule_idx + 1], "Beta"); 695 695 - } 696 696 - 697 697 - #[test] 698 698 - fn toc_hides_single_h1_when_h2_entries_exist() { 699 699 - let toc = vec![ 700 700 - TocEntry { 701 701 - level: 1, 702 702 - title: "Doc Title".to_string(), 703 703 - line: 0, 704 704 - }, 705 705 - TocEntry { 706 706 - level: 2, 707 707 - title: "Install".to_string(), 708 708 - line: 10, 709 709 - }, 710 710 - ]; 711 711 - 712 712 - assert!(should_hide_single_h1(&toc)); 713 713 - assert_eq!(toc_display_level(2, true, false), 1); 714 714 - assert_eq!(toc_display_level(3, true, false), 2); 715 715 - } 716 716 - 717 717 - #[test] 718 718 - fn toc_keeps_single_h1_when_no_h2_entries_exist() { 719 719 - let toc = vec![TocEntry { 720 720 - level: 1, 721 721 - title: "Doc Title".to_string(), 722 722 - line: 0, 723 723 - }]; 724 724 - 725 725 - assert!(!should_hide_single_h1(&toc)); 726 726 - } 727 727 - 728 728 - #[test] 729 729 - fn toc_promotes_h2_when_document_has_no_h1() { 730 730 - let toc = vec![ 731 731 - TocEntry { 732 732 - level: 2, 733 733 - title: "Build & install".to_string(), 734 734 - line: 0, 735 735 - }, 736 736 - TocEntry { 737 737 - level: 3, 738 738 - title: "Android".to_string(), 739 739 - line: 4, 740 740 - }, 741 741 - ]; 742 742 - 743 743 - assert!(should_promote_h2_when_no_h1(&toc)); 744 744 - assert_eq!(toc_display_level(2, false, true), 1); 745 745 - assert_eq!(toc_display_level(3, false, true), 2); 746 746 - let normalized = normalize_toc(toc); 747 747 - assert_eq!(normalized.len(), 2); 748 748 - assert_eq!(normalized[0].level, 2); 749 749 - assert_eq!(normalized[1].level, 3); 750 750 - } 751 751 - 752 752 - #[test] 753 753 - fn parse_theme_preset_supports_ocean_and_forest() { 754 754 - assert_eq!(parse_theme_preset("arctic"), Some(ThemePreset::Arctic)); 755 755 - assert_eq!(parse_theme_preset("ocean"), Some(ThemePreset::OceanDark)); 756 756 - assert_eq!(parse_theme_preset("forest"), Some(ThemePreset::Forest)); 757 757 - assert_eq!( 758 758 - parse_theme_preset("solarized-dark"), 759 759 - Some(ThemePreset::SolarizedDark) 760 760 - ); 761 761 - assert_eq!(parse_theme_preset("nope"), None); 762 762 - } 763 763 - 764 764 - #[test] 765 765 - fn resolve_syntax_supports_common_language_aliases() { 766 766 - let ss = SyntaxSet::load_defaults_newlines(); 767 767 - 768 768 - assert_eq!( 769 769 - resolve_syntax("py", &ss).name, 770 770 - resolve_syntax("python", &ss).name 771 771 - ); 772 772 - assert_eq!( 773 773 - resolve_syntax("cpp", &ss).name, 774 774 - resolve_syntax("c++", &ss).name 775 775 - ); 776 776 - assert_eq!(resolve_syntax("json", &ss).name, "JSON"); 777 777 - assert_eq!( 778 778 - resolve_syntax("ps1", &ss).name, 779 779 - resolve_syntax("powershell", &ss).name 780 780 - ); 781 781 - } 782 782 - 783 783 - #[test] 784 784 - fn theme_presets_are_in_alphabetical_order() { 785 785 - let labels: Vec<_> = THEME_PRESETS 786 786 - .iter() 787 787 - .map(|preset| theme_preset_label(*preset)) 788 788 - .collect(); 789 789 - let mut sorted = labels.clone(); 790 790 - sorted.sort(); 791 791 - assert_eq!(labels, sorted); 792 792 - } 793 793 - 794 794 - #[test] 795 795 - fn theme_picker_restores_original_preset_on_escape() { 796 796 - let _guard = lock_theme_test_state(); 797 797 - let (ss, theme) = test_assets(); 798 798 - let ts = ThemeSet::load_defaults(); 799 799 - let (lines, toc) = parse_markdown("# Demo\n", &ss, &theme); 800 800 - let mut app = App::new_with_source( 801 801 - lines, 802 802 - toc, 803 803 - AppConfig { 804 804 - filename: "stdin".to_string(), 805 805 - source: "# Demo\n".to_string(), 806 806 - debug_input: false, 807 807 - watch: false, 808 808 - filepath: None, 809 809 - last_file_state: None, 810 810 - }, 811 811 - ); 812 812 - 813 813 - let original = current_theme_preset(); 814 814 - set_theme_preset(ThemePreset::OceanDark); 815 815 - app.open_theme_picker(); 816 816 - assert!(app.set_theme_picker_index(theme_preset_index(ThemePreset::Forest))); 817 817 - app.preview_theme_preset(ThemePreset::Forest, &ss, &ts); 818 818 - 819 819 - assert_eq!(current_theme_preset(), ThemePreset::Forest); 820 820 - 821 821 - app.restore_theme_picker_preview(&ss, &ts); 822 822 - 823 823 - assert_eq!(current_theme_preset(), ThemePreset::OceanDark); 824 824 - assert!(!app.is_theme_picker_open()); 825 825 - assert_eq!(app.theme_picker_original(), None); 826 826 - set_theme_preset(original); 827 827 - } 828 828 - 829 829 - #[test] 830 830 - fn theme_picker_caches_previewed_themes_for_reuse() { 831 831 - let _guard = lock_theme_test_state(); 832 832 - let (ss, theme) = test_assets(); 833 833 - let ts = ThemeSet::load_defaults(); 834 834 - let (lines, toc) = parse_markdown("# Demo\n\n```rs\nfn main() {}\n```\n", &ss, &theme); 835 835 - let mut app = App::new_with_source( 836 836 - lines, 837 837 - toc, 838 838 - AppConfig { 839 839 - filename: "stdin".to_string(), 840 840 - source: "# Demo\n\n```rs\nfn main() {}\n```\n".to_string(), 841 841 - debug_input: false, 842 842 - watch: false, 843 843 - filepath: None, 844 844 - last_file_state: None, 845 845 - }, 846 846 - ); 847 847 - 848 848 - let original = current_theme_preset(); 849 849 - set_theme_preset(ThemePreset::OceanDark); 850 850 - app.open_theme_picker(); 851 851 - app.preview_theme_preset(ThemePreset::Forest, &ss, &ts); 852 852 - 853 853 - assert!(app.has_cached_theme_preview(ThemePreset::Forest)); 854 854 - assert_eq!(current_theme_preset(), ThemePreset::Forest); 855 855 - 856 856 - app.preview_theme_preset(ThemePreset::OceanDark, &ss, &ts); 857 857 - assert_eq!(current_theme_preset(), ThemePreset::OceanDark); 858 858 - assert!(app.has_cached_theme_preview(ThemePreset::OceanDark)); 859 859 - set_theme_preset(original); 860 217 } 861 218 862 219 #[test] ··· 1783 1140 parse_markdown_with_width(source, &ss, &theme, 20).0.len() 1784 1141 ); 1785 1142 } 1786 1786 - 1787 1787 - #[test] 1788 1788 - fn wrapped_list_inline_code_keeps_left_padding_in_rendered_line() { 1789 1789 - let (ss, theme) = test_assets(); 1790 1790 - let source = "- `leaf --theme ocean README.md` exercises wrapping inside a list item.\n"; 1791 1791 - let (lines, _) = parse_markdown_with_width(source, &ss, &theme, 22); 1792 1792 - 1793 1793 - let target = lines 1794 1794 - .iter() 1795 1795 - .find(|line| line_plain_text(line).contains("leaf --theme")) 1796 1796 - .expect("expected wrapped inline-code line"); 1797 1797 - 1798 1798 - assert!( 1799 1799 - target 1800 1800 - .spans 1801 1801 - .iter() 1802 1802 - .any(|span| span.style.bg.is_some() && span.content.starts_with(' ')), 1803 1803 - "expected a background-styled span with left padding" 1804 1804 - ); 1805 1805 - } 1806 1806 - 1807 1807 - #[test] 1808 1808 - fn code_block_inside_list_item_is_indented_and_has_no_blank_gap_before() { 1809 1809 - let (ss, theme) = test_assets(); 1810 1810 - let md = "To put a code block within a list item, the code block needs\nto be indented *twice* -- 8 spaces or two tabs:\n\n* A list item with a code block:\n\n <code goes here>\n"; 1811 1811 - let (lines, _) = parse_markdown(md, &ss, &theme); 1812 1812 - let rendered = rendered_non_empty_lines(&lines); 1813 1813 - 1814 1814 - let item_idx = rendered 1815 1815 - .iter() 1816 1816 - .position(|line| line.contains("A list item with a code block:")) 1817 1817 - .expect("missing list item line"); 1818 1818 - let header_idx = rendered 1819 1819 - .iter() 1820 1820 - .position(|line| line.contains("┌─ text")) 1821 1821 - .expect("missing code block header"); 1822 1822 - let code_idx = rendered 1823 1823 - .iter() 1824 1824 - .position(|line| line.contains("<code goes here>")) 1825 1825 - .expect("missing code line"); 1826 1826 - 1827 1827 - assert_eq!( 1828 1828 - header_idx, 1829 1829 - item_idx + 1, 1830 1830 - "expected no blank gap before code block" 1831 1831 - ); 1832 1832 - assert!(rendered[header_idx].starts_with(" ")); 1833 1833 - assert!(rendered[code_idx].starts_with(" ")); 1834 1834 - }

+364

src/tests/markdown.rs

reviewed

··· 1 1 + use super::{rendered_non_empty_lines, test_assets}; 2 2 + use crate::markdown::{parse_markdown, parse_markdown_with_width, resolve_syntax}; 3 3 + use crate::*; 4 4 + use syntect::parsing::SyntaxSet; 5 5 + 6 6 + #[test] 7 7 + fn h1_headings_render_double_rule_without_bottom_spacing() { 8 8 + let (ss, theme) = test_assets(); 9 9 + let (lines, _) = parse_markdown("# 東京\n", &ss, &theme); 10 10 + let rendered = rendered_non_empty_lines(&lines); 11 11 + 12 12 + assert_eq!(rendered[0], "東京"); 13 13 + assert_eq!(rendered[1], "═".repeat(display_width("東京"))); 14 14 + } 15 15 + 16 16 + #[test] 17 17 + fn loose_list_items_keep_their_markers() { 18 18 + let (ss, theme) = test_assets(); 19 19 + let (lines, _) = parse_markdown("- first\n\n- second\n", &ss, &theme); 20 20 + let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 21 21 + 22 22 + assert!(rendered.iter().any(|line| line.contains("• first"))); 23 23 + assert!(rendered.iter().any(|line| line.contains("• second"))); 24 24 + } 25 25 + 26 26 + #[test] 27 27 + fn ordered_lists_render_numeric_markers() { 28 28 + let (ss, theme) = test_assets(); 29 29 + let (lines, _) = parse_markdown("3. third\n4. fourth\n", &ss, &theme); 30 30 + let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 31 31 + 32 32 + assert!(rendered.iter().any(|line| line.contains("3. third"))); 33 33 + assert!(rendered.iter().any(|line| line.contains("4. fourth"))); 34 34 + } 35 35 + 36 36 + #[test] 37 37 + fn multiline_list_items_keep_marker_only_on_first_line() { 38 38 + let (ss, theme) = test_assets(); 39 39 + let (lines, _) = parse_markdown("- first line\n second line\n", &ss, &theme); 40 40 + let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 41 41 + 42 42 + let first = rendered 43 43 + .iter() 44 44 + .find(|line| line.contains("first line")) 45 45 + .unwrap(); 46 46 + let second = rendered 47 47 + .iter() 48 48 + .find(|line| line.contains("second line")) 49 49 + .unwrap(); 50 50 + 51 51 + assert!(first.contains("• first line")); 52 52 + assert!(!second.contains('•')); 53 53 + assert!(second.starts_with(" ")); 54 54 + } 55 55 + 56 56 + #[test] 57 57 + fn ordered_lists_preserve_non_default_start_numbers() { 58 58 + let (ss, theme) = test_assets(); 59 59 + let (lines, _) = parse_markdown("7. seven\n8. eight\n", &ss, &theme); 60 60 + let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 61 61 + 62 62 + assert!(rendered.iter().any(|line| line.contains("7. seven"))); 63 63 + assert!(rendered.iter().any(|line| line.contains("8. eight"))); 64 64 + } 65 65 + 66 66 + #[test] 67 67 + fn loose_list_items_render_expected_lines() { 68 68 + let (ss, theme) = test_assets(); 69 69 + let src = "- first loose item\n\n- second loose item after a blank line\n\n- third loose item\n\n continuation paragraph\n"; 70 70 + let (lines, _) = parse_markdown(src, &ss, &theme); 71 71 + let rendered = rendered_non_empty_lines(&lines); 72 72 + 73 73 + assert_eq!( 74 74 + rendered, 75 75 + vec![ 76 76 + "• first loose item", 77 77 + "• second loose item after a blank line", 78 78 + "• third loose item", 79 79 + " continuation paragraph", 80 80 + ] 81 81 + ); 82 82 + } 83 83 + 84 84 + #[test] 85 85 + fn ordered_loose_lists_render_expected_lines() { 86 86 + let (ss, theme) = test_assets(); 87 87 + let src = "7. seventh item\n\n8. eighth item\n\n continuation paragraph\n"; 88 88 + let (lines, _) = parse_markdown(src, &ss, &theme); 89 89 + let rendered = rendered_non_empty_lines(&lines); 90 90 + 91 91 + assert_eq!( 92 92 + rendered, 93 93 + vec![ 94 94 + "7. seventh item", 95 95 + "8. eighth item", 96 96 + " continuation paragraph", 97 97 + ] 98 98 + ); 99 99 + } 100 100 + 101 101 + #[test] 102 102 + fn ordered_lists_render_expected_lines() { 103 103 + let (ss, theme) = test_assets(); 104 104 + let (lines, _) = parse_markdown("3. third item\n4. fourth item\n", &ss, &theme); 105 105 + let rendered = rendered_non_empty_lines(&lines); 106 106 + 107 107 + assert_eq!(rendered, vec!["3. third item", "4. fourth item"]); 108 108 + } 109 109 + 110 110 + #[test] 111 111 + fn paragraph_and_following_list_have_no_blank_gap() { 112 112 + let (ss, theme) = test_assets(); 113 113 + let (lines, _) = parse_markdown("Intro paragraph\n\n- first\n- second\n", &ss, &theme); 114 114 + let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 115 115 + let intro_idx = rendered 116 116 + .iter() 117 117 + .position(|line| line == "Intro paragraph") 118 118 + .unwrap(); 119 119 + 120 120 + assert_eq!(rendered[intro_idx + 1], "• first"); 121 121 + } 122 122 + 123 123 + #[test] 124 124 + fn wrapped_list_items_align_continuation_under_text() { 125 125 + let (ss, theme) = test_assets(); 126 126 + let src = "- First item with enough text to wrap when the terminal is narrow and show continuation alignment.\n8. Eighth item with enough text to wrap and keep numeric alignment readable.\n"; 127 127 + let (lines, _) = parse_markdown_with_width(src, &ss, &theme, 36); 128 128 + let rendered = rendered_non_empty_lines(&lines); 129 129 + 130 130 + assert!(rendered.iter().any(|line| line.starts_with("• First item"))); 131 131 + assert!(rendered 132 132 + .iter() 133 133 + .any(|line| line.starts_with(" ") && line.contains("terminal is narrow"))); 134 134 + assert!(rendered 135 135 + .iter() 136 136 + .any(|line| line.starts_with("8. Eighth item"))); 137 137 + assert!(rendered 138 138 + .iter() 139 139 + .any(|line| line.starts_with(" ") && !line.starts_with("8. "))); 140 140 + } 141 141 + 142 142 + #[test] 143 143 + fn paragraph_and_following_code_block_have_no_blank_gap() { 144 144 + let (ss, theme) = test_assets(); 145 145 + let src = "Intro paragraph\n\n```rs\nfn main() {}\n```\n"; 146 146 + let (lines, _) = parse_markdown(src, &ss, &theme); 147 147 + let rendered: Vec<String> = lines.iter().map(line_plain_text).collect(); 148 148 + let intro_idx = rendered 149 149 + .iter() 150 150 + .position(|line| line == "Intro paragraph") 151 151 + .unwrap(); 152 152 + 153 153 + assert!(rendered[intro_idx + 1].starts_with("┌─ rs ")); 154 154 + } 155 155 + 156 156 + #[test] 157 157 + fn nested_blockquotes_keep_quote_prefix_after_inner_quote_ends() { 158 158 + let (ss, theme) = test_assets(); 159 159 + let src = "> outer\n> > inner\n> outer again\n"; 160 160 + let (lines, _) = parse_markdown(src, &ss, &theme); 161 161 + let rendered = rendered_non_empty_lines(&lines); 162 162 + 163 163 + assert!(rendered.iter().any(|line| line == "▏ outer")); 164 164 + assert!(rendered.iter().any(|line| line == "▏ inner")); 165 165 + assert!(rendered.iter().any(|line| line == "▏ outer again")); 166 166 + } 167 167 + 168 168 + #[test] 169 169 + fn long_blockquotes_wrap_into_multiple_prefixed_lines() { 170 170 + let (ss, theme) = test_assets(); 171 171 + let src = "> This is a long blockquote line that should wrap into multiple quoted lines at narrow widths.\n"; 172 172 + let (lines, _) = parse_markdown_with_width(src, &ss, &theme, 28); 173 173 + let rendered = rendered_non_empty_lines(&lines); 174 174 + let quoted: Vec<_> = rendered 175 175 + .into_iter() 176 176 + .filter(|line| line.starts_with('▏')) 177 177 + .collect(); 178 178 + 179 179 + assert!(quoted.len() >= 2); 180 180 + assert!(quoted.iter().all(|line| line.starts_with("▏ "))); 181 181 + } 182 182 + 183 183 + #[test] 184 184 + fn toc_only_includes_first_two_heading_levels() { 185 185 + let (ss, theme) = test_assets(); 186 186 + let (_, toc) = parse_markdown("# One\n## Two\n### Three\n#### Four\n", &ss, &theme); 187 187 + 188 188 + assert_eq!(toc.len(), 3); 189 189 + assert_eq!(toc[0].level, 1); 190 190 + assert_eq!(toc[1].level, 2); 191 191 + assert_eq!(toc[2].level, 3); 192 192 + } 193 193 + 194 194 + #[test] 195 195 + fn frontmatter_is_ignored_in_preview_and_toc() { 196 196 + let (ss, theme) = test_assets(); 197 197 + let src = "---\ntitle: Demo\nowner: me\n---\n# Visible\nBody\n"; 198 198 + let (lines, toc) = parse_markdown(src, &ss, &theme); 199 199 + let rendered = rendered_non_empty_lines(&lines); 200 200 + 201 201 + assert!(!rendered.iter().any(|line| line.contains("title: Demo"))); 202 202 + assert!(rendered.iter().any(|line| line.contains("Visible"))); 203 203 + assert_eq!(toc.len(), 1); 204 204 + assert_eq!(toc[0].title, "Visible"); 205 205 + } 206 206 + 207 207 + #[test] 208 208 + fn h2_headings_are_underlined_and_compact() { 209 209 + let (ss, theme) = test_assets(); 210 210 + let (lines, _) = parse_markdown_with_width("Intro\n\n## Section\nBody\n", &ss, &theme, 40); 211 211 + let rendered = rendered_non_empty_lines(&lines); 212 212 + 213 213 + assert!(rendered.iter().any(|line| line.contains("Section"))); 214 214 + assert!(rendered.iter().any(|line| line.contains("────"))); 215 215 + } 216 216 + 217 217 + #[test] 218 218 + fn rules_use_render_width_without_extra_blank_after() { 219 219 + let (ss, theme) = test_assets(); 220 220 + let (lines, _) = parse_markdown_with_width("Alpha\n\n---\nBeta\n", &ss, &theme, 24); 221 221 + let rendered = rendered_non_empty_lines(&lines); 222 222 + let rule = rendered 223 223 + .iter() 224 224 + .find(|line| line.trim_start().starts_with('─')) 225 225 + .unwrap(); 226 226 + 227 227 + assert_eq!(display_width(rule.trim_start()), 24); 228 228 + let rule_idx = rendered.iter().position(|line| line == rule).unwrap(); 229 229 + assert_eq!(rendered[rule_idx + 1], "Beta"); 230 230 + } 231 231 + 232 232 + #[test] 233 233 + fn toc_hides_single_h1_when_h2_entries_exist() { 234 234 + let toc = vec![ 235 235 + TocEntry { 236 236 + level: 1, 237 237 + title: "Doc Title".to_string(), 238 238 + line: 0, 239 239 + }, 240 240 + TocEntry { 241 241 + level: 2, 242 242 + title: "Install".to_string(), 243 243 + line: 10, 244 244 + }, 245 245 + ]; 246 246 + 247 247 + assert!(should_hide_single_h1(&toc)); 248 248 + assert_eq!(toc_display_level(2, true, false), 1); 249 249 + assert_eq!(toc_display_level(3, true, false), 2); 250 250 + } 251 251 + 252 252 + #[test] 253 253 + fn toc_keeps_single_h1_when_no_h2_entries_exist() { 254 254 + let toc = vec![TocEntry { 255 255 + level: 1, 256 256 + title: "Doc Title".to_string(), 257 257 + line: 0, 258 258 + }]; 259 259 + 260 260 + assert!(!should_hide_single_h1(&toc)); 261 261 + } 262 262 + 263 263 + #[test] 264 264 + fn toc_promotes_h2_when_document_has_no_h1() { 265 265 + let toc = vec![ 266 266 + TocEntry { 267 267 + level: 2, 268 268 + title: "Build & install".to_string(), 269 269 + line: 0, 270 270 + }, 271 271 + TocEntry { 272 272 + level: 3, 273 273 + title: "Android".to_string(), 274 274 + line: 4, 275 275 + }, 276 276 + ]; 277 277 + 278 278 + assert!(should_promote_h2_when_no_h1(&toc)); 279 279 + assert_eq!(toc_display_level(2, false, true), 1); 280 280 + assert_eq!(toc_display_level(3, false, true), 2); 281 281 + let normalized = normalize_toc(toc); 282 282 + assert_eq!(normalized.len(), 2); 283 283 + assert_eq!(normalized[0].level, 2); 284 284 + assert_eq!(normalized[1].level, 3); 285 285 + } 286 286 + 287 287 + #[test] 288 288 + fn resolve_syntax_supports_common_language_aliases() { 289 289 + let ss = SyntaxSet::load_defaults_newlines(); 290 290 + 291 291 + assert_eq!( 292 292 + resolve_syntax("py", &ss).name, 293 293 + resolve_syntax("python", &ss).name 294 294 + ); 295 295 + assert_eq!( 296 296 + resolve_syntax("cpp", &ss).name, 297 297 + resolve_syntax("c++", &ss).name 298 298 + ); 299 299 + assert_eq!(resolve_syntax("json", &ss).name, "JSON"); 300 300 + assert_eq!( 301 301 + resolve_syntax("ps1", &ss).name, 302 302 + resolve_syntax("powershell", &ss).name 303 303 + ); 304 304 + } 305 305 + 306 306 + #[test] 307 307 + fn narrow_tables_fit_render_width_and_wrap_cells() { 308 308 + let (ss, theme) = test_assets(); 309 309 + let md = "| Column | Description | Value |\n| --- | --- | ---: |\n| Width | Terminal-dependent layout behavior | 80 |\n"; 310 310 + let (lines, _) = parse_markdown_with_width(md, &ss, &theme, 36); 311 311 + let rendered = rendered_non_empty_lines(&lines); 312 312 + 313 313 + assert!(rendered.len() >= 6); 314 314 + assert!(rendered.iter().all(|line| display_width(line) <= 36)); 315 315 + } 316 316 + 317 317 + #[test] 318 318 + fn wrapped_list_inline_code_keeps_left_padding_in_rendered_line() { 319 319 + let (ss, theme) = test_assets(); 320 320 + let source = "- `leaf --theme ocean README.md` exercises wrapping inside a list item.\n"; 321 321 + let (lines, _) = parse_markdown_with_width(source, &ss, &theme, 22); 322 322 + 323 323 + let target = lines 324 324 + .iter() 325 325 + .find(|line| line_plain_text(line).contains("leaf --theme")) 326 326 + .expect("expected wrapped inline-code line"); 327 327 + 328 328 + assert!( 329 329 + target 330 330 + .spans 331 331 + .iter() 332 332 + .any(|span| span.style.bg.is_some() && span.content.starts_with(' ')), 333 333 + "expected a background-styled span with left padding" 334 334 + ); 335 335 + } 336 336 + 337 337 + #[test] 338 338 + fn code_block_inside_list_item_is_indented_and_has_no_blank_gap_before() { 339 339 + let (ss, theme) = test_assets(); 340 340 + let md = "To put a code block within a list item, the code block needs\nto be indented *twice* -- 8 spaces or two tabs:\n\n* A list item with a code block:\n\n <code goes here>\n"; 341 341 + let (lines, _) = parse_markdown(md, &ss, &theme); 342 342 + let rendered = rendered_non_empty_lines(&lines); 343 343 + 344 344 + let item_idx = rendered 345 345 + .iter() 346 346 + .position(|line| line.contains("A list item with a code block:")) 347 347 + .expect("missing list item line"); 348 348 + let header_idx = rendered 349 349 + .iter() 350 350 + .position(|line| line.contains("┌─ text")) 351 351 + .expect("missing code block header"); 352 352 + let code_idx = rendered 353 353 + .iter() 354 354 + .position(|line| line.contains("<code goes here>")) 355 355 + .expect("missing code line"); 356 356 + 357 357 + assert_eq!( 358 358 + header_idx, 359 359 + item_idx + 1, 360 360 + "expected no blank gap before code block" 361 361 + ); 362 362 + assert!(rendered[header_idx].starts_with(" ")); 363 363 + assert!(rendered[code_idx].starts_with(" ")); 364 364 + }

+79

src/tests/mod.rs

reviewed

··· 1 1 + use crate::*; 2 2 + use ratatui::backend::TestBackend; 3 3 + use ratatui::{text::Line, widgets::Paragraph, Terminal}; 4 4 + use std::{ 5 5 + path::PathBuf, 6 6 + sync::{Mutex, MutexGuard}, 7 7 + time::{SystemTime, UNIX_EPOCH}, 8 8 + }; 9 9 + use syntect::{ 10 10 + highlighting::{Theme, ThemeSet}, 11 11 + parsing::SyntaxSet, 12 12 + }; 13 13 + 14 14 + mod app; 15 15 + mod markdown; 16 16 + mod render; 17 17 + mod theme; 18 18 + mod update; 19 19 + 20 20 + pub(super) static THEME_TEST_MUTEX: Mutex<()> = Mutex::new(()); 21 21 + 22 22 + pub(super) fn test_assets() -> (SyntaxSet, Theme) { 23 23 + let ss = SyntaxSet::load_defaults_newlines(); 24 24 + let ts = ThemeSet::load_defaults(); 25 25 + let theme = ts.themes["base16-ocean.dark"].clone(); 26 26 + (ss, theme) 27 27 + } 28 28 + 29 29 + pub(super) fn render_buffer(lines: &[Line<'static>]) -> ratatui::buffer::Buffer { 30 30 + let width = lines 31 31 + .iter() 32 32 + .map(|line| line.width()) 33 33 + .max() 34 34 + .unwrap_or(1) 35 35 + .max(1) as u16; 36 36 + let height = lines.len().max(1) as u16; 37 37 + let backend = TestBackend::new(width, height); 38 38 + let mut terminal = Terminal::new(backend).unwrap(); 39 39 + terminal 40 40 + .draw(|f| { 41 41 + f.render_widget(Paragraph::new(lines.to_vec()), f.area()); 42 42 + }) 43 43 + .unwrap(); 44 44 + terminal.backend().buffer().clone() 45 45 + } 46 46 + 47 47 + pub(super) fn find_symbol(buffer: &ratatui::buffer::Buffer, symbol: &str) -> Option<(u16, u16)> { 48 48 + for y in 0..buffer.area.height { 49 49 + for x in 0..buffer.area.width { 50 50 + if buffer 51 51 + .cell((x, y)) 52 52 + .is_some_and(|cell| cell.symbol() == symbol) 53 53 + { 54 54 + return Some((x, y)); 55 55 + } 56 56 + } 57 57 + } 58 58 + None 59 59 + } 60 60 + 61 61 + pub(super) fn rendered_non_empty_lines(lines: &[Line<'static>]) -> Vec<String> { 62 62 + lines 63 63 + .iter() 64 64 + .map(line_plain_text) 65 65 + .filter(|line| !line.is_empty()) 66 66 + .collect() 67 67 + } 68 68 + 69 69 + pub(super) fn lock_theme_test_state() -> MutexGuard<'static, ()> { 70 70 + THEME_TEST_MUTEX.lock().unwrap() 71 71 + } 72 72 + 73 73 + pub(super) fn unique_temp_dir(prefix: &str) -> PathBuf { 74 74 + let unique = SystemTime::now() 75 75 + .duration_since(UNIX_EPOCH) 76 76 + .unwrap() 77 77 + .as_nanos(); 78 78 + std::env::temp_dir().join(format!("{prefix}-{unique}")) 79 79 + }

+59

src/tests/render.rs

reviewed

··· 1 1 + use super::{find_symbol, render_buffer, test_assets}; 2 2 + use crate::markdown::parse_markdown; 3 3 + 4 4 + #[test] 5 5 + fn code_block_box_renders_right_border_in_one_column() { 6 6 + let (ss, theme) = test_assets(); 7 7 + let md = "```ts\nconst city = \"東京\";\n\tconsole.log(city)\n```"; 8 8 + let (lines, _) = parse_markdown(md, &ss, &theme); 9 9 + let buffer = render_buffer(&lines); 10 10 + 11 11 + let (right_x, start_y) = find_symbol(&buffer, "┐").unwrap(); 12 12 + let (_, end_y) = find_symbol(&buffer, "┘").unwrap(); 13 13 + 14 14 + for y in start_y + 1..end_y { 15 15 + assert_eq!( 16 16 + buffer.cell((right_x, y)).unwrap().symbol(), 17 17 + "│", 18 18 + "missing code block right border at row {y}" 19 19 + ); 20 20 + } 21 21 + } 22 22 + 23 23 + #[test] 24 24 + fn table_render_right_border_stays_aligned() { 25 25 + let (ss, theme) = test_assets(); 26 26 + let md = "| Name | Value |\n| --- | --- |\n| 東京 | 12 |\n| tab\tcell | ok |"; 27 27 + let (lines, _) = parse_markdown(md, &ss, &theme); 28 28 + let buffer = render_buffer(&lines); 29 29 + 30 30 + let (right_x, start_y) = find_symbol(&buffer, "┐").unwrap(); 31 31 + let (_, end_y) = find_symbol(&buffer, "┘").unwrap(); 32 32 + 33 33 + for y in start_y + 1..end_y { 34 34 + let symbol = buffer.cell((right_x, y)).unwrap().symbol(); 35 35 + assert!( 36 36 + matches!(symbol, "│" | "┤" | "╡"), 37 37 + "unexpected table edge symbol {symbol:?} at row {y}" 38 38 + ); 39 39 + } 40 40 + } 41 41 + 42 42 + #[test] 43 43 + fn table_render_right_border_stays_aligned_with_emoji_cells() { 44 44 + let (ss, theme) = test_assets(); 45 45 + let md = "| Critère | Note |\n| --- | --- |\n| Tests | ✅ Bonne couverture |\n| Sécurité | ⚠ Quelques points |\n"; 46 46 + let (lines, _) = parse_markdown(md, &ss, &theme); 47 47 + let buffer = render_buffer(&lines); 48 48 + 49 49 + let (right_x, start_y) = find_symbol(&buffer, "┐").unwrap(); 50 50 + let (_, end_y) = find_symbol(&buffer, "┘").unwrap(); 51 51 + 52 52 + for y in start_y + 1..end_y { 53 53 + let symbol = buffer.cell((right_x, y)).unwrap().symbol(); 54 54 + assert!( 55 55 + matches!(symbol, "│" | "┤" | "╡"), 56 56 + "unexpected emoji-table edge symbol {symbol:?} at row {y}" 57 57 + ); 58 58 + } 59 59 + }

+97

src/tests/theme.rs

reviewed

··· 1 1 + use super::{lock_theme_test_state, test_assets}; 2 2 + use crate::app::{App, AppConfig}; 3 3 + use crate::markdown::parse_markdown; 4 4 + use crate::theme::{current_theme_preset, set_theme_preset, theme_preset_index}; 5 5 + use crate::*; 6 6 + use syntect::highlighting::ThemeSet; 7 7 + 8 8 + #[test] 9 9 + fn parse_theme_preset_supports_ocean_and_forest() { 10 10 + assert_eq!(parse_theme_preset("arctic"), Some(ThemePreset::Arctic)); 11 11 + assert_eq!(parse_theme_preset("ocean"), Some(ThemePreset::OceanDark)); 12 12 + assert_eq!(parse_theme_preset("forest"), Some(ThemePreset::Forest)); 13 13 + assert_eq!( 14 14 + parse_theme_preset("solarized-dark"), 15 15 + Some(ThemePreset::SolarizedDark) 16 16 + ); 17 17 + assert_eq!(parse_theme_preset("nope"), None); 18 18 + } 19 19 + 20 20 + #[test] 21 21 + fn theme_presets_are_in_alphabetical_order() { 22 22 + let labels: Vec<_> = THEME_PRESETS 23 23 + .iter() 24 24 + .map(|preset| theme_preset_label(*preset)) 25 25 + .collect(); 26 26 + let mut sorted = labels.clone(); 27 27 + sorted.sort(); 28 28 + assert_eq!(labels, sorted); 29 29 + } 30 30 + 31 31 + #[test] 32 32 + fn theme_picker_restores_original_preset_on_escape() { 33 33 + let _guard = lock_theme_test_state(); 34 34 + let (ss, theme) = test_assets(); 35 35 + let ts = ThemeSet::load_defaults(); 36 36 + let (lines, toc) = parse_markdown("# Demo\n", &ss, &theme); 37 37 + let mut app = App::new_with_source( 38 38 + lines, 39 39 + toc, 40 40 + AppConfig { 41 41 + filename: "stdin".to_string(), 42 42 + source: "# Demo\n".to_string(), 43 43 + debug_input: false, 44 44 + watch: false, 45 45 + filepath: None, 46 46 + last_file_state: None, 47 47 + }, 48 48 + ); 49 49 + 50 50 + let original = current_theme_preset(); 51 51 + set_theme_preset(ThemePreset::OceanDark); 52 52 + app.open_theme_picker(); 53 53 + assert!(app.set_theme_picker_index(theme_preset_index(ThemePreset::Forest))); 54 54 + app.preview_theme_preset(ThemePreset::Forest, &ss, &ts); 55 55 + 56 56 + assert_eq!(current_theme_preset(), ThemePreset::Forest); 57 57 + 58 58 + app.restore_theme_picker_preview(&ss, &ts); 59 59 + 60 60 + assert_eq!(current_theme_preset(), ThemePreset::OceanDark); 61 61 + assert!(!app.is_theme_picker_open()); 62 62 + assert_eq!(app.theme_picker_original(), None); 63 63 + set_theme_preset(original); 64 64 + } 65 65 + 66 66 + #[test] 67 67 + fn theme_picker_caches_previewed_themes_for_reuse() { 68 68 + let _guard = lock_theme_test_state(); 69 69 + let (ss, theme) = test_assets(); 70 70 + let ts = ThemeSet::load_defaults(); 71 71 + let (lines, toc) = parse_markdown("# Demo\n\n```rs\nfn main() {}\n```\n", &ss, &theme); 72 72 + let mut app = App::new_with_source( 73 73 + lines, 74 74 + toc, 75 75 + AppConfig { 76 76 + filename: "stdin".to_string(), 77 77 + source: "# Demo\n\n```rs\nfn main() {}\n```\n".to_string(), 78 78 + debug_input: false, 79 79 + watch: false, 80 80 + filepath: None, 81 81 + last_file_state: None, 82 82 + }, 83 83 + ); 84 84 + 85 85 + let original = current_theme_preset(); 86 86 + set_theme_preset(ThemePreset::OceanDark); 87 87 + app.open_theme_picker(); 88 88 + app.preview_theme_preset(ThemePreset::Forest, &ss, &ts); 89 89 + 90 90 + assert!(app.has_cached_theme_preview(ThemePreset::Forest)); 91 91 + assert_eq!(current_theme_preset(), ThemePreset::Forest); 92 92 + 93 93 + app.preview_theme_preset(ThemePreset::OceanDark, &ss, &ts); 94 94 + assert_eq!(current_theme_preset(), ThemePreset::OceanDark); 95 95 + assert!(app.has_cached_theme_preview(ThemePreset::OceanDark)); 96 96 + set_theme_preset(original); 97 97 + }

+116

src/tests/update.rs

reviewed

··· 1 1 + use crate::update::TestAsset; 2 2 + use crate::*; 3 3 + 4 4 + #[test] 5 5 + fn asset_name_matches_supported_release_targets() { 6 6 + assert_eq!( 7 7 + asset_name_for_target("macos", "x86_64"), 8 8 + Some("leaf-macos-x86_64") 9 9 + ); 10 10 + assert_eq!( 11 11 + asset_name_for_target("macos", "aarch64"), 12 12 + Some("leaf-macos-arm64") 13 13 + ); 14 14 + assert_eq!( 15 15 + asset_name_for_target("linux", "x86_64"), 16 16 + Some("leaf-linux-x86_64") 17 17 + ); 18 18 + assert_eq!( 19 19 + asset_name_for_target("linux", "aarch64"), 20 20 + Some("leaf-linux-arm64") 21 21 + ); 22 22 + assert_eq!( 23 23 + asset_name_for_target("android", "aarch64"), 24 24 + Some("leaf-android-arm64") 25 25 + ); 26 26 + assert_eq!( 27 27 + asset_name_for_target("windows", "x86_64"), 28 28 + Some("leaf-windows-x86_64.exe") 29 29 + ); 30 30 + assert_eq!(asset_name_for_target("linux", "arm"), None); 31 31 + } 32 32 + 33 33 + #[test] 34 34 + fn newer_version_comparison_accepts_optional_v_prefix() { 35 35 + assert!(is_newer_version("1.4.2", "v1.4.3").unwrap()); 36 36 + assert!(!is_newer_version("1.4.2", "1.4.2").unwrap()); 37 37 + assert!(!is_newer_version("1.4.2", "1.4.1").unwrap()); 38 38 + } 39 39 + 40 40 + #[test] 41 41 + fn expected_asset_download_url_selects_matching_asset() { 42 42 + let assets = vec![ 43 43 + TestAsset { 44 44 + name: "leaf-linux-x86_64", 45 45 + download_url: "https://example.test/linux", 46 46 + }, 47 47 + TestAsset { 48 48 + name: "leaf-windows-x86_64.exe", 49 49 + download_url: "https://example.test/windows", 50 50 + }, 51 51 + ]; 52 52 + 53 53 + let url = expected_asset_download_url("1.4.3", &assets, "leaf-linux-x86_64").unwrap(); 54 54 + assert_eq!(url, "https://example.test/linux"); 55 55 + } 56 56 + 57 57 + #[test] 58 58 + fn expected_asset_download_url_errors_when_asset_is_missing() { 59 59 + let assets = vec![TestAsset { 60 60 + name: "leaf-linux-x86_64", 61 61 + download_url: "https://example.test/linux", 62 62 + }]; 63 63 + 64 64 + let err = expected_asset_download_url("1.4.3", &assets, "leaf-macos-arm64").unwrap_err(); 65 65 + assert!(err.to_string().contains("does not contain asset")); 66 66 + } 67 67 + 68 68 + #[test] 69 69 + fn validate_download_size_accepts_matching_non_zero_sizes() { 70 70 + assert!(validate_download_size(Some(42), 42).is_ok()); 71 71 + assert!(validate_download_size(None, 42).is_ok()); 72 72 + } 73 73 + 74 74 + #[test] 75 75 + fn validate_download_size_rejects_zero_or_mismatched_sizes() { 76 76 + let empty_err = validate_download_size(None, 0).unwrap_err(); 77 77 + assert!(empty_err.to_string().contains("is empty")); 78 78 + 79 79 + let mismatch_err = validate_download_size(Some(42), 41).unwrap_err(); 80 80 + assert!(mismatch_err.to_string().contains("size mismatch")); 81 81 + } 82 82 + 83 83 + #[test] 84 84 + fn find_expected_checksum_extracts_matching_asset_checksum() { 85 85 + let checksums = "\ 86 86 + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa leaf-linux-x86_64 87 87 + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb leaf-windows-x86_64.exe 88 88 + "; 89 89 + 90 90 + let checksum = find_expected_checksum(checksums, "leaf-windows-x86_64.exe").unwrap(); 91 91 + assert_eq!( 92 92 + checksum, 93 93 + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" 94 94 + ); 95 95 + } 96 96 + 97 97 + #[test] 98 98 + fn find_expected_checksum_rejects_missing_or_invalid_entries() { 99 99 + let missing = 100 100 + find_expected_checksum("abcd leaf-linux-x86_64\n", "leaf-macos-arm64").unwrap_err(); 101 101 + assert!(missing.to_string().contains("does not contain")); 102 102 + 103 103 + let invalid = 104 104 + find_expected_checksum("xyz leaf-linux-x86_64\n", "leaf-linux-x86_64").unwrap_err(); 105 105 + assert!(invalid 106 106 + .to_string() 107 107 + .contains("Invalid SHA256 checksum format")); 108 108 + } 109 109 + 110 110 + #[test] 111 111 + fn validate_sha256_hex_accepts_expected_format() { 112 112 + assert!(validate_sha256_hex( 113 113 + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" 114 114 + ) 115 115 + .is_ok()); 116 116 + }