0.34.6_repo_cleanup

src/cache/policy/scope_tests.rs

@@ -0,0 +1,150 @@
+mod scope_tests {
+    use super::*;
+    use http_body_util::BodyExt;
+    async fn fill(cache: &Arc<Cache>, ticket: Ticket) {
+        let settings = Settings {
+            enabled: true,
+            ..Settings::default()
+        };
+        let mut response = Response::new(Body::from("scope-payload"));
+        response.headers_mut().insert(
+            "cache-control",
+            HeaderValue::from_static("public, max-age=30"),
+        );
+        let plan = plan(
+            StatusCode::OK,
+            response.headers(),
+            &settings,
+            Duration::ZERO,
+        )
+        .unwrap();
+        cache
+            .wrap(response, ticket, plan, &settings)
+            .into_body()
+            .collect()
+            .await
+            .unwrap();
+    }
+    #[tokio::test]
+    async fn selective_purge_preserves_other_hosts_and_cancels_old_fills() {
+        let cache = Cache::new(1);
+        let ticket = |scope| {
+            cache
+                .ticket_scoped(
+                    1,
+                    scope,
+                    "http",
+                    "same.test",
+                    "root",
+                    "/",
+                    &HeaderMap::new(),
+                )
+                .unwrap()
+        };
+        let a = ticket("a");
+        let b = ticket("b");
+        fill(&cache, a.clone()).await;
+        fill(&cache, b.clone()).await;
+        assert_eq!(cache.scope_view("a").entries, 1);
+        assert_eq!(cache.purge_scope("a"), 1);
+        assert!(cache.get(&a).is_none());
+        assert!(cache.get(&b).is_some());
+        fill(&cache, a).await;
+        assert_eq!(cache.scope_view("a").entries, 0);
+        fill(&cache, ticket("a")).await;
+        assert_eq!(cache.scope_view("a").entries, 1);
+    }
+    #[test]
+    fn stale_snapshot_cannot_issue_cache_ticket_after_config_commit() {
+        let cache = Cache::new(1);
+        cache.set_control_revision(7);
+        let ticket = |revision| cache.ticket_scoped_for_config(
+            revision, 1, "vhost-a", "http", "same.test", "main", "/resource", &HeaderMap::new()
+        );
+        assert!(ticket(7).is_some(), "the current snapshot can cache");
+        cache.set_control_revision(8);
+        assert_eq!(cache.revision(), 1);
+        assert!(ticket(7).is_none(), "late request from the previous snapshot must bypass");
+        assert!(ticket(8).is_some(), "the new snapshot can reuse the same cache identity");
+    }
+
+    #[test]
+    fn per_vhost_settings_inherit_and_cannot_expand_shared_capacity() {
+        let global = Settings::default();
+        let effective = Overrides {
+            enabled: Some(true),
+            max_ttl_seconds: Some(30),
+            expose_status: Some(true),
+            ..Overrides::default()
+        }
+        .resolve(&global)
+        .unwrap();
+        assert!(effective.enabled && effective.expose_status);
+        let mut globally_disabled = global.clone();
+        globally_disabled.enabled = false;
+        assert!(!Overrides { enabled: Some(true), ..Overrides::default() }
+            .resolve(&globally_disabled)
+            .unwrap()
+            .enabled);
+        assert!(!Overrides { enabled: Some(false), ..Overrides::default() }
+            .resolve(&global)
+            .unwrap()
+            .enabled);
+        assert!(!Overrides::default()
+            .resolve(&globally_disabled)
+            .unwrap()
+            .enabled);
+        assert_eq!(effective.max_bytes, global.max_bytes);
+        assert_eq!(effective.max_ttl_seconds, 30);
+        assert!(Overrides {
+            max_object_bytes: Some(global.max_object_bytes + 1),
+            ..Overrides::default()
+        }
+        .resolve(&global)
+        .is_err());
+        assert!(Overrides {
+            max_ttl_seconds: Some(1),
+            default_ttl_seconds: Some(2),
+            ..Overrides::default()
+        }
+        .resolve(&global)
+        .is_err());
+    }
+}
+
+#[test]
+fn unsafe_force_cache_is_per_vhost_and_matches_path_or_target_prefix() {
+    let force = UnsafeForce {
+        enabled: true,
+        targets: vec!["/convert?url=".into(), "/assets".into()],
+    };
+    force.validate().unwrap();
+    assert!(force.matches(
+        "/convert",
+        "/convert?url=https%3A%2F%2Fexample.test%2Flist.txt"
+    ));
+    assert!(force.matches("/assets/app.js", "/assets/app.js?v=1"));
+    assert!(!force.matches("/api", "/api?url=x"));
+    assert!(UnsafeForce {
+        enabled: true,
+        targets: vec!["https://example.test/".into()],
+    }
+    .validate()
+    .is_err());
+}
+
+#[test]
+fn forced_request_policy_keeps_protocol_safety_but_ignores_cookie_and_client_no_store() {
+    let mut headers = HeaderMap::new();
+    headers.insert("cookie", HeaderValue::from_static("session=abc"));
+    headers.insert("authorization", HeaderValue::from_static("Bearer token"));
+    headers.insert("cache-control", HeaderValue::from_static("no-store"));
+    assert_eq!(
+        forced_request_policy(&Method::GET, &headers, true),
+        RequestPolicy::Use
+    );
+    assert_eq!(
+        forced_request_policy(&Method::POST, &headers, true),
+        RequestPolicy::Bypass("request_method")
+    );
+}