Response: add Error storage, retrieval, conversion

This allows for robust creation of Response-s directly from Error-s, with error
capture for future reference, and retrieval via `error() -> Option<&Error>`.

PR-URL: #174
Refs: #169
Refs: http-rs/tide#546
Refs: http-rs/tide#532
Refs: http-rs/tide#452

Author: Fishrock123

src/response.rs

@@ -15,7 +15,7 @@ use crate::headers::{
 };
 use crate::mime::Mime;
 use crate::trailers::{self, Trailers};
-use crate::{Body, Extensions, StatusCode, Version};
+use crate::{Body, Error, Extensions, StatusCode, Version};
 
 cfg_unstable! {
     use crate::upgrade;
@@ -50,6 +50,7 @@ pin_project_lite::pin_project! {
         ext: Extensions,
         local_addr: Option<String>,
         peer_addr: Option<String>,
+        error: Option<Error>,
     }
 }
 
@@ -85,6 +86,7 @@ pin_project_lite::pin_project! {
         ext: Extensions,
         local_addr: Option<String>,
         peer_addr: Option<String>,
+        error: Option<Error>,
     }
 }
 
@@ -111,6 +113,7 @@ impl Response {
             ext: Extensions::new(),
             peer_addr: None,
             local_addr: None,
+            error: None,
         }
     }
 
@@ -140,6 +143,7 @@ impl Response {
             ext: Extensions::new(),
             peer_addr: None,
             local_addr: None,
+            error: None,
         }
     }
 
@@ -469,6 +473,16 @@ impl Response {
         self.body.is_empty()
     }
 
+    /// Returns an optional reference to the `Error` if the response was created from one, or else `None`.
+    pub fn error(&self) -> Option<&Error> {
+        self.error.as_ref()
+    }
+
+    /// Takes the `Error` from the response if one exists, replacing it with `None`.
+    pub fn take_error(&mut self) -> Option<Error> {
+        self.error.take()
+    }
+
     /// Get the HTTP version, if one has been set.
     ///
     /// # Examples
@@ -641,8 +655,10 @@ impl Response {
 }
 
 impl Clone for Response {
-    /// Clone the response, resolving the body to `Body::empty()` and removing
-    /// extensions.
+    /// Clone the response, with some exceptions:
+    /// - The body is resolved to `Body::empty()`.
+    /// - Any attached extensions are not cloned.
+    /// - Any attached error is not cloned.
     fn clone(&self) -> Self {
         Self {
             status: self.status.clone(),
@@ -661,6 +677,7 @@ impl Clone for Response {
             ext: Extensions::new(),
             peer_addr: self.peer_addr.clone(),
             local_addr: self.local_addr.clone(),
+            error: None,
         }
     }
 }
@@ -733,6 +750,58 @@ impl Index<&str> for Response {
     }
 }
 
+#[cfg(not(feature = "unstable"))]
+impl From<Error> for Response {
+    /// Create a new response from an `http_types::Error`.
+    ///
+    /// This will store the error in the `Response`, allowing it to later be
+    /// checked via `Response::error()`.
+    fn from(error: Error) -> Self {
+        let (trailers_sender, trailers_receiver) = sync::channel(1);
+        Self {
+            status: error.status(),
+            headers: Headers::new(),
+            version: None,
+            body: Body::empty(),
+            trailers_sender: Some(trailers_sender),
+            trailers_receiver: Some(trailers_receiver),
+            has_trailers: false,
+            ext: Extensions::new(),
+            peer_addr: None,
+            local_addr: None,
+            error: Some(error),
+        }
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl From<Error> for Response {
+    /// Create a new response from an `http_types::Error`.
+    ///
+    /// This will store the error in the `Response`, allowing it to later be
+    /// checked via `Response::error()`.
+    fn from(error: Error) -> Self {
+        let (trailers_sender, trailers_receiver) = sync::channel(1);
+        let (upgrade_sender, upgrade_receiver) = sync::channel(1);
+        Self {
+            status: error.status(),
+            headers: Headers::new(),
+            version: None,
+            body: Body::empty(),
+            trailers_sender: Some(trailers_sender),
+            trailers_receiver: Some(trailers_receiver),
+            has_trailers: false,
+            upgrade_sender: Some(upgrade_sender),
+            upgrade_receiver: Some(upgrade_receiver),
+            has_upgrade: false,
+            ext: Extensions::new(),
+            peer_addr: None,
+            local_addr: None,
+            error: Some(error),
+        }
+    }
+}
+
 impl From<StatusCode> for Response {
     fn from(s: StatusCode) -> Self {
         Response::new(s)

tests/error.rs

@@ -1,4 +1,4 @@
-use http_types::{bail, ensure, ensure_eq, Error, StatusCode};
+use http_types::{bail, ensure, ensure_eq, Error, Response, StatusCode};
 use std::io;
 
 #[test]
@@ -71,3 +71,21 @@ fn option_ext() {
     let err = res.unwrap_err();
     assert_eq!(err.status(), StatusCode::NotFound);
 }
+
+#[test]
+fn to_response() {
+    let msg = "This is an error";
+
+    let error = Error::from_str(StatusCode::NotFound, msg);
+    let mut res: Response = error.into();
+
+    assert!(res.error().is_some());
+    // Ensure we did not consume the error
+    assert!(res.error().is_some());
+
+    assert_eq!(res.error().unwrap().status(), StatusCode::NotFound);
+    assert_eq!(res.error().unwrap().to_string(), msg);
+
+    res.take_error();
+    assert!(res.error().is_none());
+}