wreq-rb 0.3.0

data/vendor/wreq/tests/timeouts.rs

@@ -0,0 +1,281 @@
+mod support;
+use std::time::Duration;
+
+use pretty_env_logger::env_logger;
+use support::server;
+use wreq::Client;
+
+#[tokio::test]
+async fn client_timeout() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| {
+        async {
+            // delay returning the response
+            tokio::time::sleep(Duration::from_millis(300)).await;
+            http::Response::default()
+        }
+    });
+
+    let client = Client::builder()
+        .timeout(Duration::from_millis(100))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let url = format!("http://{}/slow", server.addr());
+    let err = client.get(&url).send().await.unwrap_err();
+
+    assert!(err.is_timeout());
+    assert_eq!(err.uri().map(|u| u.to_string()), Some(url));
+}
+
+#[tokio::test]
+async fn request_timeout() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| {
+        async {
+            // delay returning the response
+            tokio::time::sleep(Duration::from_millis(300)).await;
+            http::Response::default()
+        }
+    });
+
+    let client = Client::builder().no_proxy().build().unwrap();
+
+    let url = format!("http://{}/slow", server.addr());
+
+    let err = client
+        .get(&url)
+        .timeout(Duration::from_millis(100))
+        .send()
+        .await
+        .unwrap_err();
+
+    assert!(err.is_timeout() && !err.is_connect());
+    assert_eq!(err.uri().map(|u| u.to_string()), Some(url));
+}
+
+#[tokio::test]
+async fn connect_timeout() {
+    let _ = env_logger::try_init();
+
+    let client = Client::builder()
+        .connect_timeout(Duration::from_millis(100))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let url = "http://192.0.2.1:81/slow";
+
+    let err = client
+        .get(url)
+        .timeout(Duration::from_millis(1000))
+        .send()
+        .await
+        .unwrap_err();
+
+    assert!(err.is_timeout());
+}
+
+#[tokio::test]
+async fn connect_many_timeout_succeeds() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| async { http::Response::default() });
+    let port = server.addr().port();
+
+    let client = Client::builder()
+        .resolve_to_addrs(
+            "many_addrs",
+            ["127.0.0.1:81".parse().unwrap(), server.addr()],
+        )
+        .connect_timeout(Duration::from_millis(100))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let url = format!("http://many_addrs:{port}/eventual");
+
+    let _ = client
+        .get(url)
+        .timeout(Duration::from_millis(1000))
+        .send()
+        .await
+        .unwrap();
+}
+
+#[tokio::test]
+async fn connect_many_timeout() {
+    let _ = env_logger::try_init();
+
+    let client = Client::builder()
+        .resolve_to_addrs(
+            "many_addrs",
+            [
+                "192.0.2.1:81".parse().unwrap(),
+                "192.0.2.2:81".parse().unwrap(),
+            ],
+        )
+        .connect_timeout(Duration::from_millis(100))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let url = "http://many_addrs:81/slow".to_string();
+
+    let err = client
+        .get(url)
+        .timeout(Duration::from_millis(1000))
+        .send()
+        .await
+        .unwrap_err();
+
+    assert!(err.is_connect() && err.is_timeout());
+}
+
+#[cfg(feature = "stream")]
+#[tokio::test]
+async fn response_timeout() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| {
+        async {
+            // immediate response, but delayed body
+            let body = wreq::Body::wrap_stream(futures_util::stream::once(async {
+                tokio::time::sleep(Duration::from_secs(1)).await;
+                Ok::<_, std::convert::Infallible>("Hello")
+            }));
+
+            http::Response::new(body)
+        }
+    });
+
+    let client = Client::builder()
+        .timeout(Duration::from_millis(500))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let url = format!("http://{}/slow", server.addr());
+    let res = client.get(&url).send().await.expect("Failed to get");
+    let err = res.text().await.unwrap_err();
+
+    assert!(err.is_timeout());
+}
+
+#[tokio::test]
+async fn read_timeout_applies_to_headers() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| {
+        async {
+            // delay returning the response
+            tokio::time::sleep(Duration::from_millis(300)).await;
+            http::Response::default()
+        }
+    });
+
+    let client = Client::builder()
+        .read_timeout(Duration::from_millis(100))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let url = format!("http://{}/slow", server.addr());
+
+    let err = client.get(&url).send().await.unwrap_err();
+
+    assert!(err.is_timeout());
+    assert_eq!(err.uri().map(|u| u.to_string()), Some(url));
+}
+
+#[cfg(feature = "stream")]
+#[tokio::test]
+async fn read_timeout_applies_to_body() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| {
+        async {
+            // immediate response, but delayed body
+            let body = wreq::Body::wrap_stream(futures_util::stream::once(async {
+                tokio::time::sleep(Duration::from_millis(300)).await;
+                Ok::<_, std::convert::Infallible>("Hello")
+            }));
+
+            http::Response::new(body)
+        }
+    });
+
+    let client = Client::builder()
+        .read_timeout(Duration::from_millis(100))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let url = format!("http://{}/slow", server.addr());
+    let res = client.get(&url).send().await.expect("Failed to get");
+    let err = res.text().await.unwrap_err();
+
+    assert!(err.is_timeout());
+}
+
+#[cfg(feature = "stream")]
+#[tokio::test]
+async fn read_timeout_allows_slow_response_body() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| {
+        async {
+            // immediate response, but body that has slow chunks
+            let slow = futures_util::stream::unfold(0, |state| async move {
+                if state < 3 {
+                    tokio::time::sleep(Duration::from_millis(100)).await;
+                    Some((
+                        Ok::<_, std::convert::Infallible>(state.to_string()),
+                        state + 1,
+                    ))
+                } else {
+                    None
+                }
+            });
+            let body = wreq::Body::wrap_stream(slow);
+
+            http::Response::new(body)
+        }
+    });
+
+    let client = Client::builder()
+        .read_timeout(Duration::from_millis(200))
+        //.timeout(Duration::from_millis(200))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let url = format!("http://{}/slow", server.addr());
+    let res = client.get(&url).send().await.expect("Failed to get");
+    let body = res.text().await.expect("body text");
+
+    assert_eq!(body, "012");
+}
+
+#[tokio::test]
+async fn response_body_timeout_forwards_size_hint() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| async { http::Response::new(b"hello".to_vec().into()) });
+
+    let client = Client::builder().no_proxy().build().unwrap();
+
+    let url = format!("http://{}/slow", server.addr());
+
+    let res = client
+        .get(&url)
+        .timeout(Duration::from_secs(1))
+        .send()
+        .await
+        .expect("response");
+
+    assert_eq!(res.content_length(), Some(5));
+}

