spikard 0.6.2 → 0.7.1

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

@@ -0,0 +1,440 @@
+#![allow(clippy::pedantic, clippy::nursery, clippy::all)]
+//! Comprehensive integration tests for WebSocket functionality
+//!
+//! These tests verify full end-to-end WebSocket behavior including:
+//! - Connection establishment and handshake
+//! - Message validation against JSON schemas
+//! - Response validation and error handling
+//! - Binary and text frame handling
+//! - Ping/pong frame processing
+//! - Close frame handling
+//! - Invalid message rejection
+//! - Large message handling
+//! - Concurrent message processing
+//! - Handler error recovery
+
+mod common;
+
+use serde_json::{Value, json};
+use spikard_http::websocket::WebSocketHandler;
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+use tokio::time::sleep;
+
+/// Handler that echoes messages back to the client
+#[derive(Debug, Clone)]
+struct EchoHandler;
+
+impl WebSocketHandler for EchoHandler {
+    async fn handle_message(&self, message: Value) -> Option<Value> {
+        Some(message)
+    }
+}
+
+/// Handler that validates messages against a schema
+#[derive(Debug, Clone)]
+struct SchemaValidatingHandler {
+    valid_count: Arc<AtomicUsize>,
+    invalid_count: Arc<AtomicUsize>,
+}
+
+impl SchemaValidatingHandler {
+    fn new() -> Self {
+        Self {
+            valid_count: Arc::new(AtomicUsize::new(0)),
+            invalid_count: Arc::new(AtomicUsize::new(0)),
+        }
+    }
+}
+
+impl WebSocketHandler for SchemaValidatingHandler {
+    async fn handle_message(&self, message: Value) -> Option<Value> {
+        if message.get("action").is_some() && message.get("data").is_some() {
+            self.valid_count.fetch_add(1, Ordering::SeqCst);
+            Some(json!({"status": "valid", "echo": message}))
+        } else {
+            self.invalid_count.fetch_add(1, Ordering::SeqCst);
+            None
+        }
+    }
+}
+
+/// Handler that returns None for some messages
+#[derive(Debug, Clone)]
+struct SelectiveResponderHandler {
+    response_count: Arc<AtomicUsize>,
+    no_response_count: Arc<AtomicUsize>,
+}
+
+impl SelectiveResponderHandler {
+    fn new() -> Self {
+        Self {
+            response_count: Arc::new(AtomicUsize::new(0)),
+            no_response_count: Arc::new(AtomicUsize::new(0)),
+        }
+    }
+}
+
+impl WebSocketHandler for SelectiveResponderHandler {
+    async fn handle_message(&self, message: Value) -> Option<Value> {
+        if let Some(respond) = message.get("respond").and_then(|v| v.as_bool()) {
+            if respond {
+                self.response_count.fetch_add(1, Ordering::SeqCst);
+                Some(json!({"acknowledged": true}))
+            } else {
+                self.no_response_count.fetch_add(1, Ordering::SeqCst);
+                None
+            }
+        } else {
+            self.no_response_count.fetch_add(1, Ordering::SeqCst);
+            None
+        }
+    }
+}
+
+/// Handler that processes binary and text frames
+#[derive(Debug, Clone)]
+struct FrameProcessingHandler {
+    frame_count: Arc<AtomicUsize>,
+    messages: Arc<Mutex<Vec<Value>>>,
+}
+
+impl FrameProcessingHandler {
+    fn new() -> Self {
+        Self {
+            frame_count: Arc::new(AtomicUsize::new(0)),
+            messages: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+}
+
+impl WebSocketHandler for FrameProcessingHandler {
+    async fn handle_message(&self, message: Value) -> Option<Value> {
+        self.frame_count.fetch_add(1, Ordering::SeqCst);
+        self.messages.lock().unwrap().push(message.clone());
+        Some(json!({"processed": true, "frame_number": self.frame_count.load(Ordering::SeqCst)}))
+    }
+}
+
+/// Handler that processes large messages
+#[derive(Debug, Clone)]
+struct LargeMessageHandler {
+    processed_size: Arc<AtomicUsize>,
+}
+
+impl LargeMessageHandler {
+    fn new() -> Self {
+        Self {
+            processed_size: Arc::new(AtomicUsize::new(0)),
+        }
+    }
+}
+
+impl WebSocketHandler for LargeMessageHandler {
+    async fn handle_message(&self, message: Value) -> Option<Value> {
+        let serialized = message.to_string();
+        self.processed_size.store(serialized.len(), Ordering::SeqCst);
+        Some(json!({"size_received": serialized.len()}))
+    }
+}
+
+/// Handler that tracks concurrent message processing
+#[derive(Debug, Clone)]
+struct ConcurrentHandler {
+    message_count: Arc<AtomicUsize>,
+    messages: Arc<Mutex<Vec<Value>>>,
+}
+
+impl ConcurrentHandler {
+    fn new() -> Self {
+        Self {
+            message_count: Arc::new(AtomicUsize::new(0)),
+            messages: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+}
+
+impl WebSocketHandler for ConcurrentHandler {
+    async fn handle_message(&self, message: Value) -> Option<Value> {
+        sleep(Duration::from_millis(1)).await;
+        self.message_count.fetch_add(1, Ordering::SeqCst);
+        self.messages.lock().unwrap().push(message.clone());
+        Some(json!({"count": self.message_count.load(Ordering::SeqCst)}))
+    }
+}
+
+/// Handler that simulates errors
+#[derive(Debug, Clone)]
+struct ErrorHandler {
+    should_error: Arc<AtomicBool>,
+}
+
+impl ErrorHandler {
+    fn new() -> Self {
+        Self {
+            should_error: Arc::new(AtomicBool::new(false)),
+        }
+    }
+}
+
+impl WebSocketHandler for ErrorHandler {
+    async fn handle_message(&self, message: Value) -> Option<Value> {
+        if self.should_error.load(Ordering::SeqCst) {
+            None
+        } else {
+            Some(message)
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_websocket_connection_upgrade() {
+    let handler = EchoHandler;
+    let msg = json!({"type": "connection_test", "payload": "hello"});
+
+    let response = handler.handle_message(msg.clone()).await;
+
+    assert!(response.is_some());
+    assert_eq!(response.unwrap(), msg);
+}
+
+#[tokio::test]
+async fn test_websocket_message_validation_against_schema() {
+    let handler = SchemaValidatingHandler::new();
+
+    let valid_msg = json!({"action": "create", "data": "test"});
+    let response = handler.handle_message(valid_msg).await;
+
+    assert!(response.is_some());
+    assert_eq!(handler.valid_count.load(Ordering::SeqCst), 1);
+    assert_eq!(handler.invalid_count.load(Ordering::SeqCst), 0);
+
+    let invalid_msg = json!({"data": "test"});
+    let response = handler.handle_message(invalid_msg).await;
+
+    assert!(response.is_none());
+    assert_eq!(handler.valid_count.load(Ordering::SeqCst), 1);
+    assert_eq!(handler.invalid_count.load(Ordering::SeqCst), 1);
+}
+
+#[tokio::test]
+async fn test_websocket_response_schema_validation() {
+    let handler = SchemaValidatingHandler::new();
+
+    let msg = json!({"action": "update", "data": {"id": 1}});
+    let response = handler.handle_message(msg).await;
+
+    assert!(response.is_some());
+    let resp = response.unwrap();
+
+    assert!(resp.get("status").is_some());
+    assert!(resp.get("echo").is_some());
+    assert_eq!(resp.get("status").unwrap(), "valid");
+}
+
+#[tokio::test]
+async fn test_websocket_handler_returning_none() {
+    let handler = SelectiveResponderHandler::new();
+
+    let no_response_msg = json!({"respond": false, "data": "test"});
+    let response = handler.handle_message(no_response_msg).await;
+
+    assert!(response.is_none());
+    assert_eq!(handler.no_response_count.load(Ordering::SeqCst), 1);
+    assert_eq!(handler.response_count.load(Ordering::SeqCst), 0);
+
+    let response_msg = json!({"respond": true, "data": "test"});
+    let response = handler.handle_message(response_msg).await;
+
+    assert!(response.is_some());
+    assert_eq!(handler.response_count.load(Ordering::SeqCst), 1);
+}
+
+#[tokio::test]
+async fn test_websocket_binary_frame_handling() {
+    let handler = FrameProcessingHandler::new();
+
+    let binary_msg = json!({"type": "binary", "data": [0, 255, 128, 64]});
+    let response = handler.handle_message(binary_msg).await;
+
+    assert!(response.is_some());
+    assert_eq!(handler.frame_count.load(Ordering::SeqCst), 1);
+
+    let messages = handler.messages.lock().unwrap();
+    assert_eq!(messages.len(), 1);
+}
+
+#[tokio::test]
+async fn test_websocket_text_frame_handling() {
+    let handler = FrameProcessingHandler::new();
+
+    let text_msg = json!({"type": "text", "content": "hello world"});
+    let response = handler.handle_message(text_msg.clone()).await;
+
+    assert!(response.is_some());
+    assert_eq!(handler.frame_count.load(Ordering::SeqCst), 1);
+
+    let messages = handler.messages.lock().unwrap();
+    assert_eq!(messages[0], text_msg);
+}
+
+#[tokio::test]
+async fn test_websocket_ping_pong() {
+    let handler = EchoHandler;
+
+    let msg1 = json!({"ping": 1});
+    let msg2 = json!({"ping": 2});
+
+    let resp1 = handler.handle_message(msg1.clone()).await;
+    let resp2 = handler.handle_message(msg2.clone()).await;
+
+    assert_eq!(resp1.unwrap(), msg1);
+    assert_eq!(resp2.unwrap(), msg2);
+}
+
+#[tokio::test]
+async fn test_websocket_close_frame() {
+    let handler = EchoHandler;
+
+    let close_msg = json!({"type": "close", "code": 1000, "reason": "normal"});
+    let response = handler.handle_message(close_msg).await;
+
+    assert!(response.is_some());
+
+    let msg = json!({"after_close": "test"});
+    let response = handler.handle_message(msg.clone()).await;
+    assert_eq!(response.unwrap(), msg);
+}
+
+#[tokio::test]
+async fn test_websocket_invalid_json_message() {
+    let handler = SchemaValidatingHandler::new();
+
+    let invalid_json = json!({"unknown_field": "value"});
+    let response = handler.handle_message(invalid_json).await;
+
+    assert!(response.is_none());
+    assert_eq!(handler.invalid_count.load(Ordering::SeqCst), 1);
+
+    let valid_msg = json!({"action": "test", "data": "ok"});
+    let response = handler.handle_message(valid_msg).await;
+
+    assert!(response.is_some());
+    assert_eq!(handler.valid_count.load(Ordering::SeqCst), 1);
+}
+
+#[tokio::test]
+async fn test_websocket_large_message() {
+    let handler = LargeMessageHandler::new();
+
+    let large_array: Vec<i32> = (0..2500).collect();
+    let large_msg = json!({
+        "type": "large_payload",
+        "data": large_array,
+        "metadata": {
+            "description": "Large message test"
+        }
+    });
+
+    let response = handler.handle_message(large_msg).await;
+
+    assert!(response.is_some());
+
+    let size = handler.processed_size.load(Ordering::SeqCst);
+    assert!(size > 10000, "Large message should be > 10KB");
+}
+
+#[tokio::test]
+async fn test_websocket_concurrent_messages() {
+    let handler = Arc::new(ConcurrentHandler::new());
+
+    let mut handles = vec![];
+
+    for i in 0..20 {
+        let handler_clone = handler.clone();
+        let handle = tokio::spawn(async move {
+            let msg = json!({"id": i, "data": format!("msg_{}", i)});
+            handler_clone.handle_message(msg).await
+        });
+        handles.push(handle);
+    }
+
+    for handle in handles {
+        let _ = handle.await;
+    }
+
+    assert_eq!(handler.message_count.load(Ordering::SeqCst), 20);
+    assert_eq!(handler.messages.lock().unwrap().len(), 20);
+}
+
+#[tokio::test]
+async fn test_websocket_handler_error() {
+    let handler = ErrorHandler::new();
+
+    let msg1 = json!({"id": 1});
+    let resp1 = handler.handle_message(msg1).await;
+    assert!(resp1.is_some());
+
+    handler.should_error.store(true, Ordering::SeqCst);
+    let msg2 = json!({"id": 2});
+    let resp2 = handler.handle_message(msg2).await;
+
+    assert!(resp2.is_none());
+
+    handler.should_error.store(false, Ordering::SeqCst);
+    let msg3 = json!({"id": 3});
+    let resp3 = handler.handle_message(msg3).await;
+
+    assert!(resp3.is_some());
+}
+
+#[tokio::test]
+async fn test_websocket_message_with_special_characters() {
+    let handler = EchoHandler;
+
+    let special_msg = json!({
+        "emoji": "🚀💡🔥",
+        "unicode": "你好世界",
+        "special": "!@#$%^&*()",
+        "newlines": "line1\nline2\nline3"
+    });
+
+    let response = handler.handle_message(special_msg.clone()).await;
+
+    assert!(response.is_some());
+    assert_eq!(response.unwrap(), special_msg);
+}
+
+#[tokio::test]
+async fn test_websocket_empty_and_null_values() {
+    let handler = EchoHandler;
+
+    let test_cases = vec![
+        json!({"value": null}),
+        json!({"array": []}),
+        json!({"object": {}}),
+        json!({"string": ""}),
+    ];
+
+    for msg in test_cases {
+        let response = handler.handle_message(msg.clone()).await;
+        assert!(response.is_some());
+        assert_eq!(response.unwrap(), msg);
+    }
+}
+
+#[tokio::test]
+async fn test_websocket_deeply_nested_structures() {
+    let handler = EchoHandler;
+
+    let mut nested = json!({"value": "deep"});
+    for _ in 0..30 {
+        nested = json!({"level": nested});
+    }
+
+    let response = handler.handle_message(nested.clone()).await;
+
+    assert!(response.is_some());
+    assert_eq!(response.unwrap(), nested);
+}

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

@@ -0,0 +1,152 @@
+use axum::routing::get;
+use serde_json::Value;
+use spikard_http::{WebSocketHandler, WebSocketState, websocket_handler};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use tokio::time::{Duration, timeout};
+
+#[derive(Debug)]
+struct CountingEchoHandler {
+    connects: Arc<AtomicUsize>,
+    disconnects: Arc<AtomicUsize>,
+}
+
+impl CountingEchoHandler {
+    const fn new(connects: Arc<AtomicUsize>, disconnects: Arc<AtomicUsize>) -> Self {
+        Self { connects, disconnects }
+    }
+}
+
+impl WebSocketHandler for CountingEchoHandler {
+    async fn handle_message(&self, message: Value) -> Option<Value> {
+        Some(message)
+    }
+
+    fn on_connect(&self) -> impl std::future::Future<Output = ()> + Send {
+        let connects = Arc::clone(&self.connects);
+        async move {
+            connects.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+
+    fn on_disconnect(&self) -> impl std::future::Future<Output = ()> + Send {
+        let disconnects = Arc::clone(&self.disconnects);
+        async move {
+            disconnects.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+}
+
+#[tokio::test]
+async fn websocket_handles_json_validation_invalid_json_binary_and_close() {
+    let connects = Arc::new(AtomicUsize::new(0));
+    let disconnects = Arc::new(AtomicUsize::new(0));
+
+    let message_schema = serde_json::json!({
+        "type": "object",
+        "properties": {
+            "ok": { "type": "boolean" }
+        },
+        "required": ["ok"]
+    });
+
+    let state = WebSocketState::with_schemas(
+        CountingEchoHandler::new(Arc::clone(&connects), Arc::clone(&disconnects)),
+        Some(message_schema),
+        None,
+    )
+    .expect("state");
+
+    let app = axum::Router::new()
+        .route("/ws", get(websocket_handler::<CountingEchoHandler>))
+        .with_state(state);
+
+    let server = axum_test::TestServer::new_with_config(
+        app,
+        axum_test::TestServerConfig {
+            transport: Some(axum_test::Transport::HttpRandomPort),
+            ..axum_test::TestServerConfig::default()
+        },
+    )
+    .expect("server");
+    let mut socket = server.get_websocket("/ws").await.into_websocket().await;
+
+    assert_eq!(connects.load(Ordering::SeqCst), 1);
+
+    socket.send_json(&serde_json::json!({"ok": true})).await;
+    let echoed: Value = socket.receive_json().await;
+    assert_eq!(echoed, serde_json::json!({"ok": true}));
+
+    socket.send_text("{").await;
+    let invalid_json: Value = socket.receive_json().await;
+    assert_eq!(invalid_json["type"], "error");
+    assert_eq!(invalid_json["message"], "Invalid JSON");
+
+    socket.send_json(&serde_json::json!({"nope": true})).await;
+    let validation_error: Value = socket.receive_json().await;
+    assert_eq!(validation_error["error"], "Message validation failed");
+
+    socket
+        .send_message(axum_test::WsMessage::Binary(bytes::Bytes::from_static(b"bin")))
+        .await;
+    let received = socket.receive_bytes().await;
+    assert_eq!(&received[..], b"bin");
+
+    socket
+        .send_message(axum_test::WsMessage::Ping(bytes::Bytes::from_static(b"ping")))
+        .await;
+    let pong = socket.receive_message().await;
+    assert!(matches!(pong, axum_test::WsMessage::Pong(_)));
+
+    socket.close().await;
+
+    timeout(Duration::from_secs(1), async {
+        loop {
+            if disconnects.load(Ordering::SeqCst) == 1 {
+                break;
+            }
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+    })
+    .await
+    .expect("disconnect");
+}
+
+#[derive(Debug)]
+struct AlwaysObjectHandler;
+
+impl WebSocketHandler for AlwaysObjectHandler {
+    async fn handle_message(&self, _message: Value) -> Option<Value> {
+        Some(serde_json::json!({"response": "object"}))
+    }
+}
+
+#[tokio::test]
+async fn websocket_suppresses_responses_that_fail_response_schema_validation() {
+    let response_schema = serde_json::json!({ "type": "string" });
+    let state = WebSocketState::with_schemas(AlwaysObjectHandler, None, Some(response_schema)).expect("state");
+
+    let app = axum::Router::new()
+        .route("/ws", get(websocket_handler::<AlwaysObjectHandler>))
+        .with_state(state);
+
+    let server = axum_test::TestServer::new_with_config(
+        app,
+        axum_test::TestServerConfig {
+            transport: Some(axum_test::Transport::HttpRandomPort),
+            ..axum_test::TestServerConfig::default()
+        },
+    )
+    .expect("server");
+    let mut socket = server.get_websocket("/ws").await.into_websocket().await;
+
+    socket.send_json(&serde_json::json!({"any": "thing"})).await;
+
+    let no_response = timeout(Duration::from_millis(100), socket.receive_message()).await;
+    assert!(
+        no_response.is_err(),
+        "response should be suppressed by schema validation"
+    );
+
+    socket.close().await;
+}

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

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

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

@@ -0,0 +1,80 @@
+//! GVL helpers for Ruby integration.
+
+use std::ffi::c_void;
+use std::mem::MaybeUninit;
+
+pub use paste;
+pub use rb_sys;
+
+#[allow(dead_code)]
+pub fn with_gvl<F, R>(func: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    struct WithGvlData<F, R> {
+        func: Option<F>,
+        result: MaybeUninit<R>,
+    }
+
+    unsafe extern "C" fn trampoline<F, R>(data: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> R,
+    {
+        let data = data as *mut WithGvlData<F, R>;
+        let data = unsafe { &mut *data };
+        let func = match data.func.take() {
+            Some(func) => func,
+            None => return std::ptr::null_mut(),
+        };
+        let result = func();
+        data.result.write(result);
+        std::ptr::null_mut()
+    }
+
+    let mut data = WithGvlData {
+        func: Some(func),
+        result: MaybeUninit::uninit(),
+    };
+
+    unsafe {
+        rb_sys::rb_thread_call_with_gvl(Some(trampoline::<F, R>), &mut data as *mut _ as *mut c_void);
+        data.result.assume_init()
+    }
+}
+
+#[macro_export]
+macro_rules! call_without_gvl {
+    ($func:expr, args: ($($arg:expr, $ty:ty),+), return_type: $return_ty:ty) => {{
+        $crate::gvl::paste::paste! {
+            let mut result: std::mem::MaybeUninit<$return_ty> = std::mem::MaybeUninit::uninit();
+            // Box the arguments to ensure they live on the heap for the entire duration of the FFI call
+            let data = std::boxed::Box::new((
+                ($($arg,)+),
+                &mut result as *mut std::mem::MaybeUninit<$return_ty>,
+            ));
+            let data_ptr = std::boxed::Box::into_raw(data) as *mut std::ffi::c_void;
+
+            unsafe extern "C" fn __decl_macro_anon_wrapper(data: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
+                let data = unsafe { std::boxed::Box::from_raw(data as *mut (
+                    ( $($ty,)+ ),
+                    *mut std::mem::MaybeUninit<$return_ty>,
+                )) };
+                let (( $([<__ $arg _name>],)+ ), result_output) = *data;
+                let result = $func( $( [<__ $arg _name>], )+);
+                unsafe { (*result_output).write(result); }
+                std::ptr::null_mut()
+            }
+
+            unsafe {
+                $crate::gvl::rb_sys::rb_thread_call_without_gvl(
+                    Some(__decl_macro_anon_wrapper),
+                    data_ptr,
+                    None,
+                    std::ptr::null_mut(),
+                );
+            }
+
+            unsafe { result.assume_init() }
+        }
+    }};
+}