wreq-rb 0.6.0 → 0.6.2

data/vendor/wreq/src/tls/conn.rs

@@ -222,17 +222,9 @@ impl TlsConnector {
     /// it (otherwise, boring will fail to parse the host as an IP address, eventually
     /// causing the handshake to fail due a hostname verification error).
     fn normalize_host(host: &str) -> &str {
-        if host.is_empty() {
-            return host;
-        }
-
-        let last = host.len() - 1;
-        let mut chars = host.chars();
-
-        if let (Some('['), Some(']')) = (chars.next(), chars.last()) {
-            if host[1..last].parse::<std::net::Ipv6Addr>().is_ok() {
-                return &host[1..last];
-            }
+        let normalized = crate::util::strip_ipv6_brackets(host);
+        if normalized.len() != host.len() && normalized.parse::<std::net::Ipv6Addr>().is_ok() {
+            return normalized;
         }
 
         host

data/vendor/wreq/src/tls/session.rs

@@ -189,14 +189,13 @@ impl TlsSessionCache for LruTlsSessionCache {
         // https://tools.ietf.org/html/rfc8446#appendix-C.4
         // OpenSSL will remove the session from its cache after the handshake completes anyway, but
         // this ensures that concurrent handshakes don't end up with the same session.
-        if session.protocol_version() == TlsVersion::TLS_1_3 {
-            if let Some(key) = inner.reverse.remove(&session) {
-                if let Entry::Occupied(mut entry) = inner.per_host_sessions.entry(key) {
-                    entry.get_mut().pop(&session);
-                    if entry.get().is_empty() {
-                        entry.remove();
-                    }
-                }
+        if session.protocol_version() == TlsVersion::TLS_1_3
+            && let Some(key) = inner.reverse.remove(&session)
+            && let Entry::Occupied(mut entry) = inner.per_host_sessions.entry(key)
+        {
+            entry.get_mut().pop(&session);
+            if entry.get().is_empty() {
+                entry.remove();
             }
         }
 

data/vendor/wreq/src/tls/trust/store.rs

@@ -106,10 +106,10 @@ impl CertStoreBuilder {
     /// environment variables if present, or defaults specified at OpenSSL
     /// build time otherwise.
     pub fn set_default_paths(mut self) -> Self {
-        if let Ok(ref mut builder) = self.builder {
-            if let Err(err) = builder.set_default_paths() {
-                self.builder = Err(Error::tls(err));
-            }
+        if let Ok(ref mut builder) = self.builder
+            && let Err(err) = builder.set_default_paths()
+        {
+            self.builder = Err(Error::tls(err));
         }
         self
     }

data/vendor/wreq/src/util.rs

@@ -4,6 +4,14 @@ use bytes::Bytes;
 
 use crate::header::{Entry, HeaderMap, HeaderValue, OccupiedEntry};
 
+/// Removes the square brackets around an IPv6 host literal as required by
+/// [RFC 3986, Section 3.2.2](https://www.rfc-editor.org/rfc/rfc3986.html#section-3.2.2).
+pub(crate) fn strip_ipv6_brackets(host: &str) -> &str {
+    host.strip_prefix('[')
+        .and_then(|host| host.strip_suffix(']'))
+        .unwrap_or(host)
+}
+
 pub(crate) fn basic_auth<U, P>(username: U, password: Option<P>) -> HeaderValue
 where
     U: fmt::Display,
@@ -120,3 +128,18 @@ impl fmt::Display for Escape<'_> {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::strip_ipv6_brackets;
+
+    #[test]
+    fn strips_ipv6_brackets() {
+        assert_eq!(strip_ipv6_brackets("[::1]"), "::1");
+        assert_eq!(strip_ipv6_brackets("::1"), "::1");
+        assert_eq!(strip_ipv6_brackets("example.com"), "example.com");
+        assert_eq!(strip_ipv6_brackets("[example.com"), "[example.com");
+        assert_eq!(strip_ipv6_brackets("example.com]"), "example.com]");
+        assert_eq!(strip_ipv6_brackets("[[::1]]"), "[::1]");
+    }
+}

data/vendor/wreq/tests/badssl.rs

@@ -1,7 +1,7 @@
-use std::time::Duration;
+use std::{error::Error as StdError, io, time::Duration};
 
 use wreq::{
-    Client,
+    Client, retry,
     tls::{AlpsProtocol, TlsInfo, TlsOptions, TlsVersion, trust::CertStore},
 };
 
@@ -11,11 +11,40 @@ macro_rules! join {
     };
 }
 
+fn badssl_connection_reset_retry_policy() -> retry::Policy {
+    retry::Policy::default()
+        .max_retries_per_request(10)
+        .no_budget()
+        .classify_fn(|req_rep| {
+            if req_rep.error().is_some_and(is_connection_reset) {
+                req_rep.retryable()
+            } else {
+                req_rep.success()
+            }
+        })
+}
+
+fn is_connection_reset(err: &(dyn StdError + 'static)) -> bool {
+    let mut source = Some(err);
+
+    while let Some(err) = source {
+        if let Some(io) = err.downcast_ref::<io::Error>()
+            && io.kind() == io::ErrorKind::ConnectionReset
+        {
+            return true;
+        }
+
+        source = err.source();
+    }
+
+    false
+}
+
 #[tokio::test]
 async fn test_badssl_modern() {
     let text = Client::builder()
         .no_proxy()
-        .connect_timeout(Duration::from_secs(360))
+        .retry(badssl_connection_reset_retry_policy())
         .build()
         .unwrap()
         .get("https://mozilla-modern.badssl.com/")
@@ -26,15 +55,15 @@ async fn test_badssl_modern() {
         .await
         .unwrap();
 
-    assert!(!text.is_empty());
+    assert!(text.contains("<title>mozilla-modern.badssl.com</title>"));
 }
 
 #[tokio::test]
 async fn test_badssl_self_signed() {
     let text = Client::builder()
         .tls_cert_verification(false)
-        .connect_timeout(Duration::from_secs(360))
         .no_proxy()
+        .retry(badssl_connection_reset_retry_policy())
         .build()
         .unwrap()
         .get("https://self-signed.badssl.com/")
@@ -45,8 +74,39 @@ async fn test_badssl_self_signed() {
         .await
         .unwrap();
 
-    assert!(!text.is_empty());
+    assert!(text.contains("<title>self-signed.badssl.com</title>"));
+}
+
+#[tokio::test]
+async fn test_badssl_wrong_host() {
+    let text = Client::builder()
+        .tls_verify_hostname(false)
+        .no_proxy()
+        .retry(badssl_connection_reset_retry_policy())
+        .build()
+        .unwrap()
+        .get("https://wrong.host.badssl.com/")
+        .send()
+        .await
+        .unwrap()
+        .text()
+        .await
+        .unwrap();
+
+    assert!(text.contains("<title>wrong.host.badssl.com</title>"));
+
+    let result = Client::builder()
+        .tls_verify_hostname(false)
+        .no_proxy()
+        .build()
+        .unwrap()
+        .get("https://self-signed.badssl.com/")
+        .send()
+        .await;
+
+    assert!(result.is_err());
 }
+
 const CURVES_LIST: &str = join!(
     ":",
     "X25519",
@@ -72,6 +132,7 @@ async fn test_3des_support() -> wreq::Result<()> {
     let client = Client::builder()
         .tls_options(tls_options)
         .tls_cert_verification(false)
+        .retry(badssl_connection_reset_retry_policy())
         .connect_timeout(Duration::from_secs(360))
         .build()?;
 
@@ -105,6 +166,7 @@ async fn test_firefox_7x_100_cipher() -> wreq::Result<()> {
     let client = Client::builder()
         .tls_options(tls_options)
         .tls_cert_verification(false)
+        .retry(badssl_connection_reset_retry_policy())
         .connect_timeout(Duration::from_secs(360))
         .build()?;
 
@@ -189,8 +251,9 @@ async fn test_aes_hw_override() -> wreq::Result<()> {
 async fn test_tls_self_signed_cert() {
     let client = Client::builder()
         .tls_cert_verification(false)
-        .connect_timeout(Duration::from_secs(360))
         .tls_info(true)
+        .retry(badssl_connection_reset_retry_policy())
+        .no_proxy()
         .build()
         .unwrap();
 
@@ -213,6 +276,8 @@ async fn test_tls_self_signed_cert() {
 
     let client = Client::builder()
         .tls_cert_store(self_signed_cert_store)
+        .retry(badssl_connection_reset_retry_policy())
+        .no_proxy()
         .build()
         .unwrap();
 

data/vendor/wreq/tests/brotli.rs

@@ -101,7 +101,7 @@ async fn brotli_case(response_size: usize, chunk_size: usize) {
          Content-Encoding: br\r\n\
          Content-Length: {}\r\n\
          \r\n",
-        &brotlied_content.len()
+        brotlied_content.len()
     )
     .into_bytes();
     response.extend(&brotlied_content);

data/vendor/wreq/tests/client.rs

@@ -1090,3 +1090,27 @@ async fn response_trailers() {
     assert_eq!(trailers["chunky-trailer1"], "value1");
     assert_eq!(trailers["chunky-trailer2"], "value2");
 }
+
+#[tokio::test]
+async fn dns_resolution_failure_is_dns_error() {
+    let _ = env_logger::builder().is_test(true).try_init();
+
+    struct FailingResolver;
+
+    impl wreq::dns::Resolve for FailingResolver {
+        fn resolve(&self, _name: wreq::dns::Name) -> reqwest::dns::Resolving {
+            Box::pin(async { Err("simulated resolver failure".into()) })
+        }
+    }
+
+    let client = Client::builder()
+        .no_proxy()
+        .dns_resolver(FailingResolver)
+        .build()
+        .expect("client builder");
+
+    let err = client.get("http://hyper.rs").send().await.unwrap_err();
+
+    assert!(err.is_dns(), "expected a DNS error, got: {err:?}");
+    assert!(err.is_connect(), "expected is_connect() to also be true");
+}

data/vendor/wreq/tests/connector_layers.rs

@@ -31,15 +31,17 @@ async fn non_op_layer() {
 async fn non_op_layer_with_timeout() {
     let _ = env_logger::try_init();
 
+    let server = server::http(move |_req| async { http::Response::default() });
+
     let client = Client::builder()
         .connector_layer(Identity::new())
+        .connector_layer(DelayLayer::new(Duration::from_secs(60)))
         .connect_timeout(Duration::from_millis(200))
         .no_proxy()
         .build()
         .unwrap();
 
-    // never returns
-    let url = "http://192.0.2.1:81/slow";
+    let url = format!("http://{}", server.addr());
 
     let res = client.get(url).send().await;
 
@@ -52,14 +54,16 @@ async fn non_op_layer_with_timeout() {
 async fn with_connect_timeout_layer_never_returning() {
     let _ = env_logger::try_init();
 
+    let server = server::http(move |_req| async { http::Response::default() });
+
     let client = Client::builder()
+        .connector_layer(DelayLayer::new(Duration::from_secs(60)))
         .connector_layer(TimeoutLayer::new(Duration::from_millis(100)))
         .no_proxy()
         .build()
         .unwrap();
 
-    // never returns
-    let url = "http://192.0.2.1:81/slow";
+    let url = format!("http://{}", server.addr());
 
     let res = client.get(url).send().await;
 

data/vendor/wreq/tests/cookie.rs

@@ -1,5 +1,7 @@
 mod support;
 
+use std::sync::Arc;
+
 use http::{Version, header::COOKIE};
 use support::server;
 use wreq::{Client, cookie::Jar};
@@ -302,3 +304,60 @@ async fn cookie_request_level_compression() {
         .await
         .unwrap();
 }
+
+#[tokio::test]
+async fn cookie_request_order_matches_chromium() {
+    let server = server::http(|req| async move {
+        match req.uri().path() {
+            "/foo/bar/http1" => {
+                assert_eq!(req.version(), Version::HTTP_11);
+                assert_eq!(
+                    req.headers()
+                        .get(COOKIE)
+                        .and_then(|value| value.to_str().ok()),
+                    Some("B=B3; A=A3; B=B2; A=A2; B=B1; A=A1")
+                );
+            }
+            "/foo/bar/http2" => {
+                assert_eq!(req.version(), Version::HTTP_2);
+                let cookies = req
+                    .headers()
+                    .get_all(COOKIE)
+                    .iter()
+                    .map(|value| value.to_str().unwrap())
+                    .collect::<Vec<_>>();
+                assert_eq!(cookies, ["B=B3", "A=A3", "B=B2", "A=A2", "B=B1", "A=A1"]);
+            }
+            path => panic!("unexpected request path: {path}"),
+        }
+
+        http::Response::default()
+    });
+
+    let base_url = format!("http://{}", server.addr());
+    let jar = Arc::new(Jar::default());
+    for cookie in [
+        "B=B1; Path=/",
+        "B=B2; Path=/foo",
+        "B=B3; Path=/foo/bar",
+        "A=A1; Path=/",
+        "A=A2; Path=/foo",
+        "A=A3; Path=/foo/bar",
+    ] {
+        jar.add(cookie, &base_url);
+    }
+
+    let client = Client::builder().cookie_provider(jar).build().unwrap();
+    client
+        .get(format!("{base_url}/foo/bar/http1"))
+        .version(Version::HTTP_11)
+        .send()
+        .await
+        .unwrap();
+    client
+        .get(format!("{base_url}/foo/bar/http2"))
+        .version(Version::HTTP_2)
+        .send()
+        .await
+        .unwrap();
+}

data/vendor/wreq/tests/deflate.rs

@@ -100,7 +100,7 @@ async fn deflate_case(response_size: usize, chunk_size: usize) {
          Content-Encoding: deflate\r\n\
          Content-Length: {}\r\n\
          \r\n",
-        &deflated_content.len()
+        deflated_content.len()
     )
     .into_bytes();
     response.extend(&deflated_content);

data/vendor/wreq/tests/gzip.rs

@@ -4,6 +4,7 @@ use std::io::Write;
 use flate2::{Compression, write::GzEncoder};
 use support::server;
 use tokio::io::AsyncWriteExt;
+use wreq::header;
 
 #[tokio::test]
 async fn gzip_response() {
@@ -82,6 +83,57 @@ async fn test_accept_encoding_header_is_not_changed_if_set() {
     assert_eq!(res.status(), wreq::StatusCode::OK);
 }
 
+#[tokio::test]
+async fn test_range_requests_use_identity_encoding() {
+    let server = server::http(move |req| async move {
+        match req.uri().path() {
+            "/range" => {
+                assert_eq!(req.headers()[header::RANGE], "bytes=0-3");
+                assert_eq!(req.headers()[header::ACCEPT_ENCODING], "identity");
+            }
+            "/regular" => {
+                assert!(
+                    req.headers()[header::ACCEPT_ENCODING]
+                        .to_str()
+                        .unwrap()
+                        .contains("gzip")
+                );
+            }
+            "/disabled" => {
+                assert_eq!(req.headers()[header::ACCEPT_ENCODING], "gzip");
+            }
+            path => panic!("unexpected path: {path}"),
+        }
+
+        http::Response::default()
+    });
+    let base = format!("http://{}", server.addr());
+
+    let client = wreq::Client::new();
+    client
+        .get(format!("{base}/range"))
+        .header(header::RANGE, "bytes=0-3")
+        .header(header::ACCEPT_ENCODING, "gzip")
+        .send()
+        .await
+        .unwrap();
+    client.get(format!("{base}/regular")).send().await.unwrap();
+
+    wreq::Client::builder()
+        .no_gzip()
+        .no_brotli()
+        .no_zstd()
+        .no_deflate()
+        .build()
+        .unwrap()
+        .get(format!("{base}/disabled"))
+        .header(header::RANGE, "bytes=0-3")
+        .header(header::ACCEPT_ENCODING, "gzip")
+        .send()
+        .await
+        .unwrap();
+}
+
 async fn gzip_case(response_size: usize, chunk_size: usize) {
     use futures_util::stream::StreamExt;
 
@@ -100,7 +152,7 @@ async fn gzip_case(response_size: usize, chunk_size: usize) {
          Content-Encoding: gzip\r\n\
          Content-Length: {}\r\n\
          \r\n",
-        &gzipped_content.len()
+        gzipped_content.len()
     )
     .into_bytes();
     response.extend(&gzipped_content);

data/vendor/wreq/tests/layers.rs

@@ -34,15 +34,17 @@ async fn non_op_layer() {
 async fn non_op_layer_with_timeout() {
     let _ = env_logger::try_init();
 
+    let server = server::http(move |_req| async { http::Response::default() });
+
     let client = Client::builder()
         .layer(Identity::new())
+        .connector_layer(DelayLayer::new(Duration::from_secs(60)))
         .connect_timeout(Duration::from_millis(200))
         .no_proxy()
         .build()
         .unwrap();
 
-    // never returns
-    let url = "http://192.0.2.1:81/slow";
+    let url = format!("http://{}", server.addr());
 
     let res = client.get(url).send().await;
 
@@ -55,14 +57,16 @@ async fn non_op_layer_with_timeout() {
 async fn with_connect_timeout_layer_never_returning() {
     let _ = env_logger::try_init();
 
+    let server = server::http(move |_req| async { http::Response::default() });
+
     let client = Client::builder()
+        .connector_layer(DelayLayer::new(Duration::from_secs(60)))
         .layer(TimeoutLayer::new(Duration::from_millis(100)))
         .no_proxy()
         .build()
         .unwrap();
 
-    // never returns
-    let url = "http://192.0.2.1:81/slow";
+    let url = format!("http://{}", server.addr());
 
     let res = client.get(url).send().await;