wreq-rb 0.3.0

data/vendor/wreq/tests/multipart.rs

@@ -0,0 +1,165 @@
+mod support;
+use http_body_util::BodyExt;
+use pretty_env_logger::env_logger;
+use support::server;
+
+#[tokio::test]
+async fn text_part() {
+    let _ = env_logger::try_init();
+
+    let form = wreq::multipart::Form::new().text("foo", "bar");
+
+    let expected_body = format!(
+        "\
+         --{0}\r\n\
+         Content-Disposition: form-data; name=\"foo\"\r\n\r\n\
+         bar\r\n\
+         --{0}--\r\n\
+         ",
+        form.boundary()
+    );
+
+    let ct = format!("multipart/form-data; boundary={}", form.boundary());
+
+    let server = server::http(move |mut req| {
+        let ct = ct.clone();
+        let expected_body = expected_body.clone();
+        async move {
+            assert_eq!(req.method(), "POST");
+            assert_eq!(req.headers()["content-type"], ct);
+            assert_eq!(
+                req.headers()["content-length"],
+                expected_body.len().to_string()
+            );
+
+            let mut full: Vec<u8> = Vec::new();
+            while let Some(item) = req.body_mut().frame().await {
+                full.extend(&*item.unwrap().into_data().unwrap());
+            }
+
+            assert_eq!(full, expected_body.as_bytes());
+
+            http::Response::default()
+        }
+    });
+
+    let url = format!("http://{}/multipart/1", server.addr());
+
+    let res = wreq::post(&url).multipart(form).send().await.unwrap();
+
+    assert_eq!(res.uri(), url.as_str());
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}
+
+#[cfg(feature = "stream")]
+#[tokio::test]
+async fn stream_part() {
+    use futures_util::{future, stream};
+
+    let _ = env_logger::try_init();
+
+    let stream = wreq::Body::wrap_stream(stream::once(future::ready(Ok::<_, wreq::Error>(
+        "part1 part2".to_owned(),
+    ))));
+    let part = wreq::multipart::Part::stream(stream);
+
+    let form = wreq::multipart::Form::new()
+        .text("foo", "bar")
+        .part("part_stream", part);
+
+    let expected_body = format!(
+        "\
+         --{0}\r\n\
+         Content-Disposition: form-data; name=\"foo\"\r\n\
+         \r\n\
+         bar\r\n\
+         --{0}\r\n\
+         Content-Disposition: form-data; name=\"part_stream\"\r\n\
+         \r\n\
+         part1 part2\r\n\
+         --{0}--\r\n\
+         ",
+        form.boundary()
+    );
+
+    let ct = format!("multipart/form-data; boundary={}", form.boundary());
+
+    let server = server::http(move |req| {
+        let ct = ct.clone();
+        let expected_body = expected_body.clone();
+        async move {
+            assert_eq!(req.method(), "POST");
+            assert_eq!(req.headers()["content-type"], ct);
+            assert_eq!(req.headers()["transfer-encoding"], "chunked");
+
+            let full = req.collect().await.unwrap().to_bytes();
+
+            assert_eq!(full, expected_body.as_bytes());
+
+            http::Response::default()
+        }
+    });
+
+    let url = format!("http://{}/multipart/1", server.addr());
+
+    let res = wreq::post(&url)
+        .multipart(form)
+        .send()
+        .await
+        .expect("Failed to post multipart");
+    assert_eq!(res.uri(), url.as_str());
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}
+
+#[cfg(feature = "stream")]
+#[tokio::test]
+async fn async_impl_file_part() {
+    let _ = env_logger::try_init();
+
+    let form = wreq::multipart::Form::new()
+        .file("foo", "Cargo.lock")
+        .await
+        .unwrap();
+
+    let fcontents = std::fs::read_to_string("Cargo.lock").unwrap();
+
+    let expected_body = format!(
+        "\
+         --{0}\r\n\
+         Content-Disposition: form-data; name=\"foo\"; filename=\"Cargo.lock\"\r\n\
+         Content-Type: application/octet-stream\r\n\r\n\
+         {1}\r\n\
+         --{0}--\r\n\
+         ",
+        form.boundary(),
+        fcontents
+    );
+
+    let ct = format!("multipart/form-data; boundary={}", form.boundary());
+
+    let server = server::http(move |req| {
+        let ct = ct.clone();
+        let expected_body = expected_body.clone();
+        async move {
+            assert_eq!(req.method(), "POST");
+            assert_eq!(req.headers()["content-type"], ct);
+            // files know their exact size
+            assert_eq!(
+                req.headers()["content-length"],
+                expected_body.len().to_string()
+            );
+            let full = req.collect().await.unwrap().to_bytes();
+
+            assert_eq!(full, expected_body.as_bytes());
+
+            http::Response::default()
+        }
+    });
+
+    let url = format!("http://{}/multipart/3", server.addr());
+
+    let res = wreq::post(&url).multipart(form).send().await.unwrap();
+
+    assert_eq!(res.uri(), url.as_str());
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}

