spikard 0.2.0 → 0.2.5

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

@@ -0,0 +1,231 @@
+//! Ruby SSE producer bindings
+//!
+//! This module provides the bridge between Ruby blocks/procs and Rust's SSE system.
+//! Uses magnus to safely call Ruby code from Rust async tasks.
+
+use magnus::{RHash, Value, prelude::*, value::Opaque};
+use serde_json::Value as JsonValue;
+use spikard_http::{SseEvent, SseEventProducer};
+use tracing::{debug, error};
+
+/// Ruby implementation of SseEventProducer
+pub struct RubySseEventProducer {
+    /// Producer name for debugging
+    name: String,
+    /// Ruby proc/callable for next_event (Opaque for Send safety)
+    next_event_proc: Opaque<Value>,
+    /// Ruby proc/callable for on_connect (Opaque for Send safety)
+    on_connect_proc: Option<Opaque<Value>>,
+    /// Ruby proc/callable for on_disconnect (Opaque for Send safety)
+    on_disconnect_proc: Option<Opaque<Value>>,
+}
+
+impl RubySseEventProducer {
+    /// Create a new Ruby SSE event producer
+    #[allow(dead_code)]
+    pub fn new(
+        name: String,
+        next_event_proc: Value,
+        on_connect_proc: Option<Value>,
+        on_disconnect_proc: Option<Value>,
+    ) -> Self {
+        Self {
+            name,
+            next_event_proc: next_event_proc.into(),
+            on_connect_proc: on_connect_proc.map(|v| v.into()),
+            on_disconnect_proc: on_disconnect_proc.map(|v| v.into()),
+        }
+    }
+
+    /// Convert Ruby value to JSON
+    fn ruby_to_json(ruby: &magnus::Ruby, value: Value) -> Result<JsonValue, String> {
+        if value.is_nil() {
+            return Ok(JsonValue::Null);
+        }
+
+        let json_module: Value = ruby
+            .class_object()
+            .const_get("JSON")
+            .map_err(|e| format!("JSON module not available: {}", e))?;
+
+        let json_str: String = json_module
+            .funcall("generate", (value,))
+            .map_err(|e| format!("Failed to generate JSON: {}", e))?;
+
+        serde_json::from_str(&json_str).map_err(|e| format!("Failed to parse JSON: {}", e))
+    }
+}
+
+impl SseEventProducer for RubySseEventProducer {
+    async fn next_event(&self) -> Option<SseEvent> {
+        debug!("Ruby SSE producer '{}': next_event", self.name);
+
+        match magnus::Ruby::get()
+            .map_err(|e| format!("Failed to get Ruby: {}", e))
+            .and_then(|ruby| {
+                debug!("Ruby SSE producer: acquired Ruby VM");
+
+                let proc_value = ruby.get_inner(self.next_event_proc);
+                let result: Value = proc_value
+                    .funcall("call", ())
+                    .map_err(|e| format!("Producer '{}' call failed: {}", self.name, e))?;
+
+                debug!("Ruby SSE producer: called next_event proc");
+
+                if result.is_nil() {
+                    debug!("Ruby SSE producer: received nil, ending stream");
+                    return Ok(None);
+                }
+
+                let result_hash = if let Some(hash) = RHash::from_value(result) {
+                    hash
+                } else {
+                    let hash_value: Value = result.funcall("to_h", ()).map_err(|e| {
+                        format!(
+                            "next_event must return a Hash/SseEvent convertible via to_h ({}): {}",
+                            unsafe { result.classname() },
+                            e
+                        )
+                    })?;
+                    RHash::from_value(hash_value).ok_or_else(|| {
+                        format!("next_event to_h must return a Hash, got {}", unsafe {
+                            hash_value.classname()
+                        })
+                    })?
+                };
+
+                let data_value = result_hash
+                    .get(ruby.to_symbol("data"))
+                    .ok_or_else(|| "next_event Hash must have :data key".to_string())?;
+
+                let data_json = Self::ruby_to_json(&ruby, data_value)?;
+
+                let event_type: Option<String> = result_hash
+                    .get(ruby.to_symbol("event_type"))
+                    .and_then(|v| if v.is_nil() { None } else { String::try_convert(v).ok() });
+
+                let id: Option<String> = result_hash
+                    .get(ruby.to_symbol("id"))
+                    .and_then(|v| if v.is_nil() { None } else { String::try_convert(v).ok() });
+
+                let retry: Option<u64> = result_hash
+                    .get(ruby.to_symbol("retry"))
+                    .and_then(|v| if v.is_nil() { None } else { u64::try_convert(v).ok() });
+
+                let mut event = if let Some(et) = event_type {
+                    SseEvent::with_type(et, data_json)
+                } else {
+                    SseEvent::new(data_json)
+                };
+
+                if let Some(id_str) = id {
+                    event = event.with_id(id_str);
+                }
+
+                if let Some(retry_ms) = retry {
+                    event = event.with_retry(retry_ms);
+                }
+
+                Ok(Some(event))
+            }) {
+            Ok(event) => event,
+            Err(e) => {
+                error!("Ruby error in next_event: {}", e);
+                None
+            }
+        }
+    }
+
+    async fn on_connect(&self) {
+        debug!("Ruby SSE producer '{}': on_connect", self.name);
+
+        if let Some(on_connect_proc) = self.on_connect_proc
+            && let Err(e) = magnus::Ruby::get()
+                .map_err(|e| format!("Failed to get Ruby: {}", e))
+                .and_then(|ruby| {
+                    debug!("Ruby SSE producer: on_connect acquired Ruby VM");
+                    let proc_value = ruby.get_inner(on_connect_proc);
+                    proc_value
+                        .funcall::<_, _, Value>("call", ())
+                        .map_err(|e| format!("on_connect '{}' call failed: {}", self.name, e))?;
+                    debug!("Ruby SSE producer: on_connect completed");
+                    Ok(())
+                })
+        {
+            error!("on_connect error: {}", e);
+        }
+    }
+
+    async fn on_disconnect(&self) {
+        debug!("Ruby SSE producer '{}': on_disconnect", self.name);
+
+        if let Some(on_disconnect_proc) = self.on_disconnect_proc
+            && let Err(e) = magnus::Ruby::get()
+                .map_err(|e| format!("Failed to get Ruby: {}", e))
+                .and_then(|ruby| {
+                    let proc_value = ruby.get_inner(on_disconnect_proc);
+                    proc_value
+                        .funcall::<_, _, Value>("call", ())
+                        .map_err(|e| format!("on_disconnect '{}' call failed: {}", self.name, e))?;
+                    debug!("Ruby SSE producer: on_disconnect completed");
+                    Ok(())
+                })
+        {
+            error!("on_disconnect error: {}", e);
+        }
+    }
+}
+
+unsafe impl Send for RubySseEventProducer {}
+unsafe impl Sync for RubySseEventProducer {}
+
+/// Create SseState from Ruby producer object
+///
+/// This function is designed to be called from Ruby to register SSE producers.
+#[allow(dead_code)]
+pub fn create_sse_state(
+    ruby: &magnus::Ruby,
+    producer_obj: Value,
+) -> Result<spikard_http::SseState<RubySseEventProducer>, magnus::Error> {
+    let next_event_proc: Value = producer_obj
+        .funcall("method", (ruby.to_symbol("next_event"),))
+        .map_err(|e| {
+            magnus::Error::new(
+                ruby.exception_arg_error(),
+                format!("next_event method not found: {}", e),
+            )
+        })?;
+
+    let on_connect_proc = producer_obj
+        .funcall::<_, _, Value>("method", (ruby.to_symbol("on_connect"),))
+        .ok();
+
+    let on_disconnect_proc = producer_obj
+        .funcall::<_, _, Value>("method", (ruby.to_symbol("on_disconnect"),))
+        .ok();
+
+    let event_schema = producer_obj
+        .funcall::<_, _, Value>("instance_variable_get", (ruby.to_symbol("@_event_schema"),))
+        .ok()
+        .and_then(|v| {
+            if v.is_nil() {
+                None
+            } else {
+                RubySseEventProducer::ruby_to_json(ruby, v).ok()
+            }
+        });
+
+    let ruby_producer = RubySseEventProducer::new(
+        "SseEventProducer".to_string(),
+        next_event_proc,
+        on_connect_proc,
+        on_disconnect_proc,
+    );
+
+    if event_schema.is_some() {
+        spikard_http::SseState::with_schema(ruby_producer, event_schema)
+            .map_err(|e| magnus::Error::new(ruby.exception_runtime_error(), e))
+    } else {
+        Ok(spikard_http::SseState::new(ruby_producer))
+    }
+}

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

