spikard 0.8.1 → 0.8.2

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

@@ -17,20 +17,20 @@ mod common;
 /// Test successful unary RPC with JSON payload
 #[tokio::test]
 async fn test_unary_rpc_success_with_json_payload() {
-    // Arrange: Create test server and handler
-    let mut server = GrpcTestServer::new();
-
     // Create a custom handler with proper service name
     struct UserServiceHandler;
     impl spikard_http::grpc::GrpcHandler for UserServiceHandler {
-        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 payload = serde_json::to_vec(&json!({
                 "id": 123,
                 "name": "Alice Johnson",
                 "email": "alice@example.com"
-            })).unwrap();
+            }))
+            .unwrap();
             Box::pin(async {
                 Ok(spikard_http::grpc::GrpcResponseData {
                     payload: Bytes::from(payload),
@@ -43,14 +43,14 @@ async fn test_unary_rpc_success_with_json_payload() {
         }
     }
 
+    // Arrange: Create test server and handler
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(UserServiceHandler));
 
     // Act: Create and send request
     let mut request_builder = ProtobufMessageBuilder::new();
-    let request_payload = request_builder
-        .add_int_field("user_id", 123)
-        .build()
-        .unwrap();
+    let request_payload = request_builder.add_int_field("user_id", 123).build().unwrap();
 
     let response = send_unary_request(
         &server,
@@ -63,23 +63,25 @@ async fn test_unary_rpc_success_with_json_payload() {
     .expect("Failed to send unary request");
 
     // Assert
-    assert_grpc_response(response, json!({
-        "id": 123,
-        "name": "Alice Johnson",
-        "email": "alice@example.com"
-    }));
+    assert_grpc_response(
+        &response,
+        &json!({
+            "id": 123,
+            "name": "Alice Johnson",
+            "email": "alice@example.com"
+        }),
+    );
 }
 
 /// Test server routing with multiple services
 #[tokio::test]
 async fn test_server_routes_to_correct_service() {
-    // Arrange: Register multiple services
-    let mut server = GrpcTestServer::new();
-
     struct UserServiceHandler;
     impl spikard_http::grpc::GrpcHandler for UserServiceHandler {
-        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>>
         {
             Box::pin(async {
                 Ok(spikard_http::grpc::GrpcResponseData {
@@ -95,8 +97,10 @@ async fn test_server_routes_to_correct_service() {
 
     struct OrderServiceHandler;
     impl spikard_http::grpc::GrpcHandler for OrderServiceHandler {
-        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>>
         {
             Box::pin(async {
                 Ok(spikard_http::grpc::GrpcResponseData {
@@ -110,6 +114,9 @@ async fn test_server_routes_to_correct_service() {
         }
     }
 
+    // Arrange: Register multiple services
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(UserServiceHandler));
     server.register_service(Arc::new(OrderServiceHandler));
 
@@ -124,7 +131,7 @@ async fn test_server_routes_to_correct_service() {
     .await
     .expect("UserService request failed");
 
-    assert_grpc_response(user_response, json!({"service": "UserService"}));
+    assert_grpc_response(&user_response, &json!({"service": "UserService"}));
 
     // Act & Assert: Route to OrderService
     let order_response = send_unary_request(
@@ -137,28 +144,28 @@ async fn test_server_routes_to_correct_service() {
     .await
     .expect("OrderService request failed");
 
-    assert_grpc_response(order_response, json!({"service": "OrderService"}));
+    assert_grpc_response(&order_response, &json!({"service": "OrderService"}));
 }
 
 /// Test server correctly counts registered services
 #[tokio::test]
 async fn test_server_service_registration_count() {
-    let mut server = GrpcTestServer::new();
+    let server = GrpcTestServer::new();
 
     assert_eq!(server.service_count(), 0);
 
     // Register first service
-    let handler1 = Arc::new(MockGrpcHandler::with_json("service.One", json!({"id": 1})));
+    let handler1 = Arc::new(MockGrpcHandler::with_json("service.One", &json!({"id": 1})));
     server.register_service(handler1);
     assert_eq!(server.service_count(), 1);
 
     // Register second service
-    let handler2 = Arc::new(MockGrpcHandler::with_json("service.Two", json!({"id": 2})));
+    let handler2 = Arc::new(MockGrpcHandler::with_json("service.Two", &json!({"id": 2})));
     server.register_service(handler2);
     assert_eq!(server.service_count(), 2);
 
     // Register third service
-    let handler3 = Arc::new(MockGrpcHandler::with_json("service.Three", json!({"id": 3})));
+    let handler3 = Arc::new(MockGrpcHandler::with_json("service.Three", &json!({"id": 3})));
     server.register_service(handler3);
     assert_eq!(server.service_count(), 3);
 }
@@ -166,16 +173,17 @@ async fn test_server_service_registration_count() {
 /// Test unary RPC with complex nested JSON payload
 #[tokio::test]
 async fn test_unary_rpc_with_nested_json_payload() {
-    let mut server = GrpcTestServer::new();
-
     struct ProductServiceHandler;
     impl spikard_http::grpc::GrpcHandler for ProductServiceHandler {
-        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>>
         {
             Box::pin(async {
                 Ok(spikard_http::grpc::GrpcResponseData {
-                    payload: Bytes::from(r#"{
+                    payload: Bytes::from(
+                        r#"{
                         "id": 42,
                         "name": "Laptop",
                         "price": 999.99,
@@ -184,7 +192,8 @@ async fn test_unary_rpc_with_nested_json_payload() {
                             "warehouse": "US-WEST"
                         },
                         "tags": ["electronics", "computers", "portable"]
-                    }"#),
+                    }"#,
+                    ),
                     metadata: tonic::metadata::MetadataMap::new(),
                 })
             })
@@ -194,6 +203,8 @@ async fn test_unary_rpc_with_nested_json_payload() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(ProductServiceHandler));
 
     let response = send_unary_request(
@@ -219,12 +230,12 @@ async fn test_unary_rpc_with_nested_json_payload() {
 /// Test unary RPC with binary payload (raw bytes)
 #[tokio::test]
 async fn test_unary_rpc_with_binary_payload() {
-    let mut server = GrpcTestServer::new();
-
     struct EchoServiceHandler;
     impl spikard_http::grpc::GrpcHandler for EchoServiceHandler {
-        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 payload = request.payload;
             Box::pin(async {
@@ -239,6 +250,8 @@ async fn test_unary_rpc_with_binary_payload() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(EchoServiceHandler));
 
     // Send binary payload
@@ -260,12 +273,12 @@ async fn test_unary_rpc_with_binary_payload() {
 /// Test request with custom metadata is preserved in response
 #[tokio::test]
 async fn test_request_metadata_handling() {
-    let mut server = GrpcTestServer::new();
-
     struct MetadataAwareHandler;
     impl spikard_http::grpc::GrpcHandler for MetadataAwareHandler {
-        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>>
         {
             // Check that metadata was received
             let has_custom_header = request.metadata.get("x-custom-header").is_some();
@@ -287,6 +300,8 @@ async fn test_request_metadata_handling() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(MetadataAwareHandler));
 
     let mut metadata = create_test_metadata();
@@ -302,13 +317,13 @@ async fn test_request_metadata_handling() {
     .await
     .expect("Failed to send request with metadata");
 
-    assert_grpc_response(response, json!({"status": "metadata_received"}));
+    assert_grpc_response(&response, &json!({"status": "metadata_received"}));
 }
 
-/// Test error response with NOT_FOUND status
+/// Test error response with `NOT_FOUND` status
 #[tokio::test]
 async fn test_error_response_not_found() {
-    let mut server = GrpcTestServer::new();
+    let server = GrpcTestServer::new();
 
     let handler = Arc::new(ErrorMockHandler::new(
         "api.NotFoundService",
@@ -329,10 +344,10 @@ async fn test_error_response_not_found() {
     assert!(result.is_err());
 }
 
-/// Test error response with INVALID_ARGUMENT status
+/// Test error response with `INVALID_ARGUMENT` status
 #[tokio::test]
 async fn test_error_response_invalid_argument() {
-    let mut server = GrpcTestServer::new();
+    let server = GrpcTestServer::new();
 
     let handler = Arc::new(ErrorMockHandler::new(
         "api.ValidationService",
@@ -356,7 +371,7 @@ async fn test_error_response_invalid_argument() {
 /// Test error response with INTERNAL status
 #[tokio::test]
 async fn test_error_response_internal_server_error() {
-    let mut server = GrpcTestServer::new();
+    let server = GrpcTestServer::new();
 
     let handler = Arc::new(ErrorMockHandler::new(
         "api.DatabaseService",
@@ -401,12 +416,12 @@ async fn test_server_no_services_registered() {
 /// Test unary RPC with empty request payload
 #[tokio::test]
 async fn test_unary_rpc_empty_request_payload() {
-    let mut server = GrpcTestServer::new();
-
     struct EmptyRequestHandler;
     impl spikard_http::grpc::GrpcHandler for EmptyRequestHandler {
-        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>>
         {
             Box::pin(async {
                 Ok(spikard_http::grpc::GrpcResponseData {
@@ -420,6 +435,8 @@ async fn test_unary_rpc_empty_request_payload() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(EmptyRequestHandler));
 
     let response = send_unary_request(
@@ -432,18 +449,18 @@ async fn test_unary_rpc_empty_request_payload() {
     .await
     .expect("Failed to send empty request");
 
-    assert_grpc_response(response, json!({"status": "ok"}));
+    assert_grpc_response(&response, &json!({"status": "ok"}));
 }
 
 /// Test echo handler preserves exact request payload
 #[tokio::test]
 async fn test_echo_handler_payload_preservation() {
-    let mut server = GrpcTestServer::new();
-
     struct TestEchoHandler;
     impl spikard_http::grpc::GrpcHandler for TestEchoHandler {
-        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 payload = request.payload;
             Box::pin(async move {
@@ -458,6 +475,8 @@ async fn test_echo_handler_payload_preservation() {
         }
     }
 
+    let server = GrpcTestServer::new();
+
     server.register_service(Arc::new(TestEchoHandler));
 
     let request_payload = Bytes::from(r#"{"echo": "test message"}"#);

data/vendor/crates/spikard-rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-rb"
-version = "0.8.1"
+version = "0.8.2"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"

data/vendor/crates/spikard-rb/src/grpc/handler.rs

@@ -101,9 +101,8 @@ impl RubyGrpcResponse {
             return Err(Error::new(magnus::exception::arg_error(), "wrong number of arguments"));
         };
 
-        let payload_str = RString::try_convert(payload_value).map_err(|_| {
-            Error::new(magnus::exception::arg_error(), "payload must be a String (binary)")
-        })?;
+        let payload_str = RString::try_convert(payload_value)
+            .map_err(|_| Error::new(magnus::exception::arg_error(), "payload must be a String (binary)"))?;
 
         let payload_bytes = unsafe { payload_str.as_slice() }.to_vec();
 
@@ -203,32 +202,26 @@ impl RubyGrpcHandler {
     }
 
     fn handle_request_inner(&self, request: GrpcRequestData) -> GrpcHandlerResult {
-        let ruby = Ruby::get().map_err(|_| {
-            tonic::Status::internal("Ruby VM unavailable while invoking gRPC handler")
-        })?;
+        let ruby =
+            Ruby::get().map_err(|_| tonic::Status::internal("Ruby VM unavailable while invoking gRPC handler"))?;
 
         // Convert request to Ruby object
         let ruby_request = RubyGrpcRequest::from_grpc_request(request);
-        let request_value = ruby
-            .obj_wrap(ruby_request)
-            .as_value();
+        let request_value = ruby.obj_wrap(ruby_request).as_value();
 
         // Call Ruby handler
         let handler_value = self.inner.handler.get_inner_with(&ruby);
         let response_value = handler_value
             .funcall::<_, _, Value>("handle_request", (request_value,))
-            .map_err(|err| {
-                tonic::Status::internal(format!("Ruby gRPC handler failed: {}", err))
-            })?;
+            .map_err(|err| tonic::Status::internal(format!("Ruby gRPC handler failed: {}", err)))?;
 
         // Convert Ruby response to GrpcResponseData
-        let ruby_response = <&RubyGrpcResponse>::try_convert(response_value)
-            .map_err(|err| {
-                tonic::Status::internal(format!(
-                    "Handler must return Spikard::Grpc::Response, got error: {}",
-                    err
-                ))
-            })?;
+        let ruby_response = <&RubyGrpcResponse>::try_convert(response_value).map_err(|err| {
+            tonic::Status::internal(format!(
+                "Handler must return Spikard::Grpc::Response, got error: {}",
+                err
+            ))
+        })?;
 
         ruby_response
             .clone()
@@ -299,12 +292,24 @@ mod tests {
         use spikard_bindings_shared::grpc_metadata::extract_metadata_to_hashmap;
 
         let mut metadata = MetadataMap::new();
-        metadata.insert("content-type", "application/grpc".parse().unwrap());
-        metadata.insert("authorization", "Bearer token123".parse().unwrap());
+        metadata.insert(
+            "content-type",
+            "application/grpc".parse().expect("Valid metadata value"),
+        );
+        metadata.insert(
+            "authorization",
+            "Bearer token123".parse().expect("Valid metadata value"),
+        );
 
         let extracted = extract_metadata_to_hashmap(&metadata, false);
-        assert_eq!(extracted.get("content-type").unwrap(), "application/grpc");
-        assert_eq!(extracted.get("authorization").unwrap(), "Bearer token123");
+        assert_eq!(
+            extracted.get("content-type").expect("content-type header"),
+            "application/grpc"
+        );
+        assert_eq!(
+            extracted.get("authorization").expect("authorization header"),
+            "Bearer token123"
+        );
     }
 
     #[test]
@@ -316,7 +321,7 @@ mod tests {
 
         let grpc_response = response.into_grpc_response();
         assert!(grpc_response.is_ok());
-        let grpc_response = grpc_response.unwrap();
+        let grpc_response = grpc_response.expect("Valid grpc response");
         assert_eq!(grpc_response.payload, Bytes::from("test response"));
     }
 
@@ -332,7 +337,7 @@ mod tests {
 
         let grpc_response = response.into_grpc_response();
         assert!(grpc_response.is_ok());
-        let grpc_response = grpc_response.unwrap();
+        let grpc_response = grpc_response.expect("Valid grpc response");
         assert!(!grpc_response.metadata.is_empty());
     }
 

data/vendor/crates/spikard-rb/src/lib.rs

@@ -880,8 +880,7 @@ impl RubyHandler {
 
     fn handle(&self, request_data: RequestData) -> HandlerResult {
         with_gvl(|| {
-            let result =
-                std::panic::catch_unwind(AssertUnwindSafe(|| self.handle_inner(request_data)));
+            let result = std::panic::catch_unwind(AssertUnwindSafe(|| self.handle_inner(request_data)));
             match result {
                 Ok(res) => res,
                 Err(_) => Err((

data/vendor/crates/spikard-rb-macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-rb-macros"
-version = "0.8.1"
+version = "0.8.2"
 edition = "2024"
 license = "MIT"
 publish = false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spikard
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors:
 - Na'aman Hirschfeld