0.34.13_cleaup_code

src/proxy/cache_plan/tests.rs

@@ -16,19 +16,33 @@ fn disabled_cache_retains_reason_without_matching_force_rules_or_reparsing_heade
     let settings = settings();
     let mut headers = HeaderMap::new();
     headers.insert("authorization", HeaderValue::from_static("private"));
-    headers.insert("cache-control", HeaderValue::from_static("max-age=not-a-number"));
+    headers.insert(
+        "cache-control",
+        HeaderValue::from_static("max-age=not-a-number"),
+    );
     for reason in [
-        "cache_disabled", "route_disabled", "admin_control_plane", "basic_auth",
-        "tinyauth", "sticky_cookie", "request_upgrade",
+        "cache_disabled",
+        "route_disabled",
+        "admin_control_plane",
+        "basic_auth",
+        "tinyauth",
+        "sticky_cookie",
+        "request_upgrade",
     ] {
         let plan = CachePlan::new(Some(reason), &settings, "/style.css", || {
             panic!("disabled cache must not match force-cache rules")
         });
         assert!(!plan.force_cache());
         assert!(!plan.ignore_cookie());
-        let policy = plan.request_policy(&Method::GET, &headers, true, "/style.css", false, &settings);
+        let policy =
+            plan.request_policy(&Method::GET, &headers, true, "/style.css", false, &settings);
         assert_eq!(policy, RequestPolicy::Bypass(reason));
-        assert_eq!(combine_policy(policy, || panic!("disabled cache must not parse post-rule policy")), policy);
+        assert_eq!(
+            combine_policy(policy, || panic!(
+                "disabled cache must not parse post-rule policy"
+            )),
+            policy
+        );
     }
 }
 
@@ -38,23 +52,49 @@ fn cache_on_keeps_all_existing_request_policy_outcomes() {
     for forced in [false, true] {
         let plan = CachePlan::new(None, &settings, "/style.css", || forced);
         for (name, value) in [
-            ("x-irrelevant", "yes"), ("cache-control", "no-store"),
-            ("cache-control", "no-cache"), ("cache-control", "max-age=0"),
-            ("cache-control", "min-fresh=broken"), ("authorization", "private"),
-            ("cookie", "session=private"), ("range", "bytes=0-2"),
-            ("range", "bytes=0-2,4-5"), ("if-range", "\"etag\""),
-            ("if-match", "\"etag\""), ("upgrade", "websocket"),
+            ("x-irrelevant", "yes"),
+            ("cache-control", "no-store"),
+            ("cache-control", "no-cache"),
+            ("cache-control", "max-age=0"),
+            ("cache-control", "min-fresh=broken"),
+            ("authorization", "private"),
+            ("cookie", "session=private"),
+            ("range", "bytes=0-2"),
+            ("range", "bytes=0-2,4-5"),
+            ("if-range", "\"etag\""),
+            ("if-match", "\"etag\""),
+            ("upgrade", "websocket"),
         ] {
             let mut headers = HeaderMap::new();
-            headers.insert(http::HeaderName::from_bytes(name.as_bytes()).unwrap(), value.parse().unwrap());
+            headers.insert(
+                http::HeaderName::from_bytes(name.as_bytes()).unwrap(),
+                value.parse().unwrap(),
+            );
             for method in [Method::GET, Method::HEAD, Method::POST] {
                 for body_empty in [false, true] {
                     let expected = if forced {
                         crate::cache::forced_request_policy(&method, &headers, body_empty)
                     } else {
-                        crate::cache::request_policy(&method, &headers, body_empty, "/style.css", false, &settings)
+                        crate::cache::request_policy(
+                            &method,
+                            &headers,
+                            body_empty,
+                            "/style.css",
+                            false,
+                            &settings,
+                        )
                     };
-                    assert_eq!(plan.request_policy(&method, &headers, body_empty, "/style.css", false, &settings), expected);
+                    assert_eq!(
+                        plan.request_policy(
+                            &method,
+                            &headers,
+                            body_empty,
+                            "/style.css",
+                            false,
+                            &settings
+                        ),
+                        expected
+                    );
                 }
             }
         }
@@ -73,8 +113,12 @@ fn request_header_rules_cannot_relax_bypass_or_revalidation() {
     for original in cases {
         for rewritten in cases {
             let expected = match (original, rewritten) {
-                (RequestPolicy::Bypass(reason), _) | (_, RequestPolicy::Bypass(reason)) => RequestPolicy::Bypass(reason),
-                (RequestPolicy::Revalidate(reason), _) | (_, RequestPolicy::Revalidate(reason)) => RequestPolicy::Revalidate(reason),
+                (RequestPolicy::Bypass(reason), _) | (_, RequestPolicy::Bypass(reason)) => {
+                    RequestPolicy::Bypass(reason)
+                }
+                (RequestPolicy::Revalidate(reason), _) | (_, RequestPolicy::Revalidate(reason)) => {
+                    RequestPolicy::Revalidate(reason)
+                }
                 _ => RequestPolicy::Use,
             };
             assert_eq!(combine_policy(original, || rewritten), expected);
@@ -85,16 +129,36 @@ fn request_header_rules_cannot_relax_bypass_or_revalidation() {
 #[test]
 fn cache_off_still_blocks_range_transformation_and_preserves_origin_headers() {
     for method in [Method::GET, Method::HEAD, Method::POST] {
-        for range in [None, Some("bytes=0-2"), Some("bytes=0-2,4-5"), Some("broken"), Some("bytes=99-")] {
+        for range in [
+            None,
+            Some("bytes=0-2"),
+            Some("bytes=0-2,4-5"),
+            Some("broken"),
+            Some("bytes=99-"),
+        ] {
             let mut headers = HeaderMap::new();
-            if let Some(range) = range { headers.insert("range", range.parse().unwrap()); }
+            if let Some(range) = range {
+                headers.insert("range", range.parse().unwrap());
+            }
             headers.insert("if-range", HeaderValue::from_static("\"same-validator\""));
-            headers.insert("if-none-match", HeaderValue::from_static("\"client-validator\""));
+            headers.insert(
+                "if-none-match",
+                HeaderValue::from_static("\"client-validator\""),
+            );
             let original = headers.clone();
             let baseline = crate::cache::request_range(&method, &headers);
             assert_eq!(range_selection(true, &method, &headers), baseline);
-            assert_eq!(matches!(range_selection(false, &method, &headers), RangeSelection::None), matches!(baseline, RangeSelection::None));
-            assert_eq!(headers, original, "origin must receive the original Range/conditional fields");
+            assert_eq!(
+                matches!(
+                    range_selection(false, &method, &headers),
+                    RangeSelection::None
+                ),
+                matches!(baseline, RangeSelection::None)
+            );
+            assert_eq!(
+                headers, original,
+                "origin must receive the original Range/conditional fields"
+            );
         }
     }
 }