spikard 0.8.3 → 0.10.2

data/vendor/crates/spikard-http/src/grpc/mod.rs

@@ -42,12 +42,14 @@
 //! let config = GrpcConfig::default();
 //! ```
 
+pub mod framing;
 pub mod handler;
 pub mod service;
 pub mod streaming;
 
 // Re-export main types
-pub use handler::{GrpcHandler, GrpcHandlerResult, GrpcRequestData, GrpcResponseData};
+pub use framing::parse_grpc_client_stream;
+pub use handler::{GrpcHandler, GrpcHandlerResult, GrpcRequestData, GrpcResponseData, RpcMode};
 pub use service::{GenericGrpcService, copy_metadata, is_grpc_request, parse_grpc_path};
 pub use streaming::{MessageStream, StreamingRequest, StreamingResponse};
 
@@ -59,6 +61,35 @@ use std::sync::Arc;
 ///
 /// Controls how the server handles gRPC requests, including compression,
 /// timeouts, and protocol settings.
+///
+/// # Stream Limits
+///
+/// This configuration enforces message-level size limits but delegates
+/// concurrent stream limiting to the HTTP/2 transport layer:
+///
+/// - **Message Size Limits**: The `max_message_size` field is enforced per
+///   individual message (request or response) in both unary and streaming RPCs.
+///   When a single message exceeds this limit, the request is rejected with
+///   `PAYLOAD_TOO_LARGE` (HTTP 413).
+///
+/// - **Concurrent Stream Limits**: The `max_concurrent_streams` is an advisory
+///   configuration passed to the HTTP/2 layer for connection-level stream
+///   negotiation. The HTTP/2 transport automatically enforces this limit and
+///   returns GOAWAY frames when exceeded. Applications should not rely on
+///   custom enforcement of this limit.
+///
+/// - **Stream Length Limits**: There is currently no built-in limit on the
+///   total number of messages in a stream. Handlers should implement their own
+///   message counting if needed. Future versions may add a `max_stream_response_bytes`
+///   field to limit total response size per stream.
+///
+/// # Example
+///
+/// ```ignore
+/// let mut config = GrpcConfig::default();
+/// config.max_message_size = 10 * 1024 * 1024; // 10MB per message
+/// config.max_concurrent_streams = 50; // Advised to HTTP/2 layer
+/// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct GrpcConfig {
     /// Enable gRPC support
@@ -66,6 +97,17 @@ pub struct GrpcConfig {
     pub enabled: bool,
 
     /// Maximum message size in bytes (for both sending and receiving)
+    ///
+    /// This limit applies to individual messages in both unary and streaming RPCs.
+    /// When a single message exceeds this size, the request is rejected with HTTP 413
+    /// (Payload Too Large).
+    ///
+    /// Default: 4MB (4194304 bytes)
+    ///
+    /// # Note
+    /// This limit does NOT apply to the total response size in streaming RPCs.
+    /// For multi-message streams, the total response can exceed this limit as long
+    /// as each individual message stays within the limit.
     #[serde(default = "default_max_message_size")]
     pub max_message_size: usize,
 
@@ -77,7 +119,25 @@ pub struct GrpcConfig {
     #[serde(default)]
     pub request_timeout: Option<u64>,
 
-    /// Maximum number of concurrent streams per connection
+    /// Maximum number of concurrent streams per connection (HTTP/2 advisory)
+    ///
+    /// This value is communicated to HTTP/2 clients as the server's flow control limit.
+    /// The HTTP/2 transport layer enforces this limit automatically via SETTINGS frames
+    /// and GOAWAY responses. Applications should NOT implement custom enforcement.
+    ///
+    /// Default: 100 streams per connection
+    ///
+    /// # Stream Limiting Strategy
+    /// - **Per Connection**: This limit applies per HTTP/2 connection, not globally
+    /// - **Transport Enforcement**: HTTP/2 handles all stream limiting; applications
+    ///   need not implement custom checks
+    /// - **Streaming Requests**: In server streaming or bidi streaming, each logical
+    ///   RPC consumes one stream slot. Message ordering within a stream follows
+    ///   HTTP/2 frame ordering.
+    ///
+    /// # Future Enhancement
+    /// A future `max_stream_response_bytes` field may be added to limit the total
+    /// response size in streaming RPCs (separate from per-message limits).
     #[serde(default = "default_max_concurrent_streams")]
     pub max_concurrent_streams: u32,
 
@@ -92,6 +152,8 @@ pub struct GrpcConfig {
     /// HTTP/2 keepalive timeout in seconds
     #[serde(default = "default_keepalive_timeout")]
     pub keepalive_timeout: u64,
+    // TODO: Consider adding in future versions:
+    // pub max_stream_response_bytes: Option<usize>,  // Total bytes per streaming response
 }
 
 impl Default for GrpcConfig {
@@ -131,22 +193,24 @@ const fn default_keepalive_timeout() -> u64 {
 
 /// Registry for gRPC handlers
 ///
-/// Maps service names to their handlers. Used by the server to route
-/// incoming gRPC requests to the appropriate handler.
+/// Maps service names to their handlers and RPC modes. Used by the server to route
+/// incoming gRPC requests to the appropriate handler method based on RPC mode.
 ///
 /// # Example
 ///
 /// ```ignore
-/// use spikard_http::grpc::GrpcRegistry;
+/// use spikard_http::grpc::{GrpcRegistry, RpcMode};
 /// use std::sync::Arc;
 ///
 /// let mut registry = GrpcRegistry::new();
-/// registry.register("mypackage.UserService", Arc::new(user_handler));
-/// registry.register("mypackage.PostService", Arc::new(post_handler));
+/// registry.register("mypackage.UserService", Arc::new(user_handler), RpcMode::Unary);
+/// registry.register("mypackage.StreamService", Arc::new(stream_handler), RpcMode::ServerStreaming);
 /// ```
+type GrpcHandlerEntry = (Arc<dyn GrpcHandler>, RpcMode);
+
 #[derive(Clone)]
 pub struct GrpcRegistry {
-    handlers: Arc<HashMap<String, Arc<dyn GrpcHandler>>>,
+    handlers: Arc<HashMap<String, GrpcHandlerEntry>>,
 }
 
 impl GrpcRegistry {
@@ -163,13 +227,17 @@ impl GrpcRegistry {
     ///
     /// * `service_name` - Fully qualified service name (e.g., "mypackage.MyService")
     /// * `handler` - Handler implementation for this service
-    pub fn register(&mut self, service_name: impl Into<String>, handler: Arc<dyn GrpcHandler>) {
+    /// * `rpc_mode` - The RPC mode this handler supports (Unary, ServerStreaming, etc.)
+    pub fn register(&mut self, service_name: impl Into<String>, handler: Arc<dyn GrpcHandler>, rpc_mode: RpcMode) {
         let handlers = Arc::make_mut(&mut self.handlers);
-        handlers.insert(service_name.into(), handler);
+        handlers.insert(service_name.into(), (handler, rpc_mode));
     }
 
-    /// Get a handler by service name
-    pub fn get(&self, service_name: &str) -> Option<Arc<dyn GrpcHandler>> {
+    /// Get a handler and its RPC mode by service name
+    ///
+    /// Returns both the handler and the RPC mode it was registered with,
+    /// allowing the router to dispatch to the appropriate handler method.
+    pub fn get(&self, service_name: &str) -> Option<(Arc<dyn GrpcHandler>, RpcMode)> {
         self.handlers.get(service_name).cloned()
     }
 
@@ -262,7 +330,7 @@ mod tests {
         let mut registry = GrpcRegistry::new();
         let handler = Arc::new(TestHandler);
 
-        registry.register("test.Service", handler);
+        registry.register("test.Service", handler, RpcMode::Unary);
 
         assert!(!registry.is_empty());
         assert_eq!(registry.len(), 1);
@@ -274,11 +342,13 @@ mod tests {
         let mut registry = GrpcRegistry::new();
         let handler = Arc::new(TestHandler);
 
-        registry.register("test.Service", handler);
+        registry.register("test.Service", handler, RpcMode::Unary);
 
         let retrieved = registry.get("test.Service");
         assert!(retrieved.is_some());
-        assert_eq!(retrieved.unwrap().service_name(), "test.Service");
+        let (handler, rpc_mode) = retrieved.unwrap();
+        assert_eq!(handler.service_name(), "test.Service");
+        assert_eq!(rpc_mode, RpcMode::Unary);
     }
 
     #[test]
@@ -292,9 +362,9 @@ mod tests {
     fn test_grpc_registry_service_names() {
         let mut registry = GrpcRegistry::new();
 
-        registry.register("service1", Arc::new(TestHandler));
-        registry.register("service2", Arc::new(TestHandler));
-        registry.register("service3", Arc::new(TestHandler));
+        registry.register("service1", Arc::new(TestHandler), RpcMode::Unary);
+        registry.register("service2", Arc::new(TestHandler), RpcMode::ServerStreaming);
+        registry.register("service3", Arc::new(TestHandler), RpcMode::Unary);
 
         let mut names = registry.service_names();
         names.sort();
@@ -305,7 +375,7 @@ mod tests {
     #[test]
     fn test_grpc_registry_contains() {
         let mut registry = GrpcRegistry::new();
-        registry.register("test.Service", Arc::new(TestHandler));
+        registry.register("test.Service", Arc::new(TestHandler), RpcMode::Unary);
 
         assert!(registry.contains("test.Service"));
         assert!(!registry.contains("other.Service"));
@@ -315,8 +385,8 @@ mod tests {
     fn test_grpc_registry_multiple_services() {
         let mut registry = GrpcRegistry::new();
 
-        registry.register("user.Service", Arc::new(TestHandler));
-        registry.register("post.Service", Arc::new(TestHandler));
+        registry.register("user.Service", Arc::new(TestHandler), RpcMode::Unary);
+        registry.register("post.Service", Arc::new(TestHandler), RpcMode::ServerStreaming);
 
         assert_eq!(registry.len(), 2);
         assert!(registry.contains("user.Service"));
@@ -326,7 +396,7 @@ mod tests {
     #[test]
     fn test_grpc_registry_clone() {
         let mut registry = GrpcRegistry::new();
-        registry.register("test.Service", Arc::new(TestHandler));
+        registry.register("test.Service", Arc::new(TestHandler), RpcMode::Unary);
 
         let cloned = registry.clone();
 
@@ -339,4 +409,26 @@ mod tests {
         let registry = GrpcRegistry::default();
         assert!(registry.is_empty());
     }
+
+    #[test]
+    fn test_grpc_registry_rpc_mode_storage() {
+        let mut registry = GrpcRegistry::new();
+
+        registry.register("unary.Service", Arc::new(TestHandler), RpcMode::Unary);
+        registry.register("server_stream.Service", Arc::new(TestHandler), RpcMode::ServerStreaming);
+        registry.register("client_stream.Service", Arc::new(TestHandler), RpcMode::ClientStreaming);
+        registry.register("bidi.Service", Arc::new(TestHandler), RpcMode::BidirectionalStreaming);
+
+        let (_, mode) = registry.get("unary.Service").unwrap();
+        assert_eq!(mode, RpcMode::Unary);
+
+        let (_, mode) = registry.get("server_stream.Service").unwrap();
+        assert_eq!(mode, RpcMode::ServerStreaming);
+
+        let (_, mode) = registry.get("client_stream.Service").unwrap();
+        assert_eq!(mode, RpcMode::ClientStreaming);
+
+        let (_, mode) = registry.get("bidi.Service").unwrap();
+        assert_eq!(mode, RpcMode::BidirectionalStreaming);
+    }
 }

data/vendor/crates/spikard-http/src/grpc/service.rs

@@ -5,7 +5,9 @@
 //! enabling language-agnostic gRPC handling.
 
 use crate::grpc::handler::{GrpcHandler, GrpcHandlerResult, GrpcRequestData, GrpcResponseData};
+use crate::grpc::streaming::MessageStream;
 use bytes::Bytes;
+use futures_util::StreamExt;
 use std::sync::Arc;
 use tonic::{Request, Response, Status};
 
@@ -75,6 +77,234 @@ impl GenericGrpcService {
         }
     }
 
+    /// Handle a server streaming RPC call
+    ///
+    /// Takes a single request and returns a stream of response messages.
+    /// Converts the Tonic Request into our GrpcRequestData format, calls the
+    /// handler's call_server_stream method, and converts the MessageStream
+    /// into a Tonic streaming response body.
+    ///
+    /// # Arguments
+    ///
+    /// * `service_name` - Fully qualified service name
+    /// * `method_name` - Method name
+    /// * `request` - Tonic request containing the serialized protobuf message
+    ///
+    /// # Returns
+    ///
+    /// A Response with a streaming body containing the message stream
+    ///
+    /// # Error Propagation Limitations
+    ///
+    /// When a stream returns an error mid-stream (after messages have begun
+    /// being sent), the error may not be perfectly transmitted to the client
+    /// as a gRPC trailer. This is due to limitations in Axum's `Body::from_stream`:
+    ///
+    /// - **Pre-stream errors** (before any messages): Properly converted to
+    ///   HTTP status codes and returned to the client
+    /// - **Mid-stream errors** (after messages have begun): The error is converted
+    ///   to a generic `BoxError`, and the stream terminates. The connection is
+    ///   properly closed, but the gRPC status code metadata is lost.
+    ///
+    /// For robust error handling in streaming RPCs:
+    /// - Prefer detecting errors early (before sending messages) when possible
+    /// - Include error information in the message stream itself if critical
+    ///   (application-level error messages in the protobuf)
+    /// - For true gRPC trailer support, consider implementing a custom Axum
+    ///   body type that wraps the stream and can inject trailers on error
+    ///
+    /// See: <https://github.com/tokio-rs/axum/discussions/2043>
+    pub async fn handle_server_stream(
+        &self,
+        service_name: String,
+        method_name: String,
+        request: Request<Bytes>,
+    ) -> Result<Response<axum::body::Body>, Status> {
+        // Extract metadata and payload from Tonic request
+        let (metadata, _extensions, payload) = request.into_parts();
+
+        // Create our internal request representation
+        let grpc_request = GrpcRequestData {
+            service_name,
+            method_name,
+            payload,
+            metadata,
+        };
+
+        // Call the handler's server streaming method
+        let message_stream: MessageStream = self.handler.call_server_stream(grpc_request).await?;
+
+        // Convert MessageStream to axum Body
+        //
+        // LIMITATION: When converting tonic::Status errors from the stream,
+        // we lose the gRPC status metadata. The Status is converted to a
+        // generic Box<dyn Error>, and Axum's Body::from_stream doesn't have
+        // special handling for gRPC error semantics.
+        //
+        // Current behavior:
+        // - Stream errors are converted to BoxError
+        // - Body stream terminates on the first error
+        // - Connection is properly closed
+        // - Error metadata (status code, message) is not transmitted to client
+        //
+        // TODO: Implement custom Body wrapper that can:
+        // 1. Capture tonic::Status errors
+        // 2. Extract status code and message
+        // 3. Inject gRPC trailers (grpc-status, grpc-message) when stream ends
+        // 4. Properly signal error to client while preserving partial messages
+        //
+        // This would require implementing a custom StreamBody or similar that
+        // understands gRPC error semantics.
+        let byte_stream =
+            message_stream.map(|result| result.map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>));
+
+        let body = axum::body::Body::from_stream(byte_stream);
+
+        // Create response with streaming body
+        let response = Response::new(body);
+
+        Ok(response)
+    }
+
+    /// Handle a client streaming RPC call
+    ///
+    /// Takes a request body stream of protobuf messages and returns a single response.
+    /// Parses the HTTP/2 body stream using gRPC frame parser, creates a MessageStream,
+    /// calls the handler's call_client_stream method, and converts the GrpcResponseData
+    /// back to a Tonic Response.
+    ///
+    /// # Arguments
+    ///
+    /// * `service_name` - Fully qualified service name
+    /// * `method_name` - Method name
+    /// * `request` - Axum request with streaming body containing HTTP/2 framed protobuf messages
+    /// * `max_message_size` - Maximum size per message (bytes)
+    ///
+    /// # Returns
+    ///
+    /// A Response with a single message body
+    ///
+    /// # Stream Handling
+    ///
+    /// The request body stream contains framed protobuf messages. Each frame is parsed
+    /// and validated for size:
+    /// - Messages within `max_message_size` are passed to the handler
+    /// - Messages exceeding the limit result in a ResourceExhausted error
+    /// - Invalid frames result in InvalidArgument errors
+    /// - The stream terminates when the client closes the write side
+    ///
+    /// # Frame Format
+    ///
+    /// Frames follow the gRPC HTTP/2 protocol format:
+    /// - 1 byte: compression flag (0 = uncompressed)
+    /// - 4 bytes: message size (big-endian)
+    /// - N bytes: message payload
+    ///
+    /// # Metadata and Trailers
+    ///
+    /// - Request metadata (headers) from the Tonic request is passed to the handler
+    /// - Response metadata from the handler is included in the response headers
+    /// - gRPC trailers (like grpc-status) should be handled by the caller
+    pub async fn handle_client_stream(
+        &self,
+        service_name: String,
+        method_name: String,
+        request: Request<axum::body::Body>,
+        max_message_size: usize,
+    ) -> Result<Response<Bytes>, Status> {
+        // Extract metadata and body from Tonic request
+        let (metadata, _extensions, body) = request.into_parts();
+
+        // Parse HTTP/2 body into stream of gRPC frames with size validation
+        let message_stream = crate::grpc::framing::parse_grpc_client_stream(body, max_message_size).await?;
+
+        // Create our internal streaming request representation
+        let streaming_request = crate::grpc::streaming::StreamingRequest {
+            service_name,
+            method_name,
+            message_stream,
+            metadata,
+        };
+
+        // Call the handler's client streaming method
+        let response: crate::grpc::handler::GrpcHandlerResult =
+            self.handler.call_client_stream(streaming_request).await;
+
+        // Convert result to Tonic response
+        match response {
+            Ok(grpc_response) => {
+                let mut tonic_response = Response::new(grpc_response.payload);
+                copy_metadata(&grpc_response.metadata, tonic_response.metadata_mut());
+                Ok(tonic_response)
+            }
+            Err(status) => Err(status),
+        }
+    }
+
+    /// Handle a bidirectional streaming RPC call
+    ///
+    /// Takes a request body stream and returns a stream of response messages.
+    /// Parses the HTTP/2 body stream using gRPC frame parser, creates a StreamingRequest,
+    /// calls the handler's call_bidi_stream method, and converts the MessageStream
+    /// back to an Axum streaming response body.
+    ///
+    /// # Arguments
+    ///
+    /// * `service_name` - Fully qualified service name
+    /// * `method_name` - Method name
+    /// * `request` - Axum request with streaming body containing HTTP/2 framed protobuf messages
+    /// * `max_message_size` - Maximum size per message (bytes)
+    ///
+    /// # Returns
+    ///
+    /// A Response with a streaming body containing response messages
+    ///
+    /// # Stream Handling
+    ///
+    /// - Request stream: Parsed from HTTP/2 body using frame parser
+    /// - Response stream: Converted from MessageStream to Axum Body
+    /// - Both streams are independent (full-duplex)
+    /// - Errors in either stream are propagated appropriately
+    ///
+    /// # Error Propagation
+    ///
+    /// Similar to server streaming, mid-stream errors in the response may not be
+    /// perfectly transmitted as gRPC trailers due to Axum Body::from_stream limitations.
+    /// See handle_server_stream() documentation for details.
+    pub async fn handle_bidi_stream(
+        &self,
+        service_name: String,
+        method_name: String,
+        request: Request<axum::body::Body>,
+        max_message_size: usize,
+    ) -> Result<Response<axum::body::Body>, Status> {
+        // Extract metadata and body from Tonic request
+        let (metadata, _extensions, body) = request.into_parts();
+
+        // Parse HTTP/2 body into stream of gRPC frames with size validation
+        let message_stream = crate::grpc::framing::parse_grpc_client_stream(body, max_message_size).await?;
+
+        // Create our internal streaming request representation
+        let streaming_request = crate::grpc::streaming::StreamingRequest {
+            service_name,
+            method_name,
+            message_stream,
+            metadata,
+        };
+
+        // Call the handler's bidirectional streaming method
+        let response_stream: MessageStream = self.handler.call_bidi_stream(streaming_request).await?;
+
+        // Convert MessageStream to axum Body (same as server streaming)
+        let byte_stream =
+            response_stream.map(|result| result.map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>));
+
+        let body = axum::body::Body::from_stream(byte_stream);
+        let response = Response::new(body);
+
+        Ok(response)
+    }
+
     /// Get the service name from the handler
     pub fn service_name(&self) -> &str {
         self.handler.service_name()
@@ -189,7 +419,7 @@ mod tests {
             })
         }
 
-        fn service_name(&self) -> &'static str {
+        fn service_name(&self) -> &str {
             "test.TestService"
         }
     }
@@ -371,7 +601,7 @@ mod tests {
                 Box::pin(async { Err(Status::not_found("Resource not found")) })
             }
 
-            fn service_name(&self) -> &'static str {
+            fn service_name(&self) -> &str {
                 "test.ErrorService"
             }
         }

data/vendor/crates/spikard-http/src/grpc/streaming.rs

@@ -16,6 +16,53 @@ use tonic::Status;
 /// Each item in the stream is either:
 /// - Ok(Bytes): A serialized protobuf message
 /// - Err(Status): A gRPC error
+///
+/// # Backpressure Considerations
+///
+/// Streaming responses should implement backpressure handling to avoid memory buildup with slow clients:
+///
+/// - **Problem**: If a client reads slowly but the handler produces messages quickly, messages will
+///   queue in memory, potentially causing high memory usage or OOM errors.
+/// - **Solution**: The gRPC layer (Tonic) handles backpressure automatically via the underlying TCP/HTTP/2
+///   connection. However, handlers should be aware of this behavior.
+/// - **Best Practice**: For long-running or high-volume streams, implement rate limiting or flow control
+///   in the handler to avoid overwhelming the network buffer.
+///
+/// # Example: Rate-limited streaming
+///
+/// ```ignore
+/// use spikard_http::grpc::streaming::MessageStream;
+/// use bytes::Bytes;
+/// use std::pin::Pin;
+/// use std::time::Duration;
+/// use tokio::time::sleep;
+/// use futures_util::stream::{self, StreamExt};
+///
+/// // Handler that sends 1000 messages with rate limiting
+/// fn create_rate_limited_stream() -> MessageStream {
+///     let messages = (0..1000).map(|i| {
+///         Ok(Bytes::from(format!("message_{}", i)))
+///     });
+///
+///     // Stream with delay between messages to avoid overwhelming the client
+///     let stream = stream::iter(messages)
+///         .then(|msg| async {
+///             sleep(Duration::from_millis(1)).await;  // 1ms between messages
+///             msg
+///         });
+///
+///     Box::pin(stream)
+/// }
+/// ```
+///
+/// # Memory Management
+///
+/// Keep the following in mind when implementing large streams:
+///
+/// - Messages are buffered in the gRPC transport layer's internal queue
+/// - Slow clients will cause the queue to grow, increasing memory usage
+/// - Very large individual messages may cause buffer allocation spikes
+/// - Consider implementing stream chunking for very large responses (split one large message into many small ones)
 pub type MessageStream = Pin<Box<dyn Stream<Item = Result<Bytes, Status>> + Send>>;
 
 /// Request for client streaming RPC
@@ -34,12 +81,18 @@ pub struct StreamingRequest {
 
 /// Response for server streaming RPC
 ///
-/// Contains metadata and a stream of outgoing messages to the client.
+/// Contains metadata, a stream of outgoing messages, and optional trailers.
+/// Trailers are metadata sent after the stream completes (after all messages).
 pub struct StreamingResponse {
     /// Stream of outgoing protobuf messages
     pub message_stream: MessageStream,
-    /// Response metadata
+    /// Response metadata (sent before messages)
     pub metadata: tonic::metadata::MetadataMap,
+    /// Optional trailers (sent after stream completes)
+    ///
+    /// Trailers are useful for sending status information or metrics
+    /// after all messages have been sent.
+    pub trailers: Option<tonic::metadata::MetadataMap>,
 }
 
 /// Helper to create a message stream from a vector of bytes
@@ -234,8 +287,33 @@ mod tests {
         let response = StreamingResponse {
             message_stream: stream,
             metadata: tonic::metadata::MetadataMap::new(),
+            trailers: None,
+        };
+
+        assert!(response.metadata.is_empty());
+        assert!(response.trailers.is_none());
+    }
+
+    #[test]
+    fn test_streaming_response_with_trailers() {
+        let stream = empty_message_stream();
+        let mut trailers = tonic::metadata::MetadataMap::new();
+        trailers.insert(
+            "x-request-id",
+            "test-123"
+                .parse::<tonic::metadata::MetadataValue<tonic::metadata::Ascii>>()
+                .unwrap(),
+        );
+
+        let response = StreamingResponse {
+            message_stream: stream,
+            metadata: tonic::metadata::MetadataMap::new(),
+            trailers: Some(trailers),
         };
 
         assert!(response.metadata.is_empty());
+        assert!(response.trailers.is_some());
+        let trailers = response.trailers.unwrap();
+        assert_eq!(trailers.len(), 1);
     }
 }