Extend test coverage for test and fixed modules

2026-03-19 23:37:39 -03:00 · 2026-03-19 23:37:39 -03:00 · 58c1957e9f
commit 58c1957e9f
parent 9024e56e72
7 changed files with 247 additions and 55 deletions
--- a/src/dev/test.rs
+++ b/src/dev/test.rs
@ -2,9 +2,11 @@ use std::{env, fs, io, path::PathBuf};

 use crate::prelude::*;

+#[derive(Debug)]
 pub struct Directories {
    pub original: PathBuf,
    pub templates: PathBuf,
+    pub assets: PathBuf,
    pub test: PathBuf,
 }

@ -20,6 +22,7 @@ impl Directories {
        let original = env::current_dir()?;
        let test = original.join(format!("target/mocks/{dir_name}"));
        let templates = test.join("templates");
+        let assets = test.join("static").join("public").join("assets");

        drop(fs::remove_dir_all(&test));

@ -37,6 +40,13 @@ impl Directories {
            ))
        }

+        if let Err(error) = fs::create_dir_all(&assets) {
+            return Err(Error::with_io(
+                "Failed 'assets' directory creation",
+                error,
+            ))
+        }
+
        if let Err(error) = env::set_current_dir(&test) {
            return Err(Error::with_io("Failed current directory change", error))
        }
@ -44,6 +54,7 @@ impl Directories {
        Ok(Directories {
            original,
            templates,
+            assets,
            test,
        })
    }
@ -68,10 +79,10 @@ pub struct Error {
 }

 impl Error {
-    fn with_io(message: &str, inner_io: io::Error) -> Error {
+    fn with_io(message: &str, inner_error: io::Error) -> Error {
        Error {
            message: String::from(message),
-            inner_io: Some(inner_io),
+            inner_io: Some(inner_error),
            inner_tera: None,
        }
    }
@ -132,4 +143,48 @@ mod tests {
        let dirs = Directories::setup("\0");
        assert!(dirs.is_err());
    }
+
+    #[test]
+    fn display_contains_str_from_from() {
+        let payload = "rHneusPkYNGW0Ia0";
+        let error = Error::from(payload);
+        assert!(format!("{error}").contains(payload));
+    }
+
+    #[test]
+    fn display_contains_str_from_io_error() {
+        let payload = "SsVi0d3Ywc8kVhwp";
+        let io_payload = "LoPbZP7cJEHzAjGW";
+        let io_error = std::io::Error::other(io_payload);
+        let error = Error::with_io(payload, io_error);
+        assert!(format!("{error}").contains(payload));
+        assert!(format!("{error}").contains(io_payload));
+    }
+
+    #[test]
+    fn from_io_error() {
+        let payload = "YgmTKBm3VtHt5h3x9";
+        let io_error = std::io::Error::other(payload);
+        let error = Error::from(io_error);
+
+        assert!(error.message.contains(payload));
+    }
+}
+
+#[cfg(test)]
+mod serial_tests {
+    use super::*;
+
+    #[test]
+    fn failed_working_directory_reset() {
+        let dirs = Directories::setup("\0");
+
+        let error = dirs.unwrap_err();
+        println!("{error}");
+        assert!(error.message.contains("Failed test's directory creation"));
+        assert!(
+            format!("{error}")
+                .contains("file name contained an unexpected NUL byte")
+        );
+    }
 }
--- a/src/router/handlers/fixed.rs
+++ b/src/router/handlers/fixed.rs
@ -86,9 +86,9 @@ fn assemble(asset: Asset, graph: &Graph) -> Response<Body> {
    }
 }

-#[expect(clippy::upper_case_acronyms)]
 #[derive(Debug)]
