refactor: add error details for tracing/debugging

link-for-later/src/controller/auth.rs

@@ -20,21 +20,18 @@ where
         let TypedHeader(Authorization(bearer)) =
             TypedHeader::<Authorization<Bearer>>::from_request_parts(parts, state)
                 .await
-                .map_err(|_| AppError::AuthorizationError)?;
+                .map_err(|_| {
+                    AppError::AuthorizationError(String::from("Authorization token not found"))
+                })?;
 
         let secret =
             std::env::var(JWT_SECRET_KEY).map_or_else(|_| String::default(), |secret| secret);
-        let token_data = match decode::<Self>(
+        let token_data = decode::<Self>(
             bearer.token(),
             &DecodingKey::from_secret(secret.as_bytes()),
             &Validation::default(),
-        ) {
-            Ok(token) => token,
-            Err(e) => {
-                tracing::error!("Error: {}", e.to_string());
-                return Err(AppError::AuthorizationError);
-            }
-        };
+        )
+        .map_err(|e| AppError::AuthorizationError(format!("decode() {e:?}")))?;
 
         Ok(token_data.claims)
     }

link-for-later/src/controller/error.rs

@@ -7,20 +7,45 @@ use serde_json::json;
 
 use crate::types::AppError;
 
+#[allow(clippy::cognitive_complexity)]
 impl IntoResponse for AppError {
     fn into_response(self) -> Response {
         let (status, error_message) = match self {
-            Self::ServerError | Self::DatabaseError(_) => {
+            Self::ServerError(ref e) => {
+                tracing::debug!("Server error: {}", e.to_string());
                 (StatusCode::INTERNAL_SERVER_ERROR, self.to_string())
             }
-            Self::LinkNotFound => (StatusCode::NOT_FOUND, self.to_string()),
-            Self::UserAlreadyExists
-            | Self::UserNotFound
-            | Self::InvalidEmail
-            | Self::InvalidUrl => (StatusCode::BAD_REQUEST, self.to_string()),
-            Self::AuthorizationError | Self::IncorrectPassword => {
+            Self::DatabaseError(ref e) => {
+                tracing::debug!("Database error: {}", e.to_string());
+                (StatusCode::INTERNAL_SERVER_ERROR, self.to_string())
+            }
+            Self::LinkNotFound(ref e) => {
+                tracing::debug!("Link not found: {}", e.to_string());
+                (StatusCode::NOT_FOUND, self.to_string())
+            }
+            Self::UserAlreadyExists(ref e) => {
+                tracing::debug!("User already exists: {}", e.to_string());
+                (StatusCode::BAD_REQUEST, self.to_string())
+            }
+            Self::UserNotFound(ref e) => {
+                tracing::debug!("User not found: {}", e.to_string());
+                (StatusCode::BAD_REQUEST, self.to_string())
+            }
+            Self::IncorrectPassword(ref e) => {
+                tracing::debug!("Incorrect password: {}", e.to_string());
+                (StatusCode::UNAUTHORIZED, self.to_string())
+            }
+            Self::AuthorizationError(ref e) => {
+                tracing::debug!("Authorization error: {}", e.to_string());
                 (StatusCode::UNAUTHORIZED, self.to_string())
             }
+            Self::ValidationError(ref e) => {
+                tracing::debug!("Payload validation error: {}", e.to_string());
+                (StatusCode::BAD_REQUEST, self.to_string())
+            }
+
+            #[cfg(test)]
+            Self::TestError => (StatusCode::INTERNAL_SERVER_ERROR, self.to_string()),
         };
 
         let body = Json(json!({
@@ -30,3 +55,61 @@ impl IntoResponse for AppError {
         (status, body).into_response()
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn test_error_response() {
+        assert_eq!(
+            AppError::ServerError("a server operation failed".into())
+                .into_response()
+                .status(),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+        assert_eq!(
+            AppError::DatabaseError("a database operation failed".into())
+                .into_response()
+                .status(),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+        assert_eq!(
+            AppError::LinkNotFound("link".into())
+                .into_response()
+                .status(),
+            StatusCode::NOT_FOUND
+        );
+        assert_eq!(
+            AppError::UserAlreadyExists("user".into())
+                .into_response()
+                .status(),
+            StatusCode::BAD_REQUEST
+        );
+        assert_eq!(
+            AppError::UserNotFound("user".into())
+                .into_response()
+                .status(),
+            StatusCode::BAD_REQUEST
+        );
+        assert_eq!(
+            AppError::IncorrectPassword("user".into())
+                .into_response()
+                .status(),
+            StatusCode::UNAUTHORIZED
+        );
+        assert_eq!(
+            AppError::AuthorizationError("an authorization error occurred".into())
+                .into_response()
+                .status(),
+            StatusCode::UNAUTHORIZED
+        );
+        assert_eq!(
+            AppError::ValidationError("a validation error occurred".into())
+                .into_response()
+                .status(),
+            StatusCode::BAD_REQUEST
+        );
+    }
+}

link-for-later/src/controller/links.rs

@@ -53,8 +53,7 @@ async fn post(
     match payload.validate() {
         Ok(()) => {}
         Err(e) => {
-            tracing::error!("Error: {}", e);
-            return AppError::InvalidUrl.into_response();
+            return AppError::ValidationError(format!("post_link() {e:?}")).into_response();
         }
     }
 
@@ -105,8 +104,7 @@ async fn put(
     match payload.validate() {
         Ok(()) => {}
         Err(e) => {
-            tracing::error!("Error: {}", e);
-            return AppError::InvalidUrl.into_response();
+            return AppError::ValidationError(format!("put_link() {e:?}")).into_response();
         }
     }
 
@@ -231,7 +229,7 @@ mod tests {
             .expect_search()
             .withf(move |_, query| query == &repo_query)
             .times(1)
-            .returning(|_, _| Err(AppError::ServerError));
+            .returning(|_, _| Err(AppError::TestError));
 
         let app_state = AppStateBuilder::new(Arc::new(mock_links_service)).build();
         let response = list(State(app_state), Claims::new("user-id", 0, 0)).await;
@@ -241,7 +239,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "server error"}).to_string());
+        assert_eq!(body, json!({"error": "test error"}).to_string());
     }
 
     #[traced_test]
@@ -301,7 +299,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "invalid url"}).to_string());
+        assert_eq!(body, json!({"error": "invalid request"}).to_string());
     }
 
     #[traced_test]
@@ -315,7 +313,7 @@ mod tests {
             .expect_create()
             .withf(move |_, item| item == &item_to_create)
             .times(1)
-            .returning(|_, _| Err(AppError::ServerError));
+            .returning(|_, _| Err(AppError::TestError));
 
         let app_state = AppStateBuilder::new(Arc::new(mock_links_service)).build();
         let response = post(
@@ -330,7 +328,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "server error"}).to_string());
+        assert_eq!(body, json!({"error": "test error"}).to_string());
     }
 
     #[traced_test]
@@ -378,7 +376,7 @@ mod tests {
             .expect_get()
             .withf(move |_, query| query == &repo_query)
             .times(1)
-            .returning(|_, _| Err(AppError::ServerError));
+            .returning(|_, _| Err(AppError::TestError));
 
         let app_state = AppStateBuilder::new(Arc::new(mock_links_service)).build();
         let response = get(
@@ -393,7 +391,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "server error"}).to_string());
+        assert_eq!(body, json!({"error": "test error"}).to_string());
     }
 
     #[traced_test]
