spikard 0.8.3 → 0.10.2

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

@@ -282,10 +282,10 @@ impl RequestBuilder {
 
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: build_query_json(&self.query_params),
+            query_params: Arc::new(build_query_json(&self.query_params)),
             validated_params: None,
             raw_query_params: Arc::new(self.query_params),
-            body: self.body,
+            body: Arc::new(self.body),
             raw_body: None,
             headers: Arc::new(self.headers),
             cookies: Arc::new(self.cookies),
@@ -409,10 +409,10 @@ mod tests {
         let request = Request::builder().body(Body::empty()).unwrap();
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: json!(null),
+            body: Arc::new(json!(null)),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -435,10 +435,10 @@ mod tests {
         let request = Request::builder().body(Body::empty()).unwrap();
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: json!(null),
+            body: Arc::new(json!(null)),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -463,10 +463,10 @@ mod tests {
         let request = Request::builder().body(Body::empty()).unwrap();
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: json!(null),
+            body: Arc::new(json!(null)),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -488,10 +488,10 @@ mod tests {
         let request = Request::builder().body(Body::empty()).unwrap();
         let request_data = RequestData {
             path_params: Arc::new(HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
-            body: json!(null),
+            body: Arc::new(json!(null)),
             raw_body: None,
             headers: Arc::new(HashMap::new()),
             cookies: Arc::new(HashMap::new()),
@@ -527,7 +527,7 @@ mod tests {
 
         assert_eq!(request.method(), &Method::POST);
         assert_eq!(request_data.path, "/users");
-        assert_eq!(request_data.body, body);
+        assert_eq!(*request_data.body, body);
     }
 
     #[test]
@@ -609,7 +609,7 @@ mod tests {
 
         assert_eq!(request_data.method, "PUT");
         assert_eq!(request_data.path, "/users/42");
-        assert_eq!(request_data.body, body);
+        assert_eq!(*request_data.body, body);
         assert_eq!(
             request_data.headers.get("authorization"),
             Some(&"Bearer abc123".to_string())

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

@@ -26,10 +26,10 @@ impl Handler for OkHandler {
 fn minimal_request_data() -> RequestData {
     RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: serde_json::json!({}),
+        query_params: Arc::new(serde_json::json!({})),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: serde_json::Value::Null,
+        body: Arc::new(serde_json::Value::Null),
         raw_body: None,
         headers: Arc::new(HashMap::new()),
         cookies: Arc::new(HashMap::new()),

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

@@ -73,10 +73,10 @@ async fn test_di_value_injection() {
     let request = Request::builder().body(Body::empty()).unwrap();
     let request_data = RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: serde_json::Value::Null,
+        query_params: Arc::new(serde_json::Value::Null),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: serde_json::Value::Null,
+        body: Arc::new(serde_json::Value::Null),
         raw_body: None,
         headers: Arc::new(HashMap::new()),
         cookies: Arc::new(HashMap::new()),
@@ -115,10 +115,10 @@ async fn test_di_missing_dependency_error() {
     let request = Request::builder().body(Body::empty()).unwrap();
     let request_data = RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: serde_json::Value::Null,
+        query_params: Arc::new(serde_json::Value::Null),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: serde_json::Value::Null,
+        body: Arc::new(serde_json::Value::Null),
         raw_body: None,
         headers: Arc::new(HashMap::new()),
         cookies: Arc::new(HashMap::new()),
@@ -162,10 +162,10 @@ async fn test_di_multiple_value_dependencies() {
     let request = Request::builder().body(Body::empty()).unwrap();
     let request_data = RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: serde_json::Value::Null,
+        query_params: Arc::new(serde_json::Value::Null),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: serde_json::Value::Null,
+        body: Arc::new(serde_json::Value::Null),
         raw_body: None,
         headers: Arc::new(HashMap::new()),
         cookies: Arc::new(HashMap::new()),

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

@@ -0,0 +1,430 @@
+//! Integration tests for gRPC bidirectional streaming
+//!
+//! Tests end-to-end bidirectional streaming functionality through GenericGrpcService
+//! and grpc_routing, including:
+//! - Echo service with bidirectional messages
+//! - Message transformation during streaming
+//! - Error handling in request and response streams
+//! - Empty streams
+//! - Large payloads (100+ messages in both directions)
+//! - Message ordering preservation
+//! - Concurrent bidirectional streaming requests
+#![allow(
+    clippy::doc_markdown,
+    clippy::uninlined_format_args,
+    clippy::redundant_closure_for_method_calls,
+    reason = "Integration test for streaming with many test cases"
+)]
+
+use bytes::Bytes;
+use futures_util::StreamExt;
+use spikard_http::grpc::streaming::StreamingRequest;
+use spikard_http::grpc::{GrpcHandler, GrpcHandlerResult, GrpcRequestData, RpcMode};
+use std::future::Future;
+use std::pin::Pin;
+use tonic::metadata::MetadataMap;
+
+// ============================================================================
+// Test Handlers
+// ============================================================================
+
+/// Handler that echoes back messages from bidirectional stream
+struct EchoBidiHandler;
+
+impl GrpcHandler for EchoBidiHandler {
+    fn call(&self, _request: GrpcRequestData) -> Pin<Box<dyn Future<Output = GrpcHandlerResult> + Send>> {
+        Box::pin(async { Err(tonic::Status::unimplemented("Use call_bidi_stream for streaming")) })
+    }
+
+    fn service_name(&self) -> &'static str {
+        "integration.EchoService"
+    }
+
+    fn rpc_mode(&self) -> RpcMode {
+        RpcMode::BidirectionalStreaming
+    }
+
+    fn call_bidi_stream(
+        &self,
+        request: StreamingRequest,
+    ) -> Pin<Box<dyn Future<Output = Result<spikard_http::grpc::streaming::MessageStream, tonic::Status>> + Send>> {
+        Box::pin(async move {
+            let mut messages = Vec::new();
+            let mut stream = request.message_stream;
+
+            while let Some(msg_result) = stream.next().await {
+                match msg_result {
+                    Ok(msg) => messages.push(msg),
+                    Err(e) => return Err(e),
+                }
+            }
+
+            Ok(spikard_http::grpc::streaming::message_stream_from_vec(messages))
+        })
+    }
+}
+
+/// Handler that transforms messages (uppercase) in bidirectional stream
+struct TransformBidiHandler;
+
+impl GrpcHandler for TransformBidiHandler {
+    fn call(&self, _request: GrpcRequestData) -> Pin<Box<dyn Future<Output = GrpcHandlerResult> + Send>> {
+        Box::pin(async { Err(tonic::Status::unimplemented("Use call_bidi_stream for streaming")) })
+    }
+
+    fn service_name(&self) -> &'static str {
+        "integration.TransformService"
+    }
+
+    fn rpc_mode(&self) -> RpcMode {
+        RpcMode::BidirectionalStreaming
+    }
+
+    fn call_bidi_stream(
+        &self,
+        request: StreamingRequest,
+    ) -> Pin<Box<dyn Future<Output = Result<spikard_http::grpc::streaming::MessageStream, tonic::Status>> + Send>> {
+        Box::pin(async move {
+            let mut messages = Vec::new();
+            let mut stream = request.message_stream;
+
+            while let Some(msg_result) = stream.next().await {
+                match msg_result {
+                    Ok(msg) => {
+                        let text = String::from_utf8_lossy(&msg).to_uppercase();
+                        messages.push(Bytes::from(text));
+                    }
+                    Err(e) => return Err(e),
+                }
+            }
+
+            Ok(spikard_http::grpc::streaming::message_stream_from_vec(messages))
+        })
+    }
+}
+
+// ============================================================================
+// Integration Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_integration_bidi_echo() {
+    let handler = EchoBidiHandler;
+
+    let messages = vec![Bytes::from("hello"), Bytes::from("world"), Bytes::from("test")];
+    let stream = spikard_http::grpc::streaming::message_stream_from_vec(messages.clone());
+    let request = StreamingRequest {
+        service_name: "integration.EchoService".to_string(),
+        method_name: "Echo".to_string(),
+        message_stream: stream,
+        metadata: MetadataMap::new(),
+    };
+
+    let result = handler.call_bidi_stream(request).await;
+    assert!(result.is_ok());
+
+    let mut response_stream = result.unwrap();
+    let mut responses = Vec::new();
+
+    while let Some(msg_result) = response_stream.next().await {
+        match msg_result {
+            Ok(msg) => responses.push(msg),
+            Err(_) => break,
+        }
+    }
+
+    assert_eq!(responses.len(), 3);
+    assert_eq!(responses, messages);
+}
+
+#[tokio::test]
+async fn test_integration_bidi_transform() {
+    let handler = TransformBidiHandler;
+
+    let messages = vec![Bytes::from("hello"), Bytes::from("world")];
+    let stream = spikard_http::grpc::streaming::message_stream_from_vec(messages);
+    let request = StreamingRequest {
+        service_name: "integration.TransformService".to_string(),
+        method_name: "Transform".to_string(),
+        message_stream: stream,
+        metadata: MetadataMap::new(),
+    };
+
+    let result = handler.call_bidi_stream(request).await;
+    assert!(result.is_ok());
+
+    let mut response_stream = result.unwrap();
+    let mut responses = Vec::new();
+
+    while let Some(msg_result) = response_stream.next().await {
+        match msg_result {
+            Ok(msg) => responses.push(String::from_utf8_lossy(&msg).to_string()),
+            Err(_) => break,
+        }
+    }
+
+    assert_eq!(responses.len(), 2);
+    assert_eq!(responses[0], "HELLO");
+    assert_eq!(responses[1], "WORLD");
+}
+
+#[tokio::test]
+async fn test_integration_bidi_empty_stream() {
+    let handler = EchoBidiHandler;
+
+    let messages: Vec<Bytes> = vec![];
+    let stream = spikard_http::grpc::streaming::message_stream_from_vec(messages);
+    let request = StreamingRequest {
+        service_name: "integration.EchoService".to_string(),
+        method_name: "Echo".to_string(),
+        message_stream: stream,
+        metadata: MetadataMap::new(),
+    };
+
+    let result = handler.call_bidi_stream(request).await;
+    assert!(result.is_ok());
+
+    let mut response_stream = result.unwrap();
+    let mut responses = Vec::new();
+
+    while let Some(msg_result) = response_stream.next().await {
+        match msg_result {
+            Ok(msg) => responses.push(msg),
+            Err(_) => break,
+        }
+    }
+
+    assert_eq!(responses.len(), 0);
+}
+
+#[tokio::test]
+async fn test_integration_bidi_large_stream() {
+    let handler = EchoBidiHandler;
+
+    // Create a large stream of messages (100+)
+    let messages: Vec<Bytes> = (0..150).map(|i| Bytes::from(format!("msg_{}", i))).collect();
+    let stream = spikard_http::grpc::streaming::message_stream_from_vec(messages);
+    let request = StreamingRequest {
+        service_name: "integration.EchoService".to_string(),
+        method_name: "Echo".to_string(),
+        message_stream: stream,
+        metadata: MetadataMap::new(),
+    };
+
+    let result = handler.call_bidi_stream(request).await;
+    assert!(result.is_ok());
+
+    let mut response_stream = result.unwrap();
+    let mut responses = Vec::new();
+
+    while let Some(msg_result) = response_stream.next().await {
+        match msg_result {
+            Ok(msg) => responses.push(msg),
+            Err(_) => break,
+        }
+    }
+
+    assert_eq!(responses.len(), 150);
+}
+
+#[tokio::test]
+async fn test_integration_bidi_metadata_propagation() {
+    let handler = EchoBidiHandler;
+
+    let mut metadata = MetadataMap::new();
+    metadata.insert("x-request-id", "bidi-001".parse().unwrap());
+    metadata.insert("x-custom", "value".parse().unwrap());
+
+    let messages = vec![Bytes::from("test")];
+    let stream = spikard_http::grpc::streaming::message_stream_from_vec(messages);
+    let request = StreamingRequest {
+        service_name: "integration.EchoService".to_string(),
+        method_name: "Echo".to_string(),
+        message_stream: stream,
+        metadata,
+    };
+
+    let result = handler.call_bidi_stream(request).await;
+    assert!(result.is_ok());
+
+    let mut response_stream = result.unwrap();
+    let mut count = 0;
+
+    while let Some(msg_result) = response_stream.next().await {
+        match msg_result {
+            Ok(_msg) => count += 1,
+            Err(_) => break,
+        }
+    }
+
+    assert_eq!(count, 1);
+}
+
+#[tokio::test]
+async fn test_integration_bidi_concurrent_requests() {
+    /// Handler with request-specific ID
+    struct ConcurrentBidiHandler {
+        request_id: usize,
+    }
+
+    impl GrpcHandler for ConcurrentBidiHandler {
+        fn call(&self, _request: GrpcRequestData) -> Pin<Box<dyn Future<Output = GrpcHandlerResult> + Send>> {
+            Box::pin(async { Err(tonic::Status::unimplemented("Use call_bidi_stream for streaming")) })
+        }
+
+        fn service_name(&self) -> &'static str {
+            "integration.ConcurrentService"
+        }
+
+        fn rpc_mode(&self) -> RpcMode {
+            RpcMode::BidirectionalStreaming
+        }
+
+        fn call_bidi_stream(
+            &self,
+            request: StreamingRequest,
+        ) -> Pin<Box<dyn Future<Output = Result<spikard_http::grpc::streaming::MessageStream, tonic::Status>> + Send>>
+        {
+            let request_id = self.request_id;
+            Box::pin(async move {
+                let mut stream = request.message_stream;
+                let mut count = 0;
+                let mut responses = Vec::new();
+
+                while let Some(msg_result) = stream.next().await {
+                    match msg_result {
+                        Ok(_msg) => {
+                            count += 1;
+                            responses.push(Bytes::from(format!("req_{}:{}", request_id, count)));
+                        }
+                        Err(e) => return Err(e),
+                    }
+                }
+
+                Ok(spikard_http::grpc::streaming::message_stream_from_vec(responses))
+            })
+        }
+    }
+
+    let handler1 = ConcurrentBidiHandler { request_id: 1 };
+    let handler2 = ConcurrentBidiHandler { request_id: 2 };
+    let handler3 = ConcurrentBidiHandler { request_id: 3 };
+
+    let task1 = tokio::spawn(async move {
+        let messages = vec![Bytes::from("a"), Bytes::from("b")];
+        let stream = spikard_http::grpc::streaming::message_stream_from_vec(messages);
+        let request = StreamingRequest {
+            service_name: "integration.ConcurrentService".to_string(),
+            method_name: "Concurrent".to_string(),
+            message_stream: stream,
+            metadata: MetadataMap::new(),
+        };
+        handler1.call_bidi_stream(request).await
+    });
+
+    let task2 = tokio::spawn(async move {
+        let messages = vec![Bytes::from("x"), Bytes::from("y"), Bytes::from("z")];
+        let stream = spikard_http::grpc::streaming::message_stream_from_vec(messages);
+        let request = StreamingRequest {
+            service_name: "integration.ConcurrentService".to_string(),
+            method_name: "Concurrent".to_string(),
+            message_stream: stream,
+            metadata: MetadataMap::new(),
+        };
+        handler2.call_bidi_stream(request).await
+    });
+
+    let task3 = tokio::spawn(async move {
+        let messages = vec![Bytes::from("single")];
+        let stream = spikard_http::grpc::streaming::message_stream_from_vec(messages);
+        let request = StreamingRequest {
+            service_name: "integration.ConcurrentService".to_string(),
+            method_name: "Concurrent".to_string(),
+            message_stream: stream,
+            metadata: MetadataMap::new(),
+        };
+        handler3.call_bidi_stream(request).await
+    });
+
+    let result1 = task1.await.unwrap();
+    let result2 = task2.await.unwrap();
+    let result3 = task3.await.unwrap();
+
+    assert!(result1.is_ok());
+    assert!(result2.is_ok());
+    assert!(result3.is_ok());
+
+    // Verify response counts
+    let mut responses1 = Vec::new();
+    if let Ok(mut stream) = result1 {
+        while let Some(msg_result) = stream.next().await {
+            if let Ok(msg) = msg_result {
+                responses1.push(msg);
+            }
+        }
+    }
+    assert_eq!(responses1.len(), 2);
+}
+
+#[tokio::test]
+async fn test_integration_bidi_ordering_preserved() {
+    let handler = EchoBidiHandler;
+
+    // Verify that message ordering is preserved through bidi stream
+    let messages: Vec<Bytes> = (0..10).map(|i| Bytes::from(format!("msg{:02}", i))).collect();
+    let stream = spikard_http::grpc::streaming::message_stream_from_vec(messages.clone());
+    let request = StreamingRequest {
+        service_name: "integration.EchoService".to_string(),
+        method_name: "Echo".to_string(),
+        message_stream: stream,
+        metadata: MetadataMap::new(),
+    };
+
+    let result = handler.call_bidi_stream(request).await;
+    assert!(result.is_ok());
+
+    let mut response_stream = result.unwrap();
+    let mut responses = Vec::new();
+
+    while let Some(msg_result) = response_stream.next().await {
+        match msg_result {
+            Ok(msg) => responses.push(msg),
+            Err(_) => break,
+        }
+    }
+
+    assert_eq!(responses.len(), 10);
+    for (i, resp) in responses.iter().enumerate() {
+        assert_eq!(resp, &Bytes::from(format!("msg{:02}", i)));
+    }
+}
+
+#[tokio::test]
+async fn test_integration_bidi_single_message() {
+    let handler = EchoBidiHandler;
+
+    let messages = vec![Bytes::from("single_message")];
+    let stream = spikard_http::grpc::streaming::message_stream_from_vec(messages.clone());
+    let request = StreamingRequest {
+        service_name: "integration.EchoService".to_string(),
+        method_name: "Echo".to_string(),
+        message_stream: stream,
+        metadata: MetadataMap::new(),
+    };
+
+    let result = handler.call_bidi_stream(request).await;
+    assert!(result.is_ok());
+
+    let mut response_stream = result.unwrap();
+    let mut responses = Vec::new();
+
+    while let Some(msg_result) = response_stream.next().await {
+        match msg_result {
+            Ok(msg) => responses.push(msg),
+            Err(_) => break,
+        }
+    }
+
+    assert_eq!(responses.len(), 1);
+    assert_eq!(responses[0], messages[0]);
+}