data/vendor/wreq/tests/unix_socket.rs

@@ -0,0 +1,135 @@
+#![cfg(unix)]
+
+use std::{hash::BuildHasher, time::Duration};
+
+use http::Method;
+use http_body_util::Full;
+use hyper::{Request, Response, body::Incoming, service::service_fn};
+use hyper_util::{
+    rt::{TokioExecutor, TokioIo},
+    server::conn::auto::Builder,
+};
+use tokio::{net::UnixListener, task};
+use wreq::{Client, Proxy};
+
+fn random_sock_path() -> std::path::PathBuf {
+    let mut buf = std::env::temp_dir();
+    // libstd uses system random to create each one
+    let rng = std::collections::hash_map::RandomState::new();
+    let n = rng.hash_one("uds-sock");
+    buf.push(format!("test-uds-sock-{}", n));
+    buf
+}
+
+#[tokio::test]
+async fn test_unix_socket() {
+    let sock_path = random_sock_path();
+
+    let listener = UnixListener::bind(&sock_path).unwrap();
+    let server = async move {
+        loop {
+            let (stream, _) = listener.accept().await.unwrap();
+            let io = TokioIo::new(stream);
+            let service = service_fn(|_req: Request<Incoming>| async {
+                Ok::<_, hyper::Error>(Response::new(Full::new(&b"hello unix"[..])))
+            });
+            task::spawn(async move {
+                if let Err(e) = hyper::server::conn::http1::Builder::new()
+                    .serve_connection(io, service)
+                    .await
+                {
+                    eprintln!("server error: {:?}", e);
+                }
+            });
+        }
+    };
+    tokio::spawn(server);
+
+    let client = Client::builder()
+        .proxy(Proxy::unix(sock_path).unwrap())
+        .timeout(Duration::from_secs(10))
+        .build()
+        .unwrap();
+
+    let resp = client.get("http://localhost/").send().await.unwrap();
+    let body = resp.text().await.unwrap();
+    assert_eq!(body, "hello unix");
+}
+
+#[tokio::test]
+async fn test_proxy_unix_socket() {
+    let sock_path = random_sock_path();
+
+    let listener = UnixListener::bind(&sock_path).unwrap();
+    let server = async move {
+        loop {
+            let (stream, _) = listener.accept().await.unwrap();
+            let io = TokioIo::new(stream);
+            let service = service_fn(|req: Request<Incoming>| {
+                async move {
+                    if Method::CONNECT == req.method() {
+                        // Received an HTTP request like:
+                        // ```
+                        // CONNECT www.domain.com:443 HTTP/1.1
+                        // Host: www.domain.com:443
+                        // Proxy-Connection: Keep-Alive
+                        // ```
+                        //
+                        // When HTTP method is CONNECT we should return an empty body,
+                        // then we can eventually upgrade the connection and talk a new protocol.
+                        //
+                        // Note: only after client received an empty body with STATUS_OK can the
+                        // connection be upgraded, so we can't return a response inside
+                        // `on_upgrade` future.
+                        let authority = req.uri().authority().cloned().unwrap();
+                        tokio::task::spawn({
+                            let req = req;
+                            async move {
+                                match hyper::upgrade::on(req).await {
+                                    Ok(upgraded) => {
+                                        tracing::info!("upgraded connection to: {}", authority);
+                                        if let Ok(mut io) =
+                                            tokio::net::TcpStream::connect(authority.to_string())
+                                                .await
+                                        {
+                                            let _ = tokio::io::copy_bidirectional(
+                                                &mut TokioIo::new(upgraded),
+                                                &mut io,
+                                            )
+                                            .await;
+                                        }
+                                    }
+                                    Err(e) => tracing::warn!("upgrade error: {}", e),
+                                }
+                            }
+                        });
+
+                        Ok::<_, hyper::Error>(Response::new(Full::new(&b""[..])))
+                    } else {
+                        Ok::<_, hyper::Error>(Response::new(Full::new(
+                            &b"unsupported request method"[..],
+                        )))
+                    }
+                }
+            });
+            task::spawn(async move {
+                if let Err(e) = Builder::new(TokioExecutor::new())
+                    .serve_connection_with_upgrades(io, service)
+                    .await
+                {
+                    eprintln!("server error: {:?}", e);
+                }
+            });
+        }
+    };
+    tokio::spawn(server);
+
+    let client = Client::builder()
+        .proxy(Proxy::unix(sock_path).unwrap())
+        .timeout(Duration::from_secs(10))
+        .build()
+        .unwrap();
+
+    let resp = client.get("https://www.google.com").send().await.unwrap();
+    assert!(resp.status().is_success(), "Expected successful response");
+}

