fix: serde tests

Author: conblem

Cargo.lock

@@ -38,6 +38,9 @@ toml = "0.5"
 anyhow = "1.0"
 ppp = "1.2"
 
+[dev-dependencies]
+serde_test = "1.0"
+
 [features]
 default = ["postgres"]
 

Cargo.toml

@@ -71,11 +71,8 @@ pub(super) fn routes(
         .and(MetricsConfig::path());
 
     let not_found = warp::any()
-        .map(warp::reply)
-        .and_then(|reply| async move {
-            let res = warp::reply::with_status(reply, StatusCode::NOT_FOUND).into_response();
-            Ok(res) as Result<WarpResponse, Rejection>
-        })
+        .and_then(|| async move { Ok(StatusCode::NOT_FOUND) as Result<_, Rejection> })
+        .map(Reply::into_response)
         .and(MetricsConfig::new("404"));
 
     register

src/api/routes.rs

@@ -2,7 +2,7 @@ use serde::de::{SeqAccess, Visitor};
 use serde::{Deserialize, Deserializer};
 use std::fmt::Formatter;
 
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub enum ProxyProtocol {
     Enabled,
     Disabled,
@@ -44,7 +44,7 @@ where
         where
             E: serde::de::Error,
         {
-            Ok((String::from(value).into(), ProxyProtocol::Disabled))
+            Ok((value.to_owned().into(), ProxyProtocol::Disabled))
         }
 
         fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
@@ -59,3 +59,65 @@ where
     }
     deserializer.deserialize_any(ListenerVisitor)
 }
+#[cfg(test)]
+mod tests {
+    use super::{deserialize, Listener, ProxyProtocol};
+    use serde::Deserialize;
+    use serde_test::{assert_de_tokens, Token};
+
+    #[derive(Deserialize, PartialEq, Debug)]
+    struct ListenerWrapper(#[serde(deserialize_with = "deserialize")] Listener);
+
+    #[test]
+    fn default() {
+        assert_eq!(ProxyProtocol::Disabled, ProxyProtocol::default());
+    }
+
+    #[test]
+    fn deserialize_str_test() {
+        let listener = ListenerWrapper((Some("test".into()), ProxyProtocol::Disabled));
+
+        assert_de_tokens(
+            &listener,
+            &[
+                Token::NewtypeStruct {
+                    name: "ListenerWrapper",
+                },
+                Token::Str("test"),
+            ],
+        );
+    }
+
+    #[test]
+    fn deserialize_str_and_bool() {
+        let listener = ListenerWrapper((Some("ip".into()), ProxyProtocol::Enabled));
+
+        assert_de_tokens(
+            &listener,
+            &[
+                Token::NewtypeStruct {
+                    name: "ListenerWrapper",
+                },
+                Token::Seq { len: Some(2) },
+                Token::Str("ip"),
+                Token::Bool(true),
+                Token::SeqEnd,
+            ],
+        );
+
+        let listener = ListenerWrapper((Some("name".into()), ProxyProtocol::Disabled));
+
+        assert_de_tokens(
+            &listener,
+            &[
+                Token::NewtypeStruct {
+                    name: "ListenerWrapper",
+                },
+                Token::Seq { len: Some(2) },
+                Token::Str("name"),
+                Token::Bool(false),
+                Token::SeqEnd,
+            ],
+        )
+    }
+}

src/config/listener.rs

@@ -27,7 +27,8 @@ where
         {
             let mut res = HashMap::new();
             while let Some(key) = map.next_key::<&str>()? {
-                let name = Name::from_str(key).map_err(DeError::custom)?;
+                let mut name = Name::from_str(key).map_err(DeError::custom)?;
+                name.set_fqdn(true);
                 let (record_type, record_set) = map.next_value_seed(RecordDataSeed(name))?;
 
                 res.insert(record_type, record_set);
@@ -136,3 +137,40 @@ impl<'de> DeserializeSeed<'de> for RecordSeed {
         deserializer.deserialize_seq(RecordVisitor(self.0, self.1))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{deserialize, PreconfiguredRecords};
+    use serde::Deserialize;
+    use serde_test::{assert_de_tokens, Token};
+
+    #[derive(Deserialize, PartialEq, Debug)]
+    struct PreconfiguredRecordsWrapper(
+        #[serde(deserialize_with = "deserialize")] PreconfiguredRecords,
+    );
+
+    #[test]
+    fn deserialize_test() {
+        let records = Default::default();
+        let records = PreconfiguredRecordsWrapper(records);
+
+        assert_de_tokens(
+            &records,
+            &[
+                Token::NewtypeStruct {
+                    name: "PreconfiguredRecordsWrapper",
+                },
+                Token::Map { len: Some(1) },
+                Token::BorrowedStr("acme.example.com"),
+                Token::Map { len: Some(1) },
+                Token::BorrowedStr("A"),
+                Token::Seq { len: Some(2) },
+                Token::U32(100),
+                Token::BorrowedStr("1.1.1.1"),
+                Token::SeqEnd,
+                Token::MapEnd,
+                Token::MapEnd,
+            ],
+        )
+    }
+}

src/config/records.rs

@@ -34,8 +34,9 @@ pub(crate) fn uuid() -> String {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use super::{error, now, to_i64, to_u64};
     use anyhow::anyhow;
+    use std::io::{Error as IoError, ErrorKind};
     use std::thread;
     use std::time::Duration;
 
@@ -77,9 +78,9 @@ mod tests {
 
     #[test]
     fn error_works() {
-        let expected = anyhow!("test error");
+        let expected = anyhow!("test");
 
-        let actual = match error(anyhow!("test error")) {
+        let actual = match error(anyhow!("test")) {
             acme_lib::Error::Io(err) => err,
             _ => panic!("Cannot match err"),
         };
@@ -91,6 +92,6 @@ mod tests {
 
         // here we access the actual inner error
         let actual = actual.into_inner().expect("Error has no inner error");
-        assert_eq!(format!("{:?}", expected), format!("{:?}", actual));
+        assert_eq!(format!("{}", expected), format!("{}", actual));
     }
 }