Added database incomplete error move.

src/error.rs

@@ -1,16 +1,32 @@
+use crate::data::{DBError, id::IDError};
 use std::{error::Error, fmt};
 
 #[derive(Debug)]
 pub enum ErrorType {
-    FieldIDInvalid(String),
+    DBErr(DBError),
+    IDErr(IDError),
     TableAddFieldDuplicate(String),
     TableRecordInvalidFieldName(String),
 }
 
+impl From<DBError> for ErrorType {
+    fn from(value: DBError) -> Self {
+        ErrorType::DBErr(value)
+    }
+}
+
+impl From<IDError> for ErrorType {
+    fn from(value: IDError) -> Self {
+        ErrorType::IDErr(value)
+    }
+}
+
 impl fmt::Display for ErrorType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ErrorType::FieldIDInvalid(data) => write!(f, "'{}' is not a valid uuid", data),
+            ErrorType::DBErr(data) => write!(f, "database: {}", data),
+            ErrorType::IDErr(data) => write!(f, "id: {}", data),
+
             ErrorType::TableAddFieldDuplicate(data) => write!(f, "field '{}' already exists", data),
             ErrorType::TableRecordInvalidFieldName(data) => {
                 write!(f, "invalid field name '{}'", data)
@@ -19,6 +35,25 @@ impl fmt::Display for ErrorType {
     }
 }
 
+#[cfg(test)]
+mod errortypes {
+    use super::*;
+
+    #[test]
+    fn database_error() {
+        let err = DBError::DuplicateTable("something".to_string());
+        let result = ErrorType::from(err.clone());
+        assert_eq!(result.to_string(), format!("database: {}", err));
+    }
+
+    #[test]
+    fn id_error() {
+        let err = IDError::InvalidUuid("bad".to_string());
+        let result = ErrorType::from(err.clone());
+        assert_eq!(result.to_string(), format!("id: {}", err));
+    }
+}
+
 #[derive(Debug)]
 pub struct MTTError {
     err: ErrorType,
@@ -48,6 +83,14 @@ impl fmt::Display for MTTError {
     }
 }
 
+impl From<IDError> for MTTError {
+    fn from(value: IDError) -> Self {
+        Self {
+            err: value.into(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod errors {
     use super::*;
@@ -62,18 +105,10 @@ mod errors {
     }
 
     #[test]
-    fn from_invalid_id() {
-        let data = rand_str();
-        let etype = ErrorType::FieldIDInvalid(data.clone());
-        let result = MTTError::from(etype);
-        match result.get_code() {
-            ErrorType::FieldIDInvalid(txt) => assert_eq!(txt, &data),
-            _ => unreachable!("should have been ErrorType::FieldIDInvalid"),
-        }
-        assert_eq!(
-            result.to_string(),
-            format!("'{}' is not a valid uuid", data)
-        );
+    fn from_id_error() {
+        let error = IDError::InvalidUuid(rand_str());
+        let err = MTTError::from(error.clone());
+        assert_eq!(err.to_string(), ErrorType::IDErr(error).to_string());
     }
 
     #[test]