sentry - middleware - channel - channel_load tests

Author: elpiel

sentry/src/middleware/channel.rs

@@ -70,3 +70,146 @@ where
 
     Ok(next.run(request).await)
 }
+
+#[cfg(test)]
+mod test {
+    use axum::{
+        body::Body,
+        http::{Request, StatusCode},
+        middleware::from_fn,
+        routing::get,
+        Extension, Router,
+    };
+    use tower::Service;
+
+    use adapter::{
+        dummy::Dummy,
+        ethereum::test_util::{GANACHE_1, GANACHE_1337},
+    };
+    use primitives::{
+        test_util::{CAMPAIGNS, CREATOR, IDS},
+        ChainOf, Channel,
+    };
+
+    use crate::{db::insert_channel, test_util::setup_dummy_app};
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test_channel_loading() {
+        let app_guard = setup_dummy_app().await;
+        let app = Arc::new(app_guard.app);
+
+        let channel_context = CAMPAIGNS[0].of_channel();
+        let channel = channel_context.context;
+
+        let build_request = |id: ChannelId, auth: Option<Auth>| {
+            let mut request = Request::builder()
+                .uri(format!("/{id}/test"))
+                .extension(app.clone());
+            if let Some(auth) = auth {
+                request = request.extension(auth);
+            }
+
+            request.body(Body::empty()).expect("Should build Request")
+        };
+
+        async fn handle(
+            Extension(channel_context): Extension<ChainOf<Channel>>,
+            Path((id, another)): Path<(ChannelId, String)>,
+        ) -> String {
+            assert_eq!(id, channel_context.context.id());
+            assert_eq!(another, "test");
+            "Ok".into()
+        }
+
+        let mut router = Router::new()
+            .route("/:id/:another", get(handle))
+            .layer(from_fn(channel_load::<Dummy, _>));
+
+        // bad ChannelId
+        {
+            let mut request = build_request(channel.id(), None);
+            *request.uri_mut() = "/WrongChannelId".parse().unwrap();
+
+            let response = router
+                .call(request)
+                .await
+                .expect("Should make request to Router");
+
+            assert_eq!(StatusCode::BAD_REQUEST, response.status());
+        }
+
+        // non-existent Channel
+        {
+            let request = build_request(channel.id(), None);
+
+            let response = router
+                .call(request)
+                .await
+                .expect("Should make request to Router");
+
+            assert_eq!(response.status(), StatusCode::NOT_FOUND);
+        }
+
+        // insert Channel
+        insert_channel(&app.pool, &channel_context)
+            .await
+            .expect("Should insert Channel");
+
+        // existing Channel
+        {
+            let request = build_request(channel.id(), None);
+
+            let response = router
+                .call(request)
+                .await
+                .expect("Should make request to Router");
+
+            assert_eq!(response.status(), StatusCode::OK);
+        }
+
+        // existing Channel with Auth from a different Chain
+        {
+            let not_same_chain = Auth {
+                era: 1,
+                uid: IDS[&CREATOR],
+                chain: GANACHE_1.clone(),
+            };
+
+            assert_ne!(channel_context.chain, not_same_chain.chain, "The chain of the Channel should be different than the chain of the Auth for this test!");
+
+            let request = build_request(channel.id(), Some(not_same_chain));
+
+            let response = router
+                .call(request)
+                .await
+                .expect("Should make request to Router");
+
+            assert_eq!(response.status(), StatusCode::FORBIDDEN);
+        }
+
+        // existing Channel with Auth with the same Chain
+        {
+            let same_chain = Auth {
+                era: 1,
+                uid: IDS[&CREATOR],
+                chain: GANACHE_1337.clone(),
+            };
+
+            assert_eq!(
+                channel_context.chain, same_chain.chain,
+                "The chain of the Channel should be the same as the Auth for this test!"
+            );
+
+            let request = build_request(channel.id(), Some(same_chain));
+
+            let response = router
+                .call(request)
+                .await
+                .expect("Should make request to Router");
+
+            assert_eq!(response.status(), StatusCode::OK);
+        }
+    }
+}