tests: add encode tests

Cargo.toml

@@ -68,19 +68,7 @@ thread-id = { version = "4", optional = true }
 typemap-ors = { version = "1.0.0", optional = true }
 serde_json = { version = "1.0", optional = true }
 serde_yaml = { version = "0.9", optional = true }
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
 toml = { version = "<0.8.10", optional = true }
-=======
-toml = { version = "0.8.10", optional = true }
->>>>>>> c3d7f42 (chore: clippy fixes + msrv bump)
-=======
-toml = { version = "0.8.9", optional = true }
->>>>>>> 4486edd (chore: backout msrv bump, knock toml down)
-=======
-toml = { version = "<0.8.10", optional = true }
->>>>>>> 049e2cc (limit toml)
 parking_lot = { version = "0.12.0", optional = true }
 rand = { version = "0.8", optional = true}
 thiserror = "1.0.15"

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,13 +176,17 @@ impl Deserialize for JsonEncoderDeserializer {
 mod test {
     #[cfg(feature = "chrono")]
     use chrono::{DateTime, Local};
-    use log::Level;
+    use log::{Level, Record};
 
     use super::*;
+
+    #[cfg(feature = "config_parsing")]
+    use crate::config::Deserializers;
+
     use crate::encode::writer::simple::SimpleWriter;
 
     #[test]
-    fn default() {
+    fn test_json_encode() {
         let time = DateTime::parse_from_rfc3339("2016-03-20T14:22:20.644420340-08:00")
             .unwrap()
             .with_timezone(&Local);
@@ -184,16 +196,15 @@ mod test {
         let file = "file";
         let line = 100;
         let message = "message";
-        let thread = "encode::json::test::default";
+        let thread = "encode::json::test::test_json_encode";
         log_mdc::insert("foo", "bar");
 
         let encoder = JsonEncoder::new();
 
         let mut buf = vec![];
         encoder
-            .encode_inner(
+            .encode(
                 &mut SimpleWriter(&mut buf),
-                time,
                 &Record::builder()
                     .level(level)
                     .target(target)
@@ -221,4 +232,15 @@ mod test {
         );
         assert_eq!(expected, String::from_utf8(buf).unwrap().trim());
     }
+
+    #[test]
+    #[cfg(feature = "config_parsing")]
+    fn test_cfg_deserializer() {
+        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,80 @@ impl<'a, W: Write + ?Sized> Write for &'a mut W {
         <W as Write>::set_style(*self, style)
     }
 }
+
+#[cfg(test)]
+mod test {
+    #[cfg(feature = "config_parsing")]
+    use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
+
+    #[test]
+    #[cfg(feature = "config_parsing")]
+    fn test_cfg_deserialize() {
+        use super::*;
+        use std::collections::BTreeMap;
+
+        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",
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "console_writer")]
+    fn test_set_console_writer_style() {
+        use super::*;
+        use crate::encode::writer::console::ConsoleWriter;
+
+        let w = match ConsoleWriter::stdout() {
+            Some(w) => w,
+            None => return,
+        };
+        let mut w = w.lock();
+
+        assert!(w
+            .set_style(
+                Style::new()
+                    .text(Color::Red)
+                    .background(Color::Blue)
+                    .intense(true),
+            )
+            .is_ok());
+
+        w.set_style(&Style::new()).unwrap();
+    }
+}