0.34.13_cleaup_code

src/compression/tests.rs

@@ -34,14 +34,26 @@ mod tests {
                     headers.append("accept-encoding", "deflate;q=0".parse().unwrap());
                     headers.append("cache-control", "max-age=0".parse().unwrap());
                     if let Some(name) = skip {
-                        headers.append(name, if name == "range" { "bytes=0-3" } else { "no-transform" }.parse().unwrap());
+                        headers.append(
+                            name,
+                            if name == "range" {
+                                "bytes=0-3"
+                            } else {
+                                "no-transform"
+                            }
+                            .parse()
+                            .unwrap(),
+                        );
                     }
                     headers.insert("cookie", "session=private".parse().unwrap());
                     headers.insert("authorization", "Bearer test".parse().unwrap());
                     headers.insert("x-large-custom", "x".repeat(4096).parse().unwrap());
                     let selected = request_headers(&headers);
                     for name in ["accept-encoding", "range", "cache-control"] {
-                        assert_eq!(headers.get_all(name).iter().collect::<Vec<_>>(), selected.get_all(name).iter().collect::<Vec<_>>());
+                        assert_eq!(
+                            headers.get_all(name).iter().collect::<Vec<_>>(),
+                            selected.get_all(name).iter().collect::<Vec<_>>()
+                        );
                     }
                     assert!(!selected.contains_key("cookie"));
                     assert!(!selected.contains_key("authorization"));
@@ -49,7 +61,10 @@ mod tests {
                     let narrow = encode(response(), &selected, &method, &Settings::default()).await;
                     assert_eq!(full.status(), narrow.status());
                     assert_eq!(full.headers(), narrow.headers());
-                    assert_eq!(full.into_body().collect().await.unwrap().to_bytes(), narrow.into_body().collect().await.unwrap().to_bytes());
+                    assert_eq!(
+                        full.into_body().collect().await.unwrap().to_bytes(),
+                        narrow.into_body().collect().await.unwrap().to_bytes()
+                    );
                 }
             }
         }
@@ -59,7 +74,10 @@ mod tests {
     #[test]
     fn unaccepted_codecs_cannot_be_reenabled_by_scoped_overrides() {
         let global = Settings::default();
-        let force_on = Overrides { enabled: Some(true), ..Default::default() };
+        let force_on = Overrides {
+            enabled: Some(true),
+            ..Default::default()
+        };
         for offer in ["identity", "gzip;q=0, br;q=0, zstd;q=0", "deflate", "*;q=0"] {
             let mut headers = HeaderMap::new();
             headers.insert("accept-encoding", offer.parse().unwrap());
@@ -86,10 +104,16 @@ mod tests {
         assert!(!selective.gzip);
         assert!(selective.br);
         assert!(!selective.zstd);
-        assert!(!selective.deflate, "a scope cannot enable a globally disabled codec");
+        assert!(
+            !selective.deflate,
+            "a scope cannot enable a globally disabled codec"
+        );
 
-        let disabled = Overrides { enabled: Some(false), ..Default::default() }
-            .resolve(&global, &inherited);
+        let disabled = Overrides {
+            enabled: Some(false),
+            ..Default::default()
+        }
+        .resolve(&global, &inherited);
         assert!(!disabled.enabled());
 
         let parent_disabled = global.scoped(false);
@@ -164,7 +188,16 @@ mod tests {
                 .get_all("vary")
                 .iter()
                 .any(|v| v.to_str().unwrap().contains("accept-encoding")));
-            assert!(response.into_body().collect().await.unwrap().to_bytes().len() < 1000);
+            assert!(
+                response
+                    .into_body()
+                    .collect()
+                    .await
+                    .unwrap()
+                    .to_bytes()
+                    .len()
+                    < 1000
+            );
         }
     }
 
@@ -244,10 +277,9 @@ mod tests {
         dynamic
             .headers_mut()
             .insert("set-cookie", "session=next; HttpOnly".parse().unwrap());
-        dynamic.headers_mut().insert(
-            "cache-control",
-            "private, no-store".parse().unwrap(),
-        );
+        dynamic
+            .headers_mut()
+            .insert("cache-control", "private, no-store".parse().unwrap());
         let encoded = encode(dynamic, &headers, &Method::GET, &settings).await;
         assert_eq!(encoded.headers()["content-encoding"], "gzip");
     }
@@ -306,19 +338,23 @@ mod tests {
 
         let mut no_transform_request = headers.clone();
         no_transform_request.insert("cache-control", "no-transform".parse().unwrap());
-        assert!(!encode(response(), &no_transform_request, &Method::GET, &settings)
-            .await
-            .headers()
-            .contains_key("content-encoding"));
+        assert!(
+            !encode(response(), &no_transform_request, &Method::GET, &settings)
+                .await
+                .headers()
+                .contains_key("content-encoding")
+        );
 
         let mut no_transform_response = response();
         no_transform_response
             .headers_mut()
             .insert("cache-control", "public, no-transform".parse().unwrap());
-        assert!(!encode(no_transform_response, &headers, &Method::GET, &settings)
-            .await
-            .headers()
-            .contains_key("content-encoding"));
+        assert!(
+            !encode(no_transform_response, &headers, &Method::GET, &settings)
+                .await
+                .headers()
+                .contains_key("content-encoding")
+        );
 
         let mut sse = response();
         sse.headers_mut()