logger: adding unit tests

Signed-off-by: Diana Popa <[email protected]>

Author: dianpopa

logger/src/error.rs

@@ -34,3 +34,42 @@ impl fmt::Display for LoggerError {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::ErrorKind;
+
+    #[test]
+    fn test_formatting() {
+        assert!(
+            format!(
+                "{:?}",
+                LoggerError::NeverInitialized(String::from("Bad Log Path Provided"))
+            ).contains("NeverInitialized")
+        );
+        assert!(
+            format!(
+                "{:?}",
+                LoggerError::Poisoned(String::from("Never Initialized"))
+            ).contains("Poisoned")
+        );
+        assert!(
+            format!(
+                "{:?}",
+                LoggerError::FileLogWrite(std::io::Error::new(ErrorKind::Interrupted, "write"))
+            ).contains("FileLogWrite")
+        );
+        assert!(
+            format!(
+                "{:?}",
+                LoggerError::FileLogFlush(std::io::Error::new(ErrorKind::Interrupted, "flush"))
+            ).contains("FileLogFlush")
+        );
+        assert!(
+            format!(
+                "{:?}",
+                LoggerError::FileLogLock(String::from("File log lock"))
+            ).contains("FileLogLock")
+        );
+    }
+}

logger/src/lib.rs

@@ -338,3 +338,131 @@ impl Log for Logger {
         // everything else flushes by itself
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::File;
+    use std::io::BufReader;
+    use std::io::BufRead;
+    use std::fs::remove_file;
+    use log::MetadataBuilder;
+
+    fn validate_logs(
+        log_path: &str,
+        expected: &[(&'static str, &'static str, &'static str)],
+    ) -> bool {
+        let f = File::open(log_path).unwrap();
+        let mut reader = BufReader::new(f);
+
+        let mut line = String::new();
+        for tuple in expected {
+            line.clear();
+            reader.read_line(&mut line).unwrap();
+            assert!(line.contains(&tuple.0));
+            assert!(line.contains(&tuple.1));
+            assert!(line.contains(&tuple.2));
+        }
+        false
+    }
+
+    #[test]
+    fn test_default_values() {
+        let l = Logger::new();
+        assert_eq!(l.level_info.code, log::Level::Warn);
+        assert_eq!(l.level_info.writer, Destination::Stderr);
+        assert_eq!(l.show_line_numbers, true);
+        assert_eq!(l.show_level, true);
+        format!("{:?}", l.level_info.code);
+        format!("{:?}", l.level_info.writer);
+        format!("{:?}", l.show_line_numbers);
+        format!("{:?}", l);
+    }
+
+    #[test]
+    fn test_init() {
+        let l = Logger::new().set_include_origin(false, true);
+        assert_eq!(l.show_line_numbers, false);
+
+        let l = Logger::new()
+            .set_include_origin(true, true)
+            .set_include_level(true)
+            .set_level(log::Level::Info);
+        assert_eq!(l.show_line_numbers, true);
+        assert_eq!(l.show_file_path, true);
+        assert_eq!(l.show_level, true);
+
+        assert!(l.init(Some(String::from("tmp.log"))).is_ok());
+        info!("info");
+        warn!("warning");
+
+        let l = Logger::new();
+        assert!(l.init(None).is_ok());
+
+        info!("info");
+        warn!("warning");
+        error!("error");
+
+        // here we also test that the second initialization had no effect given that the
+        // logging system can only be initialized once per program
+        validate_logs(
+            "tmp.log",
+            &[
+                ("[INFO", "lib.rs", "info"),
+                ("[WARN", "lib.rs", "warn"),
+                ("[INFO", "lib.rs", "info"),
+                ("[WARN", "lib.rs", "warn"),
+                ("[ERROR", "lib.rs", "error"),
+            ],
+        );
+        remove_file("tmp.log").unwrap();
+
+        let l = Logger::new();
+        unsafe {
+            if let Err(e) = set_boxed_logger(Box::new(l)) {
+                INIT_RES = Err(LoggerError::NeverInitialized(format!("{}", e)));
+            }
+            assert!(format!("{:?}", INIT_RES).contains("NeverInitialized"));
+        }
+        let l = Logger::new();
+        assert!(l.init(None).is_err());
+        unsafe {
+            assert!(format!("{:?}", INIT_RES).contains("Poisoned"));
+        }
+
+        let l = Logger::new()
+            .set_include_level(true)
+            .set_include_origin(false, false);
+        let error_metadata = MetadataBuilder::new().level(Level::Error).build();
+        let log_record = log::Record::builder().metadata(error_metadata).build();
+        Logger::log(&l, &log_record);
+        let l = Logger::new()
+            .set_include_level(false)
+            .set_include_origin(true, true);
+        Logger::log(&l, &log_record);
+    }
+
+    #[test]
+    fn test_get_default_destination() {
+        assert_eq!(
+            get_default_destination(log::Level::Error),
+            Destination::Stderr
+        );
+        assert_eq!(
+            get_default_destination(log::Level::Warn),
+            Destination::Stderr
+        );
+        assert_eq!(
+            get_default_destination(log::Level::Info),
+            Destination::Stdout
+        );
+        assert_eq!(
+            get_default_destination(log::Level::Debug),
+            Destination::Stdout
+        );
+        assert_eq!(
+            get_default_destination(log::Level::Trace),
+            Destination::Stdout
+        );
+    }
+}

logger/src/writers.rs

@@ -50,3 +50,40 @@ impl FileLogWriter {
             .map_err(|e| LoggerError::FileLogLock(format!("{}", e)))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::remove_file;
+
+    #[test]
+    fn test_new() {
+        let mut file: String = "./inexistent/tmp.log".to_string();
+        assert!(FileLogWriter::new(&file).is_err());
+        format!("{:?}", FileLogWriter::new(&file));
+        file = "tmp_writers_new.log".to_string();
+        let res = FileLogWriter::new(&file);
+        format!("{:?}", res);
+        remove_file(file).unwrap();
+        assert!(res.is_ok())
+    }
+
+    #[test]
+    fn test_write() {
+        let file: String = "tmp_writers_write.log".to_string();
+        let fw = FileLogWriter::new(&file).unwrap();
+        let msg = String::from("some message");
+        let res = fw.write(&msg);
+        remove_file(file).unwrap();
+        assert!(res.is_ok())
+    }
+
+    #[test]
+    fn test_flush() {
+        let file: String = "tmp_writers_flush.log".to_string();
+        let fw = FileLogWriter::new(&file).unwrap();
+        let res = fw.flush();
+        remove_file(file).unwrap();
+        assert!(res.is_ok())
+    }
+}