From 5a66ffd9e6fdd1c016e56679878fc59d5bba9a3b Mon Sep 17 00:00:00 2001 From: Tglman Date: Sat, 22 Jan 2022 14:07:50 +0000 Subject: [PATCH] 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") } }