YGGverse/ggemtext
1
0
Fork 0
mirror of https://github.com/YGGverse/ggemtext.git synced 2026-03-31 09:05:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

move integration test to separated file

Browse source
This commit is contained in:
yggverse 2024-10-20 11:44:10 +03:00
parent 9373faabb8
commit 77783af9b0
4 changed files with 219 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

96
src/lib.rs
View file

@ -1,97 +1 @@
pub mod line; pub mod line;
#[cfg(test)]
mod tests {
use super::line::{
code::Code,
header::{Header, Level},
link::Link,
list::List,
quote::Quote,
};
#[test]
fn line() {
// Code
match Code::inline_from("```inline```") {
Some(inline) => assert_eq!(inline.value, "inline"),
None => assert!(false),
};
match Code::multiline_begin_from("```alt") {
Some(mut multiline) => {
Code::multiline_continue_from(&mut multiline, "line 1");
Code::multiline_continue_from(&mut multiline, "line 2");
Code::multiline_continue_from(&mut multiline, "```");
assert!(multiline.completed);
assert_eq!(multiline.alt, Some("alt".into()));
assert_eq!(multiline.buffer.len(), 3);
}
None => assert!(false),
};
// Header
match Header::from("# H1") {
Some(h1) => {
assert_eq!(h1.level as i8, Level::H1 as i8);
assert_eq!(h1.value, "H1");
}
None => assert!(false),
};
match Header::from("## H2") {
Some(h2) => {
assert_eq!(h2.level as i8, Level::H2 as i8);
assert_eq!(h2.value, "H2");
}
None => assert!(false),
};
match Header::from("### H3") {
Some(h3) => {
assert_eq!(h3.level as i8, Level::H3 as i8);
assert_eq!(h3.value, "H3");
}
None => assert!(false),
};
// Link
match Link::from(
"=> gemini://geminiprotocol.net 1965-01-19 Gemini",
None, // absolute path given, base not wanted
Some(&gtk::glib::TimeZone::local()),
) {
Some(link) => {
// Alt
assert_eq!(link.alt, Some("Gemini".into()));
// Date
match link.timestamp {
Some(timestamp) => {
assert_eq!(timestamp.year(), 1965);
assert_eq!(timestamp.month(), 01);
assert_eq!(timestamp.day_of_month(), 19);
}
None => assert!(false),
}
// URI
assert_eq!(link.uri.to_string(), "gemini://geminiprotocol.net");
}
None => assert!(false),
};
// List
match List::from("* Item") {
Some(list) => assert_eq!(list.value, "Item"),
None => assert!(false),
};
// Quote
match Quote::from("> Quote") {
Some(quote) => assert_eq!(quote.value, "Quote"),
None => assert!(false),
};
}
}

5
tests/integration_test.gmi → tests/integration.gmi
View file

@ -10,18 +10,17 @@
* Listing item 1 * Listing item 1
* Listing item 2 * Listing item 2
* Listing item 3
```inline code``` ```inline code```
``` alt text ``` alt text
multi multi
line code preformatted line
``` ```
``` ```
alt-less alt-less
line code preformatted line
``` ```
> quoted string > quoted string

217
tests/integration.rs Normal file
View file

