MoreThanText/morethantext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Made MTTError a proper Error structure.
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 1s
Details

Browse Source
This commit is contained in:
Jeff Baskin 2026-02-12 22:49:19 -05:00
parent 7ff9ca340f
commit a9b87200ef
12 changed files with 156 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/action/calculation.rs
View File

@ -1,5 +1,8 @@
use super::{Field, FieldType}; use super::{Field, FieldType};
use crate::mtterror::MTTError; use crate::{
mtterror::{ErrorID, MTTError},
name::NameType,
};
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use std::time::Duration; use std::time::Duration;
use uuid::Uuid; use uuid::Uuid;
@ -349,7 +352,8 @@ impl Calculation {
if base == ftype { if base == ftype {
self.values.push(holder); self.values.push(holder);
} else { } else {
return Err(MTTError::DocumentFieldWrongDataType(base, ftype)); let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
return Err(err);
} }
Ok(()) Ok(())
} }
@ -376,7 +380,8 @@ impl Calculation {
if base == ftype { if base == ftype {
Ok(()) Ok(())
} else { } else {
Err(MTTError::DocumentFieldWrongDataType(base, ftype)) let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
return Err(err);
} }
} }
@ -446,13 +451,13 @@ mod calculations {
calc.add_value(Uuid::nil()).unwrap(); calc.add_value(Uuid::nil()).unwrap();
match calc.add_value("other") { match calc.add_value("other") {
Ok(_) => unreachable!("should have errored with wrong type"), Ok(_) => unreachable!("should have errored with wrong type"),
Err(err) => match err { Err(err) => {
MTTError::DocumentFieldWrongDataType(expected, got) => { let err_id = err.error_id();
assert_eq!(expected, FieldType::Uuid); match err_id {
assert_eq!(got, FieldType::StaticString); ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}, expected wrong field type", err_id),
} }
_ => unreachable!("got {:?}, expected wrong field type", err), }
},
} }
} }
@ -600,11 +605,8 @@ mod calculations {
calc.add_value(Uuid::nil()).unwrap(); calc.add_value(Uuid::nil()).unwrap();
match calc.add_value("mismatch") { match calc.add_value("mismatch") {
Ok(_) => unreachable!("should have returned an error"), Ok(_) => unreachable!("should have returned an error"),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::DocumentFieldWrongDataType(expected, got) => { ErrorID::FieldInvalidType => {}
assert_eq!(got, FieldType::StaticString);
assert_eq!(expected, FieldType::Uuid);
}
_ => unreachable!("got {:?}, expected wrong field type", err), _ => unreachable!("got {:?}, expected wrong field type", err),
}, },
} }

31
src/action/message.rs
View File

