Add conversion tests for optional integrations

Cargo.toml

@@ -49,7 +49,7 @@ sqlx = { version = "0.8", optional = true, default-features = false, features =
   "migrate",
 ] }
 redis = { version = "0.32", optional = true, default-features = false }
-validator = { version = "0.20", optional = true }
+validator = { version = "0.20", optional = true, features = ["derive"] }
 config = { version = "0.15", optional = true }
 utoipa = { version = "5.3", optional = true }
 tokio = { version = "1", optional = true, features = ["time"] }

src/convert/sqlx.rs

@@ -61,3 +61,24 @@ impl From<MigrateError> for AppError {
         AppError::database(Some(err.to_string()))
     }
 }
+
+#[cfg(all(test, feature = "sqlx"))]
+mod tests {
+    use std::io;
+
+    use super::*;
+    use crate::AppErrorKind;
+
+    #[test]
+    fn row_not_found_maps_to_not_found() {
+        let err: AppError = SqlxError::RowNotFound.into();
+        assert!(matches!(err.kind, AppErrorKind::NotFound));
+    }
+
+    #[test]
+    fn other_error_maps_to_database() {
+        let io_err = io::Error::new(io::ErrorKind::Other, "boom");
+        let err: AppError = SqlxError::Io(io_err).into();
+        assert!(matches!(err.kind, AppErrorKind::Database));
+    }
+}

src/convert/tokio.rs

@@ -49,3 +49,21 @@ impl From<Elapsed> for AppError {
         AppError::timeout("Operation timed out")
     }
 }
+
+#[cfg(all(test, feature = "tokio"))]
+mod tests {
+    use tokio::time::{Duration, sleep, timeout};
+
+    use super::*;
+    use crate::AppErrorKind;
+
+    #[tokio::test]
+    async fn elapsed_maps_to_timeout() {
+        let fut = sleep(Duration::from_millis(20));
+        let err = timeout(Duration::from_millis(1), fut)
+            .await
+            .expect_err("expect timeout");
+        let app_err: AppError = err.into();
+        assert!(matches!(app_err.kind, AppErrorKind::Timeout));
+    }
+}

src/convert/validator.rs

@@ -56,3 +56,26 @@ impl From<ValidationErrors> for AppError {
         AppError::validation(err.to_string())
     }
 }
+
+#[cfg(all(test, feature = "validator"))]
+mod tests {
+    use validator::Validate;
+
+    use super::*;
+    use crate::AppErrorKind;
+
+    #[derive(Validate)]
+    struct Payload {
+        #[validate(range(min = 1))]
+        val: i32
+    }
+
+    #[test]
+    fn validation_errors_map_to_validation_kind() {
+        let bad = Payload {
+            val: 0
+        };
+        let err: AppError = bad.validate().unwrap_err().into();
+        assert!(matches!(err.kind, AppErrorKind::Validation));
+    }
+}