Updated error to be more expressive.

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<NT>(doc_name: NT, error: ErrorID) -> MTTError
-    where
-        NT: Into<NameType>,
-    {
-        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<ErrorID>,
+}
+
+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<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() {
-        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<ErrorID> = 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<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);
     }
 }