feat(left-right-tlcache): add simple ests

Add a test provider and several tests.
Tests are serialized because they run in the same thread and access
the same cache. That could be avoided using distinct caches,though.

Signed-off-by: Fredi Raspall <[email protected]>

Author: Fredi-raspall

Cargo.lock

@@ -9,3 +9,6 @@ license = "Apache-2.0"
 left-right = { workspace = true }
 ahash = { workspace = true }
 thiserror = { workspace = true }
+
+[dev-dependencies]
+serial_test = { workspace = true }

left-right-tlcache/Cargo.toml

@@ -209,3 +209,368 @@ macro_rules! make_thread_local_readhandle_cache {
         }
     };
 }
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::collapsible_if)]
+
+    use super::*;
+    use left_right::{Absorb, ReadHandleFactory, WriteHandle};
+    use serial_test::serial;
+    use std::sync::Mutex;
+    // Our left-right protected struct
+    #[derive(Debug, Clone)]
+    struct TestStruct {
+        id: u64,
+        data: String,
+    }
+    impl TestStruct {
+        fn new(id: u64, data: &str) -> Self {
+            Self {
+                id,
+                data: data.to_string(),
+            }
+        }
+    }
+    // Implement identity for TestStruct
+    impl Identity<u64> for TestStruct {
+        fn identity(&self) -> u64 {
+            self.id
+        }
+    }
+
+    // Dummy implementation of Absorb for TestStruct
+    #[derive(Debug)]
+    enum TestStructChange {
+        Update(String),
+    }
+    impl Absorb<TestStructChange> for TestStruct {
+        fn absorb_first(&mut self, op: &mut TestStructChange, _other: &Self) {
+            match op {
+                TestStructChange::Update(data) => {
+                    self.data = data.clone();
+                }
+            }
+        }
+        fn sync_with(&mut self, first: &Self) {
+            *self = first.clone();
+        }
+    }
+
+    // create local cache
+    make_thread_local_readhandle_cache!(TEST_CACHE, u64, TestStruct);
+
+    // ReadHandle "owner" implementing ReadHandleProvider
+    #[derive(Debug)]
+    struct TestProviderEntry<TestStruct: Absorb<TestStructChange>, TestStructChange> {
+        id: u64,
+        factory: ReadHandleFactory<TestStruct>,
+        // writer owning the TestStruct. We use option to easily drop it
+        // and Mutex to make the provider Sync.
+        writer: Option<Mutex<WriteHandle<TestStruct, TestStructChange>>>,
+    }
+    impl TestProviderEntry<TestStruct, TestStructChange> {
+        fn new(
+            id: u64,
+            factory: ReadHandleFactory<TestStruct>,
+            writer: Option<Mutex<WriteHandle<TestStruct, TestStructChange>>>,
+        ) -> Self {
+            Self {
+                id,
+                factory,
+                writer,
+            }
+        }
+    }
+    #[derive(Debug)]
+    struct TestProvider {
+        data: HashMap<u64, TestProviderEntry<TestStruct, TestStructChange>>,
+        version: u64,
+    }
+    impl TestProvider {
+        fn new() -> Self {
+            Self {
+                data: HashMap::new(),
+                version: 0,
+            }
+        }
+        fn add_object(&mut self, key: u64, identity: u64) {
+            if key != identity {
+                let entry = self.data.get(&identity).unwrap();
+                let new = TestProviderEntry::new(identity, entry.factory.clone(), None);
+                self.data.insert(key, new);
+            } else {
+                let object = TestStruct::new(identity, "unset");
+                let (w, r) = left_right::new_from_empty(object);
+                let entry = TestProviderEntry::new(identity, r.factory(), Some(Mutex::new(w)));
+                self.data.insert(key, entry);
+                let stored = self.data.get(&key).unwrap();
+                assert_eq!(stored.id, identity);
+            }
+            self.version = self.version.wrapping_add(1);
+        }
+        fn mod_object(&mut self, key: u64, data: &str) {
+            if let Some(object) = self.data.get_mut(&key) {
+                if let Some(writer_lock) = &mut object.writer {
+                    #[allow(clippy::mut_mutex_lock)] // lock exists just to make provider Sync
+                    let mut writer = writer_lock.lock().unwrap();
+                    writer.append(TestStructChange::Update(data.to_owned()));
+                    writer.publish();
+                }
+            }
+        }
+        fn drop_writer(&mut self, key: u64) {
+            if let Some(object) = self.data.get_mut(&key) {
+                let x = object.writer.take();
+                drop(x);
+                self.version = self.version.wrapping_add(1);
+            }
+        }
+    }
+
+    // Implement trait ReadHandleProvider
+    impl ReadHandleProvider for TestProvider {
+        type Data = TestStruct;
+        type Key = u64;
+        fn get_version(&self) -> u64 {
+            self.version
+        }
+        fn get_factory(
+            &self,
+            key: &Self::Key,
+        ) -> Option<(&ReadHandleFactory<Self::Data>, Self::Key, u64)> {
+            self.data
+                .get(key)
+                .map(|entry| (&entry.factory, entry.id, self.version))
+        }
+        fn get_identity(&self, key: &Self::Key) -> Option<Self::Key> {
+            self.data.get(key).map(|entry| entry.id)
+        }
+    }
+
+    #[serial]
+    #[test]
+    fn test_readhandle_cache_basic() {
+        // start fresh
+        ReadHandleCache::purge(&TEST_CACHE);
+
+        // build provider
+        let mut provider = TestProvider::new();
+        provider.add_object(1, 1);
+        provider.add_object(2, 2);
+        provider.mod_object(1, "object-1");
+        provider.mod_object(2, "object-2");
+
+        // add alias for 1
+        provider.add_object(6000, 1);
+
+        {
+            let key = 1;
+            println!("Test: Access to object with key {key}");
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, key, &provider).unwrap();
+            let x = h.enter().unwrap();
+            let obj = x.as_ref();
+            assert_eq!(obj.id, 1);
+            assert_eq!(obj.data, "object-1");
+        }
+
+        {
+            let key = 2;
+            println!("Test: Access to object with key {key}");
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, key, &provider).unwrap();
+            let x = h.enter().unwrap();
+            let obj = x.as_ref();
+            assert_eq!(obj.id, 2);
+            assert_eq!(obj.data, "object-2");
+        }
+
+        {
+            // 6000 is alias for 1: should access object with id 1
+            let key = 6000;
+            println!("Test: Access to object with key {key}");
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, key, &provider).unwrap();
+            let x = h.enter().unwrap();
+            let obj = x.as_ref();
+            assert_eq!(obj.id, 1);
+            assert_eq!(obj.data, "object-1");
+        }
+
+        TEST_CACHE.with(|x| {
+            let x = x.handles.borrow();
+            assert!(x.contains_key(&6000));
+            assert!(x.contains_key(&1));
+            assert!(x.contains_key(&2));
+            assert_eq!(x.len(), 3);
+            println!("Test: cache contains entries");
+        });
+
+        println!("Change: Let 6000 be a key for 2 instead of 1");
+        provider.add_object(6000, 2);
+        provider.mod_object(2, "object-2-modified");
+        {
+            let key = 6000;
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, key, &provider).unwrap();
+            let x = h.enter().unwrap();
+            let obj = x.as_ref();
+            assert_eq!(obj.id, 2);
+            assert_eq!(obj.data, "object-2-modified");
+        }
+        {
+            let key = 6000;
+            println!("Test: Access to object with key {key}");
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, key, &provider).unwrap();
+            let x = h.enter().unwrap();
+            let obj = x.as_ref();
+            assert_eq!(obj.id, 2);
+            assert_eq!(obj.data, "object-2-modified");
+        }
+
+        println!("Change: drop data for object 1. It should not be accessible");
+        provider.drop_writer(1);
+        {
+            let key = 1;
+            println!("Test: Access to object with key {key}");
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, key, &provider);
+            assert!(h.is_err_and(|e| e == ReadHandleCacheError::NotAccessible(key)));
+        }
+
+        println!("Change: drop data for object 2: should not be accessible by keys 2 and 6000");
+        provider.drop_writer(2);
+        {
+            let key = 2;
+            println!("Test: Access to object with key {key}");
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, key, &provider);
+            assert!(h.is_err_and(|e| e == ReadHandleCacheError::NotAccessible(key)));
+        }
+        {
+            let key = 6000;
+            println!("Test: Access to object with key {key}");
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, key, &provider);
+            assert!(h.is_err_and(|e| e == ReadHandleCacheError::NotAccessible(key)));
+        }
+
+        // ensure cache is clean
+        TEST_CACHE.with(|x| {
+            let x = x.handles.borrow();
+            assert!(!x.contains_key(&6000));
+            assert!(!x.contains_key(&1));
+            assert!(!x.contains_key(&2));
+            assert!(x.is_empty());
+            println!("Test: cache is empty");
+        });
+    }
+
+    #[serial]
+    #[test]
+    fn test_readhandle_cache_multi_invalidation() {
+        // start fresh
+        ReadHandleCache::purge(&TEST_CACHE);
+
+        const NUM_ALIASES: u64 = 10;
+
+        // build provider
+        let mut provider = TestProvider::new();
+        provider.add_object(1, 1);
+        provider.mod_object(1, "object-1");
+
+        // add aliases
+        for k in 1..=NUM_ALIASES {
+            let alias = 100 + k;
+            provider.add_object(alias, 1);
+        }
+
+        // query for identity and all aliases
+        ReadHandleCache::get_reader(&TEST_CACHE, 1, &provider).unwrap();
+        for k in 1..=NUM_ALIASES {
+            let alias = 100 + k;
+            ReadHandleCache::get_reader(&TEST_CACHE, alias, &provider).unwrap();
+        }
+
+        // cache should contain NUM_ALIASES + 1 entries
+        TEST_CACHE
+            .with(|cache| assert_eq!(cache.handles.borrow().len() as u64, (NUM_ALIASES + 1u64)));
+
+        provider.drop_writer(1);
+
+        // do single query for identity
+        let h = ReadHandleCache::get_reader(&TEST_CACHE, 1, &provider);
+        assert!(h.is_err_and(|e| e == ReadHandleCacheError::NotAccessible(1)));
+
+        // all entries should have been invalidated
+        TEST_CACHE.with(|cache| assert!(cache.handles.borrow().is_empty()));
+
+        // querying again with key = identity should fail
+        let h = ReadHandleCache::get_reader(&TEST_CACHE, 1, &provider);
+        assert!(h.is_err_and(|e| e == ReadHandleCacheError::NotAccessible(1)));
+
+        // querying again with aliases should fail too. Aliases are 100 + k k=1..=NUM_ALIASES
+        let alias = 100 + 1;
+        let h = ReadHandleCache::get_reader(&TEST_CACHE, alias, &provider);
+        assert!(h.is_err_and(|e| e == ReadHandleCacheError::NotAccessible(alias)));
+    }
+
+    #[serial]
+    #[test]
+    fn test_readhandle_cache() {
+        // start fresh
+        ReadHandleCache::purge(&TEST_CACHE);
+
+        // build provider and populate it
+        const NUM_HANDLES: u64 = 1000;
+        let mut provider = TestProvider::new();
+        for id in 0..=NUM_HANDLES {
+            provider.add_object(id, id);
+            provider.mod_object(id, format!("object-id-{id}").as_ref());
+            provider.add_object(id + NUM_HANDLES + 1, id);
+        }
+
+        // access all objects by id
+        for id in 0..=NUM_HANDLES {
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, id, &provider).unwrap();
+            let x = h.enter().unwrap();
+            let obj = x.as_ref();
+            assert_eq!(obj.id, id);
+        }
+
+        // access all objects by alias
+        for id in 0..=NUM_HANDLES {
+            let alias = id + NUM_HANDLES + 1;
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, alias, &provider).unwrap();
+            let x = h.enter().unwrap();
+            let obj = x.as_ref();
+            assert_eq!(obj.id, id);
+        }
+
+        // modify all objects and replace all aliases
+        for id in 0..=NUM_HANDLES {
+            let alias = 2 * NUM_HANDLES + 1 - id;
+            provider.mod_object(id, format!("modified-id-{id}").as_ref());
+            provider.add_object(alias, id);
+        }
+
+        // access objects with re-assigned aliases
+        for id in 0..=NUM_HANDLES {
+            let alias = 2 * NUM_HANDLES + 1 - id;
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, alias, &provider).unwrap();
+            let x = h.enter().unwrap();
+            let obj = x.as_ref();
+            assert_eq!(obj.id, id);
+            assert_eq!(obj.data, format!("modified-id-{id}"));
+        }
+
+        // invalidate all writers
+        for id in 0..=NUM_HANDLES {
+            provider.drop_writer(id);
+        }
+
+        // access objects from alias: none should be accessible
+        for id in 0..=NUM_HANDLES {
+            let alias = 2 * NUM_HANDLES + 1 - id;
+            let h = ReadHandleCache::get_reader(&TEST_CACHE, alias, &provider);
+            assert!(h.is_err_and(|e| e == ReadHandleCacheError::NotAccessible(alias)));
+        }
+
+        // all handles from cache should have been removed as we looked up them all
+        TEST_CACHE.with(|cache| assert!(cache.handles.borrow().is_empty()));
+    }
+}