@ -0,0 +1,217 @@
use ggemtext::line::{
code::{inline::Inline, multiline::Multiline, Code},
header::{Header, Level},
link::Link,
list::List,
quote::Quote,
};
use gtk::glib::{TimeZone, Uri, UriFlags};
use std::fs;
#[test]
fn gemtext() {
match fs::read_to_string("tests/integration.gmi") {
Ok(gemtext) => {
// Init tags collection
let mut code_inline: Vec<Inline> = Vec::new();
let mut code_multiline: Vec<Multiline> = Vec::new();
let mut header: Vec<Header> = Vec::new();
let mut link: Vec<Link> = Vec::new();
let mut list: Vec<List> = Vec::new();
let mut quote: Vec<Quote> = Vec::new();
// Define preformatted buffer
let mut code_multiline_buffer: Option<Multiline> = None;
// Define base URI as integration.gmi contain one relative link
let base = match Uri::parse("gemini://geminiprotocol.net", UriFlags::NONE) {
Ok(uri) => Some(uri),
Err(_) => None,
};
// Define timezone as integration.gmi contain one links with date
let timezone = Some(TimeZone::local());
// Parse document by line
for line in gemtext.lines() {
// Inline code
if let Some(result) = Code::inline_from(line) {
code_inline.push(result);
continue;
}
// Multiline code
match code_multiline_buffer {
None => {
if let Some(code) = Code::multiline_begin_from(line) {
code_multiline_buffer = Some(code);
continue;
}
}
Some(ref mut result) => {
Code::multiline_continue_from(result, line);
if result.completed {
code_multiline.push(code_multiline_buffer.take().unwrap());
code_multiline_buffer = None;
}
continue;
}
};
// Header
if let Some(result) = Header::from(line) {
header.push(result);
continue;
}
// Link
if let Some(result) = Link::from(line, base.as_ref(), timezone.as_ref()) {
link.push(result);
continue;
}
// List
if let Some(result) = List::from(line) {
list.push(result);
continue;
}
// Quote
if let Some(result) = Quote::from(line) {
quote.push(result);
continue;
}
}
// Validate inline code
assert_eq!(code_inline.len(), 1);
assert_eq!(code_inline.get(0).unwrap().value, "inline code");
// Validate multiline code
assert_eq!(code_multiline.len(), 2);
{
let item = code_multiline.get(0).unwrap();
assert_eq!(item.alt.clone().unwrap(), " alt text");
assert_eq!(item.buffer.len(), 3);
assert_eq!(item.buffer.get(0).unwrap(), "multi");
assert_eq!(item.buffer.get(1).unwrap(), " preformatted line");
} // #1
{
let item = code_multiline.get(1).unwrap();
assert_eq!(item.alt.clone(), None);
assert_eq!(item.buffer.len(), 3);
assert_eq!(item.buffer.get(0).unwrap(), "alt-less");
assert_eq!(item.buffer.get(1).unwrap(), " preformatted line");
} // #2
// Validate headers
assert_eq!(header.len(), 3);
fn to_i8(level: &Level) -> i8 {
match level {
Level::H1 => 1,
Level::H2 => 2,
Level::H3 => 3,
}
} // comparison helper
{
let item = header.get(0).unwrap();
assert_eq!(to_i8(&item.level), to_i8(&Level::H1));
assert_eq!(item.value, "H1");
} // #1
{
let item = header.get(1).unwrap();
assert_eq!(to_i8(&item.level), to_i8(&Level::H2));
assert_eq!(item.value, "H2");
} // #2
{
let item = header.get(2).unwrap();
assert_eq!(to_i8(&item.level), to_i8(&Level::H3));
assert_eq!(item.value, "H3");
} // #3
// Validate links
assert_eq!(link.len(), 5);
{
let item = link.get(0).unwrap();
assert_eq!(item.alt, None);
assert_eq!(item.timestamp, None);
assert_eq!(item.uri.to_str(), "gemini://geminiprotocol.net"); // @TODO len 27?
} // #1
{
let item = link.get(1).unwrap();
assert_eq!(item.alt, None);
let timestamp = item.timestamp.clone().unwrap();
assert_eq!(timestamp.year(), 1965);
assert_eq!(timestamp.month(), 01);
assert_eq!(timestamp.day_of_month(), 19);
assert_eq!(item.uri.to_str(), "gemini://geminiprotocol.net");
} // #2
{
let item = link.get(2).unwrap();
assert_eq!(item.alt.clone().unwrap(), "Gemini");
assert_eq!(item.timestamp, None);
assert_eq!(item.uri.to_str(), "gemini://geminiprotocol.net");
} // #3
{
let item = link.get(3).unwrap();
assert_eq!(item.alt.clone().unwrap(), "Gemini");
let timestamp = item.timestamp.clone().unwrap();
assert_eq!(timestamp.year(), 1965);
assert_eq!(timestamp.month(), 01);
assert_eq!(timestamp.day_of_month(), 19);
assert_eq!(item.uri.to_str(), "gemini://geminiprotocol.net");
} // #4
{
let item = link.get(4).unwrap();
assert_eq!(item.alt.clone().unwrap(), "Gemini");
let timestamp = item.timestamp.clone().unwrap();
assert_eq!(timestamp.year(), 1965);
assert_eq!(timestamp.month(), 01);
assert_eq!(timestamp.day_of_month(), 19);
assert_eq!(
item.uri.to_str(),
"gemini://geminiprotocol.net/docs/gemtext.gmi"
);
} // #5
// Validate lists
assert_eq!(list.len(), 2);
assert_eq!(list.get(0).unwrap().value, "Listing item 1");
assert_eq!(list.get(1).unwrap().value, "Listing item 2");
// Validate quotes
assert_eq!(quote.len(), 1);
assert_eq!(quote.get(0).unwrap().value, "quoted string");
}
// Could not load gemtext file
Err(_) => {
assert!(false);
}
}
}

93
tests/integration_test.rs
View file

@ -1,93 +0,0 @@
use ggemtext::line::{
code::{inline::Inline, multiline::Multiline, Code},
header::{Header, Level},
link::Link,
list::List,
quote::Quote,
};
use gtk::glib::{TimeZone, Uri, UriFlags};
use std::fs;
#[test]
fn gemtext() {
match fs::read_to_string("tests/integration_test.gmi") {
Ok(gemtext) => {
// Init tags collection
let mut code_inline: Vec<Inline> = Vec::new();
let mut code_multiline: Vec<Multiline> = Vec::new();
let mut header: Vec<Header> = Vec::new();
let mut link: Vec<Link> = Vec::new();
let mut list: Vec<List> = Vec::new();
let mut quote: Vec<Quote> = Vec::new();
// Define preformatted buffer
let mut code_multiline_buffer: Option<Multiline> = None;
// Define base URI as integration_test.gmi contain one relative link
let base = match Uri::parse("gemini://geminiprotocol.net", UriFlags::NONE) {
Ok(uri) => Some(uri),
Err(_) => None,
};
// Define timezone as integration_test.gmi contain one links with date
let timezone = Some(TimeZone::local());
// Parse document by line
for line in gemtext.lines() {
// Inline code
if let Some(result) = Code::inline_from(line) {
code_inline.push(result);
}
// Multiline code
match code_multiline_buffer {
None => {
if let Some(code) = Code::multiline_begin_from(line) {
code_multiline_buffer = Some(code);
}
}
Some(ref mut result) => {
Code::multiline_continue_from(result, line);
if result.completed {
code_multiline.push(code_multiline_buffer.take().unwrap());
code_multiline_buffer = None;
}
}
};
// Header
if let Some(result) = Header::from(line) {
header.push(result);
}
// Link
if let Some(result) = Link::from(line, base.as_ref(), timezone.as_ref()) {
link.push(result);
}
// List
if let Some(result) = List::from(line) {
list.push(result);
}
// Quote
if let Some(result) = Quote::from(line) {
quote.push(result);
}
}
// Assert tags quantity
assert_eq!(code_inline.len(), 1);
assert_eq!(code_multiline.len(), 2);
assert_eq!(header.len(), 3);
assert_eq!(link.len(), 5);
assert_eq!(list.len(), 3);
assert_eq!(quote.len(), 1);
}
// Could not load gemtext file
Err(_) => {
assert!(false);
}
}
}