data/vendor/wreq/tests/upgrade.rs

@@ -0,0 +1,98 @@
+mod support;
+use http::Method;
+use support::server;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use wreq::Client;
+
+#[tokio::test]
+async fn http_upgrade() {
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "GET");
+        assert_eq!(req.headers()["connection"], "upgrade");
+        assert_eq!(req.headers()["upgrade"], "foobar");
+
+        tokio::spawn(async move {
+            let mut upgraded = hyper_util::rt::TokioIo::new(hyper::upgrade::on(req).await.unwrap());
+
+            let mut buf = vec![0; 7];
+            upgraded.read_exact(&mut buf).await.unwrap();
+            assert_eq!(buf, b"foo=bar");
+
+            upgraded.write_all(b"bar=foo").await.unwrap();
+        });
+
+        async {
+            http::Response::builder()
+                .status(http::StatusCode::SWITCHING_PROTOCOLS)
+                .header(http::header::CONNECTION, "upgrade")
+                .header(http::header::UPGRADE, "foobar")
+                .body(wreq::Body::default())
+                .unwrap()
+        }
+    });
+
+    let res = Client::builder()
+        .build()
+        .unwrap()
+        .get(format!("http://{}", server.addr()))
+        .header(http::header::CONNECTION, "upgrade")
+        .header(http::header::UPGRADE, "foobar")
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.status(), http::StatusCode::SWITCHING_PROTOCOLS);
+    let mut upgraded = res.upgrade().await.unwrap();
+
+    upgraded.write_all(b"foo=bar").await.unwrap();
+
+    let mut buf = vec![];
+    upgraded.read_to_end(&mut buf).await.unwrap();
+    assert_eq!(buf, b"bar=foo");
+}
+
+#[tokio::test]
+async fn http2_upgrade() {
+    let server = server::http_with_config(
+        move |req| {
+            assert_eq!(req.method(), http::Method::CONNECT);
+            assert_eq!(req.version(), http::Version::HTTP_2);
+
+            tokio::spawn(async move {
+                let mut upgraded =
+                    hyper_util::rt::TokioIo::new(hyper::upgrade::on(req).await.unwrap());
+
+                let mut buf = vec![0; 7];
+                upgraded.read_exact(&mut buf).await.unwrap();
+                assert_eq!(buf, b"foo=bar");
+
+                upgraded.write_all(b"bar=foo").await.unwrap();
+            });
+
+            async { Ok::<_, std::convert::Infallible>(http::Response::default()) }
+        },
+        |builder| {
+            let mut http2 = builder.http2();
+            http2.enable_connect_protocol();
+        },
+    );
+
+    let res = Client::builder()
+        .http2_only()
+        .build()
+        .unwrap()
+        .request(Method::CONNECT, format!("http://{}", server.addr()))
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.status(), http::StatusCode::OK);
+    assert_eq!(res.version(), http::Version::HTTP_2);
+    let mut upgraded = res.upgrade().await.unwrap();
+
+    upgraded.write_all(b"foo=bar").await.unwrap();
+
+    let mut buf = vec![];
+    upgraded.read_to_end(&mut buf).await.unwrap();
+    assert_eq!(buf, b"bar=foo");
+}