e2e test for chunked encoding from server

Author: dignifiedquire

Cargo.toml

@@ -24,3 +24,5 @@ log = "0.4"
 
 [dev-dependencies]
 pretty_assertions = "0.6.1"
+async-std = { version = "1.4.0", features = ["unstable", "attributes"] }
+tempfile = "3.1.0"

src/client.rs

@@ -68,7 +68,7 @@ pub async fn encode(req: Request) -> Result<Encoder, std::io::Error> {
     // If the body isn't streaming, we can set the content-length ahead of time. Else we need to
     // send all items in chunks.
     if let Some(len) = req.len() {
-        let val = format!("Content-Length: {}\r\n", len);
+        let val = format!("content-length: {}\r\n", len);
         log::trace!("> {}", &val);
         buf.write_all(val.as_bytes()).await?;
     } else {

src/server.rs

@@ -18,6 +18,9 @@ use crate::date::fmt_http_date;
 use crate::error::HttpError;
 use crate::{Exception, MAX_HEADERS};
 
+const CR: u8 = b'\r';
+const LF: u8 = b'\n';
+
 /// Parse an incoming HTTP connection.
 ///
 /// Supports `KeepAlive` requests by default.
@@ -35,6 +38,7 @@ where
     // Decode a request. This may be the first of many since the connection is Keep-Alive by default.
     let r = io.clone();
     let req = decode(addr, r).await?;
+
     if let Some(mut req) = req {
         loop {
             match num_requests {
@@ -113,13 +117,13 @@ impl Encoder {
         // If the body isn't streaming, we can set the content-length ahead of time. Else we need to
         // send all items in chunks.
         if let Some(len) = self.res.len() {
-            std::io::Write::write_fmt(&mut head, format_args!("Content-Length: {}\r\n", len))?;
+            std::io::Write::write_fmt(&mut head, format_args!("content-length: {}\r\n", len))?;
         } else {
-            std::io::Write::write_fmt(&mut head, format_args!("Transfer-Encoding: chunked\r\n"))?;
+            std::io::Write::write_fmt(&mut head, format_args!("transfer-encoding: chunked\r\n"))?;
         }
 
         let date = fmt_http_date(std::time::SystemTime::now());
-        std::io::Write::write_fmt(&mut head, format_args!("Date: {}\r\n", date))?;
+        std::io::Write::write_fmt(&mut head, format_args!("date: {}\r\n", date))?;
 
         for (header, values) in self.res.iter() {
             for value in values.iter() {
@@ -213,14 +217,15 @@ impl Read for Encoder {
                         body_bytes_read
                     );
                     // If we've read the `len` number of bytes, end
-                    self.state = if body_len == body_bytes_read {
-                        EncoderState::Done
+                    if body_len == body_bytes_read {
+                        self.state = EncoderState::Done;
+                        break;
                     } else {
-                        EncoderState::Body {
+                        self.state = EncoderState::Body {
                             body_bytes_read,
                             body_len,
                         }
-                    };
+                    }
                 }
                 EncoderState::UncomputedChunked => {
                     // We can read a maximum of the buffer's total size
@@ -261,8 +266,8 @@ impl Read for Encoder {
                         bytes_read += chunk_length_bytes_len;
 
                         // follow chunk length with CRLF
-                        buf[bytes_read] = b'\r';
-                        buf[bytes_read + 1] = b'\n';
+                        buf[bytes_read] = CR;
+                        buf[bytes_read + 1] = LF;
                         bytes_read += 2;
 
                         // copy chunk into buf
@@ -271,12 +276,13 @@ impl Read for Encoder {
                         bytes_read += chunk_length;
 
                         // follow chunk with CRLF
-                        buf[bytes_read] = b'\r';
-                        buf[bytes_read + 1] = b'\n';
+                        buf[bytes_read] = CR;
+                        buf[bytes_read + 1] = LF;
                         bytes_read += 2;
 
                         if chunk_length == 0 {
                             self.state = EncoderState::Done;
+                            break;
                         }
                     } else {
                         let mut chunk = vec![0; total_chunk_size];
@@ -286,8 +292,8 @@ impl Read for Encoder {
                         bytes_written += chunk_length_bytes_len;
 
                         // follow chunk length with CRLF
-                        chunk[bytes_written] = b'\r';
-                        chunk[bytes_written + 1] = b'\n';
+                        chunk[bytes_written] = CR;
+                        chunk[bytes_written + 1] = LF;
                         bytes_written += 2;
 
                         // copy chunk into buf
@@ -296,8 +302,8 @@ impl Read for Encoder {
                         bytes_written += chunk_length;
 
                         // follow chunk with CRLF
-                        chunk[bytes_written] = b'\r';
-                        chunk[bytes_written + 1] = b'\n';
+                        chunk[bytes_written] = CR;
+                        chunk[bytes_written + 1] = LF;
                         bytes_read += 2;
                         self.state = EncoderState::ComputedChunked {
                             chunk: io::Cursor::new(chunk),
@@ -341,7 +347,7 @@ where
 
     // Keep reading bytes from the stream until we hit the end of the stream.
     loop {
-        let bytes_read = reader.read_until(b'\n', &mut buf).await?;
+        let bytes_read = reader.read_until(LF, &mut buf).await?;
         // No more bytes are yielded from the stream.
         if bytes_read == 0 {
             return Ok(None);

tests/common/mod.rs

@@ -1,5 +1,4 @@
 use async_std::fs::File;
-use async_std::fs::OpenOptions;
 use async_std::io::{self, Read, SeekFrom, Write};
 use async_std::path::PathBuf;
 use async_std::sync::Arc;
@@ -33,15 +32,8 @@ impl TestCase {
                 ));
         let response_fixture = Arc::new(Mutex::new(response_fixture));
 
-        let temp = std::env::temp_dir().join("result.txt");
-        let temp = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(temp)
-            .await
-            .expect("Could not read temporary file where response will be written to");
-        let result = Arc::new(Mutex::new(temp));
+        let temp = tempfile::tempfile().expect("Failed to create tempfile");
+        let result = Arc::new(Mutex::new(temp.into()));
 
         TestCase {
             request_fixture,

tests/fixtures/request-chunked-basic.txt

@@ -0,0 +1,4 @@
+GET / HTTP/1.1
+Host: example.com
+User-Agent: curl/7.54.0
+

tests/fixtures/response-chunked-basic.txt

@@ -0,0 +1,13 @@
+HTTP/1.1 200 OK
+transfer-encoding: chunked
+date: {DATE}
+content-type: text/plain
+
+7
+Mozilla
+9
+Developer
+7
+Network
+0
+

tests/fixtures/response1.txt

@@ -1,5 +1,5 @@
 HTTP/1.1 200 OK
-Content-Length: 0
-Date: {DATE}
+content-length: 0
+date: {DATE}
 content-type: text/plain; charset=utf-8
 

tests/server.rs

@@ -1,23 +1,49 @@
-mod common;
 use async_h1::server;
-use async_std::task;
+use async_std::io::Cursor;
+use async_std::prelude::*;
 use common::TestCase;
-use http_types::{Response, StatusCode};
+use http_types::{mime, Body, Response, StatusCode};
+
+mod common;
+
+#[async_std::test]
+async fn test_basic_request() {
+    let case = TestCase::new("fixtures/request1.txt", "fixtures/response1.txt").await;
+    let addr = "http://example.com";
+
+    server::accept(addr, case.clone(), |_req| async {
+        let mut resp = Response::new(StatusCode::Ok);
+        resp.set_body("");
+        Ok(resp)
+    })
+    .await
+    .unwrap();
+
+    case.assert().await;
+}
 
-#[test]
-fn test_basic_request() {
-    task::block_on(async {
-        let case = TestCase::new("fixtures/request1.txt", "fixtures/response1.txt").await;
-        let addr = "http://example.com";
+#[async_std::test]
+async fn test_chunked_basic() {
+    let case = TestCase::new(
+        "fixtures/request-chunked-basic.txt",
+        "fixtures/response-chunked-basic.txt",
+    )
+    .await;
+    let addr = "http://example.com";
 
-        server::accept(addr, case.clone(), |_req| async {
-            let mut resp = Response::new(StatusCode::Ok);
-            resp.set_body("");
-            Ok(resp)
-        })
-        .await
-        .unwrap();
+    server::accept(addr, case.clone(), |_req| async {
+        let mut resp = Response::new(StatusCode::Ok);
+        resp.set_body(Body::from_reader(
+            Cursor::new(b"Mozilla")
+                .chain(Cursor::new(b"Developer"))
+                .chain(Cursor::new(b"Network")),
+            None,
+        ));
+        resp.set_content_type(mime::PLAIN);
+        Ok(resp)
+    })
+    .await
+    .unwrap();
 
-        case.assert().await;
-    });
+    case.assert().await;
 }