0.34.13_cleaup_code

src/upstream/client_tests.rs

@@ -49,7 +49,6 @@ mod tests {
         assert_eq!(stats.generation, 1);
     }
 
-
     #[test]
     fn generation_recycles_after_age_without_request() {
         let backend = backend("rotation-age-test", 18083);
@@ -101,14 +100,18 @@ mod tests {
         keepalive.pool_recycle_requests = 1_000;
         keepalive.pool_recycle_seconds = 0;
         let client = client_with_keepalive(
-            &backend, AddressPolicy::new(&backend).unwrap(), false, &keepalive,
-        ).unwrap();
-        for _ in 0..1_000 { client.inner.client_for_request(); }
+            &backend,
+            AddressPolicy::new(&backend).unwrap(),
+            false,
+            &keepalive,
+        )
+        .unwrap();
+        for _ in 0..1_000 {
+            client.inner.client_for_request();
+        }
         assert_eq!(client.rotation_stats().rotations, 0);
         client.inner.client_for_request();
         assert_eq!(client.rotation_stats().rotations, 1);
         assert_eq!(client.rotation_stats().generation_requests, 1);
     }
-
 }
-

src/upstream/protocol_tests.rs

@@ -232,9 +232,11 @@ async fn tls_authority_origin(
     let key = rustls::pki_types::PrivatePkcs8KeyDer::from(pair.signing_key.serialize_der());
     let provider = Arc::new(rustls::crypto::ring::default_provider());
     let mut config = rustls::ServerConfig::builder_with_provider(provider)
-        .with_safe_default_protocol_versions().unwrap()
+        .with_safe_default_protocol_versions()
+        .unwrap()
         .with_no_client_auth()
-        .with_single_cert(vec![pair.cert.der().clone()], key.into()).unwrap();
+        .with_single_cert(vec![pair.cert.der().clone()], key.into())
+        .unwrap();
     config.alpn_protocols = if offer_h2 {
         vec![b"h2".to_vec(), b"http/1.1".to_vec()]
     } else {
@@ -253,7 +255,9 @@ async fn tls_authority_origin(
             async move {
                 if let Some(tx) = observed.lock().unwrap().take() {
                     let authority = request.uri().authority().map(|v| v.as_str().to_owned());
-                    let host = request.headers().get("host")
+                    let host = request
+                        .headers()
+                        .get("host")
                         .map(|v| v.to_str().unwrap().to_owned());
                     let _ = tx.send((request.version(), authority, host, sni));
                 }
@@ -262,10 +266,12 @@ async fn tls_authority_origin(
         });
         if offer_h2 {
             let _ = hyper::server::conn::http2::Builder::new(TokioExecutor::new())
-                .serve_connection(TokioIo::new(tls), service).await;
+                .serve_connection(TokioIo::new(tls), service)
+                .await;
         } else {
             let _ = hyper::server::conn::http1::Builder::new()
-                .serve_connection(TokioIo::new(tls), service).await;
+                .serve_connection(TokioIo::new(tls), service)
+                .await;
         }
     });
     (address, observed_rx, server)
@@ -278,16 +284,23 @@ async fn strict_h2_preserves_public_authority_while_tcp_and_sni_use_private_orig
     backend.tls_server_name = Some("localhost".into());
     backend.preserve_host = true;
     let client = client(&backend, AddressPolicy::new(&backend).unwrap(), false).unwrap();
-    let request = Request::builder().version(Version::HTTP_2)
+    let request = Request::builder()
+        .version(Version::HTTP_2)
         .uri("https://unitraklub.pl/block_refresh/block/10")
-        .body(Body::empty()).unwrap();
+        .body(Body::empty())
+        .unwrap();
     let response = tokio::time::timeout(Duration::from_secs(5), client.request(request))
-        .await.unwrap().unwrap();
+        .await
+        .unwrap()
+        .unwrap();
     assert_eq!(response.version(), Version::HTTP_2);
     let (version, authority, host, sni) = seen.await.unwrap();
     assert_eq!(version, Version::HTTP_2);
     assert_eq!(authority.as_deref(), Some("unitraklub.pl"));
-    assert!(host.is_none(), "Strict H2 must not duplicate :authority with Host");
+    assert!(
+        host.is_none(),
+        "Strict H2 must not duplicate :authority with Host"
+    );
     assert_eq!(sni.as_deref(), Some("localhost"));
     server.abort();
 }
@@ -299,12 +312,16 @@ async fn auto_h1_fallback_preserves_public_host_without_resolving_it() {
     backend.tls_server_name = Some("localhost".into());
     backend.preserve_host = true;
     let client = client(&backend, AddressPolicy::new(&backend).unwrap(), false).unwrap();
-    let request = Request::builder().version(Version::HTTP_11)
+    let request = Request::builder()
+        .version(Version::HTTP_11)
         .uri("https://unitraklub.pl/block_refresh/block/10")
         .header("host", "unitraklub.pl")
-        .body(Body::empty()).unwrap();
+        .body(Body::empty())
+        .unwrap();
     let response = tokio::time::timeout(Duration::from_secs(5), client.request(request))
-        .await.unwrap().unwrap();
+        .await
+        .unwrap()
+        .unwrap();
     assert_eq!(response.version(), Version::HTTP_11);
     let (version, _authority, host, sni) = seen.await.unwrap();
     assert_eq!(version, Version::HTTP_11);
@@ -320,12 +337,16 @@ async fn auto_h2_alpn_retains_same_public_host_and_pinned_tls_origin() {
     backend.tls_server_name = Some("localhost".into());
     backend.preserve_host = true;
     let client = client(&backend, AddressPolicy::new(&backend).unwrap(), false).unwrap();
-    let request = Request::builder().version(Version::HTTP_11)
+    let request = Request::builder()
+        .version(Version::HTTP_11)
         .uri("https://unitraklub.pl/block_refresh/block/10")
         .header("host", "unitraklub.pl")
-        .body(Body::empty()).unwrap();
+        .body(Body::empty())
+        .unwrap();
     let response = tokio::time::timeout(Duration::from_secs(5), client.request(request))
-        .await.unwrap().unwrap();
+        .await
+        .unwrap()
+        .unwrap();
     assert_eq!(response.version(), Version::HTTP_2);
     let (version, authority, host, sni) = seen.await.unwrap();
     assert_eq!(version, Version::HTTP_2);
@@ -352,15 +373,20 @@ async fn cleartext_h2c_preserves_public_authority_and_pins_socket() {
             }
         });
         let _ = hyper::server::conn::http2::Builder::new(TokioExecutor::new())
-            .serve_connection(TokioIo::new(stream), service).await;
+            .serve_connection(TokioIo::new(stream), service)
+            .await;
     });
     let backend = protocol_backend(address, "http", "h2");
     let client = client(&backend, AddressPolicy::new(&backend).unwrap(), false).unwrap();
-    let request = Request::builder().version(Version::HTTP_2)
+    let request = Request::builder()
+        .version(Version::HTTP_2)
         .uri("http://unitraklub.pl/test")
-        .body(Body::empty()).unwrap();
+        .body(Body::empty())
+        .unwrap();
     let response = tokio::time::timeout(Duration::from_secs(5), client.request(request))
-        .await.unwrap().unwrap();
+        .await
+        .unwrap()
+        .unwrap();
     assert_eq!(response.version(), Version::HTTP_2);
     assert_eq!(observed.await.unwrap().as_deref(), Some("unitraklub.pl"));
     server.abort();