morethantext-web/src/morethantext/cache.rs

use super::{DBError, FileData, SessionData, Store};
use async_std::{
    fs::{read, remove_file, write},
    path::Path,
};
use rand::{distributions::Alphanumeric, thread_rng, Rng};
use std::{
    cell::Cell,
    slice, str,
    time::{Duration, Instant},
};

#[derive(Clone)]
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),
        }
    }
}

impl FileData<Self> for DataType {
    fn to_bytes(&self) -> Vec<u8> {
        let mut output = Vec::new();
        match self {
            DataType::DBMap(store) => {
                output.append(&mut "DBMap".as_bytes().to_vec());
                output.push(0);
                output.append(&mut store.to_bytes());
            }
        }
        output
    }

    fn from_bytes(data: &mut slice::Iter<u8>) -> Result<Self, DBError> {
        let mut header: Vec<u8> = Vec::new();
        loop {
            let letter = match data.next() {
                Some(a) => a.clone(),
                None => 0,
            };
            if letter == 0 {
                break;
            } else {
                header.push(letter);
            }
        }
        let header = match str::from_utf8(&header) {
            Ok(item) => item,
            Err(_) => return Err(DBError::new("file corruption")),
        };
        match header {
            "DBMap" => match Store::from_bytes(data) {
                Ok(store) => Ok(DataType::DBMap(store)),
                Err(err) => Err(err),
            },
            _ => Err(DBError::new("file corruption")),
        }
    }
}

struct Entry {
    data: DataType,
    filename: String,
    last_used: Cell<Instant>,
}

impl Entry {
    async fn new(filename: String, data: DataType) -> Result<Self, DBError> {
        if Path::new(&filename).exists().await {
            return Err(DBError::new("entry already exists"));
        } else {
            let filepath = Path::new(&filename);
            match write(filepath, data.to_bytes()).await {
                Ok(_) => (),
                Err(err) => {
                    let mut error = DBError::new("failed to write");
                    error.add_source(err);
                    return Err(error);
                }
            }
        }
        Ok(Self {
            data: data,
            filename: filename,
            last_used: Cell::new(Instant::now()),
        })
    }

    async fn get(filename: &str) -> Result<Self, DBError> {
        let filepath = Path::new(filename);
        let content = match read(filepath).await {
            Ok(text) => text,
            Err(err) => {
                let mut error = DBError::new("read error");
                error.add_source(err);
                return Err(error);
            }
        };
        let data = match DataType::from_bytes(&mut content.iter()) {
            Ok(raw) => raw,
            Err(err) => {
                let mut error = DBError::new("read error");
                error.add_source(err);
                return Err(error);
            }
        };
        Ok(Self {
            data: data,
            filename: filename.to_string(),
            last_used: Cell::new(Instant::now()),
        })
    }

    fn elapsed(&self) -> Duration {
        self.last_used.get().elapsed()
    }

    fn data(&self) -> DataType {
        self.last_used.set(Instant::now());
        self.data.clone()
    }

    async fn update(&mut self, data: DataType) -> Result<(), DBError> {
        self.last_used.set(Instant::now());
        let filepath = Path::new(&self.filename);
        match write(filepath, data.to_bytes()).await {
            Ok(_) => (),
            Err(err) => {
                let mut error = DBError::new("write error");
                error.add_source(err);
                return Err(error);
            }
        };
        self.data = data;
        Ok(())
    }
}

struct Cache;

impl Cache {
    async fn new(dir: &str) -> Self {
        Self
    }
}

