Merge pull request #50 from yoshuawuyts/connect

Implement client::connect

Author: yoshuawuyts

examples/client.rs

@@ -20,11 +20,7 @@ fn main() -> Result<(), Error> {
             println!("making request {}/2", i + 1);
             let url = Url::parse(&format!("http://{}/foo", peer_addr)).unwrap();
             let req = Request::new(Method::Get, dbg!(url));
-            let mut req = client::encode(req).await?;
-            io::copy(&mut req, &mut stream.clone()).await?;
-
-            // read the response
-            let res = client::decode(stream.clone()).await?;
+            let res = client::connect(stream.clone(), req).await?;
             println!("{:?}", res);
         }
         Ok(())

src/client.rs

@@ -1,6 +1,6 @@
 //! Process HTTP connections on the client.
 
-use async_std::io::{self, BufReader, Read};
+use async_std::io::{self, BufReader, Read, Write};
 use async_std::prelude::*;
 use async_std::task::{Context, Poll};
 use futures_core::ready;
@@ -48,6 +48,22 @@ impl Encoder {
     }
 }
 
+/// Send an HTTP request over a stream.
+pub async fn connect<RW>(mut stream: RW, req: Request) -> Result<Response, Error>
+where
+    RW: Read + Write + Send + Sync + Unpin + 'static,
+{
+    let mut req = encode(req).await?;
+    log::trace!("> {:?}", &req);
+
+    io::copy(&mut req, &mut stream).await?;
+
+    let res = decode(stream).await?;
+    log::trace!("< {:?}", &res);
+
+    Ok(res)
+}
+
 /// Encode an HTTP request on the client.
 pub async fn encode(req: Request) -> Result<Encoder, Error> {
     let mut buf: Vec<u8> = vec![];
@@ -75,8 +91,12 @@ pub async fn encode(req: Request) -> Result<Encoder, Error> {
             StatusCode::BadRequest,
         )
     })?;
+    let val = if let Some(port) = req.url().port() {
+        format!("host: {}:{}\r\n", host, port)
+    } else {
+        format!("host: {}\r\n", host)
+    };
 
-    let val = format!("host: {}\r\n", host);
     log::trace!("> {}", &val);
     buf.write_all(val.as_bytes()).await?;
 

tests/client.rs

@@ -1,32 +1,27 @@
-use crate::common::{fixture_path, munge_date};
+use crate::common::fixture_path;
 use async_h1::client;
 use async_std::fs::File;
 use async_std::io::SeekFrom;
 use async_std::prelude::*;
-use http_types::{headers, Method, Request};
+use http_types::{headers, Method, Request, StatusCode};
 use url::Url;
 
 mod common;
 
+use common::TestCase;
+
 #[async_std::test]
 async fn test_encode_request_add_date() {
-    let mut request_fixture = File::open(fixture_path("fixtures/client-request1.txt"))
-        .await
-        .unwrap();
-    let mut expected = String::new();
-    request_fixture.read_to_string(&mut expected).await.unwrap();
-
-    let url = Url::parse("http://example.com").unwrap();
-    let req = Request::new(Method::Get, url);
-
-    let mut encoded_req = client::encode(req).await.unwrap();
+    let case = TestCase::new_client("fixtures/request1.txt", "fixtures/response1.txt").await;
 
-    let mut actual = String::new();
-    encoded_req.read_to_string(&mut actual).await.unwrap();
+    let url = Url::parse("http://localhost:8080").unwrap();
+    let mut req = Request::new(Method::Post, url);
+    req.set_body("hello");
 
-    munge_date(&mut expected, &mut actual);
+    let res = client::connect(case.clone(), req).await.unwrap();
+    assert_eq!(res.status(), StatusCode::Ok);
 
-    pretty_assertions::assert_eq!(actual, expected);
+    case.assert().await;
 }
 
 #[async_std::test]

tests/common/mod.rs

@@ -6,22 +6,41 @@ use async_std::task::{Context, Poll};
 use std::pin::Pin;
 use std::sync::Mutex;
 
