Began reworking cache.

src/morethantext/mod.rs

@@ -1,4 +1,5 @@
-mod databases;
+mod cache;
+mod store;
 pub mod error;
 
 use async_std::{
@@ -7,7 +8,7 @@ use async_std::{
     sync::{Arc, Mutex},
     task::{sleep, spawn},
 };
-use databases::Databases;
+use store::Store;
 use error::DBError;
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
 use std::{
@@ -26,14 +27,14 @@ trait FileData<F> {
 
 trait SessionData {
     fn add(&mut self, key: &str, value: &str, data: &str) -> Result<Vec<String>, DBError>;
-    fn get(&self, key: &str, value: &str) -> Result<Vec<String>, DBError>;
+    fn eq(&self, key: &str, value: &str) -> Result<Vec<String>, DBError>;
     fn list(&self, keys: Vec<&str>) -> Result<Vec<String>, DBError>;
 }
 
 #[derive(Clone)]
 pub enum CacheType {
     Raw(String),
-    DBMap(Databases),
+    DBMap(Store),
     TableMap,
 }
 
@@ -81,7 +82,7 @@ impl CacheType {
                 }
                 Ok(CacheType::Raw(str::from_utf8(&output).unwrap().to_string()))
             }
-            "DBMap" => Ok(CacheType::DBMap(Databases::new())),
+            "DBMap" => Ok(CacheType::DBMap(Store::new())),
             "TableMap" => Ok(CacheType::TableMap),
             _ => Err(DBError::new("data corruption")),
         }
@@ -164,7 +165,7 @@ impl MoreThanText {
             id = str::from_utf8(&holder).unwrap().to_string();
         } else {
             id = output
-                .add_entry(CacheType::DBMap(Databases::new()))
+                .add_entry(CacheType::DBMap(Store::new()))
                 .await
                 .unwrap();
             write(entry_file, id.as_bytes()).await.unwrap();
@@ -195,6 +196,26 @@ impl MoreThanText {
         filename.into_os_string().into_string().unwrap()
     }
 
+    fn new_id(&self) -> String {
+        thread_rng().sample_iter(&Alphanumeric).take(64).collect()
+    }
+
+    async fn add(&self, feature: &str, key: &str, value: &str) -> Self {
+        let mut ids: Vec<String> = Vec::new();
+        for id in self.session.clone().into_iter() {
+            let holder = self.get_entry(&id).await.unwrap();
+            //holder.add(feature, key, value);
+        }
+        let mut output = self.clone();
+        output.session.clear();
+        output.session.push(value.to_string());
+        output
+    }
+
+    async fn list(&self, feature: Vec<&str>) -> Result<Vec<String>, DBError> {
+        Ok(Vec::new())
+    }
+
     async fn add_entry(&self, entry: CacheType) -> Result<String, DBError> {
         let mut id: String = "".to_string();
         let mut dup = true;
@@ -364,7 +385,35 @@ mod init {
 }
 
 #[cfg(test)]
-mod cache {
+mod data {
+    use super::*;
+    use setup::MTT;
+
+    #[async_std::test]
+    async fn ids_are_random() {
+        let mtt = MTT::new().await;
+        let id1 = mtt.db.new_id();
+        let id2 = mtt.db.new_id();
+        assert_ne!(id1, id2, "Ids should be random");
+    }
+
+    #[async_std::test]
+    async fn add_database() {
+        let mtt = MTT::new().await;
+        let name = "fred";
+        let id = "*gsdfg";
+        let output = mtt.db.add("database", name, id).await;
+        assert_eq!(output.session, [id], "should update session info.");
+        assert_eq!(
+            mtt.db.list(["database"].to_vec()).await.unwrap(),
+            [name],
+            "Should list the databases."
+        );
+    }
+}
+
+#[cfg(test)]
+mod cache_test {
     use super::*;
     use async_std::fs::read;
     use setup::MTT;
@@ -724,13 +773,13 @@ mod enum_ctype {
 
     #[test]
     fn get_dbmap_type() {
-        let holder = CacheType::DBMap(Databases::new());
+        let holder = CacheType::DBMap(Store::new());
         assert_eq!(holder.entry_type(), "DBMap");
     }
 
     #[test]
     fn get_new_databases_bytes() {
-        let holder = CacheType::DBMap(Databases::new());
+        let holder = CacheType::DBMap(Store::new());
         let mut expected = "DBMap".as_bytes().to_vec();
         expected.push(0);
         let output = holder.to_bytes();