feat: add test

Author: k-jingyang

tests/basic_kv.rs

@@ -1,6 +1,6 @@
 mod common;
 
-use common::{MockIndex, MockIndexWriter, NoCacher, NoCompressor};
+use common::{InMemCacher, MockIndex, MockIndexWriter, NoCacher, NoCompressor};
 use test_log::test;
 use value_log::{Config, IndexWriter, KeyRange, Slice, ValueLog};
 
@@ -72,3 +72,44 @@ fn basic_kv() -> value_log::Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn get_with_cached_fd() -> value_log::Result<()> {
+    let folder = tempfile::tempdir()?;
+    let vl_path = folder.path();
+    let items = ["a", "b", "c", "d", "e"];
+    let index = MockIndex::default();
+
+    let fd_cache = InMemCacher::default();
+    let value_log = ValueLog::open(
+        vl_path,
+        Config::<_, _, NoCompressor>::new(NoCacher, fd_cache.clone()),
+    )?;
+
+    let mut index_writer = MockIndexWriter(index.clone());
+    let mut writer = value_log.get_writer()?;
+
+    for key in items {
+        let value = key.repeat(10_000);
+        let value = value.as_bytes();
+
+        let key = key.as_bytes();
+
+        let vhandle = writer.get_next_value_handle();
+        index_writer.insert_indirect(key, vhandle, value.len() as u32)?;
+
+        writer.write(key, value)?;
+    }
+    value_log.register_writer(writer)?;
+
+    for (key, (vhandle, _)) in index.read().unwrap().iter() {
+        let item = value_log.get(vhandle)?.unwrap();
+        assert_eq!(item, key.repeat(10_000));
+    }
+
+    let index_len = index.read().unwrap().len() as u32;
+    // The first item will cache the fd, subsequent accesses will all be cache hits
+    assert_eq!(fd_cache.get_hit_count(), index_len - 1);
+
+    Ok(())
+}

tests/common.rs

@@ -3,10 +3,11 @@
 // (found in the LICENSE-* files in the repository)
 
 use std::{
-    collections::BTreeMap,
+    cell::RefCell,
+    collections::{BTreeMap, HashMap},
     fs::File,
     io::BufReader,
-    sync::{Arc, RwLock},
+    sync::{Arc, Mutex, RwLock},
 };
 use value_log::{
     BlobCache, BlobFileId, Compressor, FDCache, IndexReader, IndexWriter, UserKey, UserValue,
@@ -100,3 +101,35 @@ impl FDCache for NoCacher {
     }
     fn insert(&self, _: ValueLogId, _: BlobFileId, _: BufReader<File>) {}
 }
+
+#[derive(Clone, Default)]
+pub struct InMemCacher {
+    fd_cache: Arc<Mutex<HashMap<(ValueLogId, BlobFileId), File>>>,
+    fd_hit_count: Arc<RefCell<u32>>,
+}
+impl InMemCacher {
+    pub(crate) fn get_hit_count(&self) -> u32 {
+        *self.fd_hit_count.borrow()
+    }
+}
+
+impl FDCache for InMemCacher {
+    fn get(&self, vlog_id: ValueLogId, blob_file_id: BlobFileId) -> Option<BufReader<File>> {
+        let lock = self.fd_cache.lock().unwrap();
+        let fd = match lock.get(&(vlog_id, blob_file_id)) {
+            Some(fd) => fd,
+            None => return None,
+        };
+
+        let fd_clone = fd.try_clone().unwrap();
+        *self.fd_hit_count.borrow_mut() += 1;
+        Some(BufReader::new(fd_clone))
+    }
+
+    fn insert(&self, vlog_id: ValueLogId, blob_file_id: BlobFileId, fd: BufReader<File>) {
+        self.fd_cache
+            .lock()
+            .unwrap()
+            .insert((vlog_id, blob_file_id), fd.into_inner());
+    }
+}