Began reworking cache.

src/morethantext/cache.rs

@@ -0,0 +1,202 @@
+use rand::{distributions::Alphanumeric, Rng, thread_rng};
+use super::{DBError, Store, SessionData};
+use std::{
+    cell::Cell,
+    time::{Duration, Instant},
+};
+
+enum DataType {
+    DBMap(Store),
+}
+
+impl DataType {
+    fn new(data_type: &str) -> Result<Self, DBError> {
+        match data_type {
+            "store" => Ok(DataType::DBMap(Store::new())),
+            _ => Err(DBError::new("invalid data type")),
+        }
+    }
+}
+
+impl SessionData for DataType {
+    fn add(&mut self, key: &str, value: &str, data: &str) -> Result<Vec<String>, DBError> {
+        match self {
+            DataType::DBMap(dbs) => dbs.add(key, value, data),
+        }
+    }
+
+    fn eq(&self, key: &str, value: &str) -> Result<Vec<String>, DBError> {
+        match self {
+            DataType::DBMap(dbs) => dbs.eq(key, value),
+        }
+    }
+
+    fn list(&self, keys: Vec<&str>) -> Result<Vec<String>, DBError> {
+        match self {
+            DataType::DBMap(dbs) => dbs.list(keys),
+        }
+    }
+}
+
+struct Entry {
+    data: DataType,
+    last_used: Cell<Instant>,
+}
+
+impl Entry {
+    fn new(data_type: &str) -> Result<Self, DBError> {
+        let data = match DataType::new(data_type) {
+            Ok(item) => item,
+            Err(err) => return Err(err),
+        };
+        Ok(Self {
+            data: data,
+            last_used: Cell::new(Instant::now()),
+        })
+    }
+
+    fn elapsed(&self) -> Duration {
+        self.last_used.get().elapsed()
+    }
+}
+
+impl SessionData for Entry {
+    fn add(&mut self, key: &str, value: &str, data: &str) -> Result<Vec<String>, DBError> {
+        self.last_used.set(Instant::now());
+        self.data.add(key, value, data)
+    }
+
+    fn eq(&self, key: &str, value: &str) -> Result<Vec<String>, DBError> {
+        self.last_used.set(Instant::now());
+        self.data.eq(key, value)
+    }
+
+    fn list(&self, keys: Vec<&str>) -> Result<Vec<String>, DBError> {
+        self.last_used.set(Instant::now());
+        self.data.list(keys)
+    }
+}
+
+struct Cache;
+
+impl Cache {
+    async fn new(dir: &str) -> Self {
+        Self
+    }
+}
+
+#[cfg(test)]
+mod datatype {
+    use super::*;
+
+    #[test]
+    fn invalid_cache_type() -> Result<(), DBError> {
+        match DataType::new("dkhgdl") {
+            Ok(_) => Err(DBError::new("invalid data type should raise an error")),
+            Err(err) => {
+                assert_eq!(err.to_string(), "invalid data type");
+                Ok(())
+            }
+        }
+    }
+
+    #[test]
+    fn create_storage() {
+        let dbs = DataType::new("store").unwrap();
+        let expected: Vec<String> = Vec::new();
+        assert_eq!(dbs.list(["database"].to_vec()).unwrap(), expected);
+    }
+
+    #[test]
+    fn update_storage() {
+        let mut dbs = DataType::new("store").unwrap();
+        let name = "new_database";
+        let id = "someid";
+        dbs.add("database", name, id).unwrap();
+        assert_eq!(dbs.eq("database", name).unwrap(), [id].to_vec());
+        assert_eq!(dbs.list(["database"].to_vec()).unwrap(), [name].to_vec());
+    }
+}
+
+#[cfg(test)]
+mod entry {
+    use super::*;
+
+    #[test]
+    fn invalid_cache_type() -> Result<(), DBError> {
+        match Entry::new("uydg") {
+            Ok(_) => Err(DBError::new("invalid data type should raise an error")),
+            Err(err) => {
+                assert_eq!(err.to_string(), "invalid data type");
+                Ok(())
+            }
+        }
+    }
+
+    #[test]
+    fn create_storage() {
+        let entry = Entry::new("store").unwrap();
+        assert!(
+            Duration::from_secs(1) > entry.elapsed(),
+            "Entry last used should be now."
+        );
+        let expected: Vec<String> = Vec::new();
+        assert_eq!(entry.list(["database"].to_vec()).unwrap(), expected);
+    }
+
+    #[test]
+    fn add_database_to_storage() {
+        let mut entry = Entry::new("store").unwrap();
+        entry
+            .last_used
+            .set(Instant::now() - Duration::from_secs(500));
+        let name = "roger";
+        let id = "cormick";
+        entry.add("database", name, id).unwrap();
+        assert!(
+            Duration::from_secs(1) > entry.elapsed(),
+            "Entry last used should be now."
+        );
+        assert_eq!(entry.eq("database", name).unwrap(), [id].to_vec());
+    }
+
+    #[test]
+    fn get_database_from_storage() {
+        let mut entry = Entry::new("store").unwrap();
+        let name = "jessica";
+        entry.add("database", name, "rabbit").unwrap();
+        entry
+            .last_used
+            .set(Instant::now() - Duration::from_secs(500));
+        entry.eq("database", name).unwrap();
+        assert!(
+            Duration::from_secs(1) > entry.elapsed(),
+            "Entry last used should be now."
+        );
+    }
+
+    #[test]
+    fn list_database_from_storage() {
+        let entry = Entry::new("store").unwrap();
+        entry
+            .last_used
+            .set(Instant::now() - Duration::from_secs(500));
+        entry.list(["database"].to_vec()).unwrap();
+        assert!(
+            Duration::from_secs(1) > entry.elapsed(),
+            "Entry last used should be now."
+        );
+    }
+}
+
+#[cfg(test)]
+mod cache {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[async_std::test]
+    async fn create() {
+        let dir = tempdir().unwrap();
+        Cache::new(dir.path().to_str().unwrap()).await;
+    }
+}