Fix tests

Signed-off-by: Valerian Saliou <valerian@valeriansaliou.name>

Author: valeriansaliou

src/store/fst.rs

@@ -27,7 +27,6 @@ use std::time::SystemTime;
 use super::generic::{
     StoreGeneric, StoreGenericActionBuilder, StoreGenericBuilder, StoreGenericPool,
 };
-use super::item::StoreItemPart;
 use super::keyer::StoreKeyerHasher;
 use crate::APP_CONF;
 
@@ -92,11 +91,8 @@ impl StoreFSTPathMode {
 }
 
 impl StoreFSTPool {
-    pub fn acquire<'a>(
-        collection: StoreItemPart<'a>,
-        bucket: StoreItemPart<'a>,
-    ) -> Result<StoreFSTBox, ()> {
-        let (collection_str, bucket_str) = (collection.as_str(), bucket.as_str());
+    pub fn acquire<'a, T: Into<&'a str>>(collection: T, bucket: T) -> Result<StoreFSTBox, ()> {
+        let (collection_str, bucket_str) = (collection.into(), bucket.into());
 
         let pool_key = StoreFSTKey::from_str(collection_str, bucket_str);
 
@@ -550,10 +546,7 @@ impl StoreFSTActionBuilder {
         Self::build(store)
     }
 
-    pub fn erase<'a>(
-        collection: StoreItemPart<'a>,
-        bucket: Option<StoreItemPart<'a>>,
-    ) -> Result<u32, ()> {
+    pub fn erase<'a, T: Into<&'a str>>(collection: T, bucket: Option<T>) -> Result<u32, ()> {
         Self::dispatch_erase(
             "fst",
             collection,
@@ -569,10 +562,9 @@ impl StoreFSTActionBuilder {
 }
 
 impl StoreGenericActionBuilder for StoreFSTActionBuilder {
-    fn proceed_erase_collection<'a>(collection: StoreItemPart<'a>) -> Result<u32, ()> {
+    fn proceed_erase_collection(collection_str: &str) -> Result<u32, ()> {
         let path_mode = StoreFSTPathMode::Permanent;
 
-        let collection_str = collection.as_str();
         let collection_atom = StoreKeyerHasher::to_compact(collection_str);
         let collection_path = StoreFSTBuilder::path(path_mode, collection_atom, None);
 
@@ -643,12 +635,7 @@ impl StoreGenericActionBuilder for StoreFSTActionBuilder {
         }
     }
 
-    fn proceed_erase_bucket<'a>(
-        collection: StoreItemPart<'a>,
-        bucket: StoreItemPart<'a>,
-    ) -> Result<u32, ()> {
-        let (collection_str, bucket_str) = (collection.as_str(), bucket.as_str());
-
+    fn proceed_erase_bucket(collection_str: &str, bucket_str: &str) -> Result<u32, ()> {
         debug!(
             "sub-erase on fst bucket: {} for collection: {}",
             bucket_str, collection_str
@@ -823,12 +810,12 @@ impl StoreFSTAction {
 }
 
 impl StoreFSTMisc {
-    pub fn count_collection_buckets<'a>(collection: StoreItemPart<'a>) -> Result<usize, ()> {
+    pub fn count_collection_buckets<'a, T: Into<&'a str>>(collection: T) -> Result<usize, ()> {
         let mut count = 0;
 
         let path_mode = StoreFSTPathMode::Permanent;
 
-        let collection_atom = StoreKeyerHasher::to_compact(collection.as_str());
+        let collection_atom = StoreKeyerHasher::to_compact(collection.into());
         let collection_path = StoreFSTBuilder::path(path_mode, collection_atom, None);
 
         if collection_path.exists() == true {

src/store/generic.rs

@@ -12,8 +12,6 @@ use std::mem;
 use std::sync::{Arc, Mutex, RwLock};
 use std::time::SystemTime;
 
-use super::item::StoreItemPart;
-
 pub trait StoreGenericKey {}
 
 pub trait StoreGeneric {
@@ -130,35 +128,30 @@ pub trait StoreGenericBuilder<K, S> {
 }
 
 pub trait StoreGenericActionBuilder {
-    fn proceed_erase_bucket<'a>(
-        collection: StoreItemPart<'a>,
-        bucket: StoreItemPart<'a>,
-    ) -> Result<u32, ()>;
+    fn proceed_erase_collection(collection_str: &str) -> Result<u32, ()>;
 
-    fn proceed_erase_collection<'a>(collection: StoreItemPart<'a>) -> Result<u32, ()>;
+    fn proceed_erase_bucket(collection_str: &str, bucket_str: &str) -> Result<u32, ()>;
 
-    fn dispatch_erase<'a>(
+    fn dispatch_erase<'a, T: Into<&'a str>>(
         kind: &str,
-        collection: StoreItemPart<'a>,
-        bucket: Option<StoreItemPart<'a>>,
+        collection: T,
+        bucket: Option<T>,
         access_lock: &Arc<RwLock<bool>>,
         write_lock: &Arc<Mutex<bool>>,
     ) -> Result<u32, ()> {
-        info!(
-            "{} erase requested on collection: {}",
-            kind,
-            collection.as_str()
-        );
+        let collection_str = collection.into();
+
+        info!("{} erase requested on collection: {}", kind, collection_str);
 
         // Acquire write + access locks, and reference it in context
         // Notice: write lock prevents store to be acquired from any context; while access lock \
         //   lets the erasure process wait that any thread using the store is done with work.
         let (_access, _write) = (access_lock.write().unwrap(), write_lock.lock().unwrap());
 
         if let Some(bucket) = bucket {
-            Self::proceed_erase_bucket(collection, bucket)
+            Self::proceed_erase_bucket(collection_str, bucket.into())
         } else {
-            Self::proceed_erase_collection(collection)
+            Self::proceed_erase_collection(collection_str)
         }
     }
 }

src/store/item.rs

@@ -44,6 +44,12 @@ impl<'a> StoreItemPart<'a> {
     }
 }
 
+impl<'a> Into<&'a str> for StoreItemPart<'a> {
+    fn into(self) -> &'a str {
+        self.as_str()
+    }
+}
+
 impl StoreItemBuilder {
     pub fn from_depth_1<'a>(collection: &'a str) -> Result<StoreItem<'a>, StoreItemError> {
         // Validate & box collection

src/store/keyer.rs

@@ -161,48 +161,49 @@ mod tests {
     #[test]
     fn it_keys_meta_to_value() {
         assert_eq!(
-            StoreKeyerBuilder::meta_to_value(&StoreMetaKey::IIDIncr).as_bytes(),
-            [0, 0, 0, 0, 0]
+            StoreKeyerBuilder::meta_to_value("bucket:1", &StoreMetaKey::IIDIncr).as_bytes(),
+            [0, 108, 244, 29, 93, 0, 0, 0, 0]
         );
     }
 
     #[test]
     fn it_keys_term_to_iids() {
         assert_eq!(
-            StoreKeyerBuilder::term_to_iids(772137347).as_bytes(),
-            [1, 131, 225, 5, 46]
+            StoreKeyerBuilder::term_to_iids("bucket:2", 772137347).as_bytes(),
+            [1, 50, 220, 166, 65, 131, 225, 5, 46]
         );
         assert_eq!(
-            StoreKeyerBuilder::term_to_iids(3582484684).as_bytes(),
-            [1, 204, 96, 136, 213]
+            StoreKeyerBuilder::term_to_iids("bucket:2", 3582484684).as_bytes(),
+            [1, 50, 220, 166, 65, 204, 96, 136, 213]
         );
     }
 
     #[test]
     fn it_keys_oid_to_iid() {
         assert_eq!(
-            StoreKeyerBuilder::oid_to_iid(&"conversation:6501e83a".to_string()).as_bytes(),
-            [2, 31, 156, 118, 213]
+            StoreKeyerBuilder::oid_to_iid("bucket:3", &"conversation:6501e83a".to_string())
+                .as_bytes(),
+            [2, 171, 194, 213, 57, 31, 156, 118, 213]
         );
     }
 
     #[test]
     fn it_keys_iid_to_oid() {
         assert_eq!(
-            StoreKeyerBuilder::iid_to_oid(10292198).as_bytes(),
-            [3, 230, 11, 157, 0]
+            StoreKeyerBuilder::iid_to_oid("bucket:4", 10292198).as_bytes(),
+            [3, 105, 12, 54, 147, 230, 11, 157, 0]
         );
     }
 
     #[test]
     fn it_keys_iid_to_terms() {
         assert_eq!(
-            StoreKeyerBuilder::iid_to_terms(1).as_bytes(),
-            [4, 1, 0, 0, 0]
+            StoreKeyerBuilder::iid_to_terms("bucket:5", 1).as_bytes(),
+            [4, 137, 142, 73, 67, 1, 0, 0, 0]
         );
         assert_eq!(
-            StoreKeyerBuilder::iid_to_terms(20).as_bytes(),
-            [4, 20, 0, 0, 0]
+            StoreKeyerBuilder::iid_to_terms("bucket:5", 20).as_bytes(),
+            [4, 137, 142, 73, 67, 20, 0, 0, 0]
         );
     }
 
@@ -215,15 +216,15 @@ mod tests {
     #[test]
     fn it_formats_key() {
         assert_eq!(
-            &format!("{}", StoreKeyerBuilder::term_to_iids(772137347)),
-            "'1:2e05e183' [1, 131, 225, 5, 46]"
+            &format!("{}", StoreKeyerBuilder::term_to_iids("bucket:6", 72137347)),
+            "'1:71198b49:44cba83' [1, 73, 139, 25, 113, 131, 186, 76, 4]"
         );
         assert_eq!(
             &format!(
                 "{}",
-                StoreKeyerBuilder::meta_to_value(&StoreMetaKey::IIDIncr)
+                StoreKeyerBuilder::meta_to_value("bucket:6", &StoreMetaKey::IIDIncr)
             ),
-            "'0:0' [0, 0, 0, 0, 0]"
+            "'0:71198b49:0' [0, 73, 139, 25, 113, 0, 0, 0, 0]"
         );
     }
 }
@@ -251,28 +252,28 @@ mod benches {
 
     #[bench]
     fn bench_key_meta_to_value(b: &mut Bencher) {
-        b.iter(|| StoreKeyerBuilder::meta_to_value(&StoreMetaKey::IIDIncr));
+        b.iter(|| StoreKeyerBuilder::meta_to_value("bucket:bench:1", &StoreMetaKey::IIDIncr));
     }
 
     #[bench]
     fn bench_key_term_to_iids(b: &mut Bencher) {
-        b.iter(|| StoreKeyerBuilder::term_to_iids(772137347));
+        b.iter(|| StoreKeyerBuilder::term_to_iids("bucket:bench:2", 772137347));
     }
 
     #[bench]
     fn bench_key_oid_to_iid(b: &mut Bencher) {
         let key = "conversation:6501e83a".to_string();
 
-        b.iter(|| StoreKeyerBuilder::oid_to_iid(&key));
+        b.iter(|| StoreKeyerBuilder::oid_to_iid("bucket:bench:3", &key));
     }
 
     #[bench]
     fn bench_key_iid_to_oid(b: &mut Bencher) {
-        b.iter(|| StoreKeyerBuilder::iid_to_oid(10292198));
+        b.iter(|| StoreKeyerBuilder::iid_to_oid("bucket:bench:4", 10292198));
     }
 
     #[bench]
     fn bench_key_iid_to_terms(b: &mut Bencher) {
-        b.iter(|| StoreKeyerBuilder::iid_to_terms(1));
+        b.iter(|| StoreKeyerBuilder::iid_to_terms("bucket:bench:5", 1));
     }
 }

src/store/kv.rs

@@ -63,11 +63,11 @@ lazy_static! {
 }
 
 impl StoreKVPool {
-    pub fn acquire<'a>(
+    pub fn acquire<'a, T: Into<&'a str>>(
         mode: StoreKVAcquireMode,
-        collection: StoreItemPart<'a>,
+        collection: T,
     ) -> Result<Option<StoreKVBox>, ()> {
-        let collection_str = collection.as_str();
+        let collection_str = collection.into();
         let pool_key = StoreKVKey::from_str(collection_str);
 
         // Acquire general lock, and reference it in context
@@ -206,10 +206,7 @@ impl StoreKVActionBuilder {
         Self::build(bucket, store)
     }
 
-    pub fn erase<'a>(
-        collection: StoreItemPart<'a>,
-        bucket: Option<StoreItemPart<'a>>,
-    ) -> Result<u32, ()> {
+    pub fn erase<'a, T: Into<&'a str>>(collection: T, bucket: Option<T>) -> Result<u32, ()> {
         Self::dispatch_erase(
             "kv",
             collection,
@@ -228,8 +225,7 @@ impl StoreKVActionBuilder {
 }
 
 impl StoreGenericActionBuilder for StoreKVActionBuilder {
-    fn proceed_erase_collection<'a>(collection: StoreItemPart<'a>) -> Result<u32, ()> {
-        let collection_str = collection.as_str();
+    fn proceed_erase_collection(collection_str: &str) -> Result<u32, ()> {
         let collection_atom = StoreKeyerHasher::to_compact(collection_str);
         let collection_path = StoreKVBuilder::path(collection_atom);
 
@@ -268,10 +264,7 @@ impl StoreGenericActionBuilder for StoreKVActionBuilder {
         }
     }
 
-    fn proceed_erase_bucket<'a>(
-        _collection: StoreItemPart<'a>,
-        _bucket: StoreItemPart<'a>,
-    ) -> Result<u32, ()> {
+    fn proceed_erase_bucket(_collection: &str, _bucket: &str) -> Result<u32, ()> {
         // This one is not implemented, as we need to acquire the collection; which would cause \
         //   a party-killer dead-lock.
         Err(())
@@ -899,7 +892,8 @@ mod tests {
     #[test]
     fn it_proceeds_actions() {
         let store = StoreKVPool::acquire(StoreKVAcquireMode::Any, "c:test:3").unwrap();
-        let action = StoreKVActionBuilder::access(bucket, store);
+        let action =
+            StoreKVActionBuilder::access(StoreItemPart::from_str("b:test:3").unwrap(), store);
 
         assert!(action.get_meta_to_value(StoreMetaKey::IIDIncr).is_ok());
         assert!(action