Move forbidden into errors::http

Author: jtgeibel

src/controllers/util.rs

@@ -2,7 +2,7 @@ use super::prelude::*;
 
 use crate::middleware::current_user::TrustedUserId;
 use crate::models::{ApiToken, User};
-use crate::util::errors::{internal, AppError, AppResult, ChainError, Forbidden};
+use crate::util::errors::{forbidden, internal, AppResult, ChainError};
 
 #[derive(Debug)]
 pub struct AuthenticatedUser {
@@ -43,11 +43,10 @@ impl<'a> UserAuthenticationExt for dyn RequestExt + 'a {
                         token_id: Some(token.id),
                     })
                     .chain_error(|| internal("invalid token"))
-                    .chain_error(|| Box::new(Forbidden) as Box<dyn AppError>)
+                    .chain_error(forbidden)
             } else {
                 // Unable to authenticate the user
-                Err(internal("no cookie session or auth header found"))
-                    .chain_error(|| Box::new(Forbidden) as Box<dyn AppError>)
+                Err(internal("no cookie session or auth header found")).chain_error(forbidden)
             }
         }
     }

src/router.rs

@@ -187,7 +187,7 @@ impl Handler for R404 {
 mod tests {
     use super::*;
     use crate::util::errors::{
-        bad_request, cargo_err, internal, AppError, ChainError, Forbidden, NotFound,
+        bad_request, cargo_err, forbidden, internal, AppError, ChainError, NotFound,
     };
     use crate::util::EndpointResult;
 
@@ -209,7 +209,7 @@ mod tests {
             StatusCode::BAD_REQUEST
         );
         assert_eq!(
-            C(|_| err(Forbidden)).call(&mut req).unwrap().status(),
+            C(|_| Err(forbidden())).call(&mut req).unwrap().status(),
             StatusCode::FORBIDDEN
         );
         assert_eq!(

src/util/errors.rs

@@ -44,6 +44,10 @@ pub fn bad_request<S: ToString + ?Sized>(error: &S) -> Box<dyn AppError> {
     Box::new(http::BadRequest(error.to_string()))
 }
 
+pub fn forbidden() -> Box<dyn AppError> {
+    Box::new(http::Forbidden)
+}
+
 /// Returns an error with status 500 and the provided description as JSON
 pub fn server_error<S: ToString + ?Sized>(error: &S) -> Box<dyn AppError> {
     Box::new(http::ServerError(error.to_string()))
@@ -240,22 +244,6 @@ impl fmt::Display for NotFound {
     }
 }
 
-#[derive(Debug, Clone, Copy)]
-pub struct Forbidden;
-
-impl AppError for Forbidden {
-    fn response(&self) -> Option<AppResponse> {
-        let detail = "must be logged in to perform that action";
-        Some(json_error(detail, StatusCode::FORBIDDEN))
-    }
-}
-
-impl fmt::Display for Forbidden {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        "must be logged in to perform that action".fmt(f)
-    }
-}
-
 pub fn internal<S: ToString + ?Sized>(error: &S) -> Box<dyn AppError> {
     Box::new(InternalAppError {
         description: error.to_string(),
@@ -358,7 +346,7 @@ fn chain_error_internal() {
         "outer caused by inner"
     );
     assert_eq!(
-        Err::<(), _>(Forbidden)
+        Err::<(), _>(forbidden())
             .chain_error(|| internal("outer"))
             .unwrap_err()
             .to_string(),

src/util/errors/http.rs

@@ -5,6 +5,28 @@ use crate::util::AppResponse;
 
 use conduit::StatusCode;
 
+// The following structs are emtpy and do not provide a custom message to the user
+
+#[derive(Debug)]
+pub(super) struct Forbidden;
+#[derive(Debug)]
+pub struct NotFound;
+
+impl AppError for Forbidden {
+    fn response(&self) -> Option<AppResponse> {
+        let detail = "must be logged in to perform that action";
+        Some(json_error(detail, StatusCode::FORBIDDEN))
+    }
+}
+
+impl fmt::Display for Forbidden {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        "must be logged in to perform that action".fmt(f)
+    }
+}
+
+// The following structs wrap a String and provide a custom message to the user
+
 #[derive(Debug)]
 pub(super) struct Ok(pub(super) String);
 #[derive(Debug)]