+#[derive(Debug, Copy, Clone)]
+#[allow(dead_code)]
+enum Direction {
+    Client,
+    Server,
+}
+
 #[derive(Clone)]
 pub struct TestCase {
-    request_fixture: Arc<File>,
-    response_fixture: Arc<Mutex<File>>,
+    direction: Direction,
+    source_fixture: Arc<File>,
+    expected_fixture: Arc<Mutex<File>>,
     result: Arc<Mutex<File>>,
 }
 
 impl TestCase {
-    pub async fn new(request_file_path: &str, response_file_path: &str) -> TestCase {
+    pub async fn new_server(request_file_path: &str, response_file_path: &str) -> TestCase {
+        Self::new(Direction::Server, request_file_path, response_file_path).await
+    }
+
+    pub async fn new_client(request_file_path: &str, response_file_path: &str) -> TestCase {
+        Self::new(Direction::Client, request_file_path, response_file_path).await
+    }
+
+    async fn new(
+        direction: Direction,
+        request_file_path: &str,
+        response_file_path: &str,
+    ) -> TestCase {
         let request_fixture = File::open(fixture_path(&request_file_path))
             .await
             .expect(&format!(
                 "Could not open request fixture file: {:?}",
                 &fixture_path(request_file_path)
             ));
-        let request_fixture = Arc::new(request_fixture);
 
         let response_fixture =
             File::open(fixture_path(&response_file_path))
@@ -30,14 +49,19 @@ impl TestCase {
                     "Could not open response fixture file: {:?}",
                     &fixture_path(response_file_path)
                 ));
-        let response_fixture = Arc::new(Mutex::new(response_fixture));
 
         let temp = tempfile::tempfile().expect("Failed to create tempfile");
         let result = Arc::new(Mutex::new(temp.into()));
 
+        let (source_fixture, expected_fixture) = match direction {
+            Direction::Client => (response_fixture, request_fixture),
+            Direction::Server => (request_fixture, response_fixture),
+        };
+
         TestCase {
-            request_fixture,
-            response_fixture,
+            direction,
+            source_fixture: Arc::new(source_fixture),
+            expected_fixture: Arc::new(Mutex::new(expected_fixture)),
             result,
         }
     }
@@ -54,7 +78,7 @@ impl TestCase {
     pub async fn read_expected(&self) -> String {
         use async_std::prelude::*;
         let mut expected = std::string::String::new();
-        self.response_fixture
+        self.expected_fixture
             .lock()
             .unwrap()
             .read_to_string(&mut expected)
@@ -83,13 +107,13 @@ pub(crate) fn fixture_path(relative_path: &str) -> PathBuf {
 pub(crate) fn munge_date(expected: &mut String, actual: &mut String) {
     match expected.find("{DATE}") {
         Some(i) => {
-            expected.replace_range(i..i + 6, "");
-            match expected.get(i..i + 1) {
-                Some(byte) => {
-                    let j = actual[i..].find(byte).expect("Byte not found");
-                    actual.replace_range(i..i + j, "");
+            println!("{}", expected);
+            match actual.find("date: ") {
+                Some(j) => {
+                    let eol = actual[j + 6..].find("\r\n").expect("missing eol");
+                    expected.replace_range(i..i + 6, &actual[j + 6..j + 6 + eol]);
                 }
-                None => expected.replace_range(i.., ""),
+                None => expected.replace_range(i..i + 6, ""),
             }
         }
         None => {}
@@ -102,7 +126,7 @@ impl Read for TestCase {
         cx: &mut Context,
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut &*self.request_fixture).poll_read(cx, buf)
+        Pin::new(&mut &*self.source_fixture).poll_read(cx, buf)
     }
 }
 

tests/fixtures/request1.txt

@@ -1,7 +1,7 @@
 POST / HTTP/1.1
 host: localhost:8080
-user-agent: curl/7.54.0
-accept: */*
-content-length: 2
-content-type: application/x-www-form-urlencoded
+content-length: 5
+date: {DATE}
+content-type: text/plain; charset=utf-8
 
+hello

tests/server.rs

@@ -8,7 +8,7 @@ mod common;
 
 #[async_std::test]
 async fn test_basic_request() {
-    let case = TestCase::new("fixtures/request1.txt", "fixtures/response1.txt").await;
+    let case = TestCase::new_server("fixtures/request1.txt", "fixtures/response1.txt").await;
     let addr = "http://example.com";
 
     server::accept(addr, case.clone(), |_req| async {
@@ -24,7 +24,7 @@ async fn test_basic_request() {
 
 #[async_std::test]
 async fn test_chunked_basic() {
-    let case = TestCase::new(
+    let case = TestCase::new_server(
         "fixtures/request-chunked-basic.txt",
         "fixtures/response-chunked-basic.txt",
     )
@@ -50,7 +50,7 @@ async fn test_chunked_basic() {
 
 #[async_std::test]
 async fn test_chunked_echo() {
-    let case = TestCase::new(
+    let case = TestCase::new_server(
         "fixtures/request-chunked-echo.txt",
         "fixtures/response-chunked-echo.txt",
     )