v0.24.7

src/cache/tests.rs

@@ -662,6 +662,8 @@ mod tests {
     #[test]
     fn cache_memory_defaults_are_bounded_and_sane() {
         let s = Settings::default();
+        assert_eq!(s.memory_preset, None);
+        assert_eq!(s.cold_preset, None);
         assert_eq!(s.max_bytes, 256 * 1024 * 1024);
         assert_eq!(s.max_object_bytes, 16 * 1024 * 1024);
         assert_eq!(s.transient_max_bytes, 64 * 1024 * 1024);
@@ -672,6 +674,19 @@ mod tests {
         assert!(Cache::fill_headroom_bytes(s.max_bytes) <= 1024 * 1024);
     }
 
+    #[test]
+    fn cache_preset_intent_round_trips_with_configuration() {
+        let mut settings = Settings::default();
+        settings.memory_preset = Some(MemoryPreset::Recommended);
+        settings.cold_preset = Some(ColdPreset::Recommended);
+        let encoded = serde_json::to_value(&settings).unwrap();
+        assert_eq!(encoded["memory_preset"], "recommended");
+        assert_eq!(encoded["cold_preset"], "recommended");
+        let decoded: Settings = serde_json::from_value(encoded).unwrap();
+        assert_eq!(decoded.memory_preset, Some(MemoryPreset::Recommended));
+        assert_eq!(decoded.cold_preset, Some(ColdPreset::Recommended));
+    }
+
     #[test]
     fn transient_budget_is_hard_and_released_with_lease() {
         let cache = Cache::new(1);
@@ -2142,6 +2157,84 @@ mod v022_cache_tests {
         assert_eq!(cache.view().proactive_inflight, 0);
     }
 
+    #[test]
+    fn proactive_refresh_pending_tasks_are_bounded() {
+        let cache = Cache::new(22);
+        let mut settings = active_settings();
+        settings.proactive_refresh_enabled = true;
+        settings.proactive_refresh_percent = 100;
+        settings.proactive_refresh_max_inflight = 1;
+        let mut guards = Vec::new();
+        for index in 0..64 {
+            let ticket = cache
+                .ticket(
+                    22,
+                    "http",
+                    "refresh.example",
+                    "origin",
+                    &format!("/asset-{index}"),
+                    &HeaderMap::new(),
+                )
+                .unwrap();
+            guards.push(
+                cache
+                    .begin_proactive_schedule(&ticket, &settings)
+                    .expect("schedule below pending limit"),
+            );
+        }
+        let overflow = cache
+            .ticket(
+                22,
+                "http",
+                "refresh.example",
+                "origin",
+                "/overflow",
+                &HeaderMap::new(),
+            )
+            .unwrap();
+        assert!(cache.begin_proactive_schedule(&overflow, &settings).is_none());
+        assert!(cache.view().proactive_skipped > 0);
+        drop(guards);
+    }
+
+    #[test]
+    fn background_revalidation_set_has_a_hard_limit() {
+        let cache = Cache::new(22);
+        let base = Revalidation {
+            headers: HeaderMap::new(),
+            body: Bytes::new(),
+            body_allocated: 0,
+            _transient_leases: Vec::new(),
+            hits: 0,
+            transformed: false,
+            storage_key: [0; 32],
+            resident_age_at_lookup: Duration::ZERO,
+            skip_compression: false,
+            reusable_without_validation: false,
+            age: 0,
+            ttl: 0,
+            stale_if_error: 0,
+            must_revalidate: false,
+            proxy_revalidate: false,
+            origin_etag: None,
+            origin_last_modified: None,
+        };
+        let mut guards = Vec::new();
+        for index in 0..BACKGROUND_REVALIDATION_LIMIT {
+            let mut cached = base.clone();
+            cached.storage_key[0..8].copy_from_slice(&(index as u64).to_be_bytes());
+            guards.push(
+                cache
+                    .begin_background_revalidation(&cached)
+                    .expect("revalidation below hard limit"),
+            );
+        }
+        let mut overflow = base;
+        overflow.storage_key = [0xff; 32];
+        assert!(cache.begin_background_revalidation(&overflow).is_none());
+        drop(guards);
+    }
+
     #[tokio::test]
     async fn selective_purge_exact_prefix_tag_cache_key_and_query_are_precise() {
         let cache = Cache::new(22);
@@ -3036,6 +3129,22 @@ mod cold_tier_tests {
         panic!("cold cleanup did not finish");
     }
 
+    #[tokio::test]
+    async fn manual_cold_cleanup_is_single_flight() {
+        let dir = tempfile::tempdir().unwrap();
+        let settings = cold_settings();
+        let shutdown = CancellationToken::new();
+        let cache = Cache::start(11, Some(dir.path().to_path_buf()), settings, shutdown.clone());
+        let _held = cache.cleanup_slots.clone().try_acquire_owned().unwrap();
+        let result = cache.start_cold_cleanup(ColdCleanupRequest {
+            unused_for_seconds: None,
+            oldest: Some(1),
+            hits_zero: false,
+        });
+        assert!(result.is_err());
+        shutdown.cancel();
+    }
+
     #[tokio::test]
     async fn cold_cleanup_skips_an_entry_while_a_read_is_pinned() {
         let dir = tempfile::tempdir().unwrap();