spikard 0.8.1 → 0.8.2

data/vendor/crates/spikard-http/tests/common/grpc_helpers.rs

@@ -40,13 +40,13 @@
 //! ```
 
 use bytes::Bytes;
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 use spikard_http::grpc::{GrpcHandler, GrpcHandlerResult, GrpcRequestData, GrpcResponseData};
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
-use tonic::metadata::MetadataMap;
 use tonic::Code;
+use tonic::metadata::MetadataMap;
 
 /// Test server for gRPC integration testing
 ///
@@ -82,7 +82,7 @@ impl GrpcTestServer {
     ///
     /// # Arguments
     ///
-    /// * `url` - The base URL for the server (e.g., "http://localhost:8080")
+    /// * `url` - The base URL for the server (e.g., <http://localhost:8080>)
     pub fn with_url(url: impl Into<String>) -> Self {
         Self {
             handlers: Arc::new(std::sync::Mutex::new(Vec::new())),
@@ -102,7 +102,7 @@ impl GrpcTestServer {
     /// let mut server = GrpcTestServer::new();
     /// server.register_service(Arc::new(MyHandler));
     /// ```
-    pub fn register_service(&mut self, handler: Arc<dyn GrpcHandler>) {
+    pub fn register_service(&self, handler: Arc<dyn GrpcHandler>) {
         let mut handlers = self.handlers.lock().unwrap();
         handlers.push(handler);
     }
@@ -127,10 +127,7 @@ impl GrpcTestServer {
     /// * `service_name` - The fully qualified service name to look up
     pub fn get_handler(&self, service_name: &str) -> Option<Arc<dyn GrpcHandler>> {
         let handlers = self.handlers.lock().unwrap();
-        handlers
-            .iter()
-            .find(|h| h.service_name() == service_name)
-            .cloned()
+        handlers.iter().find(|h| h.service_name() == service_name).cloned()
     }
 
     /// Check if a service is registered
@@ -170,7 +167,7 @@ pub struct GrpcTestClient;
 
 impl GrpcTestClient {
     /// Create a new test client
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self
     }
 }
@@ -182,7 +179,7 @@ impl Default for GrpcTestClient {
 }
 
 /// Factory function to create a gRPC test client
-pub fn create_grpc_test_client() -> GrpcTestClient {
+pub const fn create_grpc_test_client() -> GrpcTestClient {
     GrpcTestClient::new()
 }
 
@@ -196,7 +193,7 @@ pub fn create_grpc_test_client() -> GrpcTestClient {
 ///
 /// * `server` - The test server instance
 /// * `service` - Fully qualified service name (e.g., "mypackage.UserService")
-/// * `method` - Method name (e.g., "GetUser")
+/// * `method` - Method name (e.g., `GetUser`)
 /// * `payload` - Serialized protobuf message bytes
 /// * `metadata` - gRPC metadata (headers) to include in the request
 ///
@@ -227,12 +224,12 @@ pub async fn send_unary_request(
     payload: Bytes,
     metadata: MetadataMap,
 ) -> Result<GrpcResponseData, Box<dyn std::error::Error>> {
-    let handler = server
-        .get_handler(service)
-        .ok_or_else(|| Box::new(std::io::Error::new(
+    let handler = server.get_handler(service).ok_or_else(|| {
+        Box::new(std::io::Error::new(
             std::io::ErrorKind::NotFound,
-            format!("Service not found: {}", service),
-        )) as Box<dyn std::error::Error>)?;
+            format!("Service not found: {service}"),
+        )) as Box<dyn std::error::Error>
+    })?;
 
     let request = GrpcRequestData {
         service_name: service.to_string(),
@@ -264,14 +261,12 @@ pub async fn send_unary_request(
 /// let response = send_unary_request(...).await?;
 /// assert_grpc_response(response, json!({"id": 1, "name": "Alice"}));
 /// ```
-pub fn assert_grpc_response(response: GrpcResponseData, expected: Value) {
-    let actual = serde_json::from_slice::<Value>(&response.payload)
-        .expect("Failed to parse response payload as JSON");
+pub fn assert_grpc_response(response: &GrpcResponseData, expected: &Value) {
+    let actual = serde_json::from_slice::<Value>(&response.payload).expect("Failed to parse response payload as JSON");
 
     assert_eq!(
-        actual, expected,
-        "Response payload mismatch.\nExpected: {}\nActual: {}",
-        expected, actual
+        actual, *expected,
+        "Response payload mismatch.\nExpected: {expected}\nActual: {actual}",
     );
 }
 
@@ -286,7 +281,7 @@ pub fn assert_grpc_response(response: GrpcResponseData, expected: Value) {
 /// # Arguments
 ///
 /// * `result` - The gRPC handler result
-/// * `expected_status` - The expected tonic::Code
+/// * `expected_status` - The expected `tonic::Code`
 ///
 /// # Example
 ///
@@ -307,10 +302,7 @@ pub fn assert_grpc_status(result: &GrpcHandlerResult, expected_status: Code) {
             );
         }
         Ok(_) => {
-            panic!(
-                "Expected error status {:?} but got success response",
-                expected_status
-            );
+            panic!("Expected error status {expected_status:?} but got success response");
         }
     }
 }
@@ -363,15 +355,13 @@ impl ProtobufMessageBuilder {
 
     /// Add a string field to the message
     pub fn add_string_field(&mut self, name: &str, value: &str) -> &mut Self {
-        self.fields
-            .insert(name.to_string(), Value::String(value.to_string()));
+        self.fields.insert(name.to_string(), Value::String(value.to_string()));
         self
     }
 
     /// Add an integer field to the message
     pub fn add_int_field(&mut self, name: &str, value: i64) -> &mut Self {
-        self.fields
-            .insert(name.to_string(), json!(value));
+        self.fields.insert(name.to_string(), json!(value));
         self
     }
 
@@ -446,11 +436,11 @@ pub fn create_test_metadata() -> MetadataMap {
 
 /// Create test metadata with custom headers
 ///
-/// Allows building metadata from a HashMap of key-value pairs.
+/// Allows building metadata from a `HashMap` of key-value pairs.
 ///
 /// # Arguments
 ///
-/// * `headers` - HashMap of header names to values (String-based)
+/// * `headers` - `HashMap` of header names to values (String-based)
 ///
 /// # Example
 ///
@@ -475,7 +465,7 @@ pub fn create_test_metadata_with_headers(
     Ok(metadata)
 }
 
-/// Add authentication metadata to an existing MetadataMap
+/// Add authentication metadata to an existing `MetadataMap`
 ///
 /// Adds a standard Bearer token authorization header.
 ///
@@ -491,12 +481,12 @@ pub fn create_test_metadata_with_headers(
 /// add_auth_metadata(&mut metadata, "secret_token_123");
 /// ```
 pub fn add_auth_metadata(metadata: &mut MetadataMap, token: &str) -> Result<(), Box<dyn std::error::Error>> {
-    let auth_value = format!("Bearer {}", token);
+    let auth_value = format!("Bearer {token}");
     metadata.insert("authorization", auth_value.parse()?);
     Ok(())
 }
 
-/// Add custom metadata header to an existing MetadataMap
+/// Add custom metadata header to an existing `MetadataMap`
 ///
 /// # Arguments
 ///
@@ -545,8 +535,8 @@ impl MockGrpcHandler {
     }
 
     /// Create a mock handler that returns JSON
-    pub fn with_json(service_name: &'static str, json: Value) -> Self {
-        let bytes = serde_json::to_vec(&json).unwrap_or_default();
+    pub fn with_json(service_name: &'static str, json: &Value) -> Self {
+        let bytes = serde_json::to_vec(json).unwrap_or_default();
         Self::new(service_name, Bytes::from(bytes))
     }
 }
@@ -643,6 +633,22 @@ impl GrpcHandler for EchoMockHandler {
 mod tests {
     use super::*;
 
+    // Mock handler for testing gRPC functionality
+    struct TestHandler;
+    impl GrpcHandler for TestHandler {
+        fn call(&self, _request: GrpcRequestData) -> Pin<Box<dyn Future<Output = GrpcHandlerResult> + Send>> {
+            Box::pin(async {
+                Ok(GrpcResponseData {
+                    payload: serde_json::to_vec(&json!({"result": "success"})).unwrap().into(),
+                    metadata: MetadataMap::new(),
+                })
+            })
+        }
+        fn service_name(&self) -> &'static str {
+            "test.TestService"
+        }
+    }
+
     #[test]
     fn test_grpc_test_server_new() {
         let server = GrpcTestServer::new();
@@ -659,7 +665,7 @@ mod tests {
 
     #[test]
     fn test_grpc_test_server_register_service() {
-        let mut server = GrpcTestServer::new();
+        let server = GrpcTestServer::new();
         let handler = Arc::new(MockGrpcHandler::new("test.Service", "response"));
 
         server.register_service(handler);
@@ -670,7 +676,7 @@ mod tests {
 
     #[test]
     fn test_grpc_test_server_register_multiple_services() {
-        let mut server = GrpcTestServer::new();
+        let server = GrpcTestServer::new();
         let handler1 = Arc::new(MockGrpcHandler::new("service1", "response1"));
         let handler2 = Arc::new(MockGrpcHandler::new("service2", "response2"));
 
@@ -706,7 +712,7 @@ mod tests {
     #[tokio::test]
     async fn test_mock_grpc_handler_with_json() {
         let json_response = json!({"id": 1, "name": "Alice"});
-        let handler = MockGrpcHandler::with_json("test.UserService", json_response.clone());
+        let handler = MockGrpcHandler::with_json("test.UserService", &json_response);
 
         let request = GrpcRequestData {
             service_name: "test.UserService".to_string(),
@@ -908,7 +914,7 @@ mod tests {
         };
 
         let expected = json!({"id": 1, "name": "Alice"});
-        assert_grpc_response(response, expected);
+        assert_grpc_response(&response, &expected);
     }
 
     #[test]
@@ -945,25 +951,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_send_unary_request_with_mock_handler() {
-        let mut server = GrpcTestServer::new();
+        let server = GrpcTestServer::new();
         let _response_payload = json!({"result": "success"});
 
-        // Create a custom handler that reports the correct service name
-        struct TestHandler;
-        impl GrpcHandler for TestHandler {
-            fn call(&self, _request: GrpcRequestData) -> Pin<Box<dyn Future<Output = GrpcHandlerResult> + Send>> {
-                Box::pin(async {
-                    Ok(GrpcResponseData {
-                        payload: serde_json::to_vec(&json!({"result": "success"})).unwrap().into(),
-                        metadata: MetadataMap::new(),
-                    })
-                })
-            }
-            fn service_name(&self) -> &'static str {
-                "test.TestService"
-            }
-        }
-
         server.register_service(Arc::new(TestHandler));
 
         let message = ProtobufMessageBuilder::new()
@@ -1016,7 +1006,6 @@ mod tests {
     #[test]
     fn test_grpc_test_client_creation() {
         let _client = create_grpc_test_client();
-        let _default_client = GrpcTestClient::default();
         let _new_client = GrpcTestClient::new();
         // Just ensure it can be created without panicking
     }

data/vendor/crates/spikard-http/tests/common/handlers.rs

@@ -141,12 +141,12 @@ pub struct JsonHandler {
 
 impl JsonHandler {
     /// Create a new JSON handler with given status code and body
-    pub fn new(status_code: StatusCode, body: serde_json::Value) -> Self {
+    pub const fn new(status_code: StatusCode, body: serde_json::Value) -> Self {
         Self { status_code, body }
     }
 
     /// Create a JSON handler with 200 OK status
-    pub fn ok(body: serde_json::Value) -> Self {
+    pub const fn ok(body: serde_json::Value) -> Self {
         Self {
             status_code: StatusCode::OK,
             body,
@@ -154,7 +154,7 @@ impl JsonHandler {
     }
 
     /// Create a JSON handler with 201 Created status
-    pub fn created(body: serde_json::Value) -> Self {
+    pub const fn created(body: serde_json::Value) -> Self {
         Self {
             status_code: StatusCode::CREATED,
             body,
@@ -162,7 +162,7 @@ impl JsonHandler {
     }
 
     /// Create a JSON handler with 400 Bad Request status
-    pub fn bad_request(body: serde_json::Value) -> Self {
+    pub const fn bad_request(body: serde_json::Value) -> Self {
         Self {
             status_code: StatusCode::BAD_REQUEST,
             body,
@@ -170,7 +170,7 @@ impl JsonHandler {
     }
 
     /// Create a JSON handler with 500 Internal Server Error status
-    pub fn server_error(body: serde_json::Value) -> Self {
+    pub const fn server_error(body: serde_json::Value) -> Self {
         Self {
             status_code: StatusCode::INTERNAL_SERVER_ERROR,
             body,

data/vendor/crates/spikard-http/tests/common/mod.rs

@@ -17,18 +17,17 @@
 
 #![allow(dead_code)]
 
+pub mod grpc_helpers;
 pub mod handlers;
 pub mod test_builders;
-pub mod grpc_helpers;
 
+#[allow(unused_imports)]
+pub use grpc_helpers::{
+    EchoMockHandler, ErrorMockHandler, GrpcTestClient, GrpcTestServer, MockGrpcHandler, ProtobufMessageBuilder,
+    add_auth_metadata, add_metadata_header, assert_grpc_response, assert_grpc_status, create_grpc_test_client,
+    create_test_metadata, create_test_metadata_with_headers, send_unary_request,
+};
 #[allow(unused_imports)]
 pub use handlers::{EchoHandler, ErrorHandler, JsonHandler, PanicHandler, SuccessHandler};
 #[allow(unused_imports)]
 pub use test_builders::{HandlerBuilder, RequestBuilder, assert_status, load_fixture, parse_json_body};
-#[allow(unused_imports)]
-pub use grpc_helpers::{
-    GrpcTestServer, GrpcTestClient, create_grpc_test_client, send_unary_request,
-    assert_grpc_response, assert_grpc_status, ProtobufMessageBuilder, create_test_metadata,
-    add_auth_metadata, add_metadata_header, create_test_metadata_with_headers,
-    MockGrpcHandler, ErrorMockHandler, EchoMockHandler,
-};

data/vendor/crates/spikard-http/tests/common/test_builders.rs

@@ -87,7 +87,7 @@ impl HandlerBuilder {
     /// Add a delay to the handler response for testing timeouts
     ///
     /// Useful for simulating slow handlers and testing timeout middleware.
-    pub fn delay(mut self, duration: Duration) -> Self {
+    pub const fn delay(mut self, duration: Duration) -> Self {
         self.delay = Some(duration);
         self
     }
@@ -95,7 +95,7 @@ impl HandlerBuilder {
     /// Configure the handler to panic when called
     ///
     /// Useful for testing panic recovery and error handling middleware.
-    pub fn panics(mut self) -> Self {
+    pub const fn panics(mut self) -> Self {
         self.should_panic = true;
         self
     }
@@ -119,7 +119,7 @@ impl Default for HandlerBuilder {
     }
 }
 
-/// Internal handler implementation constructed by HandlerBuilder
+/// Internal handler implementation constructed by `HandlerBuilder`
 struct ConfiguredHandler {
     status: StatusCode,
     body: Value,
@@ -139,9 +139,7 @@ impl Handler for ConfiguredHandler {
         let should_panic = self.should_panic;
 
         Box::pin(async move {
-            if should_panic {
-                panic!("Handler configured to panic");
-            }
+            assert!(!should_panic, "Handler configured to panic");
 
             if let Some(duration) = delay {
                 sleep(duration).await;
@@ -160,7 +158,7 @@ impl Handler for ConfiguredHandler {
 
 /// Fluent builder for constructing test HTTP requests
 ///
-/// Provides a fluent API for building both hyper Request objects and RequestData
+/// Provides a fluent API for building both hyper `Request` objects and `RequestData`
 /// structures needed for handler testing. Handles typical test scenarios without
 /// requiring manual construction of all components.
 ///
@@ -215,7 +213,7 @@ impl RequestBuilder {
         self
     }
 
-    /// Add or replace headers from a HashMap
+    /// Add or replace headers from a `HashMap`
     ///
     /// Values are stored as-is; no normalization is performed.
     pub fn headers(mut self, headers: HashMap<String, String>) -> Self {
@@ -229,7 +227,7 @@ impl RequestBuilder {
         self
     }
 
-    /// Add or replace cookies from a HashMap
+    /// Add or replace cookies from a `HashMap`
     pub fn cookies(mut self, cookies: HashMap<String, String>) -> Self {
         self.cookies = cookies;
         self
@@ -249,9 +247,9 @@ impl RequestBuilder {
         self
     }
 
-    /// Set query parameters as a HashMap of name to values
+    /// Set query parameters as a `HashMap` of name to values
     ///
-    /// Values are stored as Vec<String> to support multi-valued parameters.
+    /// Values are stored as `Vec<String>` to support multi-valued parameters.
     pub fn query_params(mut self, params: HashMap<String, Vec<String>>) -> Self {
         self.query_params = params;
         self
@@ -259,16 +257,13 @@ impl RequestBuilder {
 
     /// Add a single query parameter
     pub fn query_param(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
-        self.query_params
-            .entry(name.into())
-            .or_insert_with(Vec::new)
-            .push(value.into());
+        self.query_params.entry(name.into()).or_default().push(value.into());
         self
     }
 
-    /// Build the request into (Request<Body>, RequestData) tuple
+    /// Build the request into `(Request<Body>, RequestData)` tuple
     ///
-    /// The Request can be passed directly to handler.call(). RequestData contains
+    /// The `Request` can be passed directly to `handler.call()`. `RequestData` contains
     /// all extracted request information (params, body, headers, etc.).
     pub fn build(self) -> (Request<Body>, RequestData) {
         let body = if self.body.is_null() {
@@ -327,11 +322,11 @@ fn build_query_json(raw_params: &HashMap<String, Vec<String>>) -> Value {
     Value::Object(map)
 }
 
-/// Load a JSON fixture from the testing_data directory
+/// Load a JSON fixture from the `testing_data` directory
 ///
 /// # Arguments
 ///
-/// * `relative_path` - Path relative to project root, e.g., "testing_data/headers/01_user_agent_default.json"
+/// * `relative_path` - Path relative to project root, e.g., `"testing_data/headers/01_user_agent_default.json"`
 ///
 /// # Example
 ///