@ -104,7 +104,7 @@ impl From<UserAction> for MsgAction {
#[cfg(test)] #[cfg(test)]
mod msgactions { mod msgactions {
use super::*; use super::*;
use crate::name::Name; use crate::{mtterror::ErrorID, name::Name};
use uuid::Uuid; use uuid::Uuid;
#[test] #[test]
@ -120,23 +120,20 @@ mod msgactions {
#[test] #[test]
fn turn_error_into_action() { fn turn_error_into_action() {
let data = "data".to_string(); let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
let value = MTTError::DocumentAlreadyExists(data.clone()); let expected_name: NameType = doc_name.clone().into();
let result: MsgAction = value.into(); let error = ErrorID::DocumentNameAlreadyExists;
let err = MTTError::new(doc_name.clone(), error.clone());
let result: MsgAction = err.into();
match result { match result {
MsgAction::Error(result) => match result { MsgAction::Error(err) => {
MTTError::DocumentAlreadyExists(output) => assert_eq!(output, data), assert_eq!(err.doc_name(), &expected_name);
_ => unreachable!("Got {:?}: dhould have been create", result), let err_id = err.error_id();
}, match err_id {
_ => unreachable!("Got {:?}: dhould have been create", result), ErrorID::DocumentNameAlreadyExists => {}
} _ => unreachable!("got {:?}, expected document name exists", err_id),
let value = MTTError::DocumentNotFound(data.clone()); }
let result: MsgAction = value.into(); }
match result {
MsgAction::Error(result) => match result {
MTTError::DocumentNotFound(output) => assert_eq!(output, data),
_ => unreachable!("Got {:?}: dhould have been create", result),
},
_ => unreachable!("Got {:?}: dhould have been create", result), _ => unreachable!("Got {:?}: dhould have been create", result),
} }
} }

84
src/document/create.rs
View File

@ -5,7 +5,7 @@ use crate::{
field::Field, field::Field,
}, },
message::wrapper::{InternalRecord, InternalRecords, Message, Oid, Records, Reply, Update}, message::wrapper::{InternalRecord, InternalRecords, Message, Oid, Records, Reply, Update},
mtterror::MTTError, mtterror::{ErrorID, MTTError},
name::NameType, name::NameType,
queue::{ queue::{
data_director::{Include, Path, RegMsg, Register, RouteID}, data_director::{Include, Path, RegMsg, Register, RouteID},
@ -156,8 +156,8 @@ mod createdocs {
let result = rx.recv_timeout(TIMEOUT).unwrap(); let result = rx.recv_timeout(TIMEOUT).unwrap();
assert_eq!(result.get_message_id(), msg2.get_message_id()); assert_eq!(result.get_message_id(), msg2.get_message_id());
match result.get_action() { match result.get_action() {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::NameDuplicate(data) => assert_eq!(data, &name), ErrorID::NameAlreadyExists => {}
_ => unreachable!("got {:?}: should have been a duplicate name", err), _ => unreachable!("got {:?}: should have been a duplicate name", err),
}, },
_ => unreachable!("got {:?}: should have been a reply.", result.get_action()), _ => unreachable!("got {:?}: should have been a reply.", result.get_action()),
@ -222,7 +222,8 @@ impl Index {
} }
}; };
if self.unique && oids.len() > 0 { if self.unique && oids.len() > 0 {
return Err(MTTError::FieldDuplicate); let err = MTTError::new(NameType::None, ErrorID::IndexEntryAlreadyExists);
return Err(err);
} else { } else {
oids.insert(oid); oids.insert(oid);
} }
@ -238,7 +239,10 @@ impl Index {
output = output.union(&value).cloned().collect(); output = output.union(&value).cloned().collect();
} }
} }
_ => return Err(MTTError::FieldInvalidType), _ => {
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
return Err(err);
}
} }
} }
Ok(output) Ok(output)
@ -259,7 +263,10 @@ impl Index {
fn validate(&self, field: &Field) -> Result<(), MTTError> { fn validate(&self, field: &Field) -> Result<(), MTTError> {
if self.unique { if self.unique {
match self.data.get(field) { match self.data.get(field) {
Some(_) => return Err(MTTError::FieldDuplicate), Some(_) => {
let err = MTTError::new(NameType::None, ErrorID::IndexEntryAlreadyExists);
return Err(err);
}
None => {} None => {}
} }
} }
@ -416,10 +423,13 @@ mod indexes {
index.add(field.clone(), oids[0].clone()).unwrap(); index.add(field.clone(), oids[0].clone()).unwrap();
match index.add(field.clone(), oids[0].clone()) { match index.add(field.clone(), oids[0].clone()) {
Ok(_) => unreachable!("should have been an error"), Ok(_) => unreachable!("should have been an error"),
Err(err) => match err { Err(err) => {
MTTError::FieldDuplicate => {} let err_id = err.error_id();
_ => unreachable!("got {:?}: should have been duplicate field", err), match err_id {
}, ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have been duplicate field", err),
}
}
} }
} }
@ -443,8 +453,8 @@ mod indexes {
index.add(field.clone(), oid).unwrap(); index.add(field.clone(), oid).unwrap();
match index.validate(&field) { match index.validate(&field) {
Ok(_) => unreachable!("should have gotten a duplication error"), Ok(_) => unreachable!("should have gotten a duplication error"),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::FieldDuplicate => {} ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have been duplicate field", err), _ => unreachable!("got {:?}: should have been duplicate field", err),
}, },
} }
@ -1318,8 +1328,8 @@ mod document_files {
)); ));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
match result.get_action() { match result.get_action() {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::NameNotFound(data) => assert_eq!(data, &name), ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have been document field not found.", err), _ => unreachable!("got {:?}: should have been document field not found.", err),
}, },
_ => unreachable!("got {:?}: should have been an error", result.get_action()), _ => unreachable!("got {:?}: should have been an error", result.get_action()),
@ -1339,11 +1349,8 @@ mod document_files {
)); ));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
match result.get_action() { match result.get_action() {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::DocumentFieldWrongDataType(expected, got) => { ErrorID::FieldInvalidType => {}
assert_eq!(got, &FieldType::StaticString);
assert_eq!(expected, &FieldType::Uuid);
}
_ => unreachable!( _ => unreachable!(
"got {:?}: should have been document field data mismatch.", "got {:?}: should have been document field data mismatch.",
err err
@ -1366,8 +1373,8 @@ mod document_files {
)); ));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
match result.get_action() { match result.get_action() {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::InvalidNone => {} ErrorID::FieldInvalidNone => {}
_ => unreachable!("got {:?}: should have been document field missing", err), _ => unreachable!("got {:?}: should have been document field missing", err),
}, },
_ => unreachable!("got {:?}: should have been an error", result.get_action()), _ => unreachable!("got {:?}: should have been an error", result.get_action()),
@ -1646,8 +1653,8 @@ mod document_files {
let result = rx.recv_timeout(TIMEOUT).unwrap(); let result = rx.recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Error(data) => match data { MsgAction::Error(data) => match data.error_id() {
MTTError::NameNotFound(output) => assert_eq!(output, &field_name), ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should been field not found", data), _ => unreachable!("got {:?}: should been field not found", data),
}, },
_ => unreachable!("got {:?}: should have been a error", action), _ => unreachable!("got {:?}: should have been a error", action),
@ -1670,8 +1677,8 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Error(data) => match data { MsgAction::Error(data) => match data.error_id() {
MTTError::FieldInvalidType => {} ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}: should been invalid field type", data), _ => unreachable!("got {:?}: should been invalid field type", data),
}, },
_ => unreachable!("got {:?}: should have been a error", action), _ => unreachable!("got {:?}: should have been a error", action),
@ -1958,8 +1965,8 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::NameNotFound(data) => assert_eq!(data, &bad_name), ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have gotten an missing field", err), _ => unreachable!("got {:?}: should have gotten an missing field", err),
}, },
_ => unreachable!("got {:?}: should have gotten an error", action), _ => unreachable!("got {:?}: should have gotten an error", action),
@ -1989,11 +1996,8 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::DocumentFieldWrongDataType(expected, got) => { ErrorID::FieldInvalidType => {}
assert_eq!(expected, &FieldType::StaticString);
assert_eq!(got, &FieldType::Uuid);
}
_ => unreachable!("got {:?}: should have gotten incorrect file type", err), _ => unreachable!("got {:?}: should have gotten incorrect file type", err),
}, },
_ => unreachable!("got {:?}: should have gotten an error", action), _ => unreachable!("got {:?}: should have gotten an error", action),
@ -2043,8 +2047,8 @@ mod document_files {
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::FieldDuplicate => {} ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have gotten incorrect file type", err), _ => unreachable!("got {:?}: should have gotten incorrect file type", err),
}, },
_ => unreachable!("got {:?}: should have gotten an error", action), _ => unreachable!("got {:?}: should have gotten an error", action),
@ -2130,8 +2134,8 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::FieldDuplicate => {} ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have gotten an missing field", err), _ => unreachable!("got {:?}: should have gotten an missing field", err),
}, },
_ => unreachable!("got {:?}: should have gotten an error", action), _ => unreachable!("got {:?}: should have gotten an error", action),
@ -2171,8 +2175,8 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::FieldDuplicate => {} ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have gotten field duplicate", err), _ => unreachable!("got {:?}: should have gotten field duplicate", err),
}, },
_ => unreachable!("got {:?}: should have gotten an error", action), _ => unreachable!("got {:?}: should have gotten an error", action),
@ -2282,8 +2286,8 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::NameNotFound(data) => assert_eq!(data, &field_name), ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have gotten an missing field", err), _ => unreachable!("got {:?}: should have gotten an missing field", err),
}, },
_ => unreachable!("got {:?}: should have gotten an error", action), _ => unreachable!("got {:?}: should have gotten an error", action),

