Factor test tools between store and fragment

Those need the driver to deal with the fact that the store is stateful. Those tests can't be moved to the test suite because they use private functions.
2021-01-25 17:30:50 +01:00
parent 846ff279bb
commit ae0156d287
5 changed files with 211 additions and 253 deletions
--- a/libraries/persistent_store/src/fragment.rs
+++ b/libraries/persistent_store/src/fragment.rs
@@ -177,3 +177,168 @@ fn get_handles(store: &Store<impl Storage>, keys: &impl Keys) -> StoreResult<Vec
    }
    Ok(result)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test::MINIMAL;
+
+    #[test]
+    fn read_empty_entry() {
+        let store = MINIMAL.new_store();
+        assert_eq!(read(&store, &(0..4)), Ok(None));
+    }
+
+    #[test]
+    fn read_single_chunk() {
+        let mut store = MINIMAL.new_store();
+        let value = b"hello".to_vec();
+        assert_eq!(store.insert(0, &value), Ok(()));
+        assert_eq!(read(&store, &(0..4)), Ok(Some(value)));
+    }
+
+    #[test]
+    fn read_multiple_chunks() {
+        let mut store = MINIMAL.new_store();
+        let value: Vec<_> = (0..60).collect();
+        assert_eq!(store.insert(0, &value[..52]), Ok(()));
+        assert_eq!(store.insert(1, &value[52..]), Ok(()));
+        assert_eq!(read(&store, &(0..4)), Ok(Some(value)));
+    }
+
+    #[test]
+    fn read_range_first_chunk() {
+        let mut store = MINIMAL.new_store();
+        let value: Vec<_> = (0..60).collect();
+        assert_eq!(store.insert(0, &value[..52]), Ok(()));
+        assert_eq!(store.insert(1, &value[52..]), Ok(()));
+        assert_eq!(
+            read_range(&store, &(0..4), 0..10),
+            Ok(Some((0..10).collect()))
+        );
+        assert_eq!(
+            read_range(&store, &(0..4), 10..20),
+            Ok(Some((10..20).collect()))
+        );
+        assert_eq!(
+            read_range(&store, &(0..4), 40..52),
+            Ok(Some((40..52).collect()))
+        );
+    }
+
+    #[test]
+    fn read_range_second_chunk() {
+        let mut store = MINIMAL.new_store();
+        let value: Vec<_> = (0..60).collect();
+        assert_eq!(store.insert(0, &value[..52]), Ok(()));
+        assert_eq!(store.insert(1, &value[52..]), Ok(()));
+        assert_eq!(read_range(&store, &(0..4), 52..53), Ok(Some(vec![52])));
+        assert_eq!(read_range(&store, &(0..4), 53..54), Ok(Some(vec![53])));
+        assert_eq!(read_range(&store, &(0..4), 59..60), Ok(Some(vec![59])));
+    }
+
+    #[test]
+    fn read_range_both_chunks() {
+        let mut store = MINIMAL.new_store();
+        let value: Vec<_> = (0..60).collect();
+        assert_eq!(store.insert(0, &value[..52]), Ok(()));
+        assert_eq!(store.insert(1, &value[52..]), Ok(()));
+        assert_eq!(
+            read_range(&store, &(0..4), 40..60),
+            Ok(Some((40..60).collect()))
+        );
+        assert_eq!(
+            read_range(&store, &(0..4), 0..60),
+            Ok(Some((0..60).collect()))
+        );
+    }
+
+    #[test]
+    fn read_range_outside() {
+        let mut store = MINIMAL.new_store();
+        let value: Vec<_> = (0..60).collect();
+        assert_eq!(store.insert(0, &value[..52]), Ok(()));
+        assert_eq!(store.insert(1, &value[52..]), Ok(()));
+        assert_eq!(
+            read_range(&store, &(0..4), 40..100),
+            Ok(Some((40..60).collect()))
+        );
+        assert_eq!(read_range(&store, &(0..4), 60..100), Ok(Some(vec![])));
+    }
+
+    #[test]
+    fn write_single_chunk() {
+        let mut store = MINIMAL.new_store();
+        let value = b"hello".to_vec();
+        assert_eq!(write(&mut store, &(0..4), &value), Ok(()));
+        assert_eq!(store.find(0), Ok(Some(value)));
+        assert_eq!(store.find(1), Ok(None));
+        assert_eq!(store.find(2), Ok(None));
+        assert_eq!(store.find(3), Ok(None));
+    }
+
+    #[test]
+    fn write_multiple_chunks() {
+        let mut store = MINIMAL.new_store();
+        let value: Vec<_> = (0..60).collect();
+        assert_eq!(write(&mut store, &(0..4), &value), Ok(()));
+        assert_eq!(store.find(0), Ok(Some((0..52).collect())));
+        assert_eq!(store.find(1), Ok(Some((52..60).collect())));
+        assert_eq!(store.find(2), Ok(None));
+        assert_eq!(store.find(3), Ok(None));
+    }
+
+    #[test]
+    fn overwrite_less_chunks() {
+        let mut store = MINIMAL.new_store();
+        let value: Vec<_> = (0..60).collect();
+        assert_eq!(store.insert(0, &value[..52]), Ok(()));
+        assert_eq!(store.insert(1, &value[52..]), Ok(()));
+        let value: Vec<_> = (42..69).collect();
+        assert_eq!(write(&mut store, &(0..4), &value), Ok(()));
+        assert_eq!(store.find(0), Ok(Some((42..69).collect())));
+        assert_eq!(store.find(1), Ok(None));
+        assert_eq!(store.find(2), Ok(None));
+        assert_eq!(store.find(3), Ok(None));
+    }
+
+    #[test]
+    fn overwrite_needed_chunks() {
+        let mut store = MINIMAL.new_store();
+        let mut value: Vec<_> = (0..60).collect();
+        assert_eq!(store.insert(0, &value[..52]), Ok(()));
+        assert_eq!(store.insert(1, &value[52..]), Ok(()));
+        // Current lifetime is 2 words of overhead (2 insert) and 60 bytes of data.
+        let mut lifetime = 2 + 60 / 4;
+        assert_eq!(store.lifetime().unwrap().used(), lifetime);
+        // Update the value.
+        value.extend(60..80);
+        assert_eq!(write(&mut store, &(0..4), &value), Ok(()));
+        // Added lifetime is 1 word of overhead (1 insert) and (80 - 52) bytes of data.
+        lifetime += 1 + (80 - 52) / 4;
+        assert_eq!(store.lifetime().unwrap().used(), lifetime);
+    }
+
+    #[test]
+    fn delete_empty() {
+        let mut store = MINIMAL.new_store();
+        assert_eq!(delete(&mut store, &(0..4)), Ok(()));
+        assert_eq!(store.find(0), Ok(None));
+        assert_eq!(store.find(1), Ok(None));
+        assert_eq!(store.find(2), Ok(None));
+        assert_eq!(store.find(3), Ok(None));
+    }
+
+    #[test]
+    fn delete_chunks() {
+        let mut store = MINIMAL.new_store();
+        let value: Vec<_> = (0..60).collect();
+        assert_eq!(store.insert(0, &value[..52]), Ok(()));
+        assert_eq!(store.insert(1, &value[52..]), Ok(()));
+        assert_eq!(delete(&mut store, &(0..4)), Ok(()));
+        assert_eq!(store.find(0), Ok(None));
+        assert_eq!(store.find(1), Ok(None));
+        assert_eq!(store.find(2), Ok(None));
+        assert_eq!(store.find(3), Ok(None));
+    }
+}