data/vendor/wreq/tests/proxy.rs

@@ -0,0 +1,438 @@
+mod support;
+use std::{env, sync::LazyLock};
+
+use support::server;
+use tokio::sync::Mutex;
+use wreq::Client;
+
+// serialize tests that read from / write to environment variables
+static HTTP_PROXY_ENV_MUTEX: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
+
+#[tokio::test]
+async fn http_proxy() {
+    let url = "http://hyper.rs.local/prox";
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "GET");
+        assert_eq!(req.uri(), url);
+        assert_eq!(req.headers()["host"], "hyper.rs.local");
+
+        async { http::Response::default() }
+    });
+
+    let proxy = format!("http://{}", server.addr());
+
+    let res = Client::builder()
+        .proxy(wreq::Proxy::http(&proxy).unwrap())
+        .build()
+        .unwrap()
+        .get(url)
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.uri(), url);
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}
+
+#[tokio::test]
+async fn http_proxy_basic_auth() {
+    let url = "http://hyper.rs.local/prox";
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "GET");
+        assert_eq!(req.uri(), url);
+        assert_eq!(req.headers()["host"], "hyper.rs.local");
+        assert_eq!(
+            req.headers()["proxy-authorization"],
+            "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
+        );
+
+        async { http::Response::default() }
+    });
+
+    let proxy = format!("http://{}", server.addr());
+
+    let res = Client::builder()
+        .proxy(
+            wreq::Proxy::http(&proxy)
+                .unwrap()
+                .basic_auth("Aladdin", "open sesame"),
+        )
+        .build()
+        .unwrap()
+        .get(url)
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.uri(), url);
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}
+
+#[tokio::test]
+async fn http_proxy_basic_auth_parsed() {
+    let url = "http://hyper.rs.local/prox";
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "GET");
+        assert_eq!(req.uri(), url);
+        assert_eq!(req.headers()["host"], "hyper.rs.local");
+        assert_eq!(
+            req.headers()["proxy-authorization"],
+            "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
+        );
+
+        async { http::Response::default() }
+    });
+
+    let proxy = format!("http://Aladdin:open%20sesame@{}", server.addr());
+
+    let res = Client::builder()
+        .proxy(wreq::Proxy::http(&proxy).unwrap())
+        .build()
+        .unwrap()
+        .get(url)
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.uri(), url);
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+
+    let res = wreq::get(url)
+        .proxy(wreq::Proxy::http(&proxy).unwrap())
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.uri(), url);
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}
+
+#[tokio::test]
+async fn system_http_proxy_basic_auth_parsed() {
+    let url = "http://hyper.rs.local/prox";
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "GET");
+        assert_eq!(req.uri(), url);
+        assert_eq!(req.headers()["host"], "hyper.rs.local");
+        assert_eq!(
+            req.headers()["proxy-authorization"],
+            "Basic QWxhZGRpbjpvcGVuc2VzYW1l"
+        );
+
+        async { http::Response::default() }
+    });
+
+    // avoid races with other tests that change "http_proxy"
+    let _env_lock = HTTP_PROXY_ENV_MUTEX.lock().await;
+
+    // save system setting first.
+    let system_proxy = env::var("http_proxy");
+
+    // set-up http proxy.
+    unsafe {
+        env::set_var(
+            "http_proxy",
+            format!("http://Aladdin:opensesame@{}", server.addr()),
+        )
+    }
+
+    let res = Client::builder()
+        .build()
+        .unwrap()
+        .get(url)
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.uri(), url);
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+
+    // reset user setting.
+    unsafe {
+        match system_proxy {
+            Err(_) => env::remove_var("http_proxy"),
+            Ok(proxy) => env::set_var("http_proxy", proxy),
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_no_proxy() {
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "GET");
+        assert_eq!(req.uri(), "/4");
+
+        async { http::Response::default() }
+    });
+    let proxy = format!("http://{}", server.addr());
+    let url = format!("http://{}/4", server.addr());
+
+    // set up proxy and use no_proxy to clear up client builder proxies.
+    let res = Client::builder()
+        .proxy(wreq::Proxy::http(&proxy).unwrap())
+        .no_proxy()
+        .build()
+        .unwrap()
+        .get(&url)
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.uri(), url.as_str());
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}
+
+#[tokio::test]
+async fn test_using_system_proxy() {
+    let url = "http://not.a.real.sub.hyper.rs.local/prox";
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "GET");
+        assert_eq!(req.uri(), url);
+        assert_eq!(req.headers()["host"], "not.a.real.sub.hyper.rs.local");
+
+        async { http::Response::default() }
+    });
+
+    // avoid races with other tests that change "http_proxy"
+    let _env_lock = HTTP_PROXY_ENV_MUTEX.lock().await;
+
+    // save system setting first.
+    let system_proxy = env::var("http_proxy");
+    // set-up http proxy.
+    unsafe {
+        env::set_var("http_proxy", format!("http://{}", server.addr()));
+    }
+    // system proxy is used by default
+    let res = wreq::get(url).send().await.unwrap();
+
+    assert_eq!(res.uri(), url);
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+
+    // reset user setting.
+    unsafe {
+        match system_proxy {
+            Err(_) => env::remove_var("http_proxy"),
+            Ok(proxy) => env::set_var("http_proxy", proxy),
+        }
+    }
+}
+
+#[tokio::test]
+async fn http_over_http() {
+    let url = "http://hyper.rs.local/prox";
+
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "GET");
+        assert_eq!(req.uri(), url);
+        assert_eq!(req.headers()["host"], "hyper.rs.local");
+
+        async { http::Response::default() }
+    });
+
+    let proxy = format!("http://{}", server.addr());
+
+    let res = Client::builder()
+        .proxy(wreq::Proxy::http(&proxy).unwrap())
+        .build()
+        .unwrap()
+        .get(url)
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.uri(), url);
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}
+
+#[tokio::test]
+async fn http_proxy_custom_headers() {
+    let url = "http://hyper.rs.local/prox";
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "GET");
+        assert_eq!(req.uri(), url);
+        assert_eq!(req.headers()["host"], "hyper.rs.local");
+        assert_eq!(
+            req.headers()["proxy-authorization"],
+            "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
+        );
+        assert_eq!(req.headers()["x-custom-header"], "value");
+
+        async { http::Response::default() }
+    });
+
+    let proxy = format!("http://Aladdin:open%20sesame@{}", server.addr());
+
+    let proxy = wreq::Proxy::http(&proxy).unwrap().custom_http_headers({
+        let mut headers = http::HeaderMap::new();
+        headers.insert("x-custom-header", "value".parse().unwrap());
+        headers
+    });
+
+    let res = Client::builder()
+        .proxy(proxy.clone())
+        .build()
+        .unwrap()
+        .get(url)
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.uri(), url);
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+
+    let res = wreq::get(url).proxy(proxy).send().await.unwrap();
+
+    assert_eq!(res.uri(), url);
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}
+
+#[tokio::test]
+async fn tunnel_detects_auth_required() {
+    let url = "https://hyper.rs.local/prox";
+
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "CONNECT");
+        assert_eq!(req.uri(), "hyper.rs.local:443");
+        assert!(
+            !req.headers()
+                .contains_key(http::header::PROXY_AUTHORIZATION)
+        );
+
+        async {
+            let mut res = http::Response::default();
+            *res.status_mut() = http::StatusCode::PROXY_AUTHENTICATION_REQUIRED;
+            res
+        }
+    });
+
+    let proxy = format!("http://{}", server.addr());
+
+    let err = Client::builder()
+        .proxy(wreq::Proxy::https(&proxy).unwrap())
+        .build()
+        .unwrap()
+        .get(url)
+        .send()
+        .await
+        .unwrap_err();
+
+    let err = support::error::inspect(err).pop().unwrap();
+    assert!(
+        err.contains("auth"),
+        "proxy auth err expected, got: {err:?}"
+    );
+}
+
+#[tokio::test]
+async fn tunnel_includes_proxy_auth() {
+    let url = "https://hyper.rs.local/prox";
+
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "CONNECT");
+        assert_eq!(req.uri(), "hyper.rs.local:443");
+        assert_eq!(
+            req.headers()["proxy-authorization"],
+            "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
+        );
+
+        async {
+            // return 400 to not actually deal with TLS tunneling
+            let mut res = http::Response::default();
+            *res.status_mut() = http::StatusCode::BAD_REQUEST;
+            res
+        }
+    });
+
+    let proxy = format!("http://Aladdin:open%20sesame@{}", server.addr());
+
+    let err = Client::builder()
+        .proxy(wreq::Proxy::https(&proxy).unwrap())
+        .build()
+        .unwrap()
+        .get(url)
+        .send()
+        .await
+        .unwrap_err();
+
+    let err = support::error::inspect(err).pop().unwrap();
+    assert!(
+        err.contains("unsuccessful"),
+        "tunnel unsuccessful expected, got: {err:?}"
+    );
+}
+
+#[tokio::test]
+async fn tunnel_includes_user_agent() {
+    let url = "https://hyper.rs.local/prox";
+
+    let server = server::http(move |req| {
+        assert_eq!(req.method(), "CONNECT");
+        assert_eq!(req.uri(), "hyper.rs.local:443");
+        assert_eq!(req.headers()["user-agent"], "wreq-test");
+
+        async {
+            // return 400 to not actually deal with TLS tunneling
+            let mut res = http::Response::default();
+            *res.status_mut() = http::StatusCode::BAD_REQUEST;
+            res
+        }
+    });
+
+    let proxy = format!("http://{}", server.addr());
+
+    let err = Client::builder()
+        .proxy(wreq::Proxy::https(&proxy).unwrap().custom_http_headers({
+            let mut headers = http::HeaderMap::new();
+            headers.insert("user-agent", "wreq-test".parse().unwrap());
+            headers
+        }))
+        .user_agent("wreq-test")
+        .build()
+        .unwrap()
+        .get(url)
+        .send()
+        .await
+        .unwrap_err();
+
+    let err = support::error::inspect(err).pop().unwrap();
+    assert!(
+        err.contains("unsuccessful"),
+        "tunnel unsuccessful expected, got: {err:?}"
+    );
+}
+
+#[tokio::test]
+async fn proxy_tunnel_connect_error() {
+    let client = Client::builder()
+        .cert_verification(false)
+        .no_proxy()
+        .build()
+        .unwrap();
+
+    let invalid_proxies = vec![
+        "http://invalid.proxy:8080",
+        "https://invalid.proxy:8080",
+        "socks4://invalid.proxy:8080",
+        "socks4a://invalid.proxy:8080",
+        "socks5://invalid.proxy:8080",
+        "socks5h://invalid.proxy:8080",
+    ];
+
+    let target_urls = ["https://example.com", "http://example.com"];
+
+    for proxy in invalid_proxies {
+        for url in target_urls {
+            let err = client
+                .get(url)
+                .proxy(wreq::Proxy::all(proxy).unwrap())
+                .send()
+                .await
+                .unwrap_err();
+
+            assert!(
+                err.is_proxy_connect(),
+                "proxy connect error expected, got: {err:?}"
+            );
+        }
+    }
+}