From e770de3d3dc11afc59f83e5eac89591bf9191e12 Mon Sep 17 00:00:00 2001 From: Tglman Date: Sat, 15 Jan 2022 14:07:16 +0000 Subject: [PATCH 1/7] 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) + } +} From 326c345811aa4a253c374d57a1e20e5f4a3dc668 Mon Sep 17 00:00:00 2001 From: Tglman Date: Sat, 22 Jan 2022 13:55:58 +0000 Subject: [PATCH 2/7] test:add replace test and refactor for reduce specific test boilerplate --- src/database/abstraction/tests.rs | 65 ++++++++++++++++++++----------- 1 file changed, 43 insertions(+), 22 deletions(-) diff --git a/src/database/abstraction/tests.rs b/src/database/abstraction/tests.rs index 313a55f3..b460db75 100644 --- a/src/database/abstraction/tests.rs +++ b/src/database/abstraction/tests.rs @@ -1,4 +1,6 @@ -use crate::database::{abstraction::Tree, Config}; +use crate::database::{abstraction::{DatabaseEngine, Tree}, Config}; +use std::sync::Arc; +use tempfile::{Builder, TempDir}; fn insert_get(tree: &dyn Tree) { let key = "key".as_bytes(); @@ -8,6 +10,19 @@ fn insert_get(tree: &dyn Tree) { assert_eq!(read, Some(value.to_owned())); } +fn insert_get_replace(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())); + + let value1 = "value1".as_bytes(); + tree.insert(key, value1).unwrap(); + let read = tree.get(key).unwrap(); + assert_eq!(read, Some(value1.to_owned())); +} + fn insert_get_remove(tree: &dyn Tree) { let key = "key".as_bytes(); let value = "value".as_bytes(); @@ -153,69 +168,75 @@ database_path = "{}" .unwrap() } +/// 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) + where Arc: DatabaseEngine +{ + 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) +} + #[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) - } + use crate::database::abstraction::sqlite::Engine; #[test] fn sqlite_insert_get() { - let (tree, _inst, _temp_dir) = open_tree("insert_get"); + let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_get"); insert_get(&*tree) } + + #[test] + fn sqlite_insert_replace_get() { + let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_get_replace"); + insert_get_replace(&*tree) + } #[test] fn sqlite_insert_get_remove() { - let (tree, _inst, _temp_dir) = open_tree("insert_get_remove"); + let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_get_remove"); insert_get_remove(&*tree) } #[test] fn sqlite_batch_insert_get() { - let (tree, _inst, _temp_dir) = open_tree("batch_insert_get"); + let (tree, _inst, _temp_dir) = open_tree::("sqlite_batch_insert_get"); batch_insert_get(&*tree) } #[test] fn sqlite_insert_iter() { - let (tree, _inst, _temp_dir) = open_tree("insert_iter"); + let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_iter"); insert_iter(&*tree) } #[test] fn sqlite_insert_iter_from() { - let (tree, _inst, _temp_dir) = open_tree("insert_iter_from"); + let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_iter_from"); insert_iter_from(&*tree) } #[test] fn sqlite_insert_iter_prefix() { - let (tree, _inst, _temp_dir) = open_tree("insert_iter_prefix"); + let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_iter_prefix"); insert_iter_prefix(&*tree) } #[test] fn sqlite_insert_clear() { - let (tree, _inst, _temp_dir) = open_tree("insert_iter_prefix"); + let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_iter_prefix"); insert_clear(&*tree) } #[test] fn sqlite_increment() { - let (tree, _inst, _temp_dir) = open_tree("increment"); + let (tree, _inst, _temp_dir) = open_tree::("sqlite_increment"); increment(&*tree) } From 5a66ffd9e6fdd1c016e56679878fc59d5bba9a3b Mon Sep 17 00:00:00 2001 From: Tglman Date: Sat, 22 Jan 2022 14:07:50 +0000 Subject: [PATCH 3/7] refactor: changed tree specific impls to be one liner --- src/database/abstraction/tests.rs | 146 ++++++++++++++++++------------ 1 file changed, 90 insertions(+), 56 deletions(-) diff --git a/src/database/abstraction/tests.rs b/src/database/abstraction/tests.rs index b460db75..0187f2f1 100644 --- a/src/database/abstraction/tests.rs +++ b/src/database/abstraction/tests.rs @@ -1,8 +1,40 @@ -use crate::database::{abstraction::{DatabaseEngine, Tree}, Config}; +use crate::database::{ + abstraction::{DatabaseEngine, Tree}, + Config, +}; use std::sync::Arc; use tempfile::{Builder, TempDir}; -fn insert_get(tree: &dyn Tree) { +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() +} + +/// 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) +where + Arc: DatabaseEngine, +{ + 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) +} + +fn insert_get(name: &str) +where + Arc: DatabaseEngine, +{ + let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); let value = "value".as_bytes(); tree.insert(key, value).unwrap(); @@ -10,7 +42,11 @@ fn insert_get(tree: &dyn Tree) { assert_eq!(read, Some(value.to_owned())); } -fn insert_get_replace(tree: &dyn Tree) { +fn insert_get_replace(name: &str) +where + Arc: DatabaseEngine, +{ + let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); let value = "value".as_bytes(); tree.insert(key, value).unwrap(); @@ -23,7 +59,11 @@ fn insert_get_replace(tree: &dyn Tree) { assert_eq!(read, Some(value1.to_owned())); } -fn insert_get_remove(tree: &dyn Tree) { +fn insert_get_remove(name: &str) +where + Arc: DatabaseEngine, +{ + let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); let value = "value".as_bytes(); tree.insert(key, value).unwrap(); @@ -34,7 +74,11 @@ fn insert_get_remove(tree: &dyn Tree) { assert_eq!(read, None); } -fn batch_insert_get(tree: &dyn Tree) { +fn batch_insert_get(name: &str) +where + Arc: DatabaseEngine, +{ + let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); let value = "value".as_bytes(); let key1 = "key1".as_bytes(); @@ -58,7 +102,11 @@ fn batch_insert_get(tree: &dyn Tree) { assert_eq!(read, Some(value2.to_owned())); } -fn insert_iter(tree: &dyn Tree) { +fn insert_iter(name: &str) +where + Arc: DatabaseEngine, +{ + let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); let value = "value".as_bytes(); tree.insert(key, value).unwrap(); @@ -75,7 +123,11 @@ fn insert_iter(tree: &dyn Tree) { assert_eq!(iter.next(), None); } -fn insert_iter_from(tree: &dyn Tree) { +fn insert_iter_from(name: &str) +where + Arc: DatabaseEngine, +{ + let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); let value = "value".as_bytes(); tree.insert(key, value).unwrap(); @@ -95,7 +147,11 @@ fn insert_iter_from(tree: &dyn Tree) { assert_eq!(iter.next(), None); } -fn insert_iter_prefix(tree: &dyn Tree) { +fn insert_iter_prefix(name: &str) +where + Arc: DatabaseEngine, +{ + let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); let value = "value".as_bytes(); tree.insert(key, value).unwrap(); @@ -114,7 +170,11 @@ fn insert_iter_prefix(tree: &dyn Tree) { assert_eq!(iter.next(), None); } -fn insert_clear(tree: &dyn Tree) { +fn insert_clear(name: &str) +where + Arc: DatabaseEngine, +{ + let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); let value = "value".as_bytes(); tree.insert(key, value).unwrap(); @@ -129,7 +189,11 @@ fn insert_clear(tree: &dyn Tree) { assert_eq!(tree.iter().count(), 0); } -fn increment(tree: &dyn Tree) { +fn increment(name: &str) +where + Arc: DatabaseEngine, +{ + let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); tree.increment(key).unwrap(); let read = tree.get(key).unwrap(); @@ -139,7 +203,11 @@ fn increment(tree: &dyn Tree) { assert_eq!(crate::utils::u64_from_bytes(&read.unwrap()).unwrap(), 2); } -fn increment_batch(tree: &dyn Tree) { +fn increment_batch(name: &str) +where + Arc: DatabaseEngine, +{ + let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); let key1 = "key1".as_bytes(); tree.increment_batch(&mut vec![key.to_owned(), key1.to_owned()].into_iter()) @@ -156,30 +224,6 @@ fn increment_batch(tree: &dyn Tree) { 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() -} - -/// 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) - where Arc: DatabaseEngine -{ - 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) -} - #[cfg(feature = "sqlite")] mod sqlite { @@ -188,61 +232,51 @@ mod sqlite { #[test] fn sqlite_insert_get() { - let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_get"); - insert_get(&*tree) + insert_get::("sqlite_insert_get") } - + #[test] fn sqlite_insert_replace_get() { - let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_get_replace"); - insert_get_replace(&*tree) + insert_get_replace::("sqlite_insert_get_replace") } #[test] fn sqlite_insert_get_remove() { - let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_get_remove"); - insert_get_remove(&*tree) + insert_get_remove::("sqlite_insert_get_remove") } #[test] fn sqlite_batch_insert_get() { - let (tree, _inst, _temp_dir) = open_tree::("sqlite_batch_insert_get"); - batch_insert_get(&*tree) + batch_insert_get::("sqlite_batch_insert_get") } #[test] fn sqlite_insert_iter() { - let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_iter"); - insert_iter(&*tree) + insert_iter::("sqlite_insert_iter") } #[test] fn sqlite_insert_iter_from() { - let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_iter_from"); - insert_iter_from(&*tree) + insert_iter_from::("sqlite_insert_iter_from") } #[test] fn sqlite_insert_iter_prefix() { - let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_iter_prefix"); - insert_iter_prefix(&*tree) + insert_iter_prefix::("sqlite_insert_iter_prefix") } #[test] fn sqlite_insert_clear() { - let (tree, _inst, _temp_dir) = open_tree::("sqlite_insert_iter_prefix"); - insert_clear(&*tree) + insert_clear::("sqlite_insert_iter_prefix") } #[test] fn sqlite_increment() { - let (tree, _inst, _temp_dir) = open_tree::("sqlite_increment"); - increment(&*tree) + increment::("sqlite_increment") } #[test] fn sqlite_increment_batch() { - let (tree, _inst, _temp_dir) = open_tree("increment_batch"); - increment_batch(&*tree) + increment_batch::("sqlite_increment_batch") } } From 5591ce3e1b1cc25eb6c0171ab6e2a71a9d0eb184 Mon Sep 17 00:00:00 2001 From: Tglman Date: Sat, 22 Jan 2022 14:18:47 +0000 Subject: [PATCH 4/7] test: add tests for rocksdb and persy impl --- src/database/abstraction/tests.rs | 113 ++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) diff --git a/src/database/abstraction/tests.rs b/src/database/abstraction/tests.rs index 0187f2f1..287a3884 100644 --- a/src/database/abstraction/tests.rs +++ b/src/database/abstraction/tests.rs @@ -280,3 +280,116 @@ mod sqlite { increment_batch::("sqlite_increment_batch") } } + +#[cfg(feature = "rocksdb")] +mod rocksdb { + + use super::*; + use crate::database::abstraction::rocksdb::Engine; + + #[test] + fn rocksdb_insert_get() { + insert_get::("rocksdb_insert_get") + } + + #[test] + fn rocksdb_insert_replace_get() { + insert_get_replace::("rocksdb_insert_get_replace") + } + + #[test] + fn rocksdb_insert_get_remove() { + insert_get_remove::("rocksdb_insert_get_remove") + } + + #[test] + fn rocksdb_batch_insert_get() { + batch_insert_get::("rocksdb_batch_insert_get") + } + + #[test] + fn rocksdb_insert_iter() { + insert_iter::("rocksdb_insert_iter") + } + + #[test] + fn rocksdb_insert_iter_from() { + insert_iter_from::("rocksdb_insert_iter_from") + } + + #[test] + fn rocksdb_insert_iter_prefix() { + insert_iter_prefix::("rocksdb_insert_iter_prefix") + } + + #[test] + fn rocksdb_insert_clear() { + insert_clear::("rocksdb_insert_iter_prefix") + } + + #[test] + fn rocksdb_increment() { + increment::("rocksdb_increment") + } + + #[test] + fn rocksdb_increment_batch() { + increment_batch::("rocksdb_increment_batch") + } +} +#[cfg(feature = "persy")] +mod persy { + + use super::*; + use crate::database::abstraction::persy::Engine; + + #[test] + fn persy_insert_get() { + insert_get::("persy_insert_get") + } + + #[test] + fn persy_insert_replace_get() { + insert_get_replace::("persy_insert_get_replace") + } + + #[test] + fn persy_insert_get_remove() { + insert_get_remove::("persy_insert_get_remove") + } + + #[test] + fn persy_batch_insert_get() { + batch_insert_get::("persy_batch_insert_get") + } + + #[test] + fn persy_insert_iter() { + insert_iter::("persy_insert_iter") + } + + #[test] + fn persy_insert_iter_from() { + insert_iter_from::("persy_insert_iter_from") + } + + #[test] + fn persy_insert_iter_prefix() { + insert_iter_prefix::("persy_insert_iter_prefix") + } + + #[test] + fn persy_insert_clear() { + insert_clear::("persy_insert_iter_prefix") + } + + #[test] + fn persy_increment() { + increment::("persy_increment") + } + + #[test] + fn persy_increment_batch() { + increment_batch::("persy_increment_batch") + } +} From 62f04d22e1c64902f2bc9626fc6bd33825719cfb Mon Sep 17 00:00:00 2001 From: Tglman Date: Tue, 1 Feb 2022 20:58:51 +0000 Subject: [PATCH 5/7] test:add entry for seamless remove of not existing key from database --- src/database/abstraction/tests.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/database/abstraction/tests.rs b/src/database/abstraction/tests.rs index 287a3884..d4939537 100644 --- a/src/database/abstraction/tests.rs +++ b/src/database/abstraction/tests.rs @@ -72,6 +72,8 @@ where tree.remove(key).unwrap(); let read = tree.get(key).unwrap(); assert_eq!(read, None); + // Remove of not existing key should run seamless + tree.remove(key).unwrap(); } fn batch_insert_get(name: &str) From 2d641b62a6a0693286132c4be81ac380f4456eb2 Mon Sep 17 00:00:00 2001 From: Tglman Date: Sat, 12 Feb 2022 23:39:45 +0000 Subject: [PATCH 6/7] fix:update implementation to recent changes on next --- src/database/abstraction/tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/database/abstraction/tests.rs b/src/database/abstraction/tests.rs index d4939537..a5cd1dd6 100644 --- a/src/database/abstraction/tests.rs +++ b/src/database/abstraction/tests.rs @@ -6,7 +6,7 @@ use std::sync::Arc; use tempfile::{Builder, TempDir}; fn empty_config(database_path: &str) -> Config { - use rocket::figment::providers::{Format, Toml}; + use figment::providers::{Format, Toml}; Toml::from_str(&format!( r#" server_name = "test" From 4a087e4873f92b39f247d3bdcacd2c0f0512d252 Mon Sep 17 00:00:00 2001 From: Tglman Date: Wed, 26 Oct 2022 21:27:15 +0100 Subject: [PATCH 7/7] chore: fix tests after refactor --- src/database/abstraction/tests.rs | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/database/abstraction/tests.rs b/src/database/abstraction/tests.rs index a5cd1dd6..b9a565ea 100644 --- a/src/database/abstraction/tests.rs +++ b/src/database/abstraction/tests.rs @@ -1,5 +1,5 @@ use crate::database::{ - abstraction::{DatabaseEngine, Tree}, + abstraction::{KeyValueDatabaseEngine, KvTree}, Config, }; use std::sync::Arc; @@ -19,9 +19,9 @@ database_path = "{}" /// 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) +fn open_tree(test_name: &str) -> (Arc, impl KeyValueDatabaseEngine, TempDir) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let db_folder = Builder::new().prefix(test_name).tempdir().unwrap(); let config = empty_config(db_folder.path().to_str().unwrap()); @@ -32,7 +32,7 @@ where fn insert_get(name: &str) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); @@ -44,7 +44,7 @@ where fn insert_get_replace(name: &str) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); @@ -61,7 +61,7 @@ where fn insert_get_remove(name: &str) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); @@ -78,7 +78,7 @@ where fn batch_insert_get(name: &str) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); @@ -106,7 +106,7 @@ where fn insert_iter(name: &str) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); @@ -127,7 +127,7 @@ where fn insert_iter_from(name: &str) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); @@ -151,7 +151,7 @@ where fn insert_iter_prefix(name: &str) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); @@ -174,7 +174,7 @@ where fn insert_clear(name: &str) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); @@ -193,7 +193,7 @@ where fn increment(name: &str) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes(); @@ -207,7 +207,7 @@ where fn increment_batch(name: &str) where - Arc: DatabaseEngine, + Arc: KeyValueDatabaseEngine, { let (tree, _inst, _temp_dir) = open_tree::(name); let key = "key".as_bytes();