From a9dec059339b9ffbc826dc72c6dd52d19fe91d3f Mon Sep 17 00:00:00 2001 From: "Gustavo \"Guz\" L. de Mello" Date: Fri, 26 Apr 2024 15:11:44 -0300 Subject: [PATCH] test(npf): add basic tests for the conversion --- src/convert/npf.rs | 264 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 261 insertions(+), 3 deletions(-) diff --git a/src/convert/npf.rs b/src/convert/npf.rs index 4f20534..d4fff3d 100644 --- a/src/convert/npf.rs +++ b/src/convert/npf.rs @@ -113,6 +113,264 @@ pub fn from<'a>(node: &'a Node<'a, RefCell>) -> Result { + match ($b, $s) { + (left, right) => { + if let BlockValue::Text(b) = left { + assert_eq!(b.text, right); + } else { + panic!("Given block doesn't match BlockValue::Text\n{:#?}", left); + } + } + } + }; + } + + macro_rules! extrac_formatting { + ($b:expr) => {{ + let block = $b; + if let BlockValue::Text(b) = block { + b.formatting + .clone() + .unwrap_or_else(|| { + panic!("Given block doesn't have a formatting vector {:#?}", block) + }) + .to_vec() + } else { + panic!("Given block doesn't match BlockValue::Text {:#?}", block); + } + }}; + } + + macro_rules! assert_eq_formatting { + ($a:ident, $b:ident) => { + let vec_a = $a; + $b.iter().enumerate().for_each(|(i, f)| match f { + FormatValue::Bold(f) => { + if let FormatValue::Bold(f2) = &vec_a[i] { + assert_eq!(f.start, f2.start); + assert_eq!(f.end, f2.end); + } else { + panic!( + "Formatting value aren't the same on {f:#?} and {:#?}", + &vec_a[i] + ); + } + } + FormatValue::Italic(f) => { + if let FormatValue::Italic(f2) = &vec_a[i] { + assert_eq!(f.start, f2.start); + assert_eq!(f.end, f2.end); + } else { + panic!( + "Formatting value aren't the same on {f:#?} and {:#?}", + &vec_a[i] + ); + } + } + FormatValue::StrikeThrough(f) => { + if let FormatValue::StrikeThrough(f2) = &vec_a[i] { + assert_eq!(f.start, f2.start); + assert_eq!(f.end, f2.end); + } else { + panic!( + "Formatting value aren't the same on {f:#?} and {:#?}", + &vec_a[i] + ); + } + } + FormatValue::Small(f) => { + if let FormatValue::Small(f2) = &vec_a[i] { + assert_eq!(f.start, f2.start); + assert_eq!(f.end, f2.end); + } else { + panic!( + "Formatting value aren't the same on {f:#?} and {:#?}", + &vec_a[i] + ); + } + } + FormatValue::Link(f) => { + if let FormatValue::Link(f2) = &vec_a[i] { + assert_eq!(f.start, f2.start); + assert_eq!(f.end, f2.end); + assert_eq!(f.url, f2.url); + } else { + panic!( + "Formatting value aren't the same on {f:#?} and {:#?}", + &vec_a[i] + ); + } + } + FormatValue::Mention(f) => { + if let FormatValue::Mention(f2) = &vec_a[i] { + assert_eq!(f.start, f2.start); + assert_eq!(f.end, f2.end); + assert_eq!(f.blog.uuid, f2.blog.uuid); + assert_eq!(f.blog.name, f2.blog.name); + assert_eq!(f.blog.url, f2.blog.url); + } else { + panic!( + "Formatting value aren't the same on {f:#?} and {:#?}", + &vec_a[i] + ); + } + } + FormatValue::Color(f) => { + if let FormatValue::Color(f2) = &vec_a[i] { + assert_eq!(f.start, f2.start); + assert_eq!(f.end, f2.end); + assert_eq!(f.hex, f2.hex); + } else { + panic!( + "Formatting value aren't the same on {f:#?} and {:#?}", + &vec_a[i] + ); + } + } + }); + }; + } + + #[test] + fn text_block_plain() { + let markdown = "Hello world, this is a test of markdown."; + let arena = Arena::new(); + let ast = comrak::parse_document(&arena, &markdown, &utils::default_options()); + + let npf = npf::from(&ast).unwrap(); + + assert_eq_text!(&npf.content[0], "Hello world, this is a test of markdown."); + } + + #[test] + fn text_block_formatting() { + let markdown = "Hello world, **this is a test of markdown**."; + let arena = Arena::new(); + let ast = comrak::parse_document(&arena, &markdown, &utils::default_options()); + + let npf = npf::from(&ast).unwrap(); + + let formatting = vec![FormatValue::Bold(FormatTypeBold::from(13..39))]; + let npf_formatting = extrac_formatting!(&npf.content[0]); + + assert_eq_formatting!(formatting, npf_formatting); + assert_eq_text!(&npf.content[0], "Hello world, this is a test of markdown."); + } + + #[test] + fn text_block_formatting_nested() { + let markdown = "Hello world, **this [is a test of](https://guz.one) markdown**."; + let arena = Arena::new(); + let ast = comrak::parse_document(&arena, &markdown, &utils::default_options()); + + let npf = npf::from(&ast).unwrap(); + + let formatting = vec![ + FormatValue::Link(FormatTypeLink::new( + 18..30, + url::Url::parse("https://guz.one").unwrap(), + )), + FormatValue::Bold(FormatTypeBold::from(13..39)), + ]; + let npf_formatting = extrac_formatting!(&npf.content[0]); + + assert_eq_formatting!(formatting, npf_formatting); + assert_eq_text!(&npf.content[0], "Hello world, this is a test of markdown."); + } + + #[test] + fn text_block_formatting_broken() { + // This isn't "valid" markdown, so the conversion should reflect that + let markdown = "Hello [world, *this is](https://guz.one) a test of markdown*."; + let arena = Arena::new(); + let ast = comrak::parse_document(&arena, &markdown, &utils::default_options()); + + let npf = npf::from(&ast).unwrap(); + + let formatting = vec![FormatValue::Link(FormatTypeLink::new( + 6..21, + url::Url::parse("https://guz.one").unwrap(), + ))]; + let npf_formatting = extrac_formatting!(&npf.content[0]); + + assert_eq_formatting!(formatting, npf_formatting); + assert_eq_text!( + &npf.content[0], + "Hello world, *this is a test of markdown*." + ); + } + + #[test] + fn text_block_formatting_complex() { + let markdown = "Hello [world, *this is*](https://guz.one) ~~a test of markdown~~."; + let arena = Arena::new(); + let ast = comrak::parse_document(&arena, &markdown, &utils::default_options()); + + let npf = npf::from(&ast).unwrap(); + + let formatting = vec![ + FormatValue::Italic(FormatTypeItalic::from(13..20)), + FormatValue::Link(FormatTypeLink::new( + 6..20, + url::Url::parse("https://guz.one").unwrap(), + )), + FormatValue::StrikeThrough(FormatTypeStrikeThrough::from(21..39)), + ]; + let npf_formatting = extrac_formatting!(&npf.content[0]); + + assert_eq_formatting!(formatting, npf_formatting); + assert_eq_text!(&npf.content[0], "Hello world, this is a test of markdown."); + } + + #[test] + fn text_block_paragraph() { + let markdown = "If **you** are reading this, thanks for giving a look\n\ + and checking the ~~ugly~~ source code of this *little\n\ + **personal** project*. It is heart warming to know that *at least*\n\ + someone found this interesting and maybe useful, even knowing\n\ + how niched this whole project is.\\ + - [Gustavo \"Guz\" L. de Mello](https://guz.one), Apr 16, 12.2024"; + + let arena = Arena::new(); + let ast = comrak::parse_document(&arena, &markdown, &utils::default_options()); + + let npf = npf::from(&ast).unwrap(); + let formatting = vec![ + FormatValue::Bold(FormatTypeBold::from(3..6)), + FormatValue::StrikeThrough(FormatTypeStrikeThrough::from(67..71)), + FormatValue::Bold(FormatTypeBold::from(99..107)), + FormatValue::Italic(FormatTypeItalic::from(92..115)), + FormatValue::Italic(FormatTypeItalic::from(150..158)), + FormatValue::Link(FormatTypeLink::new( + 257..282, + url::Url::parse("https://guz.one").unwrap(), + )), + ]; + + let npf_formatting = extrac_formatting!(&npf.content[0]); + + assert_eq_formatting!(formatting, npf_formatting); + assert_eq_text!( + &npf.content[0], + "If you are reading this, thanks for giving a look \ + and checking the ugly source code of this little personal project. \ + It is heart warming to know that at least someone found this \ + interesting and maybe useful, even knowing how niched this \ + whole project is.\n\ + - Gustavo \"Guz\" L. de Mello, Apr 16, 12.2024" + ); + } +}