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

29
src/action/message.rs
View File

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

82
src/document/create.rs
View File

@ -5,7 +5,7 @@ use crate::{
field::Field,
},
message::wrapper::{InternalRecord, InternalRecords, Message, Oid, Records, Reply, Update},
mtterror::MTTError,
mtterror::{ErrorID, MTTError},
name::NameType,
queue::{
data_director::{Include, Path, RegMsg, Register, RouteID},
@ -156,8 +156,8 @@ mod createdocs {
let result = rx.recv_timeout(TIMEOUT).unwrap();
assert_eq!(result.get_message_id(), msg2.get_message_id());
match result.get_action() {
MsgAction::Error(err) => match err {
MTTError::NameDuplicate(data) => assert_eq!(data, &name),
MsgAction::Error(err) => match err.error_id() {
ErrorID::NameAlreadyExists => {}
_ => unreachable!("got {:?}: should have been a duplicate name", err),
},
_ => unreachable!("got {:?}: should have been a reply.", result.get_action()),
@ -222,7 +222,8 @@ impl Index {
}
};
if self.unique && oids.len() > 0 {
return Err(MTTError::FieldDuplicate);
let err = MTTError::new(NameType::None, ErrorID::IndexEntryAlreadyExists);
return Err(err);
} else {
oids.insert(oid);
}
@ -238,7 +239,10 @@ impl Index {
output = output.union(&value).cloned().collect();
}
}
_ => return Err(MTTError::FieldInvalidType),
_ => {
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
return Err(err);
}
}
}
Ok(output)
@ -259,7 +263,10 @@ impl Index {
fn validate(&self, field: &Field) -> Result<(), MTTError> {
if self.unique {
match self.data.get(field) {
Some(_) => return Err(MTTError::FieldDuplicate),
Some(_) => {
let err = MTTError::new(NameType::None, ErrorID::IndexEntryAlreadyExists);
return Err(err);
}
None => {}
}
}
@ -416,10 +423,13 @@ mod indexes {
index.add(field.clone(), oids[0].clone()).unwrap();
match index.add(field.clone(), oids[0].clone()) {
Ok(_) => unreachable!("should have been an error"),
Err(err) => match err {
MTTError::FieldDuplicate => {}
Err(err) => {
let err_id = err.error_id();
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();
match index.validate(&field) {
Ok(_) => unreachable!("should have gotten a duplication error"),
Err(err) => match err {
MTTError::FieldDuplicate => {}
Err(err) => match err.error_id() {
ErrorID::IndexEntryAlreadyExists => {}
_ => 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();
match result.get_action() {
MsgAction::Error(err) => match err {
MTTError::NameNotFound(data) => assert_eq!(data, &name),
MsgAction::Error(err) => match err.error_id() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have been document field not found.", err),
},
_ => 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();
match result.get_action() {
MsgAction::Error(err) => match err {
MTTError::DocumentFieldWrongDataType(expected, got) => {
assert_eq!(got, &FieldType::StaticString);
assert_eq!(expected, &FieldType::Uuid);
}
MsgAction::Error(err) => match err.error_id() {
ErrorID::FieldInvalidType => {}
_ => unreachable!(
"got {:?}: should have been document field data mismatch.",
err
@ -1366,8 +1373,8 @@ mod document_files {
));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
match result.get_action() {
MsgAction::Error(err) => match err {
MTTError::InvalidNone => {}
MsgAction::Error(err) => match err.error_id() {
ErrorID::FieldInvalidNone => {}
_ => unreachable!("got {:?}: should have been document field missing", err),
},
_ => 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 action = result.get_action();
match action {
MsgAction::Error(data) => match data {
MTTError::NameNotFound(output) => assert_eq!(output, &field_name),
MsgAction::Error(data) => match data.error_id() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should been field not found", data),
},
_ => 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 action = result.get_action();
match action {
MsgAction::Error(data) => match data {
MTTError::FieldInvalidType => {}
MsgAction::Error(data) => match data.error_id() {
ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}: should been invalid field type", data),
},
_ => 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 action = result.get_action();
match action {
MsgAction::Error(err) => match err {
MTTError::NameNotFound(data) => assert_eq!(data, &bad_name),
MsgAction::Error(err) => match err.error_id() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have gotten an missing field", err),
},
_ => 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 action = result.get_action();
match action {
MsgAction::Error(err) => match err {
MTTError::DocumentFieldWrongDataType(expected, got) => {
assert_eq!(expected, &FieldType::StaticString);
assert_eq!(got, &FieldType::Uuid);
}
MsgAction::Error(err) => match err.error_id() {
ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}: should have gotten incorrect file type", err),
},
_ => 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 action = result.get_action();
match action {
MsgAction::Error(err) => match err {
MTTError::FieldDuplicate => {}
MsgAction::Error(err) => match err.error_id() {
ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have gotten incorrect file type", err),
},
_ => 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 action = result.get_action();
match action {
MsgAction::Error(err) => match err {
MTTError::FieldDuplicate => {}
MsgAction::Error(err) => match err.error_id() {
ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have gotten an missing field", err),
},
_ => 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 action = result.get_action();
match action {
MsgAction::Error(err) => match err {
MTTError::FieldDuplicate => {}
MsgAction::Error(err) => match err.error_id() {
ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have gotten field duplicate", err),
},
_ => 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 action = result.get_action();
match action {
MsgAction::Error(err) => match err {
MTTError::NameNotFound(data) => assert_eq!(data, &field_name),
MsgAction::Error(err) => match err.error_id() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have gotten an missing field", err),
},
_ => 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},
document::create::IndexType,
message::MessageAction,
mtterror::MTTError,
mtterror::{ErrorID, MTTError},
name::{Name, NameType, Names},
queue::data_director::{Include, Path},
};
@ -31,17 +31,20 @@ impl FieldSetting {
match &value {
CalcValue::Calculate(calc) => {
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) => {
if &self.fieldtype != ftype {
return Err(MTTError::FieldInvalidType);
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
return Err(err);
}
}
CalcValue::Value(ref item) => {
if item.get_type() != self.fieldtype {
return Err(MTTError::FieldInvalidType);
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
return Err(err);
}
}
CalcValue::None => {}
@ -53,16 +56,14 @@ impl FieldSetting {
fn validate(&self, value: &Field) -> Result<Field, MTTError> {
match 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)),
},
_ => {
let vft: FieldType = value.into();
if vft != self.fieldtype {
return Err(MTTError::DocumentFieldWrongDataType(
self.fieldtype.clone(),
vft,
));
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
return Err(err);
}
Ok(value.clone())
}
@ -93,11 +94,8 @@ mod fieldsettings {
let value: Field = "text".into();
match fset.validate(&value) {
Ok(data) => unreachable!("got {:?}: should have gotten an error", data),
Err(err) => match err {
MTTError::DocumentFieldWrongDataType(expected, got) => {
assert_eq!(expected, FieldType::Uuid);
assert_eq!(got, FieldType::StaticString);
}
Err(err) => match err.error_id() {
ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}: should have gotten a value", err),
},
}
@ -108,8 +106,8 @@ mod fieldsettings {
let fset = FieldSetting::new(FieldType::Uuid);
match fset.validate(&Field::None) {
Ok(data) => unreachable!("got {:?}: should have gotten an error", data),
Err(err) => match err {
MTTError::InvalidNone => {}
Err(err) => match err.error_id() {
ErrorID::FieldInvalidNone => {}
_ => 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());
match docdef.get_field(&name) {
Ok(_) => unreachable!("should return non existant field error"),
Err(err) => match err {
MTTError::NameNotFound(data) => assert_eq!(data, name),
Err(err) => match err.error_id() {
ErrorID::NameNotFound => {}
_ => 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());
match docdef.set_default(&field_name, FieldType::Uuid) {
Ok(_) => unreachable!("should be an error"),
Err(err) => match err {
MTTError::NameNotFound(data) => assert_eq!(data, field_name),
Err(err) => match err.error_id() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have been field not found", err),
},
}
@ -478,8 +476,8 @@ mod docdefs {
docdef.add_field(name.clone(), FieldType::Uuid);
match docdef.set_default(&name, "fred") {
Ok(data) => unreachable!("got {:?}, should be an error", data),
Err(err) => match err {
MTTError::FieldInvalidType => {}
Err(err) => match err.error_id() {
ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}: should have been field not found", err),
},
}

6
src/document/session.rs
View File

@ -92,7 +92,7 @@ mod sessions {
field::Field,
},
message::wrapper::Records,
mtterror::MTTError,
mtterror::{ErrorID, MTTError},
name::{Name, NameType, Names},
queue::data_director::{Include, Path, RegMsg, Register},
support_tests::TIMEOUT,
@ -246,8 +246,8 @@ mod sessions {
let result = setup.recv().unwrap();
let action = result.get_action();
match action {
MsgAction::Error(err) => match err {
MTTError::FieldDuplicate => {}
MsgAction::Error(err) => match err.error_id() {
ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}, should have been a field duplicate", err),
},
_ => 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 uuid::Uuid;
pub use mtterror::MTTError;
pub use mtterror::{ErrorID, MTTError};
pub use name::{Name, NameType};
#[cfg(test)]
@ -118,7 +118,7 @@ impl MoreThanText {
if name == "page" {
Ok("something".to_string())
} 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 morethantext::{ActionType, ErrorType, MoreThanText};
//use morethantext::{MoreThanText, MsgAction, Query};
use morethantext::{MTTError, MoreThanText};
use morethantext::{ErrorID, MTTError, MoreThanText};
use std::{collections::HashMap, convert::Infallible};
use tokio::{spawn, sync::mpsc::channel};
use tower_cookies::{Cookie, CookieManagerLayer, Cookies};
@ -108,8 +108,8 @@ async fn mtt_conn(
result = data.clone();
}
Err(err) => {
status = match err {
MTTError::DocumentNotFound(_) => StatusCode::NOT_FOUND,
status = match err.error_id() {
ErrorID::DocumentNotFound => StatusCode::NOT_FOUND,
_ => StatusCode::INTERNAL_SERVER_ERROR,
};
}

16
src/message/wrapper.rs
View File

@ -1,7 +1,7 @@
use crate::{
action::{CalcValue, MsgAction, Operand, Query},
document::field::{Field, FieldType},
mtterror::MTTError,
mtterror::{ErrorID, MTTError},
name::{NameType, Names},
queue::data_director::{Include, Path, Route},
};
@ -195,15 +195,15 @@ mod messages {
let name = Name::english("testing");
let msg = Message::new(name.clone(), Query::new(name.clone()));
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());
match &result.document_id {
NameType::Name(data) => assert_eq!(data, &name),
_ => unreachable!("should have been a name"),
}
match result.get_action() {
MsgAction::Error(data) => match data {
MTTError::DocumentNotFound(txt) => assert_eq!(txt, &err_msg),
MsgAction::Error(data) => match data.error_id() {
ErrorID::DocumentNotFound => {}
_ => unreachable!("got {:?}, should have received not found", data),
},
_ => unreachable!("should have been a reply"),
@ -215,7 +215,7 @@ mod messages {
let doc_id = Uuid::new_v4();
let msg = Message::new(doc_id.clone(), Query::new(doc_id.clone()));
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());
assert_eq!(result1.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);
let action1 = result1.get_action();
match action1 {
MsgAction::Error(err) => match err {
MTTError::DocumentNotFound(output) => assert_eq!(output, &data),
MsgAction::Error(err) => match err.error_id() {
ErrorID::DocumentNotFound => {}
_ => unreachable!("got {:?}: should have received document not found", err),
},
_ => unreachable!("got {:?}: should have received error", action1),
@ -466,7 +466,7 @@ impl Record {
};
match self.data.get(&id) {
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;
#[derive(Clone, Debug)]
pub enum MTTError {
AdditionMissingField(Name),
CannotConvertMessageToRouteID,
DocumentAlreadyExists(String),
DocumentFieldAlreadyExists(String, Field),
DocumentFieldMissing(String),
DocumentFieldNotFound(String),
DocumentFieldWrongDataType(FieldType, FieldType),
DocumentNotFound(String),
FieldDuplicate,
pub enum ErrorID {
DocumentNameAlreadyExists,
DocumentNotFound,
FieldDataMustBeUnique,
FieldInvalidNone,
FieldInvalidType,
FieldMissingData,
InvalidNone,
RecordMismatch,
NameDuplicate(Name),
NameInvalidID(Uuid),
NameMissingTranslation(Language),
NameNotUniquePerLanguage(Name),
NameNotFound(Name),
QueryCannotChangeData,
RouteRequiresDocumentID,
}
#[derive(Clone, Debug)]
pub enum ErrorID {
InvalidDocumentName,
FieldNameAlreadyExists,
IndexEntryAlreadyExists,
InvalidFieldName(Name),
NameAlreadyExists,
NameLanguageNotUnique,
NameNotFound,
}
#[derive(Clone, Debug)]
struct MTTError2 {
pub struct MTTError {
doc_name: NameType,
error_id: ErrorID,
}
impl MTTError2 {
pub fn new<NT>(doc_name: NT, error: ErrorID) -> MTTError2
impl MTTError {
pub fn new<NT>(doc_name: NT, error: ErrorID) -> MTTError
where
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 {
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 {
&self.doc_name
}
@ -81,12 +67,12 @@ mod errors {
fn can_create_error() {
let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
let expected_name: NameType = doc_name.clone().into();
let error = ErrorID::InvalidDocumentName;
let err = MTTError2::new(doc_name.clone(), error.clone());
let error = ErrorID::DocumentNameAlreadyExists;
let err = MTTError::new(doc_name.clone(), error.clone());
assert_eq!(err.doc_name(), &expected_name);
let err_id = err.error_id();
match err_id {
ErrorID::InvalidDocumentName => {}
ErrorID::DocumentNameAlreadyExists => {}
_ => unreachable!("got {:?}, should have been invalid document name", err_id),
}
assert_eq!(
@ -101,7 +87,7 @@ mod errors {
let expected_name: NameType = doc_name.clone().into();
let field_name = Name::english(Uuid::new_v4().to_string().as_str());
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);
let err_id = err.error_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 std::{collections::HashMap, fmt};
use uuid::Uuid;
@ -94,12 +94,14 @@ impl Names {
for name in names.iter() {
let lang = name.get_language();
if languages.contains(&lang) {
return Err(MTTError::NameNotUniquePerLanguage(name.clone()));
let err = MTTError::new(NameType::None, ErrorID::NameLanguageNotUnique);
return Err(err);
} else {
languages.push(lang);
}
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();
@ -122,7 +124,7 @@ impl Names {
match name.into() {
NameType::Name(data) => match self.names.get(&data) {
Some(id) => Ok(id.clone()),
None => Err(MTTError::NameNotFound(data.clone())),
None => Err(MTTError::new(NameType::None, ErrorID::NameNotFound)),
},
NameType::ID(data) => {
if self.ids.contains_key(&data) {
@ -131,7 +133,7 @@ impl Names {
if data == Uuid::nil() {
Ok(data)
} 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();
match names.add_names(vec![name.clone()]) {
Ok(data) => unreachable!("got {:?}, should have been duplicate error", data),
Err(err) => match err {
MTTError::NameDuplicate(result) => assert_eq!(result, name),
Err(err) => match err.error_id() {
ErrorID::NameAlreadyExists => {}
_ => unreachable!("got {:?}, should have been duplicate error", err),
},
}
@ -210,8 +212,8 @@ mod names {
let mut names = Names::new();
match names.add_names(vec![name1, name2, name3.clone()]) {
Ok(data) => unreachable!("got {:?}, should have been needs to be unique", data),
Err(err) => match err {
MTTError::NameNotUniquePerLanguage(data) => assert_eq!(data, name3),
Err(err) => match err.error_id() {
ErrorID::NameLanguageNotUnique => {}
_ => unreachable!("got {:?}, should have been name needs to be unique", err),
},
}
@ -223,8 +225,8 @@ mod names {
let names = Names::new();
match names.get_id(name.clone()) {
Ok(data) => unreachable!("got {:?}, should have been missing error", data),
Err(err) => match err {
MTTError::NameNotFound(result) => assert_eq!(result, name),
Err(err) => match err.error_id() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}, should have been missing error", err),
},
}
@ -236,8 +238,8 @@ mod names {
let names = Names::new();
match names.get_id(id.clone()) {
Ok(data) => unreachable!("got {:?}, should have been missing error", data),
Err(err) => match err {
MTTError::NameInvalidID(result) => assert_eq!(result, id),
Err(err) => match err.error_id() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}, should have been missing error", err),
},
}

6
src/queue/router.rs
View File

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

11
tests/lib_document_test.rs
View File

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