From e770de3d3dc11afc59f83e5eac89591bf9191e12 Mon Sep 17 00:00:00 2001 From: Tglman Date: Sat, 15 Jan 2022 14:07:16 +0000 Subject: [PATCH] test: add abstract test implementations and specific implementation for sqlite --- Cargo.toml | 3 + src/database/abstraction.rs | 3 + src/database/abstraction/tests.rs | 227 ++++++++++++++++++++++++++++++ 3 files changed, 233 insertions(+) create mode 100644 src/database/abstraction/tests.rs diff --git a/Cargo.toml b/Cargo.toml index 0cdde4ab..cbf7ba5f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -175,6 +175,9 @@ version = "0.25" [target.'cfg(unix)'.dependencies] nix = { version = "0.28", features = ["resource"] } +[dev-dependencies] +tempfile = "3.2" + [features] default = ["backend_rocksdb", "backend_sqlite", "conduit_bin", "systemd"] #backend_sled = ["sled"] diff --git a/src/database/abstraction.rs b/src/database/abstraction.rs index 93660f9f..a3c6ccfd 100644 --- a/src/database/abstraction.rs +++ b/src/database/abstraction.rs @@ -26,6 +26,9 @@ pub mod persy; ))] pub mod watchers; +#[cfg(test)] +mod tests; + pub trait KeyValueDatabaseEngine: Send + Sync { fn open(config: &Config) -> Result where diff --git a/src/database/abstraction/tests.rs b/src/database/abstraction/tests.rs new file mode 100644 index 00000000..313a55f3 --- /dev/null +++ b/src/database/abstraction/tests.rs @@ -0,0 +1,227 @@ +use crate::database::{abstraction::Tree, Config}; + +fn insert_get(tree: &dyn Tree) { + let key = "key".as_bytes(); + let value = "value".as_bytes(); + tree.insert(key, value).unwrap(); + let read = tree.get(key).unwrap(); + assert_eq!(read, Some(value.to_owned())); +} + +fn insert_get_remove(tree: &dyn Tree) { + let key = "key".as_bytes(); + let value = "value".as_bytes(); + tree.insert(key, value).unwrap(); + let read = tree.get(key).unwrap(); + assert_eq!(read, Some(value.to_owned())); + tree.remove(key).unwrap(); + let read = tree.get(key).unwrap(); + assert_eq!(read, None); +} + +fn batch_insert_get(tree: &dyn Tree) { + let key = "key".as_bytes(); + let value = "value".as_bytes(); + let key1 = "key1".as_bytes(); + let value1 = "value1".as_bytes(); + let key2 = "key2".as_bytes(); + let value2 = "value2".as_bytes(); + tree.insert_batch( + &mut vec![ + (key.to_owned(), value.to_owned()), + (key1.to_owned(), value1.to_owned()), + (key2.to_owned(), value2.to_owned()), + ] + .into_iter(), + ) + .unwrap(); + let read = tree.get(key).unwrap(); + assert_eq!(read, Some(value.to_owned())); + let read = tree.get(key1).unwrap(); + assert_eq!(read, Some(value1.to_owned())); + let read = tree.get(key2).unwrap(); + assert_eq!(read, Some(value2.to_owned())); +} + +fn insert_iter(tree: &dyn Tree) { + let key = "key".as_bytes(); + let value = "value".as_bytes(); + tree.insert(key, value).unwrap(); + let key1 = "key1".as_bytes(); + let value1 = "value1".as_bytes(); + tree.insert(key1, value1).unwrap(); + let key2 = "key2".as_bytes(); + let value2 = "value2".as_bytes(); + tree.insert(key2, value2).unwrap(); + let mut iter = tree.iter(); + assert_eq!(iter.next(), Some((key.to_owned(), value.to_owned()))); + assert_eq!(iter.next(), Some((key1.to_owned(), value1.to_owned()))); + assert_eq!(iter.next(), Some((key2.to_owned(), value2.to_owned()))); + assert_eq!(iter.next(), None); +} + +fn insert_iter_from(tree: &dyn Tree) { + let key = "key".as_bytes(); + let value = "value".as_bytes(); + tree.insert(key, value).unwrap(); + let key1 = "key1".as_bytes(); + let value1 = "value1".as_bytes(); + tree.insert(key1, value1).unwrap(); + let key2 = "key2".as_bytes(); + let value2 = "value2".as_bytes(); + tree.insert(key2, value2).unwrap(); + let mut iter = tree.iter_from(key1, false); + assert_eq!(iter.next(), Some((key1.to_owned(), value1.to_owned()))); + assert_eq!(iter.next(), Some((key2.to_owned(), value2.to_owned()))); + assert_eq!(iter.next(), None); + let mut iter = tree.iter_from(key1, true); + assert_eq!(iter.next(), Some((key1.to_owned(), value1.to_owned()))); + assert_eq!(iter.next(), Some((key.to_owned(), value.to_owned()))); + assert_eq!(iter.next(), None); +} + +fn insert_iter_prefix(tree: &dyn Tree) { + let key = "key".as_bytes(); + let value = "value".as_bytes(); + tree.insert(key, value).unwrap(); + let key1 = "key1".as_bytes(); + let value1 = "value1".as_bytes(); + tree.insert(key1, value1).unwrap(); + let key11 = "key11".as_bytes(); + let value11 = "value11".as_bytes(); + tree.insert(key11, value11).unwrap(); + let key2 = "key2".as_bytes(); + let value2 = "value2".as_bytes(); + tree.insert(key2, value2).unwrap(); + let mut iter = tree.scan_prefix(key1.to_owned()); + assert_eq!(iter.next(), Some((key1.to_owned(), value1.to_owned()))); + assert_eq!(iter.next(), Some((key11.to_owned(), value11.to_owned()))); + assert_eq!(iter.next(), None); +} + +fn insert_clear(tree: &dyn Tree) { + let key = "key".as_bytes(); + let value = "value".as_bytes(); + tree.insert(key, value).unwrap(); + let key1 = "key1".as_bytes(); + let value1 = "value1".as_bytes(); + tree.insert(key1, value1).unwrap(); + let key2 = "key2".as_bytes(); + let value2 = "value2".as_bytes(); + tree.insert(key2, value2).unwrap(); + assert_eq!(tree.iter().count(), 3); + tree.clear().unwrap(); + assert_eq!(tree.iter().count(), 0); +} + +fn increment(tree: &dyn Tree) { + let key = "key".as_bytes(); + tree.increment(key).unwrap(); + let read = tree.get(key).unwrap(); + assert_eq!(crate::utils::u64_from_bytes(&read.unwrap()).unwrap(), 1); + tree.increment(key).unwrap(); + let read = tree.get(key).unwrap(); + assert_eq!(crate::utils::u64_from_bytes(&read.unwrap()).unwrap(), 2); +} + +fn increment_batch(tree: &dyn Tree) { + let key = "key".as_bytes(); + let key1 = "key1".as_bytes(); + tree.increment_batch(&mut vec![key.to_owned(), key1.to_owned()].into_iter()) + .unwrap(); + let read = tree.get(key).unwrap(); + assert_eq!(crate::utils::u64_from_bytes(&read.unwrap()).unwrap(), 1); + let read = tree.get(key1).unwrap(); + assert_eq!(crate::utils::u64_from_bytes(&read.unwrap()).unwrap(), 1); + tree.increment_batch(&mut vec![key.to_owned(), key1.to_owned()].into_iter()) + .unwrap(); + let read = tree.get(key).unwrap(); + assert_eq!(crate::utils::u64_from_bytes(&read.unwrap()).unwrap(), 2); + let read = tree.get(key1).unwrap(); + assert_eq!(crate::utils::u64_from_bytes(&read.unwrap()).unwrap(), 2); +} + +fn empty_config(database_path: &str) -> Config { + use rocket::figment::providers::{Format, Toml}; + Toml::from_str(&format!( + r#" +server_name = "test" +database_path = "{}" +"#, + database_path + )) + .unwrap() +} + +#[cfg(feature = "sqlite")] +mod sqlite { + + use super::*; + use crate::database::abstraction::{DatabaseEngine, Tree}; + use std::sync::Arc; + use tempfile::{Builder, TempDir}; + + /// Make sure to keep the reference of the tree returned values for + /// the length of the test, to avoid early cleanups that may create test issues + fn open_tree(test_name: &str) -> (Arc, impl DatabaseEngine, TempDir) { + let db_folder = Builder::new().prefix(test_name).tempdir().unwrap(); + let config = empty_config(db_folder.path().to_str().unwrap()); + let instance = Arc::::open(&config).unwrap(); + let tree = instance.open_tree("test").unwrap(); + (tree, instance, db_folder) + } + + #[test] + fn sqlite_insert_get() { + let (tree, _inst, _temp_dir) = open_tree("insert_get"); + insert_get(&*tree) + } + + #[test] + fn sqlite_insert_get_remove() { + let (tree, _inst, _temp_dir) = open_tree("insert_get_remove"); + insert_get_remove(&*tree) + } + + #[test] + fn sqlite_batch_insert_get() { + let (tree, _inst, _temp_dir) = open_tree("batch_insert_get"); + batch_insert_get(&*tree) + } + + #[test] + fn sqlite_insert_iter() { + let (tree, _inst, _temp_dir) = open_tree("insert_iter"); + insert_iter(&*tree) + } + + #[test] + fn sqlite_insert_iter_from() { + let (tree, _inst, _temp_dir) = open_tree("insert_iter_from"); + insert_iter_from(&*tree) + } + + #[test] + fn sqlite_insert_iter_prefix() { + let (tree, _inst, _temp_dir) = open_tree("insert_iter_prefix"); + insert_iter_prefix(&*tree) + } + + #[test] + fn sqlite_insert_clear() { + let (tree, _inst, _temp_dir) = open_tree("insert_iter_prefix"); + insert_clear(&*tree) + } + + #[test] + fn sqlite_increment() { + let (tree, _inst, _temp_dir) = open_tree("increment"); + increment(&*tree) + } + + #[test] + fn sqlite_increment_batch() { + let (tree, _inst, _temp_dir) = open_tree("increment_batch"); + increment_batch(&*tree) + } +}