Updated error to be more expressive.

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),
             },

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 error = ErrorID::Document(expected_name.clone());
-        let err = MTTError::new(doc_name.clone(), error.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),
                 }
             }

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),
             },

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<Field, MTTError> {
         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),
             },

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)),
         }
     }
 }

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<Path>) -> Receiver<Message> {
         let mut queue = self.mtt.queue.clone();
         let (tx, rx) = channel();

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,
             };

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),
             },

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,
 }
 
+impl MessageAction for ErrorID {
+    fn doc_name(&self) -> &NameType {
+        match self {
+            Self::Document(data) => data,
+            _ => &NameType::None,
+        }
+    }
+}
+
+#[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);
+        }
+    }
+
+    #[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 {
-    doc_name: NameType,
+    errors: VecDeque<ErrorID>,
-    error_id: ErrorID,
 }
 
 impl MTTError {
-    pub fn new<NT>(doc_name: NT, error: ErrorID) -> MTTError
+    pub fn new(err: ErrorID) -> Self {
-    where
+        let mut errs = VecDeque::new();
-        NT: Into<NameType>,
+        errs.push_front(err);
-    {
+        Self { errors: errs }
-        Self {
-            doc_name: doc_name.into(),
-            error_id: error,
-        }
     }
 
-    pub fn error_id(&self) -> &ErrorID {
+    pub fn add_parent(&mut self, err: ErrorID) {
-        &self.error_id
+        self.errors.push_front(err);
+    }
+
+    pub fn get_error_ids(&self) -> &VecDeque<ErrorID> {
+        &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() {
+    fn can_create_new_error() {
-        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
+        let err = MTTError::new(ErrorID::FieldInvalidNone);
-        let expected_name: NameType = doc_name.clone().into();
+        assert_eq!(err.doc_name(), &NameType::None);
-        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)
-        );
     }
 
     #[test]
-    fn does_error_ids_contain_data() {
+    fn does_error_return_none_for_most_errors() {
-        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
+        let base_err = ErrorID::FieldInvalidNone;
-        let expected_name: NameType = doc_name.clone().into();
+        let mut holder: VecDeque<ErrorID> = VecDeque::new();
-        let field_name = Name::english(Uuid::new_v4().to_string().as_str());
+        holder.push_front(base_err.clone());
-        let error = ErrorID::InvalidFieldName(field_name.clone());
+        let expected = format!("error: {:?}", holder);
-        let err = MTTError::new(doc_name.clone(), error.clone());
+        let err = MTTError::new(base_err.clone());
-        assert_eq!(err.doc_name(), &expected_name);
+        assert_eq!(err.to_string(), expected);
-        let err_id = err.error_id();
+        assert_eq!(err.doc_name(), &NameType::None);
-        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(),
+    #[test]
-            format!("{:?} error: {:?}", NameType::Name(doc_name), error)
+    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<ErrorID> = 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);
     }
 }

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),
             },

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),
                     },

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<Field> = 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
+        ),
+    }
+}

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<UserAction> = Vec::new();
     requests.push(Addition::new(doc_name.clone()).into());
     requests.push(Delete::new(doc_name.clone()).into());

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())
+}