wreq-rb 0.3.0

data/vendor/wreq/tests/connector_layers.rs

@@ -0,0 +1,227 @@
+mod support;
+
+use std::time::Duration;
+
+use futures_util::future::join_all;
+use pretty_env_logger::env_logger;
+use support::{layer::DelayLayer, server};
+use tower::{layer::util::Identity, limit::ConcurrencyLimitLayer, timeout::TimeoutLayer};
+use wreq::Client;
+
+#[tokio::test]
+async fn non_op_layer() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| async { http::Response::default() });
+
+    let url = format!("http://{}", server.addr());
+
+    let client = Client::builder()
+        .connector_layer(Identity::new())
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let res = client.get(url).send().await;
+
+    assert!(res.is_ok());
+}
+
+#[tokio::test]
+async fn non_op_layer_with_timeout() {
+    let _ = env_logger::try_init();
+
+    let client = Client::builder()
+        .connector_layer(Identity::new())
+        .connect_timeout(Duration::from_millis(200))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    // never returns
+    let url = "http://192.0.2.1:81/slow";
+
+    let res = client.get(url).send().await;
+
+    let err = res.unwrap_err();
+
+    assert!(err.is_connect() && err.is_timeout());
+}
+
+#[tokio::test]
+async fn with_connect_timeout_layer_never_returning() {
+    let _ = env_logger::try_init();
+
+    let client = Client::builder()
+        .connector_layer(TimeoutLayer::new(Duration::from_millis(100)))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    // never returns
+    let url = "http://192.0.2.1:81/slow";
+
+    let res = client.get(url).send().await;
+
+    let err = res.unwrap_err();
+
+    assert!(err.is_connect() && err.is_timeout());
+}
+
+#[tokio::test]
+async fn with_connect_timeout_layer_slow() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| async { http::Response::default() });
+
+    let url = format!("http://{}", server.addr());
+
+    let client = Client::builder()
+        .connector_layer(DelayLayer::new(Duration::from_millis(200)))
+        .connector_layer(TimeoutLayer::new(Duration::from_millis(100)))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let res = client.get(url).send().await;
+
+    let err = res.unwrap_err();
+
+    assert!(err.is_connect() && err.is_timeout());
+}
+
+#[tokio::test]
+async fn multiple_timeout_layers_under_threshold() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| async { http::Response::default() });
+
+    let url = format!("http://{}", server.addr());
+
+    let client = Client::builder()
+        .connector_layer(DelayLayer::new(Duration::from_millis(100)))
+        .connector_layer(TimeoutLayer::new(Duration::from_millis(200)))
+        .connector_layer(TimeoutLayer::new(Duration::from_millis(300)))
+        .connector_layer(TimeoutLayer::new(Duration::from_millis(500)))
+        .connect_timeout(Duration::from_millis(200))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let res = client.get(url).send().await;
+
+    assert!(res.is_ok());
+}
+
+#[tokio::test]
+async fn multiple_timeout_layers_over_threshold() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| async { http::Response::default() });
+
+    let url = format!("http://{}", server.addr());
+
+    let client = Client::builder()
+        .connector_layer(DelayLayer::new(Duration::from_millis(100)))
+        .connector_layer(TimeoutLayer::new(Duration::from_millis(50)))
+        .connector_layer(TimeoutLayer::new(Duration::from_millis(50)))
+        .connector_layer(TimeoutLayer::new(Duration::from_millis(50)))
+        .connect_timeout(Duration::from_millis(50))
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let res = client.get(url).send().await;
+
+    let err = res.unwrap_err();
+
+    assert!(err.is_connect() && err.is_timeout());
+}
+
+#[tokio::test]
+async fn with_concurrency_limit_layer_timeout() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| async { http::Response::default() });
+
+    let url = format!("http://{}", server.addr());
+
+    let client = Client::builder()
+        .connector_layer(DelayLayer::new(Duration::from_millis(100)))
+        .connector_layer(ConcurrencyLimitLayer::new(1))
+        .timeout(Duration::from_millis(200))
+        .pool_max_idle_per_host(0) // disable connection reuse to force resource contention on the concurrency limit semaphore
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    // first call succeeds since no resource contention
+    let res = client.get(url.clone()).send().await;
+    assert!(res.is_ok());
+
+    // 3 calls where the second two wait on the first and time out
+    let mut futures = Vec::new();
+    for _ in 0..3 {
+        futures.push(client.clone().get(url.clone()).send());
+    }
+
+    let all_res = join_all(futures).await;
+
+    let timed_out = all_res
+        .into_iter()
+        .any(|res| res.is_err_and(|err| err.is_timeout()));
+
+    assert!(timed_out, "at least one request should have timed out");
+}
+
+#[tokio::test]
+async fn with_concurrency_limit_layer_success() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| async { http::Response::default() });
+
+    let url = format!("http://{}", server.addr());
+
+    let client = Client::builder()
+        .connector_layer(DelayLayer::new(Duration::from_millis(100)))
+        .connector_layer(TimeoutLayer::new(Duration::from_millis(200)))
+        .connector_layer(ConcurrencyLimitLayer::new(1))
+        .timeout(Duration::from_millis(1000))
+        .pool_max_idle_per_host(0) // disable connection reuse to force resource contention on the concurrency limit semaphore
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    // first call succeeds since no resource contention
+    let res = client.get(url.clone()).send().await;
+    assert!(res.is_ok());
+
+    // 3 calls of which all are individually below the inner timeout
+    // and the sum is below outer timeout which affects the final call which waited the whole time
+    let mut futures = Vec::new();
+    for _ in 0..3 {
+        futures.push(client.clone().get(url.clone()).send());
+    }
+
+    let all_res = join_all(futures).await;
+
+    for res in all_res.into_iter() {
+        assert!(
+            res.is_ok(),
+            "neither outer long timeout or inner short timeout should be exceeded"
+        );
+    }
+}
+
+#[tokio::test]
+async fn no_generic_bounds_required_for_client_new() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| async { http::Response::default() });
+
+    let url = format!("http://{}", server.addr());
+
+    let res = wreq::get(url).send().await;
+
+    assert!(res.is_ok());
+}

