Add method, url, content_length and content_type to Response (#96)

This commit adds functions to Response for:
- request HTTP method
- request Url
- response Content-Type
- response Content-Length

Reexport url::Url and reqwest::StatusCode in http module for
convenience.

Closes: #6

Author: russcam

elasticsearch/build.rs

@@ -16,4 +16,4 @@ fn main() {
             println!("cargo:rustc-cfg=RUSTC_IS_DEV");
         }
     }
-}
+}

elasticsearch/src/http/mod.rs

@@ -5,7 +5,11 @@ pub mod request;
 pub mod response;
 pub mod transport;
 
+pub use reqwest::StatusCode;
+pub use url::Url;
+
 /// Http methods supported by Elasticsearch
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Method {
     /// get
     Get,

elasticsearch/src/http/response.rs

@@ -1,57 +1,54 @@
 //! HTTP response components
 
 use crate::error::Error;
-use reqwest::header::HeaderMap;
-use reqwest::StatusCode;
+use crate::http::{headers::HeaderMap, Method, StatusCode, Url};
 use serde::de::DeserializeOwned;
 
 /// A response from Elasticsearch
-pub struct Response(reqwest::Response);
+pub struct Response(reqwest::Response, Method);
 
 impl Response {
     /// Creates a new instance of an Elasticsearch response
-    pub fn new(response: reqwest::Response) -> Self {
-        Self(response)
+    pub fn new(response: reqwest::Response, method: Method) -> Self {
+        Self(response, method)
     }
 
-    /// The HTTP status code of the response
-    pub fn status_code(&self) -> StatusCode {
-        self.0.status()
+    /// Get the response content-length, if known.
+    ///
+    /// Reasons it may not be known:
+    ///
+    /// - The server didn't send a `content-length` header.
+    /// - The response is compressed and automatically decoded (thus changing
+    ///   the actual decoded length).
+    pub fn content_length(&self) -> Option<u64> {
+        self.0.content_length()
+    }
+
+    /// Gets the response content-type.
+    pub fn content_type(&self) -> &str {
+        self.0
+            .headers()
+            .get(crate::http::headers::CONTENT_TYPE)
+            .and_then(|value| value.to_str().ok())
+            .unwrap()
     }
 
-    /// Turn the response into an `Error` if Elasticsearch returned an error.
+    /// Turn the response into an [Error] if Elasticsearch returned an error.
     pub fn error_for_status_code(self) -> Result<Self, Error> {
         match self.0.error_for_status_ref() {
             Ok(_) => Ok(self),
             Err(err) => Err(err.into()),
         }
     }
 
-    /// Turn the response into an `Error` if Elasticsearch returned an error.
+    /// Turn the response into an [Error] if Elasticsearch returned an error.
     pub fn error_for_status_code_ref(&self) -> Result<&Self, Error> {
         match self.0.error_for_status_ref() {
             Ok(_) => Ok(self),
             Err(err) => Err(err.into()),
         }
     }
 
-    /// The response headers
-    pub fn headers(&self) -> &HeaderMap {
-        self.0.headers()
-    }
-
-    /// Gets the Deprecation warning response headers
-    ///
-    /// Deprecation headers signal the use of Elasticsearch functionality
-    /// or features that are deprecated and will be removed in a future release.
-    pub fn warning_headers(&self) -> impl Iterator<Item = &str> {
-        self.0
-            .headers()
-            .get_all("Warning")
-            .iter()
-            .map(|w| w.to_str().unwrap())
-    }
-
     /// Asynchronously reads the response body as JSON
     ///
     /// Reading the response body consumes `self`
@@ -63,11 +60,43 @@ impl Response {
         Ok(body)
     }
 
+    /// Gets the response headers.
+    pub fn headers(&self) -> &HeaderMap {
+        self.0.headers()
+    }
+
+    /// Gets the request method.
+    pub fn method(&self) -> Method {
+        self.1
+    }
+
+    /// Get the HTTP status code of the response
+    pub fn status_code(&self) -> StatusCode {
+        self.0.status()
+    }
+
     /// Asynchronously reads the response body as plain text
     ///
     /// Reading the response body consumes `self`
     pub async fn text(self) -> Result<String, Error> {
         let body = self.0.text().await?;
         Ok(body)
     }
+
+    /// Gets the request URL
+    pub fn url(&self) -> &Url {
+        self.0.url()
+    }
+
+    /// Gets the Deprecation warning response headers
+    ///
+    /// Deprecation headers signal the use of Elasticsearch functionality
+    /// or features that are deprecated and will be removed in a future release.
+    pub fn warning_headers(&self) -> impl Iterator<Item = &str> {
+        self.0
+            .headers()
+            .get_all("Warning")
+            .iter()
+            .map(|w| w.to_str().unwrap())
+    }
 }

elasticsearch/src/http/transport.rs

@@ -6,8 +6,8 @@ use crate::{
     error::Error,
     http::{
         headers::{
-            HeaderMap, HeaderName, HeaderValue, ACCEPT, AUTHORIZATION, CONTENT_TYPE, DEFAULT_ACCEPT,
-            DEFAULT_CONTENT_TYPE, DEFAULT_USER_AGENT, USER_AGENT,
+            HeaderMap, HeaderName, HeaderValue, ACCEPT, AUTHORIZATION, CONTENT_TYPE,
+            DEFAULT_ACCEPT, DEFAULT_CONTENT_TYPE, DEFAULT_USER_AGENT, USER_AGENT,
         },
         request::Body,
         response::Response,
@@ -86,7 +86,7 @@ pub struct TransportBuilder {
     proxy: Option<Url>,
     proxy_credentials: Option<Credentials>,
     disable_proxy: bool,
-    headers: HeaderMap
+    headers: HeaderMap,
 }
 
 impl TransportBuilder {
@@ -104,7 +104,7 @@ impl TransportBuilder {
             proxy: None,
             proxy_credentials: None,
             disable_proxy: false,
-            headers: HeaderMap::new()
+            headers: HeaderMap::new(),
         }
     }
 
@@ -372,7 +372,7 @@ impl Transport {
 
         let response = request_builder.send().await;
         match response {
-            Ok(r) => Ok(Response::new(r)),
+            Ok(r) => Ok(Response::new(r, method)),
             Err(e) => {
                 if e.is_timeout() {
                     Err(Error::lib(format!("Request timed out to {:?}", e.url())))

elasticsearch/tests/cert.rs

@@ -19,7 +19,7 @@ fn expected_error_message() -> String {
         let os = os_type::current_platform();
         match os.os_type {
             OSType::OSX => "The certificate was not trusted".to_string(),
-            _ => "unable to get local issuer certificate".to_string()
+            _ => "unable to get local issuer certificate".to_string(),
         }
     }
 }
@@ -96,31 +96,27 @@ async fn full_certificate_validation() -> Result<(), failure::Error> {
     let result = client.ping().send().await;
     let os_type = os_type::current_platform();
     match os_type.os_type {
-        OSType::OSX => {
-            match result {
-                Ok(_) => Ok(()),
-                Err(e) => Err(failure::err_msg(e.to_string())),
-            }
+        OSType::OSX => match result {
+            Ok(_) => Ok(()),
+            Err(e) => Err(failure::err_msg(e.to_string())),
         },
-        _ => {
-            match result {
-                Ok(response) => Err(failure::err_msg(format!(
-                    "Expected error but response was {}",
-                    response.status_code()
-                ))),
-                Err(e) => {
-                    let expected = expected_error_message();
-                    let actual = e.to_string();
-                    assert!(
-                        actual.contains(&expected),
-                        "Expected error message to contain '{}' but was '{}'",
-                        expected,
-                        actual
-                    );
-                    Ok(())
-                }
+        _ => match result {
+            Ok(response) => Err(failure::err_msg(format!(
+                "Expected error but response was {}",
+                response.status_code()
+            ))),
+            Err(e) => {
+                let expected = expected_error_message();
+                let actual = e.to_string();
+                assert!(
+                    actual.contains(&expected),
+                    "Expected error message to contain '{}' but was '{}'",
+                    expected,
+                    actual
+                );
+                Ok(())
             }
-        }
+        },
     }
 }
 
@@ -148,31 +144,27 @@ async fn certificate_certificate_validation() -> Result<(), failure::Error> {
     let result = client.ping().send().await;
     let os_type = os_type::current_platform();
     match os_type.os_type {
-        OSType::OSX => {
-            match result {
-                Ok(_) => Ok(()),
-                Err(e) => Err(failure::err_msg(e.to_string())),
-            }
+        OSType::OSX => match result {
+            Ok(_) => Ok(()),
+            Err(e) => Err(failure::err_msg(e.to_string())),
         },
-        _ => {
-            match result {
-                Ok(response) => Err(failure::err_msg(format!(
-                    "Expected error but response was {}",
-                    response.status_code()
-                ))),
-                Err(e) => {
-                    let expected = expected_error_message();
-                    let actual = e.to_string();
-                    assert!(
-                        actual.contains(&expected),
-                        "Expected error message to contain '{}' but was '{}'",
-                        expected,
-                        actual
-                    );
-                    Ok(())
-                }
+        _ => match result {
+            Ok(response) => Err(failure::err_msg(format!(
+                "Expected error but response was {}",
+                response.status_code()
+            ))),
+            Err(e) => {
+                let expected = expected_error_message();
+                let actual = e.to_string();
+                assert!(
+                    actual.contains(&expected),
+                    "Expected error message to contain '{}' but was '{}'",
+                    expected,
+                    actual
+                );
+                Ok(())
             }
-        }
+        },
     }
 }