#[cfg(test)]
mod datatype_sesssion {
    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 datatype_file {
    use super::*;

    #[test]
    fn new_store_bytes() {
        let dbs = DataType::new("store").unwrap();
        let mut expected = "DBMap".as_bytes().to_vec();
        expected.push(0);
        assert_eq!(dbs.to_bytes(), expected);
    }

    #[test]
    fn store_bytes_with_info() {
        let name = "title";
        let id = "king";
        let mut store = Store::new();
        let mut dt_store = DataType::new("store").unwrap();
        let mut expected = dt_store.to_bytes();
        store.add("database", name, id).unwrap();
        expected.append(&mut store.to_bytes());
        dt_store.add("database", name, id).unwrap();
        assert_eq!(dt_store.to_bytes(), expected);
    }

    #[test]
    fn read_empty_store() {
        let dt_store = DataType::new("store").unwrap();
        let data = dt_store.to_bytes();
        let mut feed = data.iter();
        let output = DataType::from_bytes(&mut feed).unwrap();
        assert_eq!(
            dt_store.list(["database"].to_vec()).unwrap(),
            output.list(["database"].to_vec()).unwrap()
        );
    }

    #[test]
    fn read_store_info() {
        let mut dt_store = DataType::new("store").unwrap();
        dt_store.add("database", "raven", "beastboy").unwrap();
        let data = dt_store.to_bytes();
        let mut feed = data.iter();
        let output = DataType::from_bytes(&mut feed).unwrap();
        assert_eq!(
            dt_store.list(["database"].to_vec()).unwrap(),
            output.list(["database"].to_vec()).unwrap()
        );
    }

    #[test]
    fn read_bad_header() -> Result<(), DBError> {
        let data = "sdghsdl".as_bytes().to_vec();
        let mut feed = data.iter();
        match DataType::from_bytes(&mut feed) {
            Ok(_) => Err(DBError::new("should have raised an error")),
            Err(err) => {
                assert_eq!(err.to_string(), "file corruption");
                Ok(())
            }
        }
    }

    #[test]
    fn read_bad_store() -> Result<(), DBError> {
        let mut data = "DBMap".as_bytes().to_vec();
        data.push(0);
        data.append(&mut "sdfgs".as_bytes().to_vec());
        let mut feed = data.iter();
        match DataType::from_bytes(&mut feed) {
            Ok(_) => Err(DBError::new("should have raised an error")),
            Err(err) => {
                assert_eq!(err.to_string(), "file corruption");
                Ok(())
            }
        }
    }
}

#[cfg(test)]
mod entry {
    use super::*;
    use std::error::Error;
    use tempfile::tempdir;

    #[async_std::test]
    async fn get_elapsed_time() {
        let dir = tempdir().unwrap();
        let data = DataType::new("store").unwrap();
        let filepath = dir.path().join("count");
        let filename = filepath.to_str().unwrap();
        let item = Entry::new(filename.to_string(), data).await.unwrap();
        assert!(
            Duration::from_secs(1) > item.elapsed(),
            "last_used should have been now."
        );
        item.last_used
            .set(Instant::now() - Duration::from_secs(500));
        assert!(
            Duration::from_secs(499) < item.elapsed(),
            "The duration should have increased."
        );
    }

    #[async_std::test]
    async fn create() {
        let dir = tempdir().unwrap();
        let mut data = DataType::new("store").unwrap();
        data.add("database", "roger", "moore").unwrap();
        let filepath = dir.path().join("wiliam");
        let filename = filepath.to_str().unwrap();
        let item = Entry::new(filename.to_string(), data.clone())
            .await
            .unwrap();
        assert!(
            Duration::from_secs(1) > item.elapsed(),
            "last_used should have been now."
        );
        let output = item.data();
        assert_eq!(
            data.list(["database"].to_vec()).unwrap(),
            output.list(["database"].to_vec()).unwrap()
        );
        assert!(filepath.is_file(), "Should have created the entry file.");
        let content = read(&filepath).await.unwrap();
        assert_eq!(content, data.to_bytes());
    }

    #[async_std::test]
    async fn create_errors_on_bad_files() -> Result<(), DBError> {
        let dir = tempdir().unwrap();
        let data = DataType::new("store").unwrap();
        let filepath = dir.path().join("bad").join("path");
        let filename = filepath.to_str().unwrap();
        match Entry::new(filename.to_string(), data).await {
            Ok(_) => Err(DBError::new("bad file names should raise an error")),
            Err(err) => {
                assert_eq!(err.to_string(), "failed to write");
                assert!(err.source().is_some(), "Must include the source error.");
                assert!(err
                    .source()
                    .unwrap()
                    .to_string()
                    .contains("could not write to file"));
                Ok(())
            }
        }
    }

    #[async_std::test]
    async fn create_does_not_over_writes() -> Result<(), DBError> {
        let dir = tempdir().unwrap();
        let id = "wicked";
        let file = dir.path().join(id);
        let filename = file.to_str().unwrap();
        write(&file, b"previous").await.unwrap();
        let data = DataType::new("store").unwrap();
        match Entry::new(filename.to_string(), data).await {
            Ok(_) => {
                return Err(DBError::new(
                    "Should produce an error for an existing Entry",
                ))
            }
            Err(err) => {
                assert_eq!(err.to_string(), "entry already exists");
                Ok(())
            }
        }
    }

    #[async_std::test]
    async fn get_updates_last_used() {
        let dir = tempdir().unwrap();
        let data = DataType::new("store").unwrap();
        let filepath = dir.path().join("holder");
        let filename = filepath.to_str().unwrap();
        let item = Entry::new(filename.to_string(), data).await.unwrap();
        item.last_used
            .set(Instant::now() - Duration::from_secs(300));
        item.data();
        assert!(
            Duration::from_secs(1) > item.elapsed(),
            "last_used should have been reset."
        );
    }

    #[async_std::test]
    async fn update_entry() {
        let dir = tempdir().unwrap();
        let mut data = DataType::new("store").unwrap();
        let filepath = dir.path().join("changing");
        let filename = filepath.to_str().unwrap();
        let mut item = Entry::new(filename.to_string(), data.clone())
            .await
            .unwrap();
        item.last_used
            .set(Instant::now() - Duration::from_secs(500));
        data.add("database", "new", "stuff").unwrap();
        item.update(data.clone()).await.unwrap();
        assert!(
            Duration::from_secs(1) > item.elapsed(),
            "last_used should have been reset."
        );
        let output = item.data();
        assert_eq!(
            data.list(["database"].to_vec()).unwrap(),
            output.list(["database"].to_vec()).unwrap()
        );
        let content = read(&filepath).await.unwrap();
        assert_eq!(content, data.to_bytes());
    }

    #[async_std::test]
    async fn update_write_errors() -> Result<(), DBError> {
        let dir = tempdir().unwrap();
        let data = DataType::new("store").unwrap();
        let filepath = dir.path().join("changing");
        let filename = filepath.to_str().unwrap();
        let mut item = Entry::new(filename.to_string(), data.clone())
            .await
            .unwrap();
        drop(dir);
        match item.update(data).await {
            Ok(_) => Err(DBError::new("file writes should return an error")),
            Err(err) => {
                assert_eq!(err.to_string(), "write error");
                assert!(err.source().is_some(), "Must include the source error.");
                assert!(err
                    .source()
                    .unwrap()
                    .to_string()
                    .contains("could not write to file"));
                Ok(())
            }
        }
    }

    #[async_std::test]
    async fn retrieve() {
        let dir = tempdir().unwrap();
        let mut data = DataType::new("store").unwrap();
        data.add("database", "something_old", "3.14159").unwrap();
        let filepath = dir.path().join("existing");
        let filename = filepath.to_str().unwrap();
        let item = Entry::new(filename.to_string(), data.clone())
            .await
            .unwrap();
        let output = Entry::get(filename).await.unwrap();
        assert_eq!(
            output.data().list(["database"].to_vec()).unwrap(),
            data.list(["database"].to_vec()).unwrap()
        );
        assert_eq!(output.filename, filename);
        assert!(
            Duration::from_secs(1) > item.elapsed(),
            "last_used should have been reset."
        );
    }

    #[async_std::test]
    async fn retrieve_file_missing() -> Result<(), DBError> {
        let dir = tempdir().unwrap();
        let filepath = dir.path().join("justnotthere");
        let filename = filepath.to_str().unwrap();
        match Entry::get(filename).await {
            Ok(_) => Err(DBError::new("should have returned an error")),
            Err(err) => {
                assert_eq!(err.to_string(), "read error");
                assert!(err.source().is_some(), "Error should have a source.");
                assert!(
                    err.source()
                        .unwrap()
                        .to_string()
                        .contains("could not read file"),
                    "Source Error Message: {}",
                    err.source().unwrap().to_string()
                );
                Ok(())
            }
        }
    }

    #[async_std::test]
    async fn retrieve_corrupt_file() -> Result<(), DBError> {
        let dir = tempdir().unwrap();
        let filepath = dir.path().join("garbage");
        let filename = filepath.to_str().unwrap();
        write(&filepath, b"jhsdfghlsdf").await.unwrap();
        match Entry::get(filename).await {
            Ok(_) => Err(DBError::new("should have returned an error")),
            Err(err) => {
                assert_eq!(err.to_string(), "read error");
                assert!(err.source().is_some(), "Error should have a source.");
                assert!(
                    err.source()
                        .unwrap()
                        .to_string()
                        .contains("file corruption"),
                    "Source Error Message: {}",
                    err.source().unwrap().to_string()
                );
                Ok(())
            }
        }
    }
}

#[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;
    }
}