0.34.6_repo_cleanup

src/cache/dashboard_tests.rs

@@ -0,0 +1,313 @@
+mod dashboard_tests {
+    use super::*;
+    use http_body_util::BodyExt;
+    async fn fill(cache: &Arc<Cache>, scope: &str, host: &str, path: &str) -> Ticket {
+        let t = cache
+            .ticket_scoped(
+                7,
+                scope,
+                "http",
+                host,
+                "origin@127.0.0.1:8080",
+                path,
+                &HeaderMap::new(),
+            )
+            .unwrap();
+        let settings = Settings {
+            enabled: true,
+            ..Settings::default()
+        };
+        let mut response = Response::new(Body::from("public representation"));
+        response.headers_mut().insert(
+            "cache-control",
+            HeaderValue::from_static("public, max-age=30"),
+        );
+        response
+            .headers_mut()
+            .insert("vary", HeaderValue::from_static("Accept-Language"));
+        let p = plan(
+            StatusCode::OK,
+            response.headers(),
+            &settings,
+            Duration::ZERO,
+        )
+        .unwrap();
+        cache
+            .wrap(response, t.clone(), p, &settings)
+            .into_body()
+            .collect()
+            .await
+            .unwrap();
+        t
+    }
+    #[tokio::test]
+    async fn dashboard_is_scoped_paginated_and_exposes_invalidation_identity_not_bodies() {
+        let cache = Cache::new(7);
+        let a = fill(&cache, "alpha", "a.example", "/data?private-query=secret").await;
+        fill(&cache, "beta", "b.example", "/other").await;
+        cache.record("alpha", "a.example", "MISS", "cache_miss");
+        assert!(cache.get(&a).is_some());
+        cache.record("alpha", "a.example", "HIT", "cache_hit");
+        cache.record("alpha", "a.example", "BYPASS", "request_cookie");
+        let d = cache.dashboard(Some("alpha"), 0, 50);
+        assert_eq!(d.matching_objects, 1);
+        assert_eq!(d.domains.len(), 1);
+        assert_eq!(d.domains[0].counters.hits, 1);
+        assert_eq!(d.domains[0].counters.stored, 1);
+        assert_eq!(d.domains[0].counters.saved_body_bytes, 21);
+        assert_eq!(d.objects[0].path, "/data");
+        assert_eq!(d.objects[0].target, "/data?private-query=secret");
+        assert_eq!(d.objects[0].cache_key.len(), 64);
+        assert_eq!(d.objects[0].hits, 1);
+        let encoded = serde_json::to_string(&d).unwrap();
+        assert!(encoded.contains("private-query=secret"));
+        assert!(!encoded.contains("public representation"));
+        assert_eq!(cache.dashboard(None, 1, 1).objects.len(), 1);
+        assert_eq!(cache.dashboard(None, 99, 999).limit, 200);
+        assert_eq!(cache.purge_scope("alpha"), 1);
+        assert_eq!(cache.dashboard(Some("beta"), 0, 50).matching_objects, 1);
+        assert_eq!(
+            cache.dashboard(Some("alpha"), 0, 50).domains[0]
+                .counters
+                .hits,
+            1
+        );
+        cache.purge(Some(8));
+        assert!(cache.dashboard(None, 0, 50).domains.is_empty());
+    }
+    #[tokio::test]
+    async fn dashboard_retains_expired_entries_for_client_max_stale() {
+        let cache = Cache::new(7);
+        let ticket = fill(&cache, "a", "a.example", "/").await;
+        {
+            let mut store = cache.store.lock().unwrap();
+            for entry in store.entries.values_mut() {
+                entry.received = Instant::now() - Duration::from_secs(2 * 60 * 60);
+            }
+        }
+        let dashboard = cache.dashboard(None, 0, 50);
+        assert_eq!(dashboard.matching_objects, 1);
+        assert_eq!(dashboard.objects[0].remaining_ttl_seconds, 0);
+        assert!(dashboard.objects[0].age_seconds >= 2 * 60 * 60);
+        assert_eq!(cache.view().entries, 1);
+        assert_eq!(cache.view().expired, 0);
+        assert!(
+            cache.get(&ticket).is_none(),
+            "inventory visibility cannot permit unconditional stale delivery"
+        );
+        let mut stale = ticket;
+        stale
+            .request_headers
+            .insert("cache-control", HeaderValue::from_static("max-stale"));
+        assert!(cache.get(&stale).unwrap().stale);
+    }
+    #[test]
+    fn bypass_reasons_are_fixed_and_private_inputs_are_not_echoed() {
+        let settings = Settings::default();
+        let mut headers = HeaderMap::new();
+        headers.insert("cookie", HeaderValue::from_static("session=very-private"));
+        assert_eq!(
+            request_reason(&Method::GET, &headers, true, "/", false, &settings),
+            Some("request_cookie")
+        );
+        headers.remove("cookie");
+        headers.insert("cache-control", HeaderValue::from_static("no-cache"));
+        assert_eq!(
+            request_reason(&Method::GET, &headers, true, "/", false, &settings),
+            None
+        );
+        assert_eq!(
+            request_policy(&Method::GET, &headers, true, "/", false, &settings),
+            RequestPolicy::Revalidate("request_no_cache")
+        );
+        let diagnostics = Settings {
+            expose_status: true,
+            expose_cache_status: true,
+            ..settings
+        };
+        diagnostics.annotate_reason(&mut headers, "BYPASS", 0, 0, "request_cookie");
+        assert_eq!(headers["x-cache-reason"], "request_cookie");
+        assert_eq!(
+            headers["cache-status"],
+            "RustProxy; fwd=bypass; detail=\"request_cookie\""
+        );
+        diagnostics.annotate_transformed(&mut headers, true);
+        assert_eq!(
+            headers["cache-status"],
+            "RustProxy; fwd=bypass; detail=\"request_cookie\"; transformed"
+        );
+    }
+    #[test]
+    fn hit_only_cache_diagnostics_hides_miss_bypass_and_preserves_hits() {
+        let global = Settings {
+            expose_status: true,
+            expose_hits: true,
+            expose_cache_status: true,
+            expose_resident_age: true,
+            expose_only_hits: true,
+            ..Settings::default()
+        };
+        let mut headers = HeaderMap::new();
+        headers.insert("x-cache", HeaderValue::from_static("untrusted-upstream"));
+        headers.insert(
+            "cache-status",
+            HeaderValue::from_static("untrusted-upstream"),
+        );
+        global.annotate_reason(&mut headers, "MISS", 0, 0, "response_headers_policy");
+        global.annotate_transformed(&mut headers, true);
+        for name in [
+            "x-cache",
+            "x-cache-hits",
+            "cache-status",
+            "x-cache-reason",
+            "x-cache-resident-age",
+        ] {
+            assert!(!headers.contains_key(name), "{name} leaked on MISS");
+        }
+        assert_eq!(headers["via"], "RustProxy");
+        global.annotate_reason(&mut headers, "BYPASS", 0, 0, "request_cookie");
+        assert!(!headers.contains_key("cache-status"));
+        global.annotate_reason(&mut headers, "HIT", 4, 60, "cache_hit");
+        global.annotate_resident_age(&mut headers, 10);
+        assert_eq!(headers["x-cache"], "HIT");
+        assert_eq!(headers["x-cache-hits"], "4");
+        assert!(headers["cache-status"].to_str().unwrap().contains("; hit;"));
+        assert_eq!(headers["x-cache-resident-age"], "10");
+        let mut override_on = Overrides {
+            expose_only_hits: Some(false),
+            ..Default::default()
+        };
+        let normal = override_on.resolve(&global).unwrap();
+        assert!(!normal.expose_only_hits);
+        override_on.expose_only_hits = Some(true);
+        assert!(
+            override_on
+                .resolve(&Settings::default())
+                .unwrap()
+                .expose_only_hits
+        );
+    }
+    #[test]
+    fn via_header_is_configurable_and_preserves_upstream_chain() {
+        let settings = Settings::default();
+        let mut headers = HeaderMap::new();
+        headers.append("via", HeaderValue::from_static("1.1 upstream"));
+        settings.annotate(&mut headers, "HIT", 1, 20);
+        let values: Vec<_> = headers
+            .get_all("via")
+            .iter()
+            .map(|value| value.to_str().unwrap())
+            .collect();
+        assert_eq!(values, vec!["1.1 upstream", "RustProxy"]);
+
+        let disabled = Settings {
+            via_header: None,
+            ..Settings::default()
+        };
+        let mut headers = HeaderMap::new();
+        disabled.annotate(&mut headers, "MISS", 0, 0);
+        assert!(!headers.contains_key("via"));
+    }
+
+    #[test]
+    fn disabled_cache_strips_diagnostics_without_exposing_bypass_headers() {
+        let settings = Settings {
+            enabled: false,
+            expose_status: true,
+            expose_hits: true,
+            expose_cache_status: true,
+            expose_resident_age: true,
+            ..Settings::default()
+        };
+        let mut headers = HeaderMap::new();
+        headers.insert("x-cache", HeaderValue::from_static("origin"));
+        headers.insert("x-cache-hits", HeaderValue::from_static("99"));
+        headers.insert("x-cache-status", HeaderValue::from_static("origin"));
+        headers.insert("cache-status", HeaderValue::from_static("Origin; hit"));
+        headers.insert("x-cache-reason", HeaderValue::from_static("origin"));
+        headers.insert("x-cache-resident-age", HeaderValue::from_static("5"));
+        settings.annotate_reason(&mut headers, "BYPASS", 0, 0, "cache_disabled");
+        settings.annotate_resident_age(&mut headers, 9);
+        for name in [
+            "x-cache",
+            "x-cache-hits",
+            "x-cache-status",
+            "cache-status",
+            "x-cache-reason",
+            "x-cache-resident-age",
+        ] {
+            assert!(!headers.contains_key(name), "{name}");
+        }
+    }
+
+    #[test]
+    fn cache_domain_metrics_do_not_lock_hot_store_and_preserve_reasons() {
+        let cache = Cache::new(7);
+        let store = cache.store.lock().unwrap();
+        cache.record("alpha", "a.example", "BYPASS", "cache_disabled");
+        cache.record_reason("alpha", "a.example", "background_refresh_failure");
+        drop(store);
+        let workers = 8;
+        let each = 2000;
+        let mut tasks = Vec::new();
+        for _ in 0..workers {
+            let cache = Arc::clone(&cache);
+            tasks.push(std::thread::spawn(move || {
+                for _ in 0..each {
+                    cache.record("alpha", "a.example", "BYPASS", "cache_disabled");
+                    cache.record("alpha", "a.example", "HIT", "cache_hit");
+                }
+            }));
+        }
+        for task in tasks {
+            task.join().expect("domain counter worker");
+        }
+        let scoped = cache.dashboard(Some("alpha"), 0, 1);
+        assert_eq!(scoped.domains.len(), 1);
+        let counters = &scoped.domains[0].counters;
+        assert_eq!(counters.bypasses, 1 + workers * each);
+        assert_eq!(counters.hits, workers * each);
+        assert_eq!(counters.reasons["cache_disabled"], 1 + workers * each);
+        assert_eq!(counters.reasons["cache_hit"], workers * each);
+        assert_eq!(counters.reasons["background_refresh_failure"], 1);
+        assert_eq!(cache.purge_scope("alpha"), 0);
+        assert_eq!(
+            cache.dashboard(Some("alpha"), 0, 1).domains[0]
+                .counters
+                .hits,
+            workers * each
+        );
+        cache.purge(Some(8));
+        assert!(cache.dashboard(None, 0, 1).domains.is_empty());
+        cache.record("alpha", "a.example", "MISS", "cache_miss");
+        let after_reset = cache.dashboard(Some("alpha"), 0, 1);
+        assert_eq!(after_reset.domains[0].counters.misses, 1);
+        assert_eq!(after_reset.domains[0].counters.hits, 0);
+        assert_eq!(after_reset.statistics_revision, 8);
+    }
+
+    #[test]
+    fn first_hit_saved_bytes_registers_domain_even_without_prior_record() {
+        let cache = Cache::new(7);
+        cache
+            .domain_stats
+            .saved_body_hit("cold", "restored.example", 1040);
+        let result = cache.dashboard(Some("cold"), 0, 1);
+        assert_eq!(result.domains.len(), 1);
+        assert_eq!(result.domains[0].counters.saved_body_bytes, 1040);
+    }
+
+    #[test]
+    fn per_domain_counter_cardinality_is_bounded() {
+        let cache = Cache::new(7);
+        for i in 0..5000 {
+            cache.record(
+                "legacy",
+                &format!("{i}.example"),
+                "BYPASS",
+                "cache_disabled",
+            );
+        }
+        assert_eq!(cache.dashboard(None, 0, 1).domains.len(), 4096);
+    }
+}