-enum AssetErrorKind {
+#[expect(clippy::upper_case_acronyms)]
+pub enum AssetErrorKind {
    NotFound,
    IO,
    UTF8,
@ -96,11 +96,11 @@ enum AssetErrorKind {
 }

 #[derive(Debug)]
-struct AssetError {
-    path: String,
-    kind: AssetErrorKind,
-    io_error: Option<std::io::Error>,
-    utf8_error: Option<FromUtf8Error>,
+pub struct AssetError {
+    pub path: String,
+    pub kind: AssetErrorKind,
+    pub io_error: Option<std::io::Error>,
+    pub utf8_error: Option<FromUtf8Error>,
 }

 impl AssetError {
@ -136,8 +136,7 @@ impl std::fmt::Display for AssetError {
        let mut message = match self.kind {
            AssetErrorKind::IO => {
                format!(
-                    "A default fallback for {} was found, \
-                    but it could not be loaded",
+                    "File {} was found, but it could not be loaded",
                    self.path
                )
            },
@ -170,6 +169,7 @@ impl std::fmt::Display for AssetError {
    }
 }

+#[derive(Debug)]
 struct Asset {
    blob: Option<Vec<u8>>,
    text: Option<String>,
@ -224,13 +224,14 @@ fn fallback(path: &str, graph: &Graph) -> Result<Asset, AssetError> {
    let mime = mime::Mime::guess(path);

    match std::fs::read(&target) {
-        // A matching file exists on disk
+        // A matching file exists on disk and is accessible
        Ok(content) => Ok(Asset {
            blob: Some(content),
            text: None,
            mime,
        }),
        Err(io_error) => {
+            // A matching file does not exist on disk
            if io_error.kind() == ErrorKind::NotFound {
                if let Some(content) = defaults.get(path) {
                    Ok(Asset::from_str(content, mime))
@ -252,6 +253,7 @@ fn fallback(path: &str, graph: &Graph) -> Result<Asset, AssetError> {
                        None => not_found_error,
                    }
                }
+            // A matching file exists on disk and is not accessible
            } else {
                Err(AssetError::new(
                    path,
@ -668,4 +670,103 @@ mod tests {
        let response = file(Path("/k/j/m".to_string()), State(state)).await;
        assert!(response.status() == StatusCode::NOT_FOUND);
    }
+
+    #[test]
+    fn error_from_utf8error() {
+        let bytes = vec![0, 159];
+        let utf8error = String::from_utf8(bytes.clone()).unwrap_err();
+        let error = AssetError::from(utf8error);
+        assert!(error.utf8_error.is_some());
+        assert_eq!(error.utf8_error.unwrap().into_bytes(), bytes);
+    }
+
+    #[test]
+    fn error_from_string() {
+        let payload = "r5MDnkEojW9HZDAG";
+        let asset_error = AssetError::from(payload.to_string());
+        println!("{asset_error}");
+        assert!(asset_error.path.contains(payload));
+    }
+
+    #[test]
+    fn new_text_asset() {
+        let asset = Asset::new(&[1, 0, 1], mime::Mime::Txt).unwrap();
+
+        assert!(asset.blob.is_none());
+        assert!(asset.text.is_some());
+        assert_eq!(asset.text.unwrap(), "\u{1}\0\u{1}");
+    }
+
+    #[test]
+    fn new_blob_asset() {
+        let asset = Asset::new(&[1, 0, 1], mime::Mime::Png).unwrap();
+
+        assert!(asset.blob.is_some());
+        assert!(asset.text.is_none());
+        assert_eq!(asset.blob.unwrap(), &[1, 0, 1]);
+    }
+
+    #[test]
+    fn asset_from_str() {
+        let payload = "\u{1}\0\u{6}";
+        let asset = Asset::from_str(payload, mime::Mime::Ico);
+        assert_eq!(asset.blob.unwrap(), &[1, 0, 6]);
+    }
+
+    #[test]
+    fn new_asset_utf8_error() {
+        let bad_bytes = [0xff, 0xc0, 0xf5, 0xc1, 0x80];
+
+        let error = Asset::new(&bad_bytes, mime::Mime::Txt).unwrap_err();
+
+        assert!(matches!(&error.kind, AssetErrorKind::UTF8));
+        assert!(format!("{error}").contains("UTF8 decoding error"));
+    }
+
+    #[test]
+    fn not_found_asset_error() {
+        let error = fallback("not_found.png", &Graph::default()).unwrap_err();
+
+        assert!(matches!(&error.kind, AssetErrorKind::NotFound));
+        assert!(
+            format!("{error}")
+                .contains("The file was not found in the searched path")
+        );
+    }
+}
+
+#[cfg(test)]
+#[cfg(unix)]
+#[expect(clippy::panic_in_result_fn)]
+mod serial_tests {
+    use std::{fs, os::unix::fs::PermissionsExt as _};
+
+    use super::*;
+    use crate::dev::test::{Directories, Error};
+
+    #[test]
+    fn io_asset_error() -> Result<(), Error> {
+        let dirs = Directories::setup("io_asset_error")?;
+
+        let assets = dirs.assets.clone();
+        let file = assets.join("unreadable.png");
+
+        fs::write(&file, [1, 0, 1])?;
+        let mut permissions = fs::metadata(&file)?.permissions();
+        permissions.set_mode(0o200);
+        fs::set_permissions(&file, permissions)?;
+
+        let new_permissions = fs::metadata(&file)?.permissions();
+        assert_eq!(new_permissions.mode() & 0o777, 0o200);
+
+        let error = fallback("unreadable.png", &Graph::default()).unwrap_err();
+
+        assert!(matches!(&error.kind, AssetErrorKind::IO));
+        assert!(
+            format!("{error}")
+                .contains("was found, but it could not be loaded")
+        );
+
+        Ok(())
+    }
 }
--- a/src/syntax/content/parser/token/verse.rs
+++ b/src/syntax/content/parser/token/verse.rs
@ -3,16 +3,10 @@ use crate::syntax::content::{Parseable, parser::Lexeme};
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Verse {
    open: Option<bool>,
-    citation: Option<String>,
 }

 impl Verse {
-    pub const fn new(open: bool) -> Verse {
-        Verse {
-            open: Some(open),
-            citation: None,
-        }
-    }
+    pub const fn new(open: bool) -> Verse { Verse { open: Some(open) } }

    pub fn probe_end(lexeme: &Lexeme) -> bool {
        lexeme.match_char_triple('\n', '&', '\n')
@ -24,12 +18,7 @@ impl Parseable for Verse {
        lexeme.match_char_triple('\n', '&', '\n')
    }

-    fn lex(_lexeme: &Lexeme) -> Verse {
-        Verse {
-            open: None,
-            citation: None,
-        }
-    }
+    fn lex(_lexeme: &Lexeme) -> Verse { Verse { open: None } }

    fn render(&self) -> String {
        if let Some(open) = self.open {
@ -59,12 +48,44 @@ impl std::fmt::Display for Verse {
            None => "unknown",
        };

-        let citation = if self.citation.is_some() {
-            " cited"
-        } else {
-            ""
-        };
-
-        write!(f, "Verse [{display_open_state}{citation}]")
+        write!(f, "Verse [{display_open_state}]")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lexed_verse_is_empty() {
+        let verse = Verse::lex(&Lexeme::default());
+        assert!(verse.open.is_none());
+    }
+
+    #[test]
+    fn flat_verse_is_empty() {
+        let verse = Verse::new(true);
+        assert!(verse.flatten().is_empty());
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Attempt to render a verse tag while open state is unknown"
+    )]
+    fn render_attempt_with_unknown_open_state() {
+        let verse = Verse::lex(&Lexeme::default());
+        verse.render();
+    }
+
+    #[test]
+    fn display() {
+        let open = Verse::new(true);
+        assert_eq!(format!("{open}"), "Verse [open]");
+
+        let closed = Verse::new(false);
+        assert_eq!(format!("{closed}"), "Verse [closed]");
+
+        let unknown = Verse::lex(&Lexeme::default());
+        assert_eq!(format!("{unknown}"), "Verse [unknown]");
    }
 }