Add reqwest::Response to HTTP related errors

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reqwest-eventsource"
-version = "0.4.0"
+version = "0.5.0"
 authors = ["Julian Popescu <[email protected]>"]
 edition = "2018"
 resolver = "2"

src/error.rs

@@ -3,6 +3,7 @@ use eventsource_stream::EventStreamError;
 use nom::error::Error as NomError;
 use reqwest::header::HeaderValue;
 use reqwest::Error as ReqwestError;
+use reqwest::Response;
 use reqwest::StatusCode;
 use std::string::FromUtf8Error;
 
@@ -36,10 +37,10 @@ pub enum Error {
     Transport(ReqwestError),
     /// The `Content-Type` returned by the server is invalid
     #[error("Invalid header value: {0:?}")]
-    InvalidContentType(HeaderValue),
+    InvalidContentType(HeaderValue, Response),
     /// The status code returned by the server is invalid
     #[error("Invalid status code: {0}")]
-    InvalidStatusCode(StatusCode),
+    InvalidStatusCode(StatusCode, Response),
     /// The `Last-Event-ID` cannot be formed into a Header to be submitted to the server
     #[error("Invalid `Last-Event-ID`: {0}")]
     InvalidLastEventId(String),

src/event_source.rs

@@ -115,29 +115,38 @@ impl EventSource {
     }
 }
 
-fn check_response(response: &Response) -> Result<(), Error> {
+fn check_response(response: Response) -> Result<Response, Error> {
     match response.status() {
         StatusCode::OK => {}
         status => {
-            return Err(Error::InvalidStatusCode(status));
+            return Err(Error::InvalidStatusCode(status, response));
         }
     }
-    let content_type = response
-        .headers()
-        .get(&reqwest::header::CONTENT_TYPE)
-        .ok_or_else(|| Error::InvalidContentType(HeaderValue::from_static("")))?;
-    let mime_type: mime::Mime = content_type
+    let content_type =
+        if let Some(content_type) = response.headers().get(&reqwest::header::CONTENT_TYPE) {
+            content_type
+        } else {
+            return Err(Error::InvalidContentType(
+                HeaderValue::from_static(""),
+                response,
+            ));
+        };
+    if content_type
         .to_str()
-        .map_err(|_| Error::InvalidContentType(content_type.clone()))?
-        .parse()
-        .map_err(|_| Error::InvalidContentType(content_type.clone()))?;
-    if !matches!(
-        (mime_type.type_(), mime_type.subtype()),
-        (mime::TEXT, mime::EVENT_STREAM)
-    ) {
-        return Err(Error::InvalidContentType(content_type.clone()));
+        .map_err(|_| ())
+        .and_then(|s| s.parse::<mime::Mime>().map_err(|_| ()))
+        .map(|mime_type| {
+            matches!(
+                (mime_type.type_(), mime_type.subtype()),
+                (mime::TEXT, mime::EVENT_STREAM)
+            )
+        })
+        .unwrap_or(false)
+    {
+        Ok(response)
+    } else {
+        Err(Error::InvalidContentType(content_type.clone(), response))
     }
-    Ok(())
 }
 
 impl<'a> EventSourceProjection<'a> {
@@ -226,12 +235,16 @@ impl Stream for EventSource {
             match response_future.poll(cx) {
                 Poll::Ready(Ok(res)) => {
                     this.clear_fetch();
-                    if let Err(err) = check_response(&res) {
-                        *this.is_closed = true;
-                        return Poll::Ready(Some(Err(err)));
+                    match check_response(res) {
+                        Ok(res) => {
+                            this.handle_response(res);
+                            return Poll::Ready(Some(Ok(Event::Open)));
+                        }
+                        Err(err) => {
+                            *this.is_closed = true;
+                            return Poll::Ready(Some(Err(err)));
+                        }
                     }
-                    this.handle_response(res);
-                    return Poll::Ready(Some(Ok(Event::Open)));
                 }
                 Poll::Ready(Err(err)) => {
                     let err = Error::Transport(err);