@@ -458,7 +456,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "invalid url"}).to_string());
+        assert_eq!(body, json!({"error": "invalid request"}).to_string());
     }
 
     #[traced_test]
@@ -475,7 +473,7 @@ mod tests {
             .expect_update()
             .withf(move |_, id, item| id == "1" && item == &item_to_update)
             .times(1)
-            .returning(|_, _, _| Err(AppError::ServerError));
+            .returning(|_, _, _| Err(AppError::TestError));
 
         let app_state = AppStateBuilder::new(Arc::new(mock_links_service)).build();
         let response = put(
@@ -491,7 +489,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "server error"}).to_string());
+        assert_eq!(body, json!({"error": "test error"}).to_string());
     }
 
     #[traced_test]
@@ -528,7 +526,7 @@ mod tests {
             .expect_delete()
             .withf(move |_, item| item == &item_to_delete)
             .times(1)
-            .returning(|_, _| Err(AppError::ServerError));
+            .returning(|_, _| Err(AppError::TestError));
 
         let app_state = AppStateBuilder::new(Arc::new(mock_links_service)).build();
         let response = delete(
@@ -543,7 +541,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "server error"}).to_string());
+        assert_eq!(body, json!({"error": "test error"}).to_string());
     }
 
     struct AppStateBuilder {

link-for-later/src/controller/users.rs

@@ -31,8 +31,7 @@ async fn register(
     match payload.validate() {
         Ok(()) => {}
         Err(e) => {
-            tracing::error!("Error: {}", e);
-            return AppError::InvalidEmail.into_response();
+            return AppError::ValidationError(format!("register() {e:?}")).into_response();
         }
     }
 
@@ -58,8 +57,7 @@ async fn login(
     match payload.validate() {
         Ok(()) => {}
         Err(e) => {
-            tracing::error!("Error: {}", e);
-            return AppError::InvalidEmail.into_response();
+            return AppError::ValidationError(format!("login() {e:?}")).into_response();
         }
     }
 
@@ -141,7 +139,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "invalid email"}).to_string());
+        assert_eq!(body, json!({"error": "invalid request"}).to_string());
     }
 
     #[traced_test]
