refactor: return 400 if json is not valid

Author: null8626

src/webhook/actix_web.rs

@@ -1,16 +1,16 @@
 use crate::Incoming;
 use actix_web::{
   dev::Payload,
-  error::{Error, ErrorUnauthorized},
+  error::{Error, ErrorBadRequest, ErrorUnauthorized},
   web::Json,
   FromRequest, HttpRequest,
 };
+use serde::de::DeserializeOwned;
 use std::{
   future::Future,
   pin::Pin,
   task::{ready, Context, Poll},
 };
-use serde::de::DeserializeOwned;
 
 #[doc(hidden)]
 pub struct IncomingFut<T: DeserializeOwned> {
@@ -36,9 +36,11 @@ where
           }));
         }
       }
+
+      return Poll::Ready(Err(ErrorUnauthorized("401")));
     }
 
-    Poll::Ready(Err(ErrorUnauthorized("401")))
+    Poll::Ready(Err(ErrorBadRequest("400")))
   }
 }
 

src/webhook/axum.rs

@@ -35,31 +35,31 @@ impl<T> Clone for WebhookState<T> {
 /// use topgg::{Vote, Webhook};
 /// use tokio::net::TcpListener;
 /// use std::sync::Arc;
-/// 
+///
 /// struct MyVoteListener {}
-/// 
+///
 /// #[async_trait::async_trait]
 /// impl Webhook<Vote> for MyVoteListener {
 ///   async fn callback(&self, vote: Vote) {
 ///     println!("A user with the ID of {} has voted us on Top.gg!", vote.voter_id);
 ///   }
 /// }
-/// 
+///
 /// async fn index() -> &'static str {
 ///   "Hello, World!"
 /// }
-/// 
+///
 /// #[tokio::main]
 /// async fn main() {
 ///   let state = Arc::new(MyVoteListener {});
-/// 
+///
 ///   let router = Router::new().route("/", get(index)).nest(
 ///     "/votes",
 ///     topgg::axum::webhook(env!("MY_TOPGG_WEBHOOK_SECRET").to_string(), Arc::clone(&state)),
 ///   );
-/// 
+///
 ///   let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
-/// 
+///
 ///   axum::serve(listener, router).await.unwrap();
 /// }
 /// ```
@@ -71,21 +71,26 @@ where
   T: Webhook<D>,
 {
   Router::new()
-    .route("/", post(async |headers: HeaderMap, State(webhook): State<WebhookState<T>>, body: String| {
-      if let Some(authorization) = headers.get("Authorization") {
-        if let Ok(authorization) = authorization.to_str() {
-          if authorization == *(webhook.password) {
-            if let Ok(data) = serde_json::from_str(&body) {
-              webhook.state.callback(data).await;
-    
-              return (StatusCode::NO_CONTENT, ()).into_response();
+    .route(
+      "/",
+      post(
+        async |headers: HeaderMap, State(webhook): State<WebhookState<T>>, body: String| {
+          if let Some(authorization) = headers.get("Authorization") {
+            if let Ok(authorization) = authorization.to_str() {
+              if authorization == *(webhook.password) {
+                if let Ok(data) = serde_json::from_str(&body) {
+                  webhook.state.callback(data).await;
+
+                  return (StatusCode::NO_CONTENT, ()).into_response();
+                }
+              }
             }
           }
-        }
-      }
-    
-      (StatusCode::UNAUTHORIZED, ()).into_response()
-    }))
+
+          (StatusCode::UNAUTHORIZED, ()).into_response()
+        },
+      ),
+    )
     .with_state(WebhookState {
       state,
       password: Arc::new(password),

src/webhook/mod.rs

@@ -46,7 +46,7 @@ cfg_if::cfg_if! {
         }
       }
     }
-  
+
     impl<T> Clone for Incoming<T>
     where
       T: Clone,
@@ -62,7 +62,6 @@ cfg_if::cfg_if! {
   }
 }
 
-
 cfg_if::cfg_if! {
   if #[cfg(any(feature = "axum", feature = "warp"))] {
     /// Webhook event handler.
@@ -72,4 +71,4 @@ cfg_if::cfg_if! {
       async fn callback(&self, data: T);
     }
   }
-}
+}

src/webhook/rocket.rs

@@ -19,12 +19,13 @@ where
     let headers = request.headers();
 
     if let Some(authorization) = headers.get_one("Authorization") {
-      if let Outcome::Success(data) = <Json<T> as FromData>::from_data(request, data).await {
-        return Outcome::Success(Self {
+      return match <Json<T> as FromData>::from_data(request, data).await {
+        Outcome::Success(data) => Outcome::Success(Self {
           authorization: authorization.to_owned(),
           data: data.into_inner(),
-        });
-      }
+        }),
+        _ => Outcome::Error((Status::BadRequest, ())),
+      };
     }
 
     Outcome::Error((Status::Unauthorized, ()))

src/webhook/vote.rs

@@ -64,4 +64,4 @@ pub struct Vote {
   /// Query strings found on the vote page.
   #[serde(default, deserialize_with = "deserialize_query_string")]
   pub query: HashMap<String, String>,
-}
+}

src/webhook/warp.rs

@@ -1,6 +1,6 @@
 use super::Webhook;
-use std::sync::Arc;
 use serde::de::DeserializeOwned;
+use std::sync::Arc;
 use warp::{body, header, http::StatusCode, path, Filter, Rejection, Reply};
 
 /// Creates a new `warp` [`Filter`] for receiving webhook events.
@@ -13,31 +13,31 @@ use warp::{body, header, http::StatusCode, path, Filter, Rejection, Reply};
 /// use std::{net::SocketAddr, sync::Arc};
 /// use topgg::{Vote, Webhook};
 /// use warp::Filter;
-/// 
+///
 /// struct MyVoteListener {}
-/// 
+///
 /// #[async_trait::async_trait]
 /// impl Webhook<Vote> for MyVoteListener {
 ///   async fn callback(&self, vote: Vote) {
 ///     println!("A user with the ID of {} has voted us on Top.gg!", vote.voter_id);
 ///   }
 /// }
-/// 
+///
 /// #[tokio::main]
 /// async fn main() {
 ///   let state = Arc::new(MyVoteListener {});
-/// 
+///
 ///   // POST /votes
 ///   let webhook = topgg::warp::webhook(
 ///     "votes",
 ///     env!("MY_TOPGG_WEBHOOK_SECRET").to_string(),
 ///     Arc::clone(&state),
 ///   );
-/// 
+///
 ///   let routes = warp::get().map(|| "Hello, World!").or(webhook);
-/// 
+///
 ///   let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
-/// 
+///
 ///   warp::serve(routes).run(addr).await
 /// }
 /// ```