diff --git a/src/action/calculation.rs b/src/action/calculation.rs index bbf014f..ac23ba9 100644 --- a/src/action/calculation.rs +++ b/src/action/calculation.rs @@ -352,7 +352,7 @@ impl Calculation { if base == ftype { self.values.push(holder); } else { - let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType); + let err = MTTError::new(ErrorID::FieldInvalidType); return Err(err); } Ok(()) @@ -380,7 +380,7 @@ impl Calculation { if base == ftype { Ok(()) } else { - let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType); + let err = MTTError::new(ErrorID::FieldInvalidType); return Err(err); } } @@ -452,7 +452,7 @@ mod calculations { match calc.add_value("other") { Ok(_) => unreachable!("should have errored with wrong type"), Err(err) => { - let err_id = err.error_id(); + let err_id = err.get_error_ids().back().unwrap(); match err_id { ErrorID::FieldInvalidType => {} _ => unreachable!("got {:?}, expected wrong field type", err_id), @@ -605,7 +605,7 @@ mod calculations { calc.add_value(Uuid::nil()).unwrap(); match calc.add_value("mismatch") { Ok(_) => unreachable!("should have returned an error"), - Err(err) => match err.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::FieldInvalidType => {} _ => unreachable!("got {:?}, expected wrong field type", err), }, diff --git a/src/action/message.rs b/src/action/message.rs index 8ba74a0..0f8499a 100644 --- a/src/action/message.rs +++ b/src/action/message.rs @@ -130,15 +130,15 @@ mod msgactions { fn turn_error_into_action() { 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 error = ErrorID::Document(expected_name.clone()); + let err = MTTError::new(error.clone()); let result: MsgAction = err.into(); match result { MsgAction::Error(err) => { assert_eq!(err.doc_name(), &expected_name); - let err_id = err.error_id(); + let err_id = err.get_error_ids().back().unwrap(); match err_id { - ErrorID::DocumentNameAlreadyExists => {} + ErrorID::Document(_) => {} _ => unreachable!("got {:?}, expected document name exists", err_id), } } diff --git a/src/document/create.rs b/src/document/create.rs index 4ad546e..548ce49 100644 --- a/src/document/create.rs +++ b/src/document/create.rs @@ -118,7 +118,7 @@ impl Index { } }; if self.unique && oids.len() > 0 { - let err = MTTError::new(NameType::None, ErrorID::IndexEntryAlreadyExists); + let err = MTTError::new(ErrorID::IndexEntryAlreadyExists); return Err(err); } else { oids.insert(oid); @@ -136,7 +136,7 @@ impl Index { } } _ => { - let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType); + let err = MTTError::new(ErrorID::FieldInvalidType); return Err(err); } } @@ -160,7 +160,7 @@ impl Index { if self.unique { match self.data.get(field) { Some(_) => { - let err = MTTError::new(NameType::None, ErrorID::IndexEntryAlreadyExists); + let err = MTTError::new(ErrorID::IndexEntryAlreadyExists); return Err(err); } None => {} @@ -320,7 +320,7 @@ mod indexes { match index.add(field.clone(), oids[0].clone()) { Ok(_) => unreachable!("should have been an error"), Err(err) => { - let err_id = err.error_id(); + let err_id = err.get_error_ids().back().unwrap(); match err_id { ErrorID::IndexEntryAlreadyExists => {} _ => unreachable!("got {:?}: should have been duplicate field", err), @@ -349,7 +349,7 @@ mod indexes { index.add(field.clone(), oid).unwrap(); match index.validate(&field) { Ok(_) => unreachable!("should have gotten a duplication error"), - Err(err) => match err.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::IndexEntryAlreadyExists => {} _ => unreachable!("got {:?}: should have been duplicate field", err), }, @@ -1040,6 +1040,7 @@ mod document_files { } } + /* #[test] fn can_document_be_added() { let doc_name = Name::english("document"); @@ -1124,6 +1125,7 @@ mod document_files { } assert!(entries.is_empty(), "did not use {:?}", entries); } + */ #[test] fn errors_on_wrong_field_name() { @@ -1136,7 +1138,7 @@ mod document_files { queue.send(Message::new(addition)); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); match result.get_action() { - MsgAction::Error(err) => match err.error_id() { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameNotFound => {} _ => unreachable!("got {:?}: should have been document field not found.", err), }, @@ -1154,7 +1156,7 @@ mod document_files { queue.send(Message::new(addition)); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); match result.get_action() { - MsgAction::Error(err) => match err.error_id() { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::FieldInvalidType => {} _ => unreachable!( "got {:?}: should have been document field data mismatch.", @@ -1175,7 +1177,7 @@ mod document_files { queue.send(Message::new(addition)); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); match result.get_action() { - MsgAction::Error(err) => match err.error_id() { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::FieldInvalidNone => {} _ => unreachable!("got {:?}: should have been document field missing", err), }, @@ -1446,7 +1448,7 @@ mod document_files { let result = rx.recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); match action { - MsgAction::Error(data) => match data.error_id() { + MsgAction::Error(data) => match data.get_error_ids().back().unwrap() { ErrorID::NameNotFound => {} _ => unreachable!("got {:?}: should been field not found", data), }, @@ -1470,7 +1472,7 @@ mod document_files { let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); match action { - MsgAction::Error(data) => match data.error_id() { + MsgAction::Error(data) => match data.get_error_ids().back().unwrap() { ErrorID::FieldInvalidType => {} _ => unreachable!("got {:?}: should been invalid field type", data), }, @@ -1758,7 +1760,7 @@ mod document_files { let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); match action { - MsgAction::Error(err) => match err.error_id() { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameNotFound => {} _ => unreachable!("got {:?}: should have gotten an missing field", err), }, @@ -1789,7 +1791,7 @@ mod document_files { let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); match action { - MsgAction::Error(err) => match err.error_id() { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::FieldInvalidType => {} _ => unreachable!("got {:?}: should have gotten incorrect file type", err), }, @@ -1840,7 +1842,7 @@ 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.error_id() { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::IndexEntryAlreadyExists => {} _ => unreachable!("got {:?}: should have gotten incorrect file type", err), }, @@ -1927,7 +1929,7 @@ mod document_files { let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); match action { - MsgAction::Error(err) => match err.error_id() { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::IndexEntryAlreadyExists => {} _ => unreachable!("got {:?}: should have gotten an missing field", err), }, @@ -1968,7 +1970,7 @@ mod document_files { let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); match action { - MsgAction::Error(err) => match err.error_id() { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::IndexEntryAlreadyExists => {} _ => unreachable!("got {:?}: should have gotten field duplicate", err), }, @@ -2081,7 +2083,7 @@ mod document_files { let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let action = result.get_action(); match action { - MsgAction::Error(err) => match err.error_id() { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameNotFound => {} _ => unreachable!("got {:?}: should have gotten an missing field", err), }, diff --git a/src/document/definition.rs b/src/document/definition.rs index d3ebfed..785c6f1 100644 --- a/src/document/definition.rs +++ b/src/document/definition.rs @@ -31,19 +31,19 @@ impl FieldSetting { match &value { CalcValue::Calculate(calc) => { if self.fieldtype != calc.get_type() { - let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType); + let err = MTTError::new(ErrorID::FieldInvalidType); return Err(err); } } CalcValue::Existing(ftype) | CalcValue::FType(ftype) => { if &self.fieldtype != ftype { - let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType); + let err = MTTError::new(ErrorID::FieldInvalidType); return Err(err); } } CalcValue::Value(ref item) => { if item.get_type() != self.fieldtype { - let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType); + let err = MTTError::new(ErrorID::FieldInvalidType); return Err(err); } } @@ -56,13 +56,13 @@ impl FieldSetting { fn validate(&self, value: &Field) -> Result { match value { Field::None => match &self.default_value { - CalcValue::None => Err(MTTError::new(NameType::None, ErrorID::FieldInvalidNone)), + CalcValue::None => Err(MTTError::new(ErrorID::FieldInvalidNone)), _ => Ok(self.default_value.get(&Field::None)), }, _ => { let vft: FieldType = value.into(); if vft != self.fieldtype { - let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType); + let err = MTTError::new(ErrorID::FieldInvalidType); return Err(err); } Ok(value.clone()) @@ -94,7 +94,7 @@ 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.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::FieldInvalidType => {} _ => unreachable!("got {:?}: should have gotten a value", err), }, @@ -106,7 +106,7 @@ 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.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::FieldInvalidNone => {} _ => unreachable!("got {:?}: should have gotten a invalid none", err), }, @@ -407,7 +407,7 @@ 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.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameNotFound => {} _ => unreachable!("got {:?}: should have been document field not found", err), }, @@ -455,7 +455,7 @@ 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.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameNotFound => {} _ => unreachable!("got {:?}: should have been field not found", err), }, @@ -470,7 +470,7 @@ 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.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::FieldInvalidType => {} _ => unreachable!("got {:?}: should have been field not found", err), }, diff --git a/src/document/record.rs b/src/document/record.rs index 715e77f..a1e2251 100644 --- a/src/document/record.rs +++ b/src/document/record.rs @@ -136,7 +136,7 @@ impl Record { }; match self.data.get(&id) { Some(data) => Ok(data.clone()), - None => Err(MTTError::new(NameType::None, ErrorID::FieldMissingData)), + None => Err(MTTError::new(ErrorID::FieldMissingData)), } } } diff --git a/src/lib.rs b/src/lib.rs index eb3cc74..678a700 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -24,9 +24,14 @@ pub use queue::data_director::{Include, Path}; #[cfg(test)] mod support_tests { + use super::*; use std::time::Duration; pub static TIMEOUT: Duration = Duration::from_millis(500); + + pub fn random_name() -> Name { + Name::english(Uuid::new_v4().to_string().as_str()) + } } static TIMEOUT: Duration = Duration::from_secs(10); @@ -127,7 +132,7 @@ impl MoreThanText { MsgAction::Error(err) => Err(err.clone()), _ => unreachable!("should only receive records or errors"), }, - Err(_) => Err(MTTError::new(NameType::None, ErrorID::TimeOut)), + Err(_) => Err(MTTError::new(ErrorID::TimeOut)), }; self.queue.remove_sender(&sender_id); output @@ -162,7 +167,7 @@ impl MoreThanText { MsgAction::Error(err) => Err(err.clone()), _ => unreachable!("should only receive records or errors"), }, - Err(_) => Err(MTTError::new(NameType::None, ErrorID::TimeOut)), + Err(_) => Err(MTTError::new(ErrorID::TimeOut)), }; self.queue.remove_sender(&sender_id); output @@ -172,7 +177,7 @@ impl MoreThanText { if name == "page" { Ok("something".to_string()) } else { - Err(MTTError::new(NameType::None, ErrorID::DocumentNotFound)) + Err(MTTError::new(ErrorID::DocumentNotFound)) } } } @@ -212,10 +217,6 @@ impl TestMoreThanText { self.queue.send(msg); } - pub fn random_name() -> Name { - Name::english(Uuid::new_v4().to_string().as_str()) - } - pub fn register_channel(&self, paths: Vec) -> Receiver { let mut queue = self.mtt.queue.clone(); let (tx, rx) = channel(); diff --git a/src/main.rs b/src/main.rs index 41a1a19..7359965 100644 --- a/src/main.rs +++ b/src/main.rs @@ -108,7 +108,7 @@ async fn mtt_conn( result = data.clone(); } Err(err) => { - status = match err.error_id() { + status = match err.get_error_ids().back().unwrap() { ErrorID::DocumentNotFound => StatusCode::NOT_FOUND, _ => StatusCode::INTERNAL_SERVER_ERROR, }; diff --git a/src/message/wrapper.rs b/src/message/wrapper.rs index d9e2dc3..1b5adae 100644 --- a/src/message/wrapper.rs +++ b/src/message/wrapper.rs @@ -191,10 +191,10 @@ mod messages { let name = Name::english("testing"); let msg = Message::new(Query::new(name.clone())); let err_msg = Uuid::new_v4().to_string(); - let result = msg.response(MTTError::new(NameType::None, ErrorID::DocumentNotFound)); + let result = msg.response(MTTError::new(ErrorID::DocumentNotFound)); assert_eq!(result.get_message_id(), msg.get_message_id()); match result.get_action() { - MsgAction::Error(data) => match data.error_id() { + MsgAction::Error(data) => match data.get_error_ids().back().unwrap() { ErrorID::DocumentNotFound => {} _ => unreachable!("got {:?}, should have received not found", data), }, @@ -207,13 +207,13 @@ mod messages { let doc_id = Uuid::new_v4(); let msg = Message::new(Query::new(doc_id.clone())); let data = Uuid::new_v4().to_string(); - let result1 = msg.response(MTTError::new(NameType::None, ErrorID::DocumentNotFound)); + let result1 = msg.response(MTTError::new(ErrorID::DocumentNotFound)); let result2 = msg.response(Reply::new(NameType::None)); assert_eq!(result1.get_message_id(), msg.get_message_id()); assert_eq!(result2.get_message_id(), msg.get_message_id()); let action1 = result1.get_action(); match action1 { - MsgAction::Error(err) => match err.error_id() { + MsgAction::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::DocumentNotFound => {} _ => unreachable!("got {:?}: should have received document not found", err), }, diff --git a/src/mtterror.rs b/src/mtterror.rs index 27b8a01..997d2df 100644 --- a/src/mtterror.rs +++ b/src/mtterror.rs @@ -4,11 +4,12 @@ use crate::{ name::{Name, NameType}, }; use isolang::Language; -use std::{error::Error, fmt}; +use std::{collections::VecDeque, error::Error, fmt}; use uuid::Uuid; #[derive(Clone, Debug)] pub enum ErrorID { + Document(NameType), DocumentNameAlreadyExists, DocumentNotFound, FieldDataMustBeUnique, @@ -24,31 +25,60 @@ pub enum ErrorID { TimeOut, } -#[derive(Clone, Debug)] -pub struct MTTError { - doc_name: NameType, - error_id: ErrorID, +impl MessageAction for ErrorID { + fn doc_name(&self) -> &NameType { + match self { + Self::Document(data) => data, + _ => &NameType::None, + } + } } -impl MTTError { - pub fn new(doc_name: NT, error: ErrorID) -> MTTError - where - NT: Into, - { - Self { - doc_name: doc_name.into(), - error_id: error, +#[cfg(test)] +mod error_ids { + use super::*; + use crate::support_tests::random_name; + + #[test] + fn do_errors_return_none_doc_name() { + let errors = [ErrorID::FieldInvalidNone, ErrorID::FieldMissingData]; + for err in errors.iter() { + assert_eq!(err.doc_name(), &NameType::None); } } - pub fn error_id(&self) -> &ErrorID { - &self.error_id + #[test] + fn does_document_error_return_document_name() { + let name: NameType = random_name().into(); + let err = ErrorID::Document(name.clone()); + assert_eq!(err.doc_name(), &name); + } +} + +#[derive(Clone, Debug)] +pub struct MTTError { + errors: VecDeque, +} + +impl MTTError { + pub fn new(err: ErrorID) -> Self { + let mut errs = VecDeque::new(); + errs.push_front(err); + Self { errors: errs } + } + + pub fn add_parent(&mut self, err: ErrorID) { + self.errors.push_front(err); + } + + pub fn get_error_ids(&self) -> &VecDeque { + &self.errors } } impl fmt::Display for MTTError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "{:?} error: {:?}", self.doc_name, self.error_id) + write!(f, "error: {:?}", self.errors) } } @@ -56,48 +86,44 @@ impl Error for MTTError {} impl MessageAction for MTTError { fn doc_name(&self) -> &NameType { - &self.doc_name + self.errors.front().unwrap().doc_name() } } #[cfg(test)] mod errors { use super::*; + use crate::support_tests::random_name; #[test] - 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::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::DocumentNameAlreadyExists => {} - _ => unreachable!("got {:?}, should have been invalid document name", err_id), - } - assert_eq!( - err.to_string(), - format!("{:?} error: {:?}", NameType::Name(doc_name), error) - ); + fn can_create_new_error() { + let err = MTTError::new(ErrorID::FieldInvalidNone); + assert_eq!(err.doc_name(), &NameType::None); } #[test] - fn does_error_ids_contain_data() { - let doc_name = Name::english(Uuid::new_v4().to_string().as_str()); - 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 = MTTError::new(doc_name.clone(), error.clone()); - assert_eq!(err.doc_name(), &expected_name); - let err_id = err.error_id(); - match err_id { - ErrorID::InvalidFieldName(data) => assert_eq!(data, &field_name), - _ => unreachable!("got {:?}, should have been invalid field name", err_id), - } - assert_eq!( - err.to_string(), - format!("{:?} error: {:?}", NameType::Name(doc_name), error) - ); + fn does_error_return_none_for_most_errors() { + let base_err = ErrorID::FieldInvalidNone; + let mut holder: VecDeque = VecDeque::new(); + holder.push_front(base_err.clone()); + let expected = format!("error: {:?}", holder); + let err = MTTError::new(base_err.clone()); + assert_eq!(err.to_string(), expected); + assert_eq!(err.doc_name(), &NameType::None); + } + + #[test] + fn can_add_parent_error() { + let base_err = ErrorID::FieldInvalidNone; + let name: NameType = random_name().into(); + let doc_err = ErrorID::Document(name.clone()); + let mut err = MTTError::new(ErrorID::FieldInvalidNone); + err.add_parent(doc_err.clone()); + let mut holder: VecDeque = VecDeque::new(); + holder.push_front(base_err.clone()); + holder.push_front(doc_err.clone()); + let expected = format!("error: {:?}", holder); + assert_eq!(err.to_string(), expected); + assert_eq!(err.doc_name(), &name); } } diff --git a/src/name.rs b/src/name.rs index 9d291ec..fdde48b 100644 --- a/src/name.rs +++ b/src/name.rs @@ -103,13 +103,13 @@ impl Names { for name in names.iter() { let lang = name.get_language(); if languages.contains(&lang) { - let err = MTTError::new(NameType::None, ErrorID::NameLanguageNotUnique); + let err = MTTError::new(ErrorID::NameLanguageNotUnique); return Err(err); } else { languages.push(lang); } if self.names.contains_key(&name) { - let err = MTTError::new(NameType::None, ErrorID::NameAlreadyExists); + let err = MTTError::new(ErrorID::NameAlreadyExists); return Err(err); } } @@ -133,7 +133,7 @@ impl Names { match name.into() { NameType::Name(data) => match self.names.get(&data) { Some(id) => Ok(id.clone()), - None => Err(MTTError::new(NameType::None, ErrorID::NameNotFound)), + None => Err(MTTError::new(ErrorID::NameNotFound)), }, NameType::ID(data) => { if self.ids.contains_key(&data) { @@ -142,7 +142,7 @@ impl Names { if data == Uuid::nil() { Ok(data) } else { - Err(MTTError::new(NameType::None, ErrorID::NameNotFound)) + Err(MTTError::new(ErrorID::NameNotFound)) } } } @@ -206,7 +206,7 @@ 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.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameAlreadyExists => {} _ => unreachable!("got {:?}, should have been duplicate error", err), }, @@ -221,7 +221,7 @@ 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.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameLanguageNotUnique => {} _ => unreachable!("got {:?}, should have been name needs to be unique", err), }, @@ -234,7 +234,7 @@ 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.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameNotFound => {} _ => unreachable!("got {:?}, should have been missing error", err), }, @@ -247,7 +247,7 @@ 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.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameNotFound => {} _ => unreachable!("got {:?}, should have been missing error", err), }, diff --git a/src/queue/router.rs b/src/queue/router.rs index efebe80..500c0b6 100644 --- a/src/queue/router.rs +++ b/src/queue/router.rs @@ -313,7 +313,7 @@ mod queues { MsgAction::Register(data) => { let regmsg = data.get_msg(); match data.get_msg() { - RegMsg::Error(err) => match err.error_id() { + RegMsg::Error(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameNotFound => {} _ => unreachable!("got {:?} should have been missing name", err), }, diff --git a/tests/add_test.rs b/tests/add_test.rs new file mode 100644 index 0000000..16f6b6a --- /dev/null +++ b/tests/add_test.rs @@ -0,0 +1,67 @@ +mod support; + +use morethantext::{ + action::{Addition, DocDef, Field, FieldType, Query}, + ErrorID, MoreThanText, Name, +}; +use std::collections::HashSet; +use support::random_name; +use uuid::Uuid; + +#[test] +fn can_new_documents_be_added() { + let count = 5; + let mut mtt = MoreThanText::new(); + let doc_name = random_name(); + let field_name = random_name(); + let mut data: HashSet = HashSet::new(); + for i in 0..count { + data.insert(i.into()); + } + let mut docdef = DocDef::new(doc_name.clone()); + docdef.add_field(field_name.clone(), FieldType::Integer); + mtt.create_document(docdef); + for item in data.iter() { + let mut add = Addition::new(doc_name.clone()); + add.add_field(field_name.clone(), item.clone()); + mtt.records(add).unwrap(); + } + let qry = Query::new(doc_name.clone()); + let recs = mtt.records(qry).unwrap(); + assert_eq!(recs.len(), data.len()); + for rec in recs.iter() { + let result = rec.get(&field_name).unwrap(); + assert!( + data.contains(&result), + "did not find {:?} in {:?}", + result, + data + ); + data.remove(&result); + } + assert_eq!(data.len(), 0, "{:?} did not appear in query", data); +} + +#[test] +#[ignore = "need to alter error"] +fn does_it_error_on_a_bad_field_name() { + let mut mtt = MoreThanText::new(); + let doc_name = Name::english("empty"); + mtt.create_document(DocDef::new(doc_name.clone())); + let mut add = Addition::new(doc_name.clone()); + add.add_field(Name::english("missing"), "stuff"); + let result = mtt + .records(add) + .unwrap_err() + .get_error_ids() + .back() + .unwrap() + .clone(); + match result { + ErrorID::NameNotFound => {} + _ => unreachable!( + "got {:?}: should have been document field not found.", + result + ), + } +} diff --git a/tests/document_test.rs b/tests/document_test.rs index a364a15..c42fd49 100644 --- a/tests/document_test.rs +++ b/tests/document_test.rs @@ -1,8 +1,11 @@ +mod support; + use morethantext::{action::*, ErrorID, Include, MoreThanText, Name, Path, TestMoreThanText}; use std::{ sync::mpsc::{channel, RecvTimeoutError}, time::Duration, }; +use support::random_name; use uuid::Uuid; pub static TIMEOUT: Duration = Duration::from_millis(500); @@ -14,7 +17,7 @@ fn are_errors_produced_for_duplicate_names() { mtt.create_document(docdef.clone()).unwrap(); match mtt.create_document(docdef) { Ok(_) => assert!(false, "should have failed"), - Err(err) => match err.error_id() { + Err(err) => match err.get_error_ids().back().unwrap() { ErrorID::NameAlreadyExists => {} _ => unreachable!("got {:?}, should be name already exists", err), }, @@ -24,7 +27,7 @@ fn are_errors_produced_for_duplicate_names() { #[test] fn does_document_respond_to() { let mut mtt = MoreThanText::new(); - let doc_name = TestMoreThanText::random_name(); + let doc_name = random_name(); let mut requests: Vec = Vec::new(); requests.push(Addition::new(doc_name.clone()).into()); requests.push(Delete::new(doc_name.clone()).into()); diff --git a/tests/lib_session_test.rs b/tests/session_test.rs similarity index 100% rename from tests/lib_session_test.rs rename to tests/session_test.rs diff --git a/tests/support.rs b/tests/support.rs new file mode 100644 index 0000000..648cf19 --- /dev/null +++ b/tests/support.rs @@ -0,0 +1,6 @@ +use morethantext::Name; +use uuid::Uuid; + +pub fn random_name() -> Name { + Name::english(Uuid::new_v4().to_string().as_str()) +}