42
src/document/definition.rs
View File

@ -2,7 +2,7 @@ use crate::{
action::{Action, CalcValue, Field, FieldType, MsgAction}, action::{Action, CalcValue, Field, FieldType, MsgAction},
document::create::IndexType, document::create::IndexType,
message::MessageAction, message::MessageAction,
mtterror::MTTError, mtterror::{ErrorID, MTTError},
name::{Name, NameType, Names}, name::{Name, NameType, Names},
queue::data_director::{Include, Path}, queue::data_director::{Include, Path},
}; };
@ -31,17 +31,20 @@ impl FieldSetting {
match &value { match &value {
CalcValue::Calculate(calc) => { CalcValue::Calculate(calc) => {
if self.fieldtype != calc.get_type() { if self.fieldtype != calc.get_type() {
return Err(MTTError::FieldInvalidType); let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
return Err(err);
} }
} }
CalcValue::Existing(ftype) | CalcValue::FType(ftype) => { CalcValue::Existing(ftype) | CalcValue::FType(ftype) => {
if &self.fieldtype != ftype { if &self.fieldtype != ftype {
return Err(MTTError::FieldInvalidType); let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
return Err(err);
} }
} }
CalcValue::Value(ref item) => { CalcValue::Value(ref item) => {
if item.get_type() != self.fieldtype { if item.get_type() != self.fieldtype {
return Err(MTTError::FieldInvalidType); let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
return Err(err);
} }
} }
CalcValue::None => {} CalcValue::None => {}
@ -53,16 +56,14 @@ impl FieldSetting {
fn validate(&self, value: &Field) -> Result<Field, MTTError> { fn validate(&self, value: &Field) -> Result<Field, MTTError> {
match value { match value {
Field::None => match &self.default_value { Field::None => match &self.default_value {
CalcValue::None => Err(MTTError::InvalidNone), CalcValue::None => Err(MTTError::new(NameType::None, ErrorID::FieldInvalidNone)),
_ => Ok(self.default_value.get(&Field::None)), _ => Ok(self.default_value.get(&Field::None)),
}, },
_ => { _ => {
let vft: FieldType = value.into(); let vft: FieldType = value.into();
if vft != self.fieldtype { if vft != self.fieldtype {
return Err(MTTError::DocumentFieldWrongDataType( let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
self.fieldtype.clone(), return Err(err);
vft,
));
} }
Ok(value.clone()) Ok(value.clone())
} }
@ -93,11 +94,8 @@ mod fieldsettings {
let value: Field = "text".into(); let value: Field = "text".into();
match fset.validate(&value) { match fset.validate(&value) {
Ok(data) => unreachable!("got {:?}: should have gotten an error", data), Ok(data) => unreachable!("got {:?}: should have gotten an error", data),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::DocumentFieldWrongDataType(expected, got) => { ErrorID::FieldInvalidType => {}
assert_eq!(expected, FieldType::Uuid);
assert_eq!(got, FieldType::StaticString);
}
_ => unreachable!("got {:?}: should have gotten a value", err), _ => unreachable!("got {:?}: should have gotten a value", err),
}, },
} }
@ -108,8 +106,8 @@ mod fieldsettings {
let fset = FieldSetting::new(FieldType::Uuid); let fset = FieldSetting::new(FieldType::Uuid);
match fset.validate(&Field::None) { match fset.validate(&Field::None) {
Ok(data) => unreachable!("got {:?}: should have gotten an error", data), Ok(data) => unreachable!("got {:?}: should have gotten an error", data),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::InvalidNone => {} ErrorID::FieldInvalidNone => {}
_ => unreachable!("got {:?}: should have gotten a invalid none", err), _ => unreachable!("got {:?}: should have gotten a invalid none", err),
}, },
} }
@ -415,8 +413,8 @@ mod docdefs {
let name = Name::english(Uuid::new_v4().to_string().as_str()); let name = Name::english(Uuid::new_v4().to_string().as_str());
match docdef.get_field(&name) { match docdef.get_field(&name) {
Ok(_) => unreachable!("should return non existant field error"), Ok(_) => unreachable!("should return non existant field error"),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::NameNotFound(data) => assert_eq!(data, name), ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have been document field not found", err), _ => unreachable!("got {:?}: should have been document field not found", err),
}, },
} }
@ -463,8 +461,8 @@ mod docdefs {
let field_name = Name::english(Uuid::new_v4().to_string().as_str()); let field_name = Name::english(Uuid::new_v4().to_string().as_str());
match docdef.set_default(&field_name, FieldType::Uuid) { match docdef.set_default(&field_name, FieldType::Uuid) {
Ok(_) => unreachable!("should be an error"), Ok(_) => unreachable!("should be an error"),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::NameNotFound(data) => assert_eq!(data, field_name), ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have been field not found", err), _ => unreachable!("got {:?}: should have been field not found", err),
}, },
} }
@ -478,8 +476,8 @@ mod docdefs {
docdef.add_field(name.clone(), FieldType::Uuid); docdef.add_field(name.clone(), FieldType::Uuid);
match docdef.set_default(&name, "fred") { match docdef.set_default(&name, "fred") {
Ok(data) => unreachable!("got {:?}, should be an error", data), Ok(data) => unreachable!("got {:?}, should be an error", data),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::FieldInvalidType => {} ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}: should have been field not found", err), _ => unreachable!("got {:?}: should have been field not found", err),
}, },
} }

6
src/document/session.rs
View File

@ -92,7 +92,7 @@ mod sessions {
field::Field, field::Field,
}, },
message::wrapper::Records, message::wrapper::Records,
mtterror::MTTError, mtterror::{ErrorID, MTTError},
name::{Name, NameType, Names}, name::{Name, NameType, Names},
queue::data_director::{Include, Path, RegMsg, Register}, queue::data_director::{Include, Path, RegMsg, Register},
support_tests::TIMEOUT, support_tests::TIMEOUT,
@ -246,8 +246,8 @@ mod sessions {
let result = setup.recv().unwrap(); let result = setup.recv().unwrap();
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::FieldDuplicate => {} ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}, should have been a field duplicate", err), _ => unreachable!("got {:?}, should have been a field duplicate", err),
}, },
_ => unreachable!("got {:?}, should have been an error", action), _ => unreachable!("got {:?}, should have been an error", action),