data/vendor/wreq/tests/cookie.rs

@@ -0,0 +1,306 @@
+mod support;
+use std::sync::Arc;
+
+use http::header::COOKIE;
+use support::server;
+use wreq::{Client, cookie::Jar};
+
+#[tokio::test]
+async fn cookie_response_accessor() {
+    let server = server::http(move |_req| async move {
+        http::Response::builder()
+            .header("Set-Cookie", "key=val")
+            .header(
+                "Set-Cookie",
+                "expires=1; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
+            )
+            .header("Set-Cookie", "path=1; Path=/the-path")
+            .header("Set-Cookie", "maxage=1; Max-Age=100")
+            .header("Set-Cookie", "domain=1; Domain=mydomain")
+            .header("Set-Cookie", "secure=1; Secure")
+            .header("Set-Cookie", "httponly=1; HttpOnly")
+            .header("Set-Cookie", "samesitelax=1; SameSite=Lax")
+            .header("Set-Cookie", "samesitestrict=1; SameSite=Strict")
+            .body(Default::default())
+            .unwrap()
+    });
+
+    let url = format!("http://{}/", server.addr());
+    let res = wreq::get(&url).send().await.unwrap();
+
+    let cookies = res.cookies().collect::<Vec<_>>();
+
+    // key=val
+    assert_eq!(cookies[0].name(), "key");
+    assert_eq!(cookies[0].value(), "val");
+
+    // expires
+    assert_eq!(cookies[1].name(), "expires");
+    assert_eq!(
+        cookies[1].expires().unwrap(),
+        std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(1_445_412_480)
+    );
+
+    // path
+    assert_eq!(cookies[2].name(), "path");
+    assert_eq!(cookies[2].path().unwrap(), "/the-path");
+
+    // max-age
+    assert_eq!(cookies[3].name(), "maxage");
+    assert_eq!(
+        cookies[3].max_age().unwrap(),
+        std::time::Duration::from_secs(100)
+    );
+
+    // domain
+    assert_eq!(cookies[4].name(), "domain");
+    assert_eq!(cookies[4].domain().unwrap(), "mydomain");
+
+    // secure
+    assert_eq!(cookies[5].name(), "secure");
+    assert!(cookies[5].secure());
+
+    // httponly
+    assert_eq!(cookies[6].name(), "httponly");
+    assert!(cookies[6].http_only());
+
+    // samesitelax
+    assert_eq!(cookies[7].name(), "samesitelax");
+    assert!(cookies[7].same_site_lax());
+
+    // samesitestrict
+    assert_eq!(cookies[8].name(), "samesitestrict");
+    assert!(cookies[8].same_site_strict());
+}
+
+#[tokio::test]
+async fn cookie_store_simple() {
+    let server = server::http(move |req| async move {
+        if req.uri() == "/2" {
+            assert_eq!(req.headers()["cookie"], "key=val");
+        }
+        http::Response::builder()
+            .header("Set-Cookie", "key=val; HttpOnly")
+            .body(Default::default())
+            .unwrap()
+    });
+
+    let client = Client::builder().cookie_store(true).build().unwrap();
+
+    let url = format!("http://{}/", server.addr());
+    client.get(&url).send().await.unwrap();
+
+    let url = format!("http://{}/2", server.addr());
+    client.get(&url).send().await.unwrap();
+}
+
+#[tokio::test]
+async fn cookie_store_overwrite_existing() {
+    let server = server::http(move |req| async move {
+        if req.uri() == "/" {
+            http::Response::builder()
+                .header("Set-Cookie", "key=val")
+                .body(Default::default())
+                .unwrap()
+        } else if req.uri() == "/2" {
+            assert_eq!(req.headers()["cookie"], "key=val");
+            http::Response::builder()
+                .header("Set-Cookie", "key=val2")
+                .body(Default::default())
+                .unwrap()
+        } else {
+            assert_eq!(req.uri(), "/3");
+            assert_eq!(req.headers()["cookie"], "key=val2");
+            http::Response::default()
+        }
+    });
+
+    let client = Client::builder().cookie_store(true).build().unwrap();
+
+    let url = format!("http://{}/", server.addr());
+    client.get(&url).send().await.unwrap();
+
+    let url = format!("http://{}/2", server.addr());
+    client.get(&url).send().await.unwrap();
+
+    let url = format!("http://{}/3", server.addr());
+    client.get(&url).send().await.unwrap();
+}
+
+#[tokio::test]
+async fn cookie_store_max_age() {
+    let server = server::http(move |req| async move {
+        assert_eq!(req.headers().get("cookie"), None);
+        http::Response::builder()
+            .header("Set-Cookie", "key=val; Max-Age=0")
+            .body(Default::default())
+            .unwrap()
+    });
+
+    let client = Client::builder().cookie_store(true).build().unwrap();
+    let url = format!("http://{}/", server.addr());
+    client.get(&url).send().await.unwrap();
+    client.get(&url).send().await.unwrap();
+}
+
+#[tokio::test]
+async fn cookie_store_expires() {
+    let server = server::http(move |req| async move {
+        assert_eq!(req.headers().get("cookie"), None);
+        http::Response::builder()
+            .header(
+                "Set-Cookie",
+                "key=val; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
+            )
+            .body(Default::default())
+            .unwrap()
+    });
+
+    let client = Client::builder().cookie_store(true).build().unwrap();
+
+    let url = format!("http://{}/", server.addr());
+    client.get(&url).send().await.unwrap();
+    client.get(&url).send().await.unwrap();
+}
+
+#[tokio::test]
+async fn cookie_store_path() {
+    let server = server::http(move |req| async move {
+        if req.uri() == "/" {
+            assert_eq!(req.headers().get("cookie"), None);
+            http::Response::builder()
+                .header("Set-Cookie", "key=val; Path=/subpath")
+                .body(Default::default())
+                .unwrap()
+        } else {
+            assert_eq!(req.uri(), "/subpath");
+            assert_eq!(req.headers()["cookie"], "key=val");
+            http::Response::default()
+        }
+    });
+
+    let client = Client::builder().cookie_store(true).build().unwrap();
+
+    let url = format!("http://{}/", server.addr());
+    client.get(&url).send().await.unwrap();
+    client.get(&url).send().await.unwrap();
+
+    let url = format!("http://{}/subpath", server.addr());
+    client.get(&url).send().await.unwrap();
+}
+
+#[tokio::test]
+async fn cookie_store_stores_response_cookie_with_manual_cookie() {
+    let server = server::http(|req| async move {
+        if req.uri() == "/1" {
+            assert_eq!(req.headers()["cookie"], "key=val");
+        }
+
+        if req.uri() == "/2" {
+            assert_eq!(req.headers()["cookie"], "key=val");
+        }
+
+        http::Response::builder()
+            .header("Set-Cookie", "key=val; HttpOnly")
+            .body(Default::default())
+            .unwrap()
+    });
+
+    let client = Client::builder().cookie_store(true).build().unwrap();
+
+    let set_url = format!("http://{}/1", server.addr());
+    let _ = client
+        .get(&set_url)
+        .header("cookie", "key=val")
+        .send()
+        .await
+        .unwrap();
+
+    let check_url = format!("http://{}/2", server.addr());
+    let _ = client.get(&check_url).send().await.unwrap();
+}
+
+#[tokio::test]
+async fn cookie_request_level_compression() {
+    let server = server::http(|req| async move {
+        match req.uri().path() {
+            "/set" => http::Response::builder()
+                .header("Set-Cookie", "cookie1=value1")
+                .header("Set-Cookie", "cookie2=value2")
+                .header("Set-Cookie", "cookie3=value3")
+                .body(Default::default())
+                .unwrap(),
+            "/default" | "/compressed" => {
+                let cookies = req
+                    .headers()
+                    .get(COOKIE)
+                    .and_then(|v| v.to_str().ok())
+                    .unwrap();
+                assert!(
+                    cookies.contains("cookie1=value1")
+                        && cookies.contains("cookie2=value2")
+                        && cookies.contains("cookie3=value3")
+                );
+                assert!(cookies.contains("; "));
+                http::Response::default()
+            }
+            "/uncompressed" => {
+                let cookies: Vec<_> = req
+                    .headers()
+                    .get_all(COOKIE)
+                    .iter()
+                    .map(|v| v.to_str().unwrap())
+                    .collect();
+
+                assert_eq!(cookies.len(), 3);
+
+                assert!(cookies.contains(&"cookie1=value1"));
+                assert!(cookies.contains(&"cookie2=value2"));
+                assert!(cookies.contains(&"cookie3=value3"));
+                http::Response::default()
+            }
+            _ => unreachable!(),
+        }
+    });
+
+    let base_url = format!("http://{}", server.addr());
+
+    // Create a jar with compression enabled (default)
+    let jar = Arc::new(Jar::default());
+
+    // Create a client with this jar
+    let client = Client::builder()
+        .cookie_provider(jar.clone())
+        .build()
+        .unwrap();
+
+    // Set cookies
+    client
+        .get(format!("{}/set", base_url))
+        .send()
+        .await
+        .unwrap();
+
+    // Request with default behavior (compressed)
+    client
+        .get(format!("{}/default", base_url))
+        .send()
+        .await
+        .unwrap();
+
+    // Request with compressed cookies
+    client
+        .get(format!("{}/compressed", base_url))
+        .cookie_provider(jar.compressed())
+        .send()
+        .await
+        .unwrap();
+
+    // Request with uncompressed cookies
+    client
+        .get(format!("{}/uncompressed", base_url))
+        .cookie_provider(jar.uncompressed())
+        .send()
+        .await
+        .unwrap();
+}