fix: more edge casing in error function

Author: conblem

src/dns/authority.rs

@@ -1,5 +1,6 @@
 use anyhow::{anyhow, Result};
 use futures_util::TryFutureExt;
+use std::io::{Error as IoError, ErrorKind};
 use std::net::IpAddr::V4;
 use std::str::FromStr;
 use std::sync::Arc;
@@ -218,7 +219,7 @@ impl<F: DomainFacade + CertFacade + Send + Sync + 'static> AuthorityObject
                 let txt = match authority.facade.find_domain_by_id(&first).await {
                     Ok(Some(Domain { txt: Some(txt), .. })) => txt,
                     Ok(Some(Domain { txt: None, .. })) => return Ok(LookupRecords::Empty),
-                    Ok(None) => return Err(error(anyhow!("Not found"))),
+                    Ok(None) => return Err(error(IoError::from(ErrorKind::NotFound))),
                     Err(e) => return Err(error(e)),
                 };
                 let txt = TXT::new(vec![txt]);

src/util.rs

@@ -1,5 +1,6 @@
 use anyhow::Error;
 use std::any::Any;
+use std::error::Error as StdError;
 use std::fmt::{Debug, Display};
 use std::io::{Error as IoError, ErrorKind};
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -20,35 +21,35 @@ pub fn now() -> u64 {
         .as_secs()
 }
 
-// E allows all StdError + Send + Sync + 'static or AnyhowError as this can only be constructed from the former
 pub(crate) fn error<I, E>(err: I) -> E
 where
-    I: Into<Error> + 'static,
+    I: Into<Box<dyn StdError + Send + Sync>> + 'static,
     E: From<IoError> + Display + Debug + Send + Sync + 'static,
 {
-    // specialization if error is E or IoError
-    // gets optimized away at compile time
     let mut err = Some(err);
+
     if let Some(err) = Any::downcast_mut::<Option<E>>(&mut err) {
         return err.take().unwrap();
     }
+
     if let Some(err) = Any::downcast_mut::<Option<IoError>>(&mut err) {
         return err.take().unwrap().into();
     }
 
-    let err = err.unwrap().into();
-
-    let err = match err.downcast::<E>() {
-        Ok(err) => return err,
-        Err(err) => err,
-    };
-
-    let err = match err.downcast::<IoError>() {
-        Ok(err) => err,
-        Err(err) => IoError::new(ErrorKind::Other, err),
-    };
+    if let Some(err) = Any::downcast_mut::<Option<Error>>(&mut err) {
+        let err = match err.take().unwrap().downcast::<E>() {
+            Ok(err) => return err,
+            Err(err) => err,
+        };
+
+        let err = match err.downcast::<IoError>() {
+            Ok(err) => err,
+            Err(err) => IoError::new(ErrorKind::Other, err),
+        };
+        return err.into();
+    }
 
-    err.into()
+    IoError::new(ErrorKind::Other, err.unwrap()).into()
 }
 
 pub(crate) fn uuid() -> String {
@@ -57,7 +58,7 @@ pub(crate) fn uuid() -> String {
 
 #[cfg(test)]
 mod tests {
-    use anyhow::anyhow;
+    use anyhow::{anyhow, Error};
     use std::io::{Error as IoError, ErrorKind};
     use std::thread;
     use std::time::Duration;
@@ -108,6 +109,17 @@ mod tests {
         }
     }
 
+    #[test]
+    fn self_error_works() {
+        let expected = acme_lib::Error::Other("Test".to_owned());
+
+        let actual = acme_lib::Error::Other("Test".to_owned());
+        let actual: acme_lib::Error = error(actual);
+
+        assert_eq!(format!("{:?}", expected), format!("{:?}", actual));
+        assert_eq!(format!("{}", expected), format!("{}", actual));
+    }
+
     #[test]
     fn io_error_works() {
         let expected = IoError::new(ErrorKind::InvalidData, "Hallo");
@@ -116,21 +128,48 @@ mod tests {
         let actual = extract_error(error(actual));
 
         assert_eq!(format!("{:?}", expected), format!("{:?}", actual));
+        assert_eq!(format!("{}", expected), format!("{}", actual));
     }
 
     #[test]
-    fn error_works() {
-        let expected = anyhow!("test");
+    fn anyhow_works() {
+        let expected = acme_lib::Error::Other("Test".to_owned());
+
+        let actual = Error::new(acme_lib::Error::Other("Test".to_owned()));
+        let actual: acme_lib::Error = error(actual);
+
+        assert_eq!(format!("{:?}", expected), format!("{:?}", actual));
+        assert_eq!(format!("{}", expected), format!("{}", actual));
+    }
+
+    #[test]
+    fn anyhow_io_works() {
+        let expected = IoError::from(ErrorKind::Other);
+
+        let actual = Error::new(IoError::from(ErrorKind::Other));
+        let actual = extract_error(error(actual));
+
+        assert_eq!(format!("{:?}", expected), format!("{:?}", actual));
+        assert_eq!(format!("{}", expected), format!("{}", actual));
+    }
 
-        let actual = extract_error(error(anyhow!("test")));
+    #[test]
+    fn anyhow_error_works() {
+        let expected = IoError::new(ErrorKind::Other, anyhow!("Test"));
 
-        assert_eq!(ErrorKind::Other, actual.kind());
+        let actual = extract_error(error(anyhow!("Test")));
 
-        // is not equal because original error gets boxed in an io error
-        assert_ne!(format!("{:?}", expected), format!("{:?}", actual));
+        assert_eq!(format!("{:?}", expected), format!("{:?}", actual));
+        assert_eq!(format!("{}", expected), format!("{}", actual));
+    }
 
-        // here we access the actual inner error
-        let actual = actual.into_inner().expect("Error has no inner error");
+    #[test]
+    fn error_works() {
+        let expected = IoError::new(ErrorKind::Other, "Test");
+
+        let actual = extract_error(error("Test"));
+
+        assert_eq!(format!("{:?}", expected), format!("{:?}", actual));
         assert_eq!(format!("{}", expected), format!("{}", actual));
     }
 }