test: add tests to check coverage

Cargo.toml

@@ -88,6 +88,7 @@ streaming-stats = "0.2.3"
 humantime = "2.1"
 tempfile = "3.8"
 mock_instant = "0.3"
+serde_test = "1.0.176"
 
 [[example]]
 name = "json_logger"

src/config/raw.rs

@@ -465,9 +465,33 @@ fn logger_additive_default() -> bool {
 #[allow(unused_imports)]
 mod test {
     use std::fs;
-
+    use serde_value::Value;
     use super::*;
 
+    #[test]
+    #[cfg(feature = "threshold_filter")]
+    fn deserialize_filter() {
+        use crate::filter::{Filter, FilterConfig};
+
+        let d = Deserializers::default();
+        let filter = FilterConfig{
+            kind: "threshold".to_owned(),
+            config: Value::String("foobar".to_owned()),
+        };
+
+        let res: Result<Box<dyn Filter>, anyhow::Error> = d.deserialize(&filter.kind, filter.config.clone());
+        assert!(res.is_err());
+        // panic!("{:#?}", res);
+
+        // let filter = FilterConfig{
+        //     kind: "threshold".to_owned(),
+        //     config: Value::String("info".to_owned()),
+        // };
+        // let res: Result<Box<dyn Filter>, anyhow::Error> = d.deserialize(&filter.kind, filter.config.clone());
+        // assert!(res.is_ok());
+        // panic!("{:#?}", res);
+    }
+
     #[test]
     #[cfg(all(feature = "yaml_format", feature = "threshold_filter"))]
     fn full_deserialize() {

src/encode/json.rs

@@ -85,7 +85,15 @@ impl JsonEncoder {
 
 impl Encode for JsonEncoder {
     fn encode(&self, w: &mut dyn Write, record: &Record) -> anyhow::Result<()> {
-        self.encode_inner(w, Local::now(), record)
+        #[cfg(test)]
+        let time = DateTime::parse_from_rfc3339("2016-03-20T14:22:20.644420340-08:00")
+            .unwrap()
+            .with_timezone(&Local);
+
+        #[cfg(not(test))]
+        let time = Local::now();
+
+        self.encode_inner(w, time, record)
     }
 }
 
@@ -168,7 +176,7 @@ impl Deserialize for JsonEncoderDeserializer {
 mod test {
     #[cfg(feature = "chrono")]
     use chrono::{DateTime, Local};
-    use log::Level;
+    use log::{Level, Record};
 
     use super::*;
     use crate::encode::writer::simple::SimpleWriter;
@@ -191,9 +199,8 @@ mod test {
 
         let mut buf = vec![];
         encoder
-            .encode_inner(
+            .encode(
                 &mut SimpleWriter(&mut buf),
-                time,
                 &Record::builder()
                     .level(level)
                     .target(target)
@@ -221,4 +228,14 @@ mod test {
         );
         assert_eq!(expected, String::from_utf8(buf).unwrap().trim());
     }
+
+    #[test]
+    fn cfg_to_encoder() {
+        let json_cfg = JsonEncoderConfig { _p: () };
+
+        let deserializer = JsonEncoderDeserializer;
+
+        let res = deserializer.deserialize(json_cfg, &Deserializers::default());
+        assert!(res.is_ok());
+    }
 }

src/encode/mod.rs

@@ -154,3 +154,60 @@ impl<'a, W: Write + ?Sized> Write for &'a mut W {
         <W as Write>::set_style(*self, style)
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[cfg(feature = "config_parsing")]
+    use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
+    #[cfg(feature = "config_parsing")]
+    use serde_value::Value;
+
+    #[test]
+    #[cfg(feature = "config_parsing")]
+    fn cfg_deser() {
+        let pattern = "[{d(%Y-%m-%dT%H:%M:%S%.6f)} {h({l}):<5.5} {M}] {m}{n}".to_owned();
+
+        let mut config = BTreeMap::new();
+        config.insert(
+            Value::String("pattern".to_owned()),
+            Value::String(pattern)
+        );
+
+        let encoder_cfg = EncoderConfig {
+            kind: "pattern".to_owned(),
+            config: Value::Map(config),
+        };
+
+        assert_de_tokens(
+            &encoder_cfg,
+            &[
+                Token::Struct {
+                    name: "EncoderConfig",
+                    len: 2,
+                },
+                Token::Str("kind"),
+                Token::Str("pattern"),
+                Token::Str("pattern"),
+                Token::Str("[{d(%Y-%m-%dT%H:%M:%S%.6f)} {h({l}):<5.5} {M}] {m}{n}"),
+                Token::StructEnd,
+            ]
+        );
+
+        // No pattern defined, should fail to deserializez into a map
+        assert_de_tokens_error::<EncoderConfig>(
+            &[
+                Token::Struct {
+                    name: "EncoderConfig",
+                    len: 2,
+                },
+                Token::Str("kind"),
+                Token::Str("pattern"),
+                Token::Str("pattern"),
+                Token::StructEnd,
+            ],
+            "deserialization did not expect this token: StructEnd",
+        );
+    }
+}

src/filter/mod.rs

@@ -31,6 +31,7 @@ impl Deserializable for dyn Filter {
     }
 }
 
+#[derive(PartialEq, Debug)]
 /// The response returned by a filter.
 pub enum Response {
     /// Accept the log event.
@@ -78,3 +79,29 @@ impl<'de> de::Deserialize<'de> for FilterConfig {
         })
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    #[cfg(all(feature = "config_parsing", feature = "yaml_format"))]
+    fn deser() {
+        // This point in the config should have already parsed out the filters portion of the config.
+        let cfg_str = "
+        filters:
+        -  kind: threshold
+           level: error
+        ";
+        let filter: Result<FilterConfig, serde_yaml::Error> = serde_yaml::from_str(cfg_str);
+        assert!(filter.is_err());
+
+        let cfg_str = "
+          kind: threshold
+          level: error
+        ";
+
+        let filter: Result<FilterConfig, serde_yaml::Error> = serde_yaml::from_str(cfg_str);
+        assert!(filter.is_ok());
+    }
+}

src/filter/threshold.rs

@@ -66,3 +66,108 @@ impl Deserialize for ThresholdFilterDeserializer {
         Ok(Box::new(ThresholdFilter::new(config.level)))
     }
 }
+
+#[cfg(test)]
+mod test {
+    use log::{Level, LevelFilter, Record};
+
+    use super::*;
+    use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
+
+    #[test]
+    #[cfg(feature = "config_parsing")]
+    fn deser_cfg() {
+        let filter_cfg = ThresholdFilterConfig {
+            level: LevelFilter::Off,
+        };
+
+        assert_de_tokens(
+            &filter_cfg,
+            &[
+                Token::Struct {
+                    name: "ThresholdFilterConfig",
+                    len: 1,
+                },
+                Token::Str("level"),
+                Token::Enum { name: "LevelFilter" },
+                Token::Str("Off"),
+                Token::Unit,
+                Token::StructEnd,
+            ],
+        );
+
+        assert_de_tokens_error::<ThresholdFilterConfig>(
+            &[
+                Token::Struct {
+                    name: "ThresholdFilterConfig",
+                    len: 1,
+                },
+                Token::Str("leel"),
+                Token::Enum { name: "LevelFilter" },
+                Token::Str("Off"),
+                Token::Unit,
+                Token::StructEnd,
+            ],
+            "missing field `level`",
+        );
+
+        assert_de_tokens_error::<ThresholdFilterConfig>(
+            &[
+                Token::Struct {
+                    name: "ThresholdFilterConfig",
+                    len: 1,
+                },
+                Token::Str("level"),
+                Token::Enum { name: "LevelFilter" },
+                Token::Str("On"),
+                // No Unit on this one as the Option is invalid
+                Token::StructEnd,
+            ],
+            "unknown variant `On`, expected one of `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`",
+        );
+    }
+
+    #[test]
+    fn new_thres() {
+        assert_eq!(
+            ThresholdFilter::new(LevelFilter::Info),
+            ThresholdFilter{ level: LevelFilter::Info }
+        );
+    }
+
+    #[test]
+    fn filter_thres() {
+        let thres = ThresholdFilter::new(LevelFilter::Info);
+        let debug_record = Record::builder()
+            .level(Level::Debug)
+            .args(format_args!("the message"))
+            .module_path(Some("path"))
+            .file(Some("file"))
+            .line(Some(132))
+            .build();
+
+        assert_eq!(thres.filter(&debug_record), Response::Reject);
+
+        let error_record = Record::builder()
+            .level(Level::Error)
+            .args(format_args!("the message"))
+            .module_path(Some("path"))
+            .file(Some("file"))
+            .line(Some(132))
+            .build();
+
+        assert_eq!(thres.filter(&error_record), Response::Neutral);
+    }
+
+    #[test]
+    fn cfg_to_filter() {
+        let filter_cfg = ThresholdFilterConfig {
+            level: LevelFilter::Off,
+        };
+
+        let deserializer = ThresholdFilterDeserializer;
+
+        let res = deserializer.deserialize(filter_cfg, &Deserializers::default());
+        assert!(res.is_ok());
+    }
+}