refactor(pager): gate cache-eviction test helpers to test builds

evict_clean_main_pages and its cache-layer counterpart are exercised
only by tests, so mark them #[cfg(test)] rather than shipping them in
the crate's public build surface. Move the test that exercises them
into the unit tests beside Db, per this crate's convention that
implementation-detail coverage lives with the code it tests.

Author: farhan-syah

src/pager/cache.rs

@@ -270,42 +270,33 @@ impl PageCache {
     /// when compaction replaces the backing file (the cached pages no longer
     /// match what is on disk). Pinned entries are left untouched.
     pub fn clear_file(&mut self, file: FileKey) {
-        let keys: Vec<(FileKey, u64)> = self
-            .map
-            .keys()
-            .filter(|(f, _)| *f == file)
-            .copied()
-            .collect();
-        for key in keys {
-            if self.pins.get(&key).copied().unwrap_or(0) > 0 {
-                continue;
-            }
-            if let Some(idx) = self.map.remove(&key) {
-                let (prev, next) = {
-                    let node = self.slab[idx].as_ref().expect("indexed node alive");
-                    (node.prev, node.next)
-                };
-                if self.hand == Some(idx) {
-                    self.hand = next;
-                }
-                self.unlink_node(idx, prev, next);
-                self.free_node(idx);
-            }
-            self.dirty.remove(&key);
-        }
+        self.clear_file_entries(file, false);
     }
 
     /// Drop every unpinned clean entry for `file`, leaving dirty entries
     /// available for a later flush and pinned entries available to readers.
+    /// Used to force a re-read of the durable bytes without discarding the
+    /// in-flight writes that have not reached them yet.
+    #[cfg(test)]
     pub fn clear_clean_file(&mut self, file: FileKey) {
+        self.clear_file_entries(file, true);
+    }
+
+    /// Shared body of the two `clear_*` entry points. Pinned entries are always
+    /// spared: a reader holds them. `keep_dirty` decides whether an unflushed
+    /// entry is spared as well, or dropped along with its dirty marker.
+    fn clear_file_entries(&mut self, file: FileKey, keep_dirty: bool) {
         let keys: Vec<(FileKey, u64)> = self
             .map
             .keys()
             .filter(|(f, _)| *f == file)
             .copied()
             .collect();
         for key in keys {
-            if self.pins.get(&key).copied().unwrap_or(0) > 0 || self.dirty.contains(&key) {
+            if self.pins.get(&key).copied().unwrap_or(0) > 0 {
+                continue;
+            }
+            if keep_dirty && self.dirty.contains(&key) {
                 continue;
             }
             if let Some(idx) = self.map.remove(&key) {
@@ -319,6 +310,9 @@ impl PageCache {
                 self.unlink_node(idx, prev, next);
                 self.free_node(idx);
             }
+            if !keep_dirty {
+                self.dirty.remove(&key);
+            }
         }
     }
 }
@@ -407,7 +401,7 @@ mod tests {
 
         assert!(c.get((FileKey::Main, 1)).is_none());
         assert!(c.get((FileKey::Main, 2)).is_some());
-        assert!(c.is_dirty((FileKey::Main, 2)));
+        assert_eq!(c.dirty_for_file(FileKey::Main), vec![2]);
     }
 
     #[test]

src/pager/core.rs

@@ -872,6 +872,11 @@ impl<V: Vfs> Pager<V> {
 
     /// Evict unpinned clean main.db pages so later reads fetch and authenticate
     /// durable bytes without discarding in-flight writes.
+    ///
+    /// Compiled only for the crate's own tests, matching the handle-level
+    /// accessor that is its sole caller: correctness never depends on whether a
+    /// page is warm, so nothing in the shipped crate should be steering that.
+    #[cfg(test)]
     pub fn evict_clean_main_pages(&self, _realm_id: crate::RealmId) {
         self.inner
             .buffer_pool

src/txn/db/misc.rs

@@ -219,6 +219,39 @@ mod tests {
     const PAGE: usize = 4096;
     const REALM: RealmId = RealmId::new([0xA5; 16]);
 
+    #[tokio::test(flavor = "current_thread")]
+    async fn evict_main_pages_forces_next_read_to_miss_cache() {
+        let db = Db::open_internal(MemVfs::new(), [9u8; 32], PAGE, REALM)
+            .await
+            .unwrap();
+        {
+            let mut txn = db.begin_write().await.unwrap();
+            txn.put(b"hello", b"world").await.unwrap();
+            txn.commit().await.unwrap();
+        }
+        {
+            let reader = db.begin_read().await.unwrap();
+            assert_eq!(
+                reader.get(b"hello").await.unwrap().as_deref(),
+                Some(b"world".as_slice())
+            );
+        }
+        let before = db.stats().await.unwrap();
+
+        db.evict_main_pages(REALM);
+
+        let reader = db.begin_read().await.unwrap();
+        assert_eq!(
+            reader.get(b"hello").await.unwrap().as_deref(),
+            Some(b"world".as_slice())
+        );
+        let after = db.stats().await.unwrap();
+        assert!(
+            after.buffer_pool_misses > before.buffer_pool_misses,
+            "eviction must force a VFS-backed cache miss: before={before:?}, after={after:?}"
+        );
+    }
+
     #[tokio::test(flavor = "current_thread")]
     async fn stats_surfaces_malformed_segment_catalog_row() {
         let db = Db::open_internal(MemVfs::new(), [9u8; 32], PAGE, REALM)

tests/stats_basic.rs

@@ -117,38 +117,6 @@ async fn stats_reports_buffer_pool() {
     );
 }
 
-#[tokio::test]
-async fn evict_main_pages_forces_next_read_to_miss_cache() {
-    let db = fresh_db().await;
-    {
-        let mut txn = db.begin_write().await.unwrap();
-        txn.put(b"hello", b"world").await.unwrap();
-        txn.commit().await.unwrap();
-    }
-
-    {
-        let reader = db.begin_read().await.unwrap();
-        assert_eq!(
-            reader.get(b"hello").await.unwrap().as_deref(),
-            Some(b"world".as_slice())
-        );
-    }
-    let before = db.stats().await.unwrap();
-
-    db.evict_main_pages(realm());
-
-    let reader = db.begin_read().await.unwrap();
-    assert_eq!(
-        reader.get(b"hello").await.unwrap().as_deref(),
-        Some(b"world".as_slice())
-    );
-    let after = db.stats().await.unwrap();
-    assert!(
-        after.buffer_pool_misses > before.buffer_pool_misses,
-        "eviction must force a VFS-backed cache miss: before={before:?}, after={after:?}"
-    );
-}
-
 #[tokio::test]
 async fn stats_reports_mode() {
     let vfs = MemVfs::new();