Add empty body conversion from unit

src/async_impl/body.rs

@@ -208,6 +208,13 @@ impl From<hyper::Body> for Body {
 }
 */
 
+impl From<()> for Body {
+    #[inline]
+    fn from(_: ()) -> Body {
+        Body::empty()
+    }
+}
+
 impl From<Bytes> for Body {
     #[inline]
     fn from(bytes: Bytes) -> Body {
@@ -467,6 +474,22 @@ mod tests {
 
     use super::Body;
 
+    #[test]
+    fn empty() {
+        let body = Body::empty();
+        assert_eq!(body.as_bytes(), Some(&[] as &[u8]));
+        assert_eq!(body.size_hint().exact(), Some(0));
+        assert!(body.is_end_stream());
+    }
+
+    #[test]
+    fn from_unit() {
+        let body = Body::from(());
+        assert_eq!(body.as_bytes(), Some(&[] as &[u8]));
+        assert_eq!(body.size_hint().exact(), Some(0));
+        assert!(body.is_end_stream());
+    }
+
     #[test]
     fn test_as_bytes() {
         let test_data = b"Test body";

src/async_impl/request.rs

@@ -656,6 +656,7 @@ mod tests {
 
     use super::{Client, HttpRequest, Request, RequestBuilder, Version};
     use crate::Method;
+    use http::HeaderMap;
     use serde::Serialize;
     use std::collections::BTreeMap;
     use std::convert::TryFrom;
@@ -877,6 +878,19 @@ mod tests {
         assert!(req.headers()["hiding"].is_sensitive());
     }
 
+    #[test]
+    fn from_empty_http_request() {
+        let http_request = HttpRequest::builder()
+            .uri("http://localhost/")
+            .body(())
+            .unwrap();
+        let req = Request::try_from(http_request).unwrap();
+        assert_eq!(req.body().unwrap().as_bytes(), Some(&[] as &[u8]));
+        assert_eq!(req.headers(), &HeaderMap::new());
+        assert_eq!(req.method(), Method::GET);
+        assert_eq!(req.url().as_str(), "http://localhost/");
+    }
+
     #[test]
     fn convert_from_http_request() {
         let http_request = HttpRequest::builder()

src/blocking/body.rs

@@ -115,6 +115,12 @@ impl Body {
         }
     }
 
+    pub(crate) fn empty() -> Body {
+        Body {
+            kind: Kind::Bytes(Bytes::new()),
+        }
+    }
+
     #[cfg(feature = "multipart")]
     pub(crate) fn len(&self) -> Option<u64> {
         match self.kind {
@@ -167,6 +173,20 @@ impl Kind {
     }
 }
 
+impl Default for Body {
+    #[inline]
+    fn default() -> Body {
+        Body::empty()
+    }
+}
+
+impl From<()> for Body {
+    #[inline]
+    fn from(_: ()) -> Body {
+        Body::empty()
+    }
+}
+
 impl From<Vec<u8>> for Body {
     #[inline]
     fn from(v: Vec<u8>) -> Body {
@@ -367,3 +387,26 @@ pub(crate) fn read_to_string(mut body: Body) -> io::Result<String> {
     }
     .map(|_| s)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Body;
+
+    #[test]
+    fn empty() {
+        let body = Body::empty();
+        assert_eq!(body.as_bytes(), Some(&[] as &[u8]));
+    }
+
+    #[test]
+    fn from_unit() {
+        let body = Body::from(());
+        assert_eq!(body.as_bytes(), Some(&[] as &[u8]));
+    }
+
+    #[test]
+    fn from_vec() {
+        let body = Body::from(vec![1, 2, 3]);
+        assert_eq!(body.as_bytes(), Some(&[1, 2, 3][..]));
+    }
+}

src/blocking/request.rs

@@ -1010,6 +1010,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn from_empty_http_request() {
+        let http_request = HttpRequest::builder()
+            .method("GET")
+            .uri("http://localhost/")
+            .body(())
+            .unwrap();
+        let req = Request::try_from(http_request).unwrap();
+        assert_eq!(req.body().unwrap().as_bytes(), Some(&[] as &[u8]));
+        assert_eq!(req.headers(), &HeaderMap::new());
+        assert_eq!(req.method(), Method::GET);
+        assert_eq!(req.url().as_str(), "http://localhost/");
+    }
+
     #[test]
     fn convert_from_http_request() {
         let http_request = HttpRequest::builder()

src/wasm/body.rs

@@ -129,6 +129,20 @@ impl Body {
             Inner::MultipartForm(_) => None,
         }
     }
+
+    #[inline]
+    pub(crate) fn empty() -> Body {
+        Body {
+            inner: Inner::Single(Single::Bytes(Bytes::new())),
+        }
+    }
+}
+
+impl From<()> for Body {
+    #[inline]
+    fn from(_: ()) -> Body {
+        Body::empty()
+    }
 }
 
 impl From<Bytes> for Body {
@@ -203,6 +217,12 @@ mod tests {
         fn log(s: String);
     }
 
+    #[wasm_bindgen_test]
+    async fn test_body_empty() {
+        let body = Body::empty();
+        assert_eq!(body.as_bytes(), Some(&[] as &[u8]));
+    }
+
     #[wasm_bindgen_test]
     async fn test_body() {
         let body = Body::from("TEST");