jbaskin/morethantext-web
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

got datatype read/write working with database.

Browse Source
This commit is contained in:
Jeff Baskin 2023-03-19 13:02:20 -04:00
parent 418ba26da9
commit abfa7114df
3 changed files with 113 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

154
src/morethantext/cache.rs
View File

@ -1,4 +1,4 @@
use super::{Database, DBError, ErrorCode, FileData, SessionData, Store}; use super::{DBError, Database, ErrorCode, FileData, SessionData, Store};
use async_std::{ use async_std::{
fs::{read, remove_file, write}, fs::{read, remove_file, write},
path::{Path, PathBuf}, path::{Path, PathBuf},
@ -22,6 +22,7 @@ impl DataType {
fn new(data_type: &str) -> Result<Self, DBError> { fn new(data_type: &str) -> Result<Self, DBError> {
match data_type { match data_type {
"store" => Ok(DataType::DBMap(Store::new())), "store" => Ok(DataType::DBMap(Store::new())),
"database" => Ok(DataType::TableMap(Database::new())),
_ => Err(DBError::from_code(ErrorCode::DataTypeIncorrect( _ => Err(DBError::from_code(ErrorCode::DataTypeIncorrect(
data_type.to_string(), data_type.to_string(),
))), ))),
@ -56,12 +57,13 @@ impl FileData<Self> for DataType {
fn to_bytes(&self) -> Vec<u8> { fn to_bytes(&self) -> Vec<u8> {
let mut output = Vec::new(); let mut output = Vec::new();
match self { match self {
DataType::DBMap(store) => { DataType::DBMap(_) => output.append(&mut "DBMap".as_bytes().to_vec()),
output.append(&mut "DBMap".as_bytes().to_vec()); DataType::TableMap(_) => output.append(&mut "TableMap".as_bytes().to_vec()),
output.push(0); }
output.append(&mut store.to_bytes()); output.push(0);
}, match self {
DataType::TableMap(_) => todo!(), DataType::DBMap(store) => output.append(&mut store.to_bytes()),
DataType::TableMap(db) => (),
} }
output output
} }
@ -88,6 +90,7 @@ impl FileData<Self> for DataType {
Ok(store) => Ok(DataType::DBMap(store)), Ok(store) => Ok(DataType::DBMap(store)),
Err(err) => Err(err), Err(err) => Err(err),
}, },
"TableMap" => Ok(DataType::new("database").unwrap()),
_ => Err(DBError::from_code(ErrorCode::CorruptFile)), _ => Err(DBError::from_code(ErrorCode::CorruptFile)),
} }
} }
@ -166,7 +169,8 @@ impl Entry {
match write(&self.filename, data.to_bytes()).await { match write(&self.filename, data.to_bytes()).await {
Ok(_) => (), Ok(_) => (),
Err(err) => { 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); error.add_source(err);
return Err(error); return Err(error);
} }
@ -179,7 +183,8 @@ impl Entry {
match remove_file(&self.filename).await { match remove_file(&self.filename).await {
Ok(_) => Ok(()), Ok(_) => Ok(()),
Err(err) => { 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); error.add_source(err);
Err(error) Err(error)
} }
@ -203,38 +208,66 @@ impl Cache {
match Entry::new(entry, store).await { match Entry::new(entry, store).await {
Ok(_) => Ok(Self {}), Ok(_) => Ok(Self {}),
Err(err) => { Err(err) => {
let mut error = DBError::from_code(ErrorCode::CacheReadWrite); let mut error = DBError::from_code(ErrorCode::CacheReadWrite);
error.add_source(err); error.add_source(err);
Err(error) 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)] #[cfg(test)]
mod datatype_sesssion { mod datatype_sesssion {
use super::*; 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<String> = Vec::new();
assert_eq!(dbs.list(["database"].to_vec()).unwrap(), expected);
}
#[test] #[test]
fn update_storage() { fn update_storage() {
let mut dbs = DataType::new("store").unwrap(); 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] #[test]
fn read_bad_header() -> Result<(), DBError> { fn read_bad_header() -> Result<(), DBError> {
let data = "sdghsdl".as_bytes().to_vec(); let data = "sdghsdl".as_bytes().to_vec();
@ -320,7 +372,7 @@ mod datatype_file {
Err(err) => match err.code { Err(err) => match err.code {
ErrorCode::CorruptFile => Ok(()), ErrorCode::CorruptFile => Ok(()),
_ => Err(DBError::new("incorrect error code")), _ => Err(DBError::new("incorrect error code")),
} },
} }
} }
} }
@ -481,9 +533,9 @@ mod entry {
.to_string() .to_string()
.contains("could not write to file")); .contains("could not write to file"));
Ok(()) Ok(())
}, }
_ => Err(DBError::new("incorrect error code")), _ => Err(DBError::new("incorrect error code")),
} },
} }
} }
@ -530,7 +582,7 @@ mod entry {
Ok(()) Ok(())
} }
_ => Err(DBError::new("incorrect error code")), _ => Err(DBError::new("incorrect error code")),
} },
} }
} }
@ -551,9 +603,9 @@ mod entry {
err.source().unwrap().to_string() err.source().unwrap().to_string()
); );
Ok(()) Ok(())
}, }
_ => Err(DBError::new("incorrect error code")), _ => Err(DBError::new("incorrect error code")),
} },
} }
} }
@ -594,9 +646,9 @@ mod entry {
err.source().unwrap().to_string() err.source().unwrap().to_string()
); );
Ok(()) Ok(())
}, }
_ => Err(DBError::new("incorrect error code")), _ => Err(DBError::new("incorrect error code")),
} },
} }
} }
} }
@ -630,20 +682,18 @@ mod cache {
let path = dir.path().join("bad").join("path"); let path = dir.path().join("bad").join("path");
match Cache::new(path).await { match Cache::new(path).await {
Ok(_) => Err(DBError::new("Should have produced an error.")), Ok(_) => Err(DBError::new("Should have produced an error.")),
Err(err) => { Err(err) => match err.code {
match err.code { ErrorCode::CacheReadWrite => {
ErrorCode::CacheReadWrite => { assert!(err.source().is_some(), "Error should have a source.");
assert!(err.source().is_some(), "Error should have a source."); assert!(
assert!( err.source().unwrap().to_string().contains("write failure"),
err.source().unwrap().to_string().contains("write failure"), "Source Error Message: {}",
"Source Error Message: {}", err.source().unwrap().to_string()
err.source().unwrap().to_string() );
); Ok(())
Ok(())
},
_ => Err(DBError::new("incorrect error code")),
} }
} _ => Err(DBError::new("incorrect error code")),
},
} }
} }

6
src/morethantext/database.rs
View File

@ -4,6 +4,12 @@ use std::slice;
#[derive(Clone)] #[derive(Clone)]
pub struct Database; pub struct Database;
impl Database {
pub fn new() -> Self {
Self
}
}
impl FileData<Self> for Database { impl FileData<Self> for Database {
fn to_bytes(&self) -> Vec<u8> { fn to_bytes(&self) -> Vec<u8> {
let output = Vec::new(); let output = Vec::new();

10
src/morethantext/store.rs
View File

@ -191,7 +191,7 @@ mod file_data {
Err(err) => match err.code { Err(err) => match err.code {
ErrorCode::CorruptFile => Ok(()), ErrorCode::CorruptFile => Ok(()),
_ => Err(DBError::new("incorrect error code")), _ => Err(DBError::new("incorrect error code")),
} },
} }
} }
@ -214,15 +214,15 @@ mod file_data {
assert!( assert!(
err.source().is_some(), err.source().is_some(),
"Should state file corruption cause." "Should state file corruption cause."
); );
assert_eq!( assert_eq!(
err.source().unwrap().to_string(), err.source().unwrap().to_string(),
format!("database {} already exists", name) format!("database {} already exists", name)
); );
Ok(()) Ok(())
}, }
_ => Err(DBError::new("incorrect error code")), _ => Err(DBError::new("incorrect error code")),
} },
} }
} }
} }