@@ -155,7 +153,7 @@ mod tests {
             .expect_register()
             .withf(move |_, user| user == &user_to_register)
             .times(1)
-            .returning(|_, _| Err(AppError::ServerError));
+            .returning(|_, _| Err(AppError::TestError));
 
         let app_state = AppStateBuilder::new(Arc::new(mock_users_service)).build();
         let response = register(State(app_state), Json(request)).await;
@@ -165,7 +163,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "server error"}).to_string());
+        assert_eq!(body, json!({"error": "test error"}).to_string());
     }
 
     #[traced_test]
@@ -209,7 +207,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "invalid email"}).to_string());
+        assert_eq!(body, json!({"error": "invalid request"}).to_string());
     }
 
     #[traced_test]
@@ -223,7 +221,7 @@ mod tests {
             .expect_login()
             .withf(move |_, user| user == &user_to_login)
             .times(1)
-            .returning(|_, _| Err(AppError::ServerError));
+            .returning(|_, _| Err(AppError::TestError));
 
         let app_state = AppStateBuilder::new(Arc::new(mock_users_service)).build();
         let response = login(State(app_state), Json(request)).await;
@@ -233,7 +231,7 @@ mod tests {
 
         let body = body.collect().await.unwrap().to_bytes();
         let body = std::str::from_utf8(&body).unwrap();
-        assert_eq!(body, json!({"error": "server error"}).to_string());
+        assert_eq!(body, json!({"error": "test error"}).to_string());
     }
 
     struct AppStateBuilder {

link-for-later/src/repository/inmemory.rs

@@ -46,7 +46,7 @@ impl LinksRepository for LinksRepositoryProvider {
             .iter()
             .find(|link| link.id() == query.id() && link.owner() == query.owner())
             .cloned()
-            .ok_or(AppError::LinkNotFound)
+            .ok_or_else(|| AppError::LinkNotFound(query.id().to_owned()))
     }
 
     async fn create(&self, item: &LinkItem) -> Result<LinkItem> {
@@ -66,7 +66,7 @@ impl LinksRepository for LinksRepositoryProvider {
             .iter()
             .find(|link| link.id() == id && link.owner() == item.owner())
             .cloned()
-            .ok_or(AppError::LinkNotFound)?;
+            .ok_or_else(|| AppError::LinkNotFound(id.to_owned()))?;
         self.delete(item).await?;
         INMEMORY_LINKS_DATA.lock().unwrap().push(item.clone());
         Ok(item.clone())
@@ -92,7 +92,7 @@ impl UsersRepository for UsersRepositoryProvider {
             .iter()
             .find(|user| user.email() == query.email())
             .cloned()
-            .ok_or(AppError::UserNotFound)
+            .ok_or_else(|| AppError::UserNotFound(query.email().to_owned()))
     }
 
     async fn create(&self, info: &UserInfo) -> Result<UserInfo> {

link-for-later/src/repository/mongodb.rs

@@ -65,7 +65,7 @@ impl LinksRepository for LinksRepositoryProvider {
             .find_one(db_query, None)
             .await
             .map_err(|e| AppError::DatabaseError(format!("find_one() {e:?}")))?;
-        item.ok_or(AppError::LinkNotFound)
+        item.ok_or_else(|| AppError::LinkNotFound(query.id().to_owned()))
     }
 
     async fn create(&self, item: &LinkItem) -> Result<LinkItem> {
@@ -123,7 +123,7 @@ impl UsersRepository for UsersRepositoryProvider {
             .find_one(db_query, None)
             .await
             .map_err(|e| AppError::DatabaseError(format!("find_one() {e:?}")))?;
-        item.ok_or(AppError::UserNotFound)
+        item.ok_or_else(|| AppError::UserNotFound(query.email().to_owned()))
     }
 
     async fn create(&self, info: &UserInfo) -> Result<UserInfo> {