Implement Debug for Headers and related structs

Author: jreyes33

src/headers/header_name.rs

@@ -5,7 +5,7 @@ use std::str::FromStr;
 use crate::Error;
 
 /// A header name.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub struct HeaderName(Cow<'static, str>);
 
 impl HeaderName {
@@ -49,6 +49,12 @@ impl HeaderName {
     }
 }
 
+impl Debug for HeaderName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.0)
+    }
+}
+
 impl Display for HeaderName {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
@@ -150,4 +156,10 @@ mod tests {
         let mut res = crate::Response::new(200);
         res.insert_header(&crate::headers::HOST, "127.0.0.1");
     }
+
+    #[test]
+    fn test_debug() {
+        let header_name = HeaderName::from_str("hello").unwrap();
+        assert_eq!(format!("{:?}", header_name), "\"hello\"");
+    }
 }

src/headers/header_value.rs

@@ -1,13 +1,13 @@
 use std::convert::TryFrom;
-use std::fmt::{self, Display};
+use std::fmt::{self, Debug, Display};
 use std::str::FromStr;
 
 use crate::headers::HeaderValues;
 use crate::Error;
 use crate::{Cookie, Mime};
 
 /// A header value.
-#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+#[derive(Clone, Eq, PartialEq, Hash)]
 pub struct HeaderValue {
     inner: String,
 }
@@ -92,6 +92,12 @@ impl<'a> TryFrom<&'a str> for HeaderValue {
     }
 }
 
+impl Debug for HeaderValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.inner)
+    }
+}
+
 impl Display for HeaderValue {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.inner)
@@ -131,3 +137,14 @@ impl From<HeaderValues> for HeaderValue {
             .expect("HeaderValues should contain at least one value")
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_debug() {
+        let header_value = HeaderValue::from_str("foo0").unwrap();
+        assert_eq!(format!("{:?}", header_value), "\"foo0\"");
+    }
+}

src/headers/header_values.rs

@@ -1,14 +1,14 @@
 use crate::headers::{HeaderValue, Values};
 
-use std::fmt::{self, Display};
+use std::fmt::{self, Debug, Display};
 use std::iter::FromIterator;
 use std::ops::{Deref, DerefMut, Index};
 use std::slice::SliceIndex;
 
 /// A list of `HeaderValue`s.
 ///
 /// This always contains at least one header value.
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct HeaderValues {
     pub(crate) inner: Vec<HeaderValue>,
 }
@@ -73,6 +73,16 @@ impl FromIterator<HeaderValue> for HeaderValues {
     }
 }
 
+impl Debug for HeaderValues {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.inner.len() == 1 {
+            write!(f, "{:?}", self.inner[0])
+        } else {
+            f.debug_list().entries(self.inner.iter()).finish()
+        }
+    }
+}
+
 impl Display for HeaderValues {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut list = f.debug_list();
@@ -153,3 +163,23 @@ impl<'a> IntoIterator for &'a HeaderValues {
         self.iter()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_debug_single() {
+        let header_values = HeaderValues {
+            inner: vec!["foo0".parse().unwrap()],
+        };
+        assert_eq!(format!("{:?}", header_values), "\"foo0\"");
+    }
+    #[test]
+    fn test_debug_multiple() {
+        let header_values = HeaderValues {
+            inner: vec!["foo0".parse().unwrap(), "foo1".parse().unwrap()],
+        };
+        assert_eq!(format!("{:?}", header_values), r#"["foo0", "foo1"]"#);
+    }
+}

src/headers/headers.rs

@@ -2,6 +2,7 @@
 
 use std::collections::HashMap;
 use std::convert::Into;
+use std::fmt::{self, Debug};
 use std::iter::IntoIterator;
 use std::ops::Index;
 use std::str::FromStr;
@@ -26,7 +27,7 @@ use crate::headers::{
 /// res.insert_header("hello", "foo0");
 /// assert_eq!(res["hello"], "foo0");
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct Headers {
     pub(crate) headers: HashMap<HeaderName, HeaderValues>,
 }
@@ -176,6 +177,12 @@ impl<'a> IntoIterator for &'a mut Headers {
     }
 }
 
+impl Debug for Headers {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_map().entries(self.headers.iter()).finish()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -207,4 +214,19 @@ mod tests {
         assert_eq!(headers["hello"], "foo0");
         assert_eq!(headers.get("hello").unwrap(), "foo0");
     }
+
+    #[test]
+    fn test_debug_single() {
+        let mut headers = Headers::new();
+        headers.insert("single", "foo0");
+        assert_eq!(format!("{:?}", headers), r#"{"single": "foo0"}"#);
+    }
+
+    #[test]
+    fn test_debug_multiple() {
+        let mut headers = Headers::new();
+        headers.append("multi", "foo0");
+        headers.append("multi", "foo1");
+        assert_eq!(format!("{:?}", headers), r#"{"multi": ["foo0", "foo1"]}"#);
+    }
 }