From a9b87200ef5c593cfca7e4a7f5cff14056ef228c Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Thu, 12 Feb 2026 22:49:19 -0500 Subject: [PATCH] Made MTTError a proper Error structure. --- src/action/calculation.rs | 30 +++++++------- src/action/message.rs | 31 +++++++------- src/document/create.rs | 84 ++++++++++++++++++++------------------ src/document/definition.rs | 42 +++++++++---------- src/document/session.rs | 6 +-- src/lib.rs | 4 +- src/main.rs | 6 +-- src/message/wrapper.rs | 16 ++++---- src/mtterror.rs | 54 +++++++++--------------- src/name.rs | 28 +++++++------ src/queue/router.rs | 6 +-- tests/lib_document_test.rs | 13 +++--- 12 files changed, 156 insertions(+), 164 deletions(-) diff --git a/src/action/calculation.rs b/src/action/calculation.rs index 5b3ab6d..bbf014f 100644 --- a/src/action/calculation.rs +++ b/src/action/calculation.rs @@ -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), }, } diff --git a/src/action/message.rs b/src/action/message.rs index 382785d..3c5aff2 100644 --- a/src/action/message.rs +++ b/src/action/message.rs @@ -104,7 +104,7 @@ impl From 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), - } - 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), - }, + 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), + } + } _ => unreachable!("Got {:?}: dhould have been create", result), } } diff --git a/src/document/create.rs b/src/document/create.rs index f84f740..3e97f28 100644 --- a/src/document/create.rs +++ b/src/document/create.rs @@ -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 => {} - _ => unreachable!("got {:?}: should have been duplicate field", err), - }, + 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), diff --git a/src/document/definition.rs b/src/document/definition.rs index 4215c68..e39548a 100644 --- a/src/document/definition.rs +++ b/src/document/definition.rs @@ -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 { 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), }, } diff --git a/src/document/session.rs b/src/document/session.rs index ac86e3a..e9b8b38 100644 --- a/src/document/session.rs +++ b/src/document/session.rs @@ -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), diff --git a/src/lib.rs b/src/lib.rs index 3027a02..398438a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -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)) } } } diff --git a/src/main.rs b/src/main.rs index 32a0e40..41a1a19 100644 --- a/src/main.rs +++ b/src/main.rs @@ -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, }; } diff --git a/src/message/wrapper.rs b/src/message/wrapper.rs index a844930..615d516 100644 --- a/src/message/wrapper.rs +++ b/src/message/wrapper.rs @@ -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)), } } } diff --git a/src/mtterror.rs b/src/mtterror.rs index d240e7c..699ef0c 100644 --- a/src/mtterror.rs +++ b/src/mtterror.rs @@ -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(doc_name: NT, error: ErrorID) -> MTTError2 +impl MTTError { + pub fn new(doc_name: NT, error: ErrorID) -> MTTError where NT: Into, { @@ -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 { diff --git a/src/name.rs b/src/name.rs index 27ed81f..e2b1bbb 100644 --- a/src/name.rs +++ b/src/name.rs @@ -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), }, } diff --git a/src/queue/router.rs b/src/queue/router.rs index 4802083..9b62254 100644 --- a/src/queue/router.rs +++ b/src/queue/router.rs @@ -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), diff --git a/tests/lib_document_test.rs b/tests/lib_document_test.rs index 52b7b28..d973902 100644 --- a/tests/lib_document_test.rs +++ b/tests/lib_document_test.rs @@ -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), - _ => unreachable!("got {:?}, should have been not found", err), - }, + Err(err) => { + let err_id = err.error_id(); + match err_id { + ErrorID::DocumentNotFound => {} + _ => unreachable!("got {:?}, should have been not found", err), + } + } } }