Merge branch 'master' into release-2.0

src/test/timeout.rs

@@ -19,7 +19,7 @@ fn dribble_body_respond(mut stream: TcpStream, contents: &[u8]) -> io::Result<()
         stream.write_all(&contents[i..i + 1])?;
         stream.write_all(&[b'\n'; 1])?;
         stream.flush()?;
-        thread::sleep(Duration::from_millis(10));
+        thread::sleep(Duration::from_millis(100));
     }
     Ok(())
 }
@@ -47,17 +47,38 @@ fn overall_timeout_during_body() {
     get_and_expect_timeout(url);
 }
 
+#[test]
+fn read_timeout_during_body() {
+    let server = TestServer::new(|stream| dribble_body_respond(stream, &[b'a'; 300]));
+    let url = format!("http://localhost:{}/", server.port);
+    let agent = builder().timeout_read(Duration::from_millis(70)).build();
+    let resp = match agent.get(&url).call() {
+        Ok(r) => r,
+        Err(e) => panic!("got error during headers, not body: {:?}", e),
+    };
+    match resp.into_string() {
+        Err(io_error) => match io_error.kind() {
+            io::ErrorKind::TimedOut => Ok(()),
+            _ => Err(format!("{:?}", io_error)),
+        },
+        Ok(_) => Err("successful response".to_string()),
+    }
+    .expect("expected timeout but got something else");
+}
+
 // Send HTTP headers on the TcpStream at a rate of one header every 100
 // milliseconds, for a total of 30 headers.
-//fn dribble_headers_respond(mut stream: TcpStream) -> io::Result<()> {
-//    stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n")?;
-//    for _ in 0..30 {
-//        stream.write_all(b"a: b\n")?;
-//        stream.flush()?;
-//        thread::sleep(Duration::from_millis(100));
-//    }
-//    Ok(())
-//}
+fn dribble_headers_respond(mut stream: TcpStream) -> io::Result<()> {
+    stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n")?;
+    for _ in 0..30 {
+        stream.write_all(b"a: b\r\n")?;
+        stream.flush()?;
+        thread::sleep(Duration::from_millis(100));
+    }
+    stream.write_all(b"\r\n")?;
+
+    Ok(())
+}
 
 #[test]
 // TODO: Our current behavior is actually incorrect (we'll return BadHeader if a timeout occurs during headers).
@@ -70,6 +91,35 @@ fn overall_timeout_during_body() {
 //    let url = format!("http://localhost:{}/", server.port);
 //    get_and_expect_timeout(url);
 //}
+#[test]
+fn read_timeout_during_headers() {
+    let server = TestServer::new(dribble_headers_respond);
+    let url = format!("http://localhost:{}/", server.port);
+    let agent = builder().timeout_read(Duration::from_millis(10)).build();
+    let resp = agent.get(&url).call();
+    match resp {
+        Ok(_) => Err("successful response".to_string()),
+        Err(Error::Io(e)) if e.kind() == io::ErrorKind::TimedOut => Ok(()),
+        Err(e) => Err(format!("Unexpected error type: {:?}", e)),
+    }
+    .expect("expected timeout but got something else");
+}
+
+#[test]
+fn overall_timeout_during_headers() {
+    // Start a test server on an available port, that dribbles out a response at 1 write per 10ms.
+    let server = TestServer::new(dribble_headers_respond);
+    let url = format!("http://localhost:{}/", server.port);
+    let agent = builder().timeout(Duration::from_millis(500)).build();
+    let resp = agent.get(&url).call();
+    match resp {
+        Ok(_) => Err("successful response".to_string()),
+        Err(Error::Io(e)) if e.kind() == io::ErrorKind::TimedOut => Ok(()),
+        Err(e) => Err(format!("Unexpected error type: {:?}", e)),
+    }
+    .expect("expected timeout but got something else");
+}
+
 #[test]
 #[cfg(feature = "json")]
 fn overall_timeout_reading_json() {