spikard 0.8.1 → 0.8.2

data/vendor/crates/spikard-http/tests/grpc_metadata_test.rs

@@ -19,12 +19,12 @@ mod common;
 /// Test metadata extraction from request
 #[tokio::test]
 async fn test_metadata_extraction_from_request() {
-    let mut server = GrpcTestServer::new();
-
     struct MetadataCheckHandler;
     impl spikard_http::grpc::GrpcHandler for MetadataCheckHandler {
-        fn call(&self, request: spikard_http::grpc::GrpcRequestData)
-            -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
+        fn call(
+            &self,
+            request: spikard_http::grpc::GrpcRequestData,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
         {
             // Extract and verify metadata
             let has_user_agent = request.metadata.get("user-agent").is_some();
@@ -48,6 +48,8 @@ async fn test_metadata_extraction_from_request() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(MetadataCheckHandler));
 
     let metadata = create_test_metadata();
@@ -62,24 +64,23 @@ async fn test_metadata_extraction_from_request() {
     .await
     .expect("Failed to send request with metadata");
 
-    assert_grpc_response(response, serde_json::json!({"extracted": true}));
+    assert_grpc_response(&response, &serde_json::json!({"extracted": true}));
 }
 
 /// Test Bearer token authentication metadata
 #[tokio::test]
 async fn test_authentication_bearer_token_metadata() {
-    let mut server = GrpcTestServer::new();
-
     struct AuthServiceHandler;
     impl spikard_http::grpc::GrpcHandler for AuthServiceHandler {
-        fn call(&self, request: spikard_http::grpc::GrpcRequestData)
-            -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
+        fn call(
+            &self,
+            request: spikard_http::grpc::GrpcRequestData,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
         {
             let token_present = request
                 .metadata
                 .get("authorization")
-                .map(|v| v.to_str().unwrap_or("").starts_with("Bearer "))
-                .unwrap_or(false);
+                .is_some_and(|v| v.to_str().unwrap_or("").starts_with("Bearer "));
 
             let response = if token_present {
                 Bytes::from(r#"{"authenticated": true, "user": "alice"}"#)
@@ -99,36 +100,35 @@ async fn test_authentication_bearer_token_metadata() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(AuthServiceHandler));
 
     let mut metadata = create_test_metadata();
     add_auth_metadata(&mut metadata, "secret_token_abc123").unwrap();
 
-    let response = send_unary_request(
-        &server,
-        "api.AuthService",
-        "Authenticate",
-        Bytes::from("{}"),
-        metadata,
-    )
-    .await
-    .expect("Failed to authenticate");
-
-    assert_grpc_response(response, serde_json::json!({
-        "authenticated": true,
-        "user": "alice"
-    }));
+    let response = send_unary_request(&server, "api.AuthService", "Authenticate", Bytes::from("{}"), metadata)
+        .await
+        .expect("Failed to authenticate");
+
+    assert_grpc_response(
+        &response,
+        &serde_json::json!({
+            "authenticated": true,
+            "user": "alice"
+        }),
+    );
 }
 
 /// Test custom header metadata
 #[tokio::test]
 async fn test_custom_header_metadata() {
-    let mut server = GrpcTestServer::new();
-
     struct CustomHeaderHandler;
     impl spikard_http::grpc::GrpcHandler for CustomHeaderHandler {
-        fn call(&self, request: spikard_http::grpc::GrpcRequestData)
-            -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
+        fn call(
+            &self,
+            request: spikard_http::grpc::GrpcRequestData,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
         {
             let custom_value = request
                 .metadata
@@ -137,7 +137,7 @@ async fn test_custom_header_metadata() {
                 .unwrap_or("missing")
                 .to_string();
 
-            let response = format!(r#"{{"custom_value": "{}"}}"#, custom_value);
+            let response = format!(r#"{{"custom_value": "{custom_value}"}}"#);
 
             Box::pin(async move {
                 Ok(spikard_http::grpc::GrpcResponseData {
@@ -151,6 +151,8 @@ async fn test_custom_header_metadata() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(CustomHeaderHandler));
 
     let mut metadata = create_test_metadata();
@@ -166,18 +168,18 @@ async fn test_custom_header_metadata() {
     .await
     .expect("Failed to send custom header");
 
-    assert_grpc_response(response, serde_json::json!({"custom_value": "custom_value_123"}));
+    assert_grpc_response(&response, &serde_json::json!({"custom_value": "custom_value_123"}));
 }
 
 /// Test multiple custom headers
 #[tokio::test]
 async fn test_multiple_custom_headers() {
-    let mut server = GrpcTestServer::new();
-
     struct MultiHeaderHandler;
     impl spikard_http::grpc::GrpcHandler for MultiHeaderHandler {
-        fn call(&self, request: spikard_http::grpc::GrpcRequestData)
-            -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
+        fn call(
+            &self,
+            request: spikard_http::grpc::GrpcRequestData,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
         {
             let req_id = request
                 .metadata
@@ -193,10 +195,7 @@ async fn test_multiple_custom_headers() {
                 .unwrap_or("missing")
                 .to_string();
 
-            let response = format!(
-                r#"{{"request_id": "{}", "trace_id": "{}"}}"#,
-                req_id, trace_id
-            );
+            let response = format!(r#"{{"request_id": "{req_id}", "trace_id": "{trace_id}"}}"#);
 
             Box::pin(async move {
                 Ok(spikard_http::grpc::GrpcResponseData {
@@ -210,6 +209,8 @@ async fn test_multiple_custom_headers() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(MultiHeaderHandler));
 
     let mut metadata = create_test_metadata();
@@ -226,21 +227,24 @@ async fn test_multiple_custom_headers() {
     .await
     .expect("Failed to send multiple headers");
 
-    assert_grpc_response(response, serde_json::json!({
-        "request_id": "req-12345",
-        "trace_id": "trace-67890"
-    }));
+    assert_grpc_response(
+        &response,
+        &serde_json::json!({
+            "request_id": "req-12345",
+            "trace_id": "trace-67890"
+        }),
+    );
 }
 
 /// Test metadata with special characters in values
 #[tokio::test]
 async fn test_metadata_special_characters() {
-    let mut server = GrpcTestServer::new();
-
     struct SpecialCharHandler;
     impl spikard_http::grpc::GrpcHandler for SpecialCharHandler {
-        fn call(&self, request: spikard_http::grpc::GrpcRequestData)
-            -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
+        fn call(
+            &self,
+            request: spikard_http::grpc::GrpcRequestData,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
         {
             let special_header = request
                 .metadata
@@ -249,7 +253,7 @@ async fn test_metadata_special_characters() {
                 .unwrap_or("")
                 .to_string();
 
-            let response = format!(r#"{{"received": "{}"}}"#, special_header);
+            let response = format!(r#"{{"received": "{special_header}"}}"#);
 
             Box::pin(async move {
                 Ok(spikard_http::grpc::GrpcResponseData {
@@ -263,6 +267,8 @@ async fn test_metadata_special_characters() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(SpecialCharHandler));
 
     let mut metadata = create_test_metadata();
@@ -279,12 +285,15 @@ async fn test_metadata_special_characters() {
     .await
     .expect("Failed to send special chars");
 
-    assert_grpc_response(response, serde_json::json!({
-        "received": "value-with_underscore.and.dots"
-    }));
+    assert_grpc_response(
+        &response,
+        &serde_json::json!({
+            "received": "value-with_underscore.and.dots"
+        }),
+    );
 }
 
-/// Test metadata creation with HashMap
+/// Test metadata creation with `HashMap`
 #[test]
 fn test_create_metadata_with_headers_map() {
     let mut headers = HashMap::new();
@@ -314,12 +323,12 @@ fn test_default_metadata_headers() {
 /// Test response metadata is preserved
 #[tokio::test]
 async fn test_response_metadata_preservation() {
-    let mut server = GrpcTestServer::new();
-
     struct ResponseMetadataHandler;
     impl spikard_http::grpc::GrpcHandler for ResponseMetadataHandler {
-        fn call(&self, _request: spikard_http::grpc::GrpcRequestData)
-            -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
+        fn call(
+            &self,
+            _request: spikard_http::grpc::GrpcRequestData,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
         {
             let mut response_metadata = MetadataMap::new();
             response_metadata.insert("x-response-header", "response-value".parse().unwrap());
@@ -336,6 +345,8 @@ async fn test_response_metadata_preservation() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(ResponseMetadataHandler));
 
     let response = send_unary_request(
@@ -372,12 +383,12 @@ fn test_bearer_token_format() {
 /// Test metadata extraction with no headers
 #[tokio::test]
 async fn test_metadata_extraction_empty_metadata() {
-    let mut server = GrpcTestServer::new();
-
     struct EmptyMetadataHandler;
     impl spikard_http::grpc::GrpcHandler for EmptyMetadataHandler {
-        fn call(&self, request: spikard_http::grpc::GrpcRequestData)
-            -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
+        fn call(
+            &self,
+            request: spikard_http::grpc::GrpcRequestData,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
         {
             let is_empty = request.metadata.is_empty();
 
@@ -399,6 +410,8 @@ async fn test_metadata_extraction_empty_metadata() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(EmptyMetadataHandler));
 
     let empty_metadata = MetadataMap::new();
@@ -413,18 +426,18 @@ async fn test_metadata_extraction_empty_metadata() {
     .await
     .expect("Failed to send with empty metadata");
 
-    assert_grpc_response(response, serde_json::json!({"metadata_empty": true}));
+    assert_grpc_response(&response, &serde_json::json!({"metadata_empty": true}));
 }
 
 /// Test metadata header with numeric value
 #[tokio::test]
 async fn test_metadata_numeric_value() {
-    let mut server = GrpcTestServer::new();
-
     struct NumericHeaderHandler;
     impl spikard_http::grpc::GrpcHandler for NumericHeaderHandler {
-        fn call(&self, request: spikard_http::grpc::GrpcRequestData)
-            -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
+        fn call(
+            &self,
+            request: spikard_http::grpc::GrpcRequestData,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
         {
             let count = request
                 .metadata
@@ -433,7 +446,7 @@ async fn test_metadata_numeric_value() {
                 .unwrap_or("0")
                 .to_string();
 
-            let response = format!(r#"{{"count": {}}}"#, count);
+            let response = format!(r#"{{"count": {count}}}"#);
 
             Box::pin(async move {
                 Ok(spikard_http::grpc::GrpcResponseData {
@@ -447,6 +460,8 @@ async fn test_metadata_numeric_value() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(NumericHeaderHandler));
 
     let mut metadata = create_test_metadata();
@@ -462,18 +477,18 @@ async fn test_metadata_numeric_value() {
     .await
     .expect("Failed to send numeric header");
 
-    assert_grpc_response(response, serde_json::json!({"count": 42}));
+    assert_grpc_response(&response, &serde_json::json!({"count": 42}));
 }
 
 /// Test metadata with UUID value
 #[tokio::test]
 async fn test_metadata_uuid_value() {
-    let mut server = GrpcTestServer::new();
-
     struct UuidHeaderHandler;
     impl spikard_http::grpc::GrpcHandler for UuidHeaderHandler {
-        fn call(&self, request: spikard_http::grpc::GrpcRequestData)
-            -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
+        fn call(
+            &self,
+            request: spikard_http::grpc::GrpcRequestData,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = spikard_http::grpc::GrpcHandlerResult> + Send>>
         {
             let uuid = request
                 .metadata
@@ -482,7 +497,7 @@ async fn test_metadata_uuid_value() {
                 .unwrap_or("invalid")
                 .to_string();
 
-            let response = format!(r#"{{"uuid": "{}"}}"#, uuid);
+            let response = format!(r#"{{"uuid": "{uuid}"}}"#);
 
             Box::pin(async move {
                 Ok(spikard_http::grpc::GrpcResponseData {
@@ -496,23 +511,22 @@ async fn test_metadata_uuid_value() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(UuidHeaderHandler));
 
     let mut metadata = create_test_metadata();
     let uuid = "550e8400-e29b-41d4-a716-446655440000";
     add_metadata_header(&mut metadata, "x-request-uuid", uuid).unwrap();
 
-    let response = send_unary_request(
-        &server,
-        "test.UuidService",
-        "Process",
-        Bytes::from("{}"),
-        metadata,
-    )
-    .await
-    .expect("Failed to send UUID header");
+    let response = send_unary_request(&server, "test.UuidService", "Process", Bytes::from("{}"), metadata)
+        .await
+        .expect("Failed to send UUID header");
 
-    assert_grpc_response(response, serde_json::json!({
-        "uuid": "550e8400-e29b-41d4-a716-446655440000"
-    }));
+    assert_grpc_response(
+        &response,
+        &serde_json::json!({
+            "uuid": "550e8400-e29b-41d4-a716-446655440000"
+        }),
+    );
 }