morethantext-web/src/morethantext/cachetype.rs

use super::DBError;
use std::{collections::HashMap, fmt, str};

#[derive(Clone)]
pub struct Databases;

impl Databases {
    pub fn new() -> Self {
        Self {}
    }
}

#[derive(Clone)]
pub enum CacheType {
    Raw(String),
    DBMap(Databases),
    TableMap,
}

impl CacheType {
    pub fn entry_type(&self) -> String {
        match self {
            CacheType::Raw(_) => "Raw".to_string(),
            CacheType::DBMap(_) => "DBMap".to_string(),
            CacheType::TableMap => "TableMap".to_string(),
        }
    }

    pub fn to_bytes(&self) -> Vec<u8> {
        let mut output = self.entry_type().into_bytes();
        output.push(0);
        match self {
            CacheType::Raw(s) => output.append(&mut s.as_bytes().to_vec()),
            CacheType::DBMap(_) => (),
            CacheType::TableMap => (),
        }
        return output;
    }

    pub fn from_bytes(data: Vec<u8>) -> Result<CacheType, DBError> {
        let mut data_iter = data.iter();
        let mut letter: u8;
        match data_iter.next() {
            Some(item) => letter = *item,
            None => return Err(DBError::new("empty file")),
        }
        let mut header: Vec<u8> = Vec::new();
        while letter != 0 {
            header.push(letter.clone());
            match data_iter.next() {
                Some(item) => letter = *item,
                None => return Err(DBError::new("incomplete file")),
            }
        }
        let header = str::from_utf8(&header).unwrap().to_string();
        match header.as_str() {
            "Raw" => {
                let mut output: Vec<u8> = Vec::new();
                for letter in data_iter {
                    output.push(letter.clone());
                }
                Ok(CacheType::Raw(str::from_utf8(&output).unwrap().to_string()))
            }
            "DBMap" => Ok(CacheType::DBMap(Databases::new())),
            _ => Err(DBError::new("data corruption")),
        }
    }
}

impl fmt::Display for CacheType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CacheType::Raw(s) => write!(f, "{}", s),
            CacheType::DBMap(_) => todo!(),
            CacheType::TableMap => todo!(),
        }
    }
}

#[cfg(test)]
mod databases {
    use super::*;

    #[test]
    fn get_bytes_for_new() {
        Databases::new();
    }
}

#[cfg(test)]
mod enum_ctype {
    use super::*;

    #[test]
    fn bad_file_header() {
        let mut data: Vec<u8> = Vec::new();
        let mut ctype = "jlksdfg".as_bytes().to_vec();
        let mut cdata = "ghjk".as_bytes().to_vec();
        data.append(&mut ctype);
        data.push(0);
        data.append(&mut cdata);
        match CacheType::from_bytes(data) {
            Ok(_) => assert!(false, "This should fail."),
            Err(err) => assert_eq!(err.to_string(), "data corruption"),
        }
    }

    #[test]
    fn incomplete_file() {
        let mut data: Vec<u8> = Vec::new();
        let mut ctype = "uoisfde".as_bytes().to_vec();
        data.append(&mut ctype);
        match CacheType::from_bytes(data) {
            Ok(_) => assert!(false, "This should fail."),
            Err(err) => assert_eq!(err.to_string(), "incomplete file"),
        }
    }

    #[test]
    fn empty_file() {
        let data: Vec<u8> = Vec::new();
        match CacheType::from_bytes(data) {
            Ok(_) => assert!(false, "This should fail."),
            Err(err) => assert_eq!(err.to_string(), "empty file"),
        }
    }

    #[test]
    fn get_raw_type() {
        let holder = CacheType::Raw("nothing important".to_string());
        assert_eq!(holder.entry_type(), "Raw");
    }

    #[test]
    fn get_raw_bytes() {
        let data = "addams";
        let holder = CacheType::Raw(data.to_string());
        let mut expected = holder.entry_type().into_bytes();
        expected.push(0);
        expected.append(&mut data.as_bytes().to_vec());
        let output = holder.to_bytes();
        assert_eq!(output, expected);
    }

    #[test]
    fn from_raw_bytes() {
        let holder = CacheType::Raw("stored item".to_string());
        let data = holder.to_bytes();
        let output = CacheType::from_bytes(data).unwrap();
        assert_eq!(output.to_string(), holder.to_string());
    }

    #[test]
    fn get_dbmap_type() {
        let holder = CacheType::DBMap(Databases::new());
        assert_eq!(holder.entry_type(), "DBMap");
    }

    #[test]
    fn get_new_databases_bytes() {
        let holder = CacheType::DBMap(Databases::new());
        let mut expected = "DBMap".as_bytes().to_vec();
        expected.push(0);
        let output = holder.to_bytes();
        assert_eq!(output, expected);
    }

    #[test]
    fn from_new_databases_bytes() {
        let mut data = "DBMap".as_bytes().to_vec();
        data.push(0);
        let output = CacheType::from_bytes(data).unwrap();
        assert_eq!(output.entry_type(), "DBMap");
    }

    #[test]
    fn get_tablemap_type() {
        let holder = CacheType::TableMap;
        assert_eq!(holder.entry_type(), "TableMap");
    }
}