refactor: changed tree specific impls to be one liner

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<T>(test_name: &str) -> (Arc<dyn Tree>, impl DatabaseEngine, TempDir)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let db_folder = Builder::new().prefix(test_name).tempdir().unwrap();
+    let config = empty_config(db_folder.path().to_str().unwrap());
+    let instance = Arc::<T>::open(&config).unwrap();
+    let tree = instance.open_tree("test").unwrap();
+    (tree, instance, db_folder)
+}
+
+fn insert_get<T>(name: &str)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let (tree, _inst, _temp_dir) = open_tree::<T>(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<T>(name: &str)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let (tree, _inst, _temp_dir) = open_tree::<T>(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<T>(name: &str)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let (tree, _inst, _temp_dir) = open_tree::<T>(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<T>(name: &str)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let (tree, _inst, _temp_dir) = open_tree::<T>(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<T>(name: &str)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let (tree, _inst, _temp_dir) = open_tree::<T>(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<T>(name: &str)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let (tree, _inst, _temp_dir) = open_tree::<T>(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<T>(name: &str)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let (tree, _inst, _temp_dir) = open_tree::<T>(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<T>(name: &str)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let (tree, _inst, _temp_dir) = open_tree::<T>(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<T>(name: &str)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let (tree, _inst, _temp_dir) = open_tree::<T>(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<T>(name: &str)
+where
+    Arc<T>: DatabaseEngine,
+{
+    let (tree, _inst, _temp_dir) = open_tree::<T>(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<T>(test_name: &str) -> (Arc<dyn Tree>, impl DatabaseEngine, TempDir) 
-    where Arc<T>: DatabaseEngine
-{
-    let db_folder = Builder::new().prefix(test_name).tempdir().unwrap();
-    let config = empty_config(db_folder.path().to_str().unwrap());
-    let instance = Arc::<T>::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::<Engine>("sqlite_insert_get");
+        insert_get::<Engine>("sqlite_insert_get")
-        insert_get(&*tree)
     }
 
     #[test]
     fn sqlite_insert_replace_get() {
-        let (tree, _inst, _temp_dir) = open_tree::<Engine>("sqlite_insert_get_replace");
+        insert_get_replace::<Engine>("sqlite_insert_get_replace")
-        insert_get_replace(&*tree)
     }
 
     #[test]
     fn sqlite_insert_get_remove() {
-        let (tree, _inst, _temp_dir) = open_tree::<Engine>("sqlite_insert_get_remove");
+        insert_get_remove::<Engine>("sqlite_insert_get_remove")
-        insert_get_remove(&*tree)
     }
 
     #[test]
     fn sqlite_batch_insert_get() {
-        let (tree, _inst, _temp_dir) = open_tree::<Engine>("sqlite_batch_insert_get");
+        batch_insert_get::<Engine>("sqlite_batch_insert_get")
-        batch_insert_get(&*tree)
     }
 
     #[test]
     fn sqlite_insert_iter() {
-        let (tree, _inst, _temp_dir) = open_tree::<Engine>("sqlite_insert_iter");
+        insert_iter::<Engine>("sqlite_insert_iter")
-        insert_iter(&*tree)
     }
 
     #[test]
     fn sqlite_insert_iter_from() {
-        let (tree, _inst, _temp_dir) = open_tree::<Engine>("sqlite_insert_iter_from");
+        insert_iter_from::<Engine>("sqlite_insert_iter_from")
-        insert_iter_from(&*tree)
     }
 
     #[test]
     fn sqlite_insert_iter_prefix() {
-        let (tree, _inst, _temp_dir) = open_tree::<Engine>("sqlite_insert_iter_prefix");
+        insert_iter_prefix::<Engine>("sqlite_insert_iter_prefix")
-        insert_iter_prefix(&*tree)
     }
 
     #[test]
     fn sqlite_insert_clear() {
-        let (tree, _inst, _temp_dir) = open_tree::<Engine>("sqlite_insert_iter_prefix");
+        insert_clear::<Engine>("sqlite_insert_iter_prefix")
-        insert_clear(&*tree)
     }
 
     #[test]
     fn sqlite_increment() {
-        let (tree, _inst, _temp_dir) = open_tree::<Engine>("sqlite_increment");
+        increment::<Engine>("sqlite_increment")
-        increment(&*tree)
     }
 
     #[test]
     fn sqlite_increment_batch() {
-        let (tree, _inst, _temp_dir) = open_tree("increment_batch");
+        increment_batch::<Engine>("sqlite_increment_batch")
-        increment_batch(&*tree)
     }
 }