Merge pull request #27 from jbr/update-http-types

http types and async-h1 for 2.0.0

Author: yoshuawuyts

Cargo.toml

@@ -24,13 +24,13 @@ curl_client = ["isahc", "async-std"]
 wasm_client = ["js-sys", "web-sys", "wasm-bindgen", "wasm-bindgen-futures"]
 
 [dependencies]
-futures = { version = "0.3.1", features = ["compat", "io-compat"] }
-http-types = { version = "1.0.1", features = ["hyperium_http"] }
+futures = { version = "0.3.1" }
+http-types = "2.0.1"
 log = "0.4.7"
 
 # h1-client
-async-h1 = { version = "1.0.0", optional = true }
-async-std = { version = "1.4.0", default-features = false, optional = true }
+async-h1 = { version = "2.0.0", optional = true }
+async-std = { version = "1.6.0", default-features = false, optional = true }
 async-native-tls = { version = "0.3.1", optional = true }
 
 # isahc-client
@@ -62,3 +62,6 @@ features = [
 ]
 
 [dev-dependencies]
+async-std = { version = "1.6.0", features = ["unstable", "attributes"] }
+tide = { version = "0.9.0" }
+portpicker = "0.1.0"

src/h1.rs

@@ -32,13 +32,14 @@ impl Clone for H1Client {
 impl HttpClient for H1Client {
     type Error = Error;
 
-    fn send(&self, req: Request) -> BoxFuture<'static, Result<Response, Self::Error>> {
+    fn send(&self, mut req: Request) -> BoxFuture<'static, Result<Response, Self::Error>> {
         Box::pin(async move {
             // Insert host
             let host = req
                 .url()
                 .host_str()
-                .ok_or_else(|| Error::from_str(StatusCode::BadRequest, "missing hostname"))?;
+                .ok_or_else(|| Error::from_str(StatusCode::BadRequest, "missing hostname"))?
+                .to_string();
 
             let scheme = req.url().scheme();
             if scheme != "http" && scheme != "https" {
@@ -64,10 +65,14 @@ impl HttpClient for H1Client {
             match scheme {
                 "http" => {
                     let stream = async_std::net::TcpStream::connect(addr).await?;
+                    req.set_peer_addr(stream.peer_addr().ok());
+                    req.set_local_addr(stream.local_addr().ok());
                     client::connect(stream, req).await
                 }
                 "https" => {
                     let raw_stream = async_std::net::TcpStream::connect(addr).await?;
+                    req.set_peer_addr(raw_stream.peer_addr().ok());
+                    req.set_local_addr(raw_stream.local_addr().ok());
 
                     let stream = async_native_tls::connect(host, raw_stream).await?;
 
@@ -78,3 +83,49 @@ impl HttpClient for H1Client {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use async_std::prelude::*;
+    use async_std::task;
+    use http_types::url::Url;
+    use http_types::Result;
+    use std::time::Duration;
+
+    fn build_test_request(url: Url) -> Request {
+        let mut req = Request::new(http_types::Method::Post, url);
+        req.set_body("hello");
+        req.append_header("test", "value");
+        req
+    }
+
+    #[async_std::test]
+    async fn basic_functionality() -> Result<()> {
+        let port = portpicker::pick_unused_port().unwrap();
+        let mut app = tide::new();
+        app.at("/").all(|mut r: tide::Request<()>| async move {
+            let mut response = tide::Response::new(http_types::StatusCode::Ok);
+            response.set_body(r.body_bytes().await.unwrap());
+            Ok(response)
+        });
+
+        let server = task::spawn(async move {
+            app.listen(("localhost", port)).await?;
+            Result::Ok(())
+        });
+
+        let client = task::spawn(async move {
+            task::sleep(Duration::from_millis(100)).await;
+            let request =
+                build_test_request(Url::parse(&format!("http://localhost:{}/", port)).unwrap());
+            let mut response: Response = H1Client::new().send(request).await?;
+            assert_eq!(response.body_string().await.unwrap(), "hello");
+            Ok(())
+        });
+
+        server.race(client).await?;
+
+        Ok(())
+    }
+}

src/isahc.rs

@@ -5,7 +5,6 @@ use super::{Body, HttpClient, Request, Response};
 use async_std::io::BufReader;
 use futures::future::BoxFuture;
 use isahc::http;
-
 use std::sync::Arc;
 
 /// Curl-based HTTP Client.
@@ -45,25 +44,83 @@ impl Clone for IsahcClient {
 impl HttpClient for IsahcClient {
     type Error = isahc::Error;
 
-    fn send(&self, req: Request) -> BoxFuture<'static, Result<Response, Self::Error>> {
+    fn send(&self, mut req: Request) -> BoxFuture<'static, Result<Response, Self::Error>> {
         let client = self.client.clone();
         Box::pin(async move {
-            let req_hyperium: http::Request<http_types::Body> = req.into();
-            let (parts, body) = req_hyperium.into_parts();
+            let mut builder = http::Request::builder()
+                .uri(req.url().as_str())
+                .method(http::Method::from_bytes(req.method().to_string().as_bytes()).unwrap());
+
+            for name in req.header_names() {
+                if let Some(value) = req.header(name) {
+                    builder = builder.header(name.as_str(), value.as_str());
+                }
+            }
+
+            let body = req.take_body();
+
             let body = match body.len() {
                 Some(len) => isahc::Body::from_reader_sized(body, len as u64),
                 None => isahc::Body::from_reader(body),
             };
-            let req: http::Request<isahc::Body> = http::Request::from_parts(parts, body);
-
-            let res = client.send_async(req).await?;
 
+            let request = builder.body(body).unwrap();
+            let res = client.send_async(request).await?;
             let (parts, body) = res.into_parts();
-
             let len = body.len().map(|len| len as usize);
             let body = Body::from_reader(BufReader::new(body), len);
-            let res = http::Response::from_parts(parts, body);
-            Ok(res.into())
+            let mut response = http_types::Response::new(parts.status.as_u16());
+            for (name, value) in &parts.headers {
+                response.insert_header(name.as_str(), value.to_str().unwrap());
+            }
+            response.set_body(body);
+            Ok(response)
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use async_std::prelude::*;
+    use async_std::task;
+    use http_types::url::Url;
+    use http_types::Result;
+    use std::time::Duration;
+
+    fn build_test_request(url: Url) -> Request {
+        let mut req = Request::new(http_types::Method::Post, url);
+        req.set_body("hello");
+        req.append_header("test", "value");
+        req
+    }
+
+    #[async_std::test]
+    async fn basic_functionality() -> Result<()> {
+        let port = portpicker::pick_unused_port().unwrap();
+        let mut app = tide::new();
+        app.at("/").all(|mut r: tide::Request<()>| async move {
+            let mut response = tide::Response::new(http_types::StatusCode::Ok);
+            response.set_body(r.body_bytes().await.unwrap());
+            Ok(response)
+        });
+
+        let server = task::spawn(async move {
+            app.listen(("localhost", port)).await?;
+            Result::Ok(())
+        });
+
+        let client = task::spawn(async move {
+            task::sleep(Duration::from_millis(100)).await;
+            let request =
+                build_test_request(Url::parse(&format!("http://localhost:{}/", port)).unwrap());
+            let mut response: Response = IsahcClient::new().send(request).await?;
+            assert_eq!(response.body_string().await.unwrap(), "hello");
+            Ok(())
+        });
+
+        server.race(client).await?;
+
+        Ok(())
+    }
+}

src/lib.rs

@@ -38,6 +38,8 @@ pub type Request = http_types::Request;
 /// An HTTP Response type with a streaming body.
 pub type Response = http_types::Response;
 
+pub use http_types;
+
 /// An abstract HTTP client.
 ///
 /// __note that this is only exposed for use in middleware. Building new backing clients is not