add integration test

tests/integration_test.rs

@@ -0,0 +1,92 @@
+use ggemtext::line::{
+    code::{inline::Inline, multiline::Multiline, Code},
+    header::{Header, Level},
+    link::Link,
+    list::List,
+    quote::Quote,
+};
+
+#[test]
+fn gemtext() {
+    match std::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 gtk::glib::Uri::parse(
+                "gemini://geminiprotocol.net",
+                gtk::glib::UriFlags::NONE,
+            ) {
+                Ok(uri) => Some(uri),
+                Err(_) => None,
+            };
+
+            // 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(), Some(&gtk::glib::TimeZone::local()))
+                {
+                    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);
+        }
+    }
+}