From abfa7114df1bf8b4c6dc32bae893005d73c06766 Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Sun, 19 Mar 2023 13:02:20 -0400 Subject: [PATCH] got datatype read/write working with database. --- src/morethantext/cache.rs | 154 +++++++++++++++++++++++------------ src/morethantext/database.rs | 6 ++ src/morethantext/store.rs | 10 +-- 3 files changed, 113 insertions(+), 57 deletions(-) diff --git a/src/morethantext/cache.rs b/src/morethantext/cache.rs index 8878770..05bb3b8 100644 --- a/src/morethantext/cache.rs +++ b/src/morethantext/cache.rs @@ -1,4 +1,4 @@ -use super::{Database, DBError, ErrorCode, FileData, SessionData, Store}; +use super::{DBError, Database, ErrorCode, FileData, SessionData, Store}; use async_std::{ fs::{read, remove_file, write}, path::{Path, PathBuf}, @@ -22,6 +22,7 @@ impl DataType { fn new(data_type: &str) -> Result { match data_type { "store" => Ok(DataType::DBMap(Store::new())), + "database" => Ok(DataType::TableMap(Database::new())), _ => Err(DBError::from_code(ErrorCode::DataTypeIncorrect( data_type.to_string(), ))), @@ -56,12 +57,13 @@ impl FileData for DataType { fn to_bytes(&self) -> Vec { 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()); - }, - DataType::TableMap(_) => todo!(), + DataType::DBMap(_) => output.append(&mut "DBMap".as_bytes().to_vec()), + DataType::TableMap(_) => output.append(&mut "TableMap".as_bytes().to_vec()), + } + output.push(0); + match self { + DataType::DBMap(store) => output.append(&mut store.to_bytes()), + DataType::TableMap(db) => (), } output } @@ -88,6 +90,7 @@ impl FileData for DataType { Ok(store) => Ok(DataType::DBMap(store)), Err(err) => Err(err), }, + "TableMap" => Ok(DataType::new("database").unwrap()), _ => Err(DBError::from_code(ErrorCode::CorruptFile)), } } @@ -166,7 +169,8 @@ impl Entry { match write(&self.filename, data.to_bytes()).await { Ok(_) => (), Err(err) => { - let mut error = DBError::from_code(ErrorCode::EntryWriteFailure(self.filename.clone())); + let mut error = + DBError::from_code(ErrorCode::EntryWriteFailure(self.filename.clone())); error.add_source(err); return Err(error); } @@ -179,7 +183,8 @@ impl Entry { match remove_file(&self.filename).await { Ok(_) => Ok(()), Err(err) => { - let mut error = DBError::from_code(ErrorCode::EntryDeleteFailure(self.filename.clone())); + let mut error = + DBError::from_code(ErrorCode::EntryDeleteFailure(self.filename.clone())); error.add_source(err); Err(error) } @@ -203,38 +208,66 @@ impl Cache { match Entry::new(entry, store).await { Ok(_) => Ok(Self {}), Err(err) => { - let mut error = DBError::from_code(ErrorCode::CacheReadWrite); - error.add_source(err); - Err(error) - }, + let mut error = DBError::from_code(ErrorCode::CacheReadWrite); + error.add_source(err); + Err(error) + } + } + } + } + } +} + +#[cfg(test)] +mod datatype { + use super::*; + + #[test] + fn bad_data_type() -> Result<(), DBError> { + let dt = "bufcuss"; + match DataType::new(dt) { + Ok(_) => Err(DBError::new("should have produced an error")), + Err(err) => match err.code { + ErrorCode::DataTypeIncorrect(value) => { + assert_eq!(value, dt, "Incorrect input value"); + Ok(()) + } + _ => { + let mut error = DBError::new("incorrect error"); + error.add_source(err); + Err(error) } }, } } + + #[test] + fn create_store() -> Result<(), DBError> { + match DataType::new("store") { + Ok(dt) => match dt { + DataType::DBMap(_) => Ok(()), + _ => Err(DBError::new("incorrect data type")), + }, + Err(err) => Err(err), + } + } + + #[test] + fn create_database() -> Result<(), DBError> { + match DataType::new("database") { + Ok(dt) => match dt { + DataType::TableMap(_) => Ok(()), + _ => Err(DBError::new("incorrect data type")), + }, + Err(err) => Err(err), + } + } } #[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) => match err.code { - ErrorCode::DataTypeIncorrect(_) => Ok(()), - _ => Err(DBError::new("Invalid error code")), - }, - } - } - - #[test] - fn create_storage() { - let dbs = DataType::new("store").unwrap(); - let expected: Vec = Vec::new(); - assert_eq!(dbs.list(["database"].to_vec()).unwrap(), expected); - } - #[test] fn update_storage() { let mut dbs = DataType::new("store").unwrap(); @@ -296,6 +329,25 @@ mod datatype_file { ); } + #[test] + fn new_database_bytes() { + let db = DataType::new("database").unwrap(); + let mut expected = "TableMap".as_bytes().to_vec(); + expected.push(0); + assert_eq!(db.to_bytes(), expected); + } + + #[test] + fn read_empty_database() { + let dt = DataType::new("database").unwrap(); + let data = dt.to_bytes(); + let mut feed = data.iter(); + match DataType::from_bytes(&mut feed).unwrap() { + DataType::TableMap(_) => (), + _ => assert!(false, "Incorrect data type"), + } + } + #[test] fn read_bad_header() -> Result<(), DBError> { let data = "sdghsdl".as_bytes().to_vec(); @@ -320,7 +372,7 @@ mod datatype_file { Err(err) => match err.code { ErrorCode::CorruptFile => Ok(()), _ => Err(DBError::new("incorrect error code")), - } + }, } } } @@ -481,9 +533,9 @@ mod entry { .to_string() .contains("could not write to file")); Ok(()) - }, + } _ => Err(DBError::new("incorrect error code")), - } + }, } } @@ -530,7 +582,7 @@ mod entry { Ok(()) } _ => Err(DBError::new("incorrect error code")), - } + }, } } @@ -551,9 +603,9 @@ mod entry { err.source().unwrap().to_string() ); Ok(()) - }, + } _ => Err(DBError::new("incorrect error code")), - } + }, } } @@ -594,9 +646,9 @@ mod entry { err.source().unwrap().to_string() ); Ok(()) - }, + } _ => Err(DBError::new("incorrect error code")), - } + }, } } } @@ -630,20 +682,18 @@ mod cache { let path = dir.path().join("bad").join("path"); match Cache::new(path).await { Ok(_) => Err(DBError::new("Should have produced an error.")), - Err(err) => { - match err.code { - ErrorCode::CacheReadWrite => { - assert!(err.source().is_some(), "Error should have a source."); - assert!( - err.source().unwrap().to_string().contains("write failure"), - "Source Error Message: {}", - err.source().unwrap().to_string() - ); - Ok(()) - }, - _ => Err(DBError::new("incorrect error code")), + Err(err) => match err.code { + ErrorCode::CacheReadWrite => { + assert!(err.source().is_some(), "Error should have a source."); + assert!( + err.source().unwrap().to_string().contains("write failure"), + "Source Error Message: {}", + err.source().unwrap().to_string() + ); + Ok(()) } - } + _ => Err(DBError::new("incorrect error code")), + }, } } diff --git a/src/morethantext/database.rs b/src/morethantext/database.rs index 31e7b3d..92ab607 100644 --- a/src/morethantext/database.rs +++ b/src/morethantext/database.rs @@ -4,6 +4,12 @@ use std::slice; #[derive(Clone)] pub struct Database; +impl Database { + pub fn new() -> Self { + Self + } +} + impl FileData for Database { fn to_bytes(&self) -> Vec { let output = Vec::new(); diff --git a/src/morethantext/store.rs b/src/morethantext/store.rs index 421f609..b504389 100644 --- a/src/morethantext/store.rs +++ b/src/morethantext/store.rs @@ -191,7 +191,7 @@ mod file_data { Err(err) => match err.code { ErrorCode::CorruptFile => Ok(()), _ => Err(DBError::new("incorrect error code")), - } + }, } } @@ -214,15 +214,15 @@ mod file_data { assert!( err.source().is_some(), "Should state file corruption cause." - ); + ); assert_eq!( err.source().unwrap().to_string(), format!("database {} already exists", name) - ); + ); Ok(()) - }, + } _ => Err(DBError::new("incorrect error code")), - } + }, } } }