4
src/lib.rs
View File

@ -18,7 +18,7 @@ use queue::{
use std::sync::mpsc::{channel, Receiver}; use std::sync::mpsc::{channel, Receiver};
use uuid::Uuid; use uuid::Uuid;
pub use mtterror::MTTError; pub use mtterror::{ErrorID, MTTError};
pub use name::{Name, NameType}; pub use name::{Name, NameType};
#[cfg(test)] #[cfg(test)]
@ -118,7 +118,7 @@ impl MoreThanText {
if name == "page" { if name == "page" {
Ok("something".to_string()) Ok("something".to_string())
} else { } else {
Err(MTTError::DocumentNotFound(name.to_string())) Err(MTTError::new(NameType::None, ErrorID::DocumentNotFound))
} }
} }
} }

6
src/main.rs
View File

@ -8,7 +8,7 @@ use axum::{
use clap::Parser; use clap::Parser;
//use morethantext::{ActionType, ErrorType, MoreThanText}; //use morethantext::{ActionType, ErrorType, MoreThanText};
//use morethantext::{MoreThanText, MsgAction, Query}; //use morethantext::{MoreThanText, MsgAction, Query};
use morethantext::{MTTError, MoreThanText}; use morethantext::{ErrorID, MTTError, MoreThanText};
use std::{collections::HashMap, convert::Infallible}; use std::{collections::HashMap, convert::Infallible};
use tokio::{spawn, sync::mpsc::channel}; use tokio::{spawn, sync::mpsc::channel};
use tower_cookies::{Cookie, CookieManagerLayer, Cookies}; use tower_cookies::{Cookie, CookieManagerLayer, Cookies};
@ -108,8 +108,8 @@ async fn mtt_conn(
result = data.clone(); result = data.clone();
} }
Err(err) => { Err(err) => {
status = match err { status = match err.error_id() {
MTTError::DocumentNotFound(_) => StatusCode::NOT_FOUND, ErrorID::DocumentNotFound => StatusCode::NOT_FOUND,
_ => StatusCode::INTERNAL_SERVER_ERROR, _ => StatusCode::INTERNAL_SERVER_ERROR,
}; };
} }

16
src/message/wrapper.rs
View File

@ -1,7 +1,7 @@
use crate::{ use crate::{
action::{CalcValue, MsgAction, Operand, Query}, action::{CalcValue, MsgAction, Operand, Query},
document::field::{Field, FieldType}, document::field::{Field, FieldType},
mtterror::MTTError, mtterror::{ErrorID, MTTError},
name::{NameType, Names}, name::{NameType, Names},
queue::data_director::{Include, Path, Route}, queue::data_director::{Include, Path, Route},
}; };
@ -195,15 +195,15 @@ mod messages {
let name = Name::english("testing"); let name = Name::english("testing");
let msg = Message::new(name.clone(), Query::new(name.clone())); let msg = Message::new(name.clone(), Query::new(name.clone()));
let err_msg = Uuid::new_v4().to_string(); let err_msg = Uuid::new_v4().to_string();
let result = msg.response(MTTError::DocumentNotFound(err_msg.clone())); let result = msg.response(MTTError::new(NameType::None, ErrorID::DocumentNotFound));
assert_eq!(result.get_message_id(), msg.get_message_id()); assert_eq!(result.get_message_id(), msg.get_message_id());
match &result.document_id { match &result.document_id {
NameType::Name(data) => assert_eq!(data, &name), NameType::Name(data) => assert_eq!(data, &name),
_ => unreachable!("should have been a name"), _ => unreachable!("should have been a name"),
} }
match result.get_action() { match result.get_action() {
MsgAction::Error(data) => match data { MsgAction::Error(data) => match data.error_id() {
MTTError::DocumentNotFound(txt) => assert_eq!(txt, &err_msg), ErrorID::DocumentNotFound => {}
_ => unreachable!("got {:?}, should have received not found", data), _ => unreachable!("got {:?}, should have received not found", data),
}, },
_ => unreachable!("should have been a reply"), _ => unreachable!("should have been a reply"),
@ -215,7 +215,7 @@ mod messages {
let doc_id = Uuid::new_v4(); let doc_id = Uuid::new_v4();
let msg = Message::new(doc_id.clone(), Query::new(doc_id.clone())); let msg = Message::new(doc_id.clone(), Query::new(doc_id.clone()));
let data = Uuid::new_v4().to_string(); let data = Uuid::new_v4().to_string();
let result1 = msg.response(MTTError::DocumentNotFound(data.clone())); let result1 = msg.response(MTTError::new(NameType::None, ErrorID::DocumentNotFound));
let result2 = msg.response(Reply::new()); let result2 = msg.response(Reply::new());
assert_eq!(result1.get_message_id(), msg.get_message_id()); assert_eq!(result1.get_message_id(), msg.get_message_id());
assert_eq!(result2.get_message_id(), msg.get_message_id()); assert_eq!(result2.get_message_id(), msg.get_message_id());
@ -223,8 +223,8 @@ mod messages {
assert_eq!(result2.document_id, msg.document_id); assert_eq!(result2.document_id, msg.document_id);
let action1 = result1.get_action(); let action1 = result1.get_action();
match action1 { match action1 {
MsgAction::Error(err) => match err { MsgAction::Error(err) => match err.error_id() {
MTTError::DocumentNotFound(output) => assert_eq!(output, &data), ErrorID::DocumentNotFound => {}
_ => unreachable!("got {:?}: should have received document not found", err), _ => unreachable!("got {:?}: should have received document not found", err),
}, },
_ => unreachable!("got {:?}: should have received error", action1), _ => unreachable!("got {:?}: should have received error", action1),
@ -466,7 +466,7 @@ impl Record {
}; };
match self.data.get(&id) { match self.data.get(&id) {
Some(data) => Ok(data.clone()), Some(data) => Ok(data.clone()),
None => Err(MTTError::FieldMissingData), None => Err(MTTError::new(NameType::None, ErrorID::FieldMissingData)),
} }
} }
} }

54
src/mtterror.rs
View File

@ -8,43 +8,29 @@ use std::{error::Error, fmt};
use uuid::Uuid; use uuid::Uuid;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum MTTError { pub enum ErrorID {
AdditionMissingField(Name), DocumentNameAlreadyExists,
CannotConvertMessageToRouteID, DocumentNotFound,
DocumentAlreadyExists(String), FieldDataMustBeUnique,
DocumentFieldAlreadyExists(String, Field), FieldInvalidNone,
DocumentFieldMissing(String),
DocumentFieldNotFound(String),
DocumentFieldWrongDataType(FieldType, FieldType),
DocumentNotFound(String),
FieldDuplicate,
FieldInvalidType, FieldInvalidType,
FieldMissingData, FieldMissingData,
InvalidNone, FieldNameAlreadyExists,
RecordMismatch, IndexEntryAlreadyExists,
NameDuplicate(Name),
NameInvalidID(Uuid),
NameMissingTranslation(Language),
NameNotUniquePerLanguage(Name),
NameNotFound(Name),
QueryCannotChangeData,
RouteRequiresDocumentID,
}
#[derive(Clone, Debug)]
pub enum ErrorID {
InvalidDocumentName,
InvalidFieldName(Name), InvalidFieldName(Name),
NameAlreadyExists,
NameLanguageNotUnique,
NameNotFound,
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct MTTError2 { pub struct MTTError {
doc_name: NameType, doc_name: NameType,
error_id: ErrorID, error_id: ErrorID,
} }
impl MTTError2 { impl MTTError {
pub fn new<NT>(doc_name: NT, error: ErrorID) -> MTTError2 pub fn new<NT>(doc_name: NT, error: ErrorID) -> MTTError
where where
NT: Into<NameType>, NT: Into<NameType>,
{ {
@ -59,15 +45,15 @@ impl MTTError2 {
} }
} }
impl fmt::Display for MTTError2 { impl fmt::Display for MTTError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:?} error: {:?}", self.doc_name, self.error_id) write!(f, "{:?} error: {:?}", self.doc_name, self.error_id)
} }
} }
impl Error for MTTError2 {} impl Error for MTTError {}
impl MessageAction for MTTError2 { impl MessageAction for MTTError {
fn doc_name(&self) -> &NameType { fn doc_name(&self) -> &NameType {
&self.doc_name &self.doc_name
} }
@ -81,12 +67,12 @@ mod errors {
fn can_create_error() { fn can_create_error() {
let doc_name = Name::english(Uuid::new_v4().to_string().as_str()); let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
let expected_name: NameType = doc_name.clone().into(); let expected_name: NameType = doc_name.clone().into();
let error = ErrorID::InvalidDocumentName; let error = ErrorID::DocumentNameAlreadyExists;
let err = MTTError2::new(doc_name.clone(), error.clone()); let err = MTTError::new(doc_name.clone(), error.clone());
assert_eq!(err.doc_name(), &expected_name); assert_eq!(err.doc_name(), &expected_name);
let err_id = err.error_id(); let err_id = err.error_id();
match err_id { match err_id {
ErrorID::InvalidDocumentName => {} ErrorID::DocumentNameAlreadyExists => {}
_ => unreachable!("got {:?}, should have been invalid document name", err_id), _ => unreachable!("got {:?}, should have been invalid document name", err_id),
} }
assert_eq!( assert_eq!(
@ -101,7 +87,7 @@ mod errors {
let expected_name: NameType = doc_name.clone().into(); let expected_name: NameType = doc_name.clone().into();
let field_name = Name::english(Uuid::new_v4().to_string().as_str()); let field_name = Name::english(Uuid::new_v4().to_string().as_str());
let error = ErrorID::InvalidFieldName(field_name.clone()); let error = ErrorID::InvalidFieldName(field_name.clone());
let err = MTTError2::new(doc_name.clone(), error.clone()); let err = MTTError::new(doc_name.clone(), error.clone());
assert_eq!(err.doc_name(), &expected_name); assert_eq!(err.doc_name(), &expected_name);
let err_id = err.error_id(); let err_id = err.error_id();
match err_id { match err_id {

28
src/name.rs
View File

@ -1,4 +1,4 @@
use crate::mtterror::MTTError; use crate::mtterror::{ErrorID, MTTError};
use isolang::Language; use isolang::Language;
use std::{collections::HashMap, fmt}; use std::{collections::HashMap, fmt};
use uuid::Uuid; use uuid::Uuid;
@ -94,12 +94,14 @@ impl Names {
for name in names.iter() { for name in names.iter() {
let lang = name.get_language(); let lang = name.get_language();
if languages.contains(&lang) { if languages.contains(&lang) {
return Err(MTTError::NameNotUniquePerLanguage(name.clone())); let err = MTTError::new(NameType::None, ErrorID::NameLanguageNotUnique);
return Err(err);
} else { } else {
languages.push(lang); languages.push(lang);
} }
if self.names.contains_key(&name) { if self.names.contains_key(&name) {
return Err(MTTError::NameDuplicate(name.clone())); let err = MTTError::new(NameType::None, ErrorID::NameAlreadyExists);
return Err(err);
} }
} }
let mut id = Uuid::new_v4(); let mut id = Uuid::new_v4();
@ -122,7 +124,7 @@ impl Names {
match name.into() { match name.into() {
NameType::Name(data) => match self.names.get(&data) { NameType::Name(data) => match self.names.get(&data) {
Some(id) => Ok(id.clone()), Some(id) => Ok(id.clone()),
None => Err(MTTError::NameNotFound(data.clone())), None => Err(MTTError::new(NameType::None, ErrorID::NameNotFound)),
}, },
NameType::ID(data) => { NameType::ID(data) => {
if self.ids.contains_key(&data) { if self.ids.contains_key(&data) {
@ -131,7 +133,7 @@ impl Names {
if data == Uuid::nil() { if data == Uuid::nil() {
Ok(data) Ok(data)
} else { } else {
Err(MTTError::NameInvalidID(data)) Err(MTTError::new(NameType::None, ErrorID::NameNotFound))
} }
} }
} }
@ -195,8 +197,8 @@ mod names {
names.add_names(vec![name.clone()]).unwrap(); names.add_names(vec![name.clone()]).unwrap();
match names.add_names(vec![name.clone()]) { match names.add_names(vec![name.clone()]) {
Ok(data) => unreachable!("got {:?}, should have been duplicate error", data), Ok(data) => unreachable!("got {:?}, should have been duplicate error", data),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::NameDuplicate(result) => assert_eq!(result, name), ErrorID::NameAlreadyExists => {}
_ => unreachable!("got {:?}, should have been duplicate error", err), _ => unreachable!("got {:?}, should have been duplicate error", err),
}, },
} }
@ -210,8 +212,8 @@ mod names {
let mut names = Names::new(); let mut names = Names::new();
match names.add_names(vec![name1, name2, name3.clone()]) { match names.add_names(vec![name1, name2, name3.clone()]) {
Ok(data) => unreachable!("got {:?}, should have been needs to be unique", data), Ok(data) => unreachable!("got {:?}, should have been needs to be unique", data),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::NameNotUniquePerLanguage(data) => assert_eq!(data, name3), ErrorID::NameLanguageNotUnique => {}
_ => unreachable!("got {:?}, should have been name needs to be unique", err), _ => unreachable!("got {:?}, should have been name needs to be unique", err),
}, },
} }
@ -223,8 +225,8 @@ mod names {
let names = Names::new(); let names = Names::new();
match names.get_id(name.clone()) { match names.get_id(name.clone()) {
Ok(data) => unreachable!("got {:?}, should have been missing error", data), Ok(data) => unreachable!("got {:?}, should have been missing error", data),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::NameNotFound(result) => assert_eq!(result, name), ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}, should have been missing error", err), _ => unreachable!("got {:?}, should have been missing error", err),
}, },
} }
@ -236,8 +238,8 @@ mod names {
let names = Names::new(); let names = Names::new();
match names.get_id(id.clone()) { match names.get_id(id.clone()) {
Ok(data) => unreachable!("got {:?}, should have been missing error", data), Ok(data) => unreachable!("got {:?}, should have been missing error", data),
Err(err) => match err { Err(err) => match err.error_id() {
MTTError::NameInvalidID(result) => assert_eq!(result, id), ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}, should have been missing error", err), _ => unreachable!("got {:?}, should have been missing error", err),
}, },
} }

6
src/queue/router.rs
View File

@ -249,7 +249,7 @@ mod queues {
use super::*; use super::*;
use crate::{ use crate::{
action::MsgAction, action::MsgAction,
mtterror::MTTError, mtterror::{ErrorID, MTTError},
name::Name, name::Name,
queue::data_director::{Include, Path}, queue::data_director::{Include, Path},
support_tests::TIMEOUT, support_tests::TIMEOUT,
@ -321,8 +321,8 @@ mod queues {
MsgAction::Register(data) => { MsgAction::Register(data) => {
let regmsg = data.get_msg(); let regmsg = data.get_msg();
match data.get_msg() { match data.get_msg() {
RegMsg::Error(err) => match err { RegMsg::Error(err) => match err.error_id() {
MTTError::NameNotFound(failed_name) => assert_eq!(failed_name, &name), ErrorID::NameNotFound => {}
_ => unreachable!("got {:?} should have been missing name", err), _ => unreachable!("got {:?} should have been missing name", err),
}, },
_ => unreachable!("got {:?} should have been error", regmsg), _ => unreachable!("got {:?} should have been error", regmsg),

13
tests/lib_document_test.rs
View File

@ -1,6 +1,6 @@
use morethantext::{ use morethantext::{
action::{DocDef, FieldType, Query}, action::{DocDef, FieldType, Query},
MTTError, MoreThanText, Name, ErrorID, MTTError, MoreThanText, Name,
}; };
use uuid::Uuid; use uuid::Uuid;
@ -10,10 +10,13 @@ fn errors_on_missing_page() {
let doc_name = "missing"; let doc_name = "missing";
match mtt.get_document(doc_name, "something") { match mtt.get_document(doc_name, "something") {
Ok(data) => assert!(false, "got '{}', should have been not found error", data), Ok(data) => assert!(false, "got '{}', should have been not found error", data),
Err(err) => match err { Err(err) => {
MTTError::DocumentNotFound(result) => assert_eq!(result, doc_name), let err_id = err.error_id();
_ => unreachable!("got {:?}, should have been not found", err), match err_id {
}, ErrorID::DocumentNotFound => {}
_ => unreachable!("got {:?}, should have been not found", err),
}
}
} }
} }