@@ -0,0 +1,404 @@
+//! Native Ruby test client for HTTP testing.
+//!
+//! This module implements `NativeTestClient`, a wrapped Ruby class that provides
+//! HTTP testing capabilities against a Spikard server. It manages test servers
+//! for both HTTP and WebSocket/SSE transports.
+
+#![allow(dead_code)]
+
+use axum::http::Method;
+use axum_test::{TestServer, TestServerConfig, Transport};
+use bytes::Bytes;
+use cookie::Cookie;
+use magnus::prelude::*;
+use magnus::{Error, RHash, Ruby, Value, gc::Marker};
+use serde_json::Value as JsonValue;
+use spikard_http::testing::{
+    MultipartFilePart, SnapshotError, build_multipart_body, encode_urlencoded_body, snapshot_response,
+};
+use spikard_http::{Route, RouteMetadata};
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::conversion::{parse_request_config, response_to_ruby};
+use crate::handler::RubyHandler;
+use crate::server::GLOBAL_RUNTIME;
+
+/// Request configuration built from Ruby options hash.
+pub struct RequestConfig {
+    pub query: Option<JsonValue>,
+    pub headers: HashMap<String, String>,
+    pub cookies: HashMap<String, String>,
+    pub body: Option<RequestBody>,
+}
+
+/// HTTP request body variants.
+pub enum RequestBody {
+    Json(JsonValue),
+    Form(JsonValue),
+    Raw(String),
+    Multipart {
+        form_data: Vec<(String, String)>,
+        files: Vec<MultipartFilePart>,
+    },
+}
+
+/// Snapshot of an HTTP response.
+pub struct TestResponseData {
+    pub status: u16,
+    pub headers: HashMap<String, String>,
+    pub body_text: Option<String>,
+}
+
+/// Error wrapper for native request failures.
+#[derive(Debug)]
+pub struct NativeRequestError(pub String);
+
+/// Inner client state containing the test servers and handlers.
+pub struct ClientInner {
+    pub http_server: Arc<TestServer>,
+    pub transport_server: Arc<TestServer>,
+    /// Keep Ruby handler closures alive for GC; accessed via the `mark` hook.
+    #[allow(dead_code)]
+    pub handlers: Vec<RubyHandler>,
+}
+
+/// Native Ruby TestClient wrapper for integration testing.
+///
+/// Wraps an optional `ClientInner` that holds the HTTP test servers
+/// and keeps handler references alive for Ruby's garbage collector.
+#[derive(Default)]
+#[magnus::wrap(class = "Spikard::Native::TestClient", free_immediately, mark)]
+pub struct NativeTestClient {
+    pub inner: RefCell<Option<ClientInner>>,
+}
+
+impl NativeTestClient {
+    /// Initialize the test client with routes, handlers, and server config.
+    ///
+    /// # Arguments
+    ///
+    /// * `ruby` - Ruby VM reference
+    /// * `this` - The wrapped NativeTestClient instance
+    /// * `routes_json` - JSON string containing route metadata
+    /// * `handlers` - Ruby Hash mapping handler_name => Proc
+    /// * `config_value` - Ruby ServerConfig object
+    /// * `ws_handlers` - Ruby Hash of WebSocket handlers (optional)
+    /// * `sse_producers` - Ruby Hash of SSE producers (optional)
+    pub fn initialize(
+        ruby: &Ruby,
+        this: &Self,
+        routes_json: String,
+        handlers: Value,
+        config_value: Value,
+        ws_handlers: Value,
+        sse_producers: Value,
+    ) -> Result<(), Error> {
+        let metadata: Vec<RouteMetadata> = serde_json::from_str(&routes_json)
+            .map_err(|err| Error::new(ruby.exception_arg_error(), format!("Invalid routes JSON: {err}")))?;
+
+        let handlers_hash = RHash::from_value(handlers).ok_or_else(|| {
+            Error::new(
+                ruby.exception_arg_error(),
+                "handlers parameter must be a Hash of handler_name => Proc",
+            )
+        })?;
+
+        let json_module = ruby
+            .class_object()
+            .const_get("JSON")
+            .map_err(|_| Error::new(ruby.exception_runtime_error(), "JSON module not available"))?;
+
+        let server_config = crate::config::extract_server_config(ruby, config_value)?;
+
+        let schema_registry = spikard_http::SchemaRegistry::new();
+        let mut prepared_routes = Vec::with_capacity(metadata.len());
+        let mut handler_refs = Vec::with_capacity(metadata.len());
+        let mut route_metadata_vec = Vec::with_capacity(metadata.len());
+
+        for meta in metadata.clone() {
+            let handler_value = crate::conversion::fetch_handler(ruby, &handlers_hash, &meta.handler_name)?;
+            let route = Route::from_metadata(meta.clone(), &schema_registry)
+                .map_err(|err| Error::new(ruby.exception_runtime_error(), format!("Failed to build route: {err}")))?;
+
+            let handler = RubyHandler::new(&route, handler_value, json_module)?;
+            prepared_routes.push((route, Arc::new(handler.clone()) as Arc<dyn spikard_http::Handler>));
+            handler_refs.push(handler);
+            route_metadata_vec.push(meta);
+        }
+
+        let mut router = spikard_http::server::build_router_with_handlers_and_config(
+            prepared_routes,
+            server_config,
+            route_metadata_vec,
+        )
+        .map_err(|err| Error::new(ruby.exception_runtime_error(), format!("Failed to build router: {err}")))?;
+
+        let mut ws_endpoints = Vec::new();
+        if !ws_handlers.is_nil() {
+            let ws_hash = RHash::from_value(ws_handlers)
+                .ok_or_else(|| Error::new(ruby.exception_arg_error(), "WebSocket handlers must be a Hash"))?;
+
+            ws_hash.foreach(
+                |path: String, factory: Value| -> Result<magnus::r_hash::ForEach, Error> {
+                    let handler_instance = factory.funcall::<_, _, Value>("call", ()).map_err(|e| {
+                        Error::new(
+                            ruby.exception_runtime_error(),
+                            format!("Failed to create WebSocket handler: {}", e),
+                        )
+                    })?;
+
+                    let ws_state = crate::websocket::create_websocket_state(ruby, handler_instance)?;
+
+                    ws_endpoints.push((path, ws_state));
+
+                    Ok(magnus::r_hash::ForEach::Continue)
+                },
+            )?;
+        }
+
+        let mut sse_endpoints = Vec::new();
+        if !sse_producers.is_nil() {
+            let sse_hash = RHash::from_value(sse_producers)
+                .ok_or_else(|| Error::new(ruby.exception_arg_error(), "SSE producers must be a Hash"))?;
+
+            sse_hash.foreach(
+                |path: String, factory: Value| -> Result<magnus::r_hash::ForEach, Error> {
+                    let producer_instance = factory.funcall::<_, _, Value>("call", ()).map_err(|e| {
+                        Error::new(
+                            ruby.exception_runtime_error(),
+                            format!("Failed to create SSE producer: {}", e),
+                        )
+                    })?;
+
+                    let sse_state = crate::sse::create_sse_state(ruby, producer_instance)?;
+
+                    sse_endpoints.push((path, sse_state));
+
+                    Ok(magnus::r_hash::ForEach::Continue)
+                },
+            )?;
+        }
+
+        use axum::routing::get;
+        for (path, ws_state) in ws_endpoints {
+            router = router.route(
+                &path,
+                get(spikard_http::websocket_handler::<crate::websocket::RubyWebSocketHandler>).with_state(ws_state),
+            );
+        }
+
+        for (path, sse_state) in sse_endpoints {
+            router = router.route(
+                &path,
+                get(spikard_http::sse_handler::<crate::sse::RubySseEventProducer>).with_state(sse_state),
+            );
+        }
+
+        let http_server = GLOBAL_RUNTIME
+            .block_on(async { TestServer::new(router.clone()) })
+            .map_err(|err| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to initialise test server: {err}"),
+                )
+            })?;
+
+        let ws_config = TestServerConfig {
+            transport: Some(Transport::HttpRandomPort),
+            ..Default::default()
+        };
+        let transport_server = GLOBAL_RUNTIME
+            .block_on(async { TestServer::new_with_config(router, ws_config) })
+            .map_err(|err| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to initialise WebSocket transport server: {err}"),
+                )
+            })?;
+
+        *this.inner.borrow_mut() = Some(ClientInner {
+            http_server: Arc::new(http_server),
+            transport_server: Arc::new(transport_server),
+            handlers: handler_refs,
+        });
+
+        Ok(())
+    }
+
+    /// Execute an HTTP request against the test server.
+    ///
+    /// # Arguments
+    ///
+    /// * `ruby` - Ruby VM reference
+    /// * `this` - The wrapped NativeTestClient instance
+    /// * `method` - HTTP method (GET, POST, etc.)
+    /// * `path` - URL path
+    /// * `options` - Ruby Hash with query, headers, cookies, body, etc.
+    pub fn request(ruby: &Ruby, this: &Self, method: String, path: String, options: Value) -> Result<Value, Error> {
+        let inner_borrow = this.inner.borrow();
+        let inner = inner_borrow
+            .as_ref()
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "TestClient not initialised"))?;
+        let method_upper = method.to_ascii_uppercase();
+        let http_method = Method::from_bytes(method_upper.as_bytes()).map_err(|err| {
+            Error::new(
+                ruby.exception_arg_error(),
+                format!("Unsupported method {method_upper}: {err}"),
+            )
+        })?;
+
+        let request_config = parse_request_config(ruby, options)?;
+
+        let response = GLOBAL_RUNTIME
+            .block_on(execute_request(
+                inner.http_server.clone(),
+                http_method,
+                path.clone(),
+                request_config,
+            ))
+            .map_err(|err| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Request failed for {method_upper} {path}: {}", err.0),
+                )
+            })?;
+
+        response_to_ruby(ruby, response)
+    }
+
+    /// Close the test client and clean up resources.
+    pub fn close(&self) -> Result<(), Error> {
+        *self.inner.borrow_mut() = None;
+        Ok(())
+    }
+
+    /// Connect to a WebSocket endpoint on the test server.
+    pub fn websocket(ruby: &Ruby, this: &Self, path: String) -> Result<Value, Error> {
+        let inner_borrow = this.inner.borrow();
+        let inner = inner_borrow
+            .as_ref()
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "TestClient not initialised"))?;
+
+        let server = Arc::clone(&inner.transport_server);
+
+        drop(inner_borrow);
+
+        let handle =
+            GLOBAL_RUNTIME.spawn(async move { spikard_http::testing::connect_websocket(&server, &path).await });
+
+        let ws = GLOBAL_RUNTIME.block_on(async {
+            handle
+                .await
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("WebSocket task failed: {}", e)))
+        })?;
+
+        let ws_conn = crate::test_websocket::WebSocketTestConnection::new(ws);
+        Ok(ruby.obj_wrap(ws_conn).as_value())
+    }
+
+    /// Connect to an SSE endpoint on the test server.
+    pub fn sse(ruby: &Ruby, this: &Self, path: String) -> Result<Value, Error> {
+        let inner_borrow = this.inner.borrow();
+        let inner = inner_borrow
+            .as_ref()
+            .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "TestClient not initialised"))?;
+
+        let response = GLOBAL_RUNTIME
+            .block_on(async {
+                let axum_response = inner.transport_server.get(&path).await;
+                snapshot_response(axum_response).await
+            })
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("SSE request failed: {}", e)))?;
+
+        crate::test_sse::sse_stream_from_response(ruby, &response)
+    }
+
+    /// GC mark hook so Ruby keeps handler closures alive.
+    #[allow(dead_code)]
+    pub fn mark(&self, marker: &Marker) {
+        let inner_ref = self.inner.borrow();
+        if let Some(inner) = inner_ref.as_ref() {
+            for handler in &inner.handlers {
+                handler.mark(marker);
+            }
+        }
+    }
+}
+
+/// Execute an HTTP request against a test server.
+///
+/// Handles method routing, query params, headers, cookies, and various body formats.
+pub async fn execute_request(
+    server: Arc<TestServer>,
+    method: Method,
+    path: String,
+    config: RequestConfig,
+) -> Result<TestResponseData, NativeRequestError> {
+    let mut request = match method {
+        Method::GET => server.get(&path),
+        Method::POST => server.post(&path),
+        Method::PUT => server.put(&path),
+        Method::PATCH => server.patch(&path),
+        Method::DELETE => server.delete(&path),
+        Method::HEAD => server.method(Method::HEAD, &path),
+        Method::OPTIONS => server.method(Method::OPTIONS, &path),
+        Method::TRACE => server.method(Method::TRACE, &path),
+        other => return Err(NativeRequestError(format!("Unsupported HTTP method {other}"))),
+    };
+
+    if let Some(query) = config.query {
+        request = request.add_query_params(&query);
+    }
+
+    for (name, value) in config.headers {
+        request = request.add_header(name.as_str(), value.as_str());
+    }
+
+    for (name, value) in config.cookies {
+        request = request.add_cookie(Cookie::new(name, value));
+    }
+
+    if let Some(body) = config.body {
+        match body {
+            RequestBody::Json(json_value) => {
+                request = request.json(&json_value);
+            }
+            RequestBody::Form(form_value) => {
+                let encoded = encode_urlencoded_body(&form_value)
+                    .map_err(|err| NativeRequestError(format!("Failed to encode form body: {err}")))?;
+                request = request
+                    .content_type("application/x-www-form-urlencoded")
+                    .bytes(Bytes::from(encoded));
+            }
+            RequestBody::Raw(raw) => {
+                request = request.bytes(Bytes::from(raw));
+            }
+            RequestBody::Multipart { form_data, files } => {
+                let (multipart_body, boundary) = build_multipart_body(&form_data, &files);
+                request = request
+                    .content_type(&format!("multipart/form-data; boundary={}", boundary))
+                    .bytes(Bytes::from(multipart_body));
+            }
+        }
+    }
+
+    let response = request.await;
+    let snapshot = snapshot_response(response).await.map_err(snapshot_err_to_native)?;
+    let body_text = if snapshot.body.is_empty() {
+        None
+    } else {
+        Some(String::from_utf8_lossy(&snapshot.body).into_owned())
+    };
+
+    Ok(TestResponseData {
+        status: snapshot.status,
+        headers: snapshot.headers,
+        body_text,
+    })
+}
+
+fn snapshot_err_to_native(err: SnapshotError) -> NativeRequestError {
+    NativeRequestError(err.to_string())
+}