RubyGems - spikard - Versions diffs - 0.6.2 → 0.7.1 - Mend

spikard 0.6.2 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (68) hide show

checksums.yaml +4 -4
data/README.md +90 -508
data/ext/spikard_rb/Cargo.lock +3287 -0
data/ext/spikard_rb/Cargo.toml +1 -1
data/ext/spikard_rb/extconf.rb +3 -3
data/lib/spikard/app.rb +72 -49
data/lib/spikard/background.rb +38 -7
data/lib/spikard/testing.rb +42 -4
data/lib/spikard/version.rb +1 -1
data/sig/spikard.rbs +4 -0
data/vendor/crates/spikard-bindings-shared/Cargo.toml +1 -1
data/vendor/crates/spikard-bindings-shared/tests/config_extractor_behavior.rs +191 -0
data/vendor/crates/spikard-core/Cargo.toml +1 -1
data/vendor/crates/spikard-core/src/http.rs +1 -0
data/vendor/crates/spikard-core/src/lifecycle.rs +63 -0
data/vendor/crates/spikard-core/tests/bindings_response_tests.rs +136 -0
data/vendor/crates/spikard-core/tests/di_dependency_defaults.rs +37 -0
data/vendor/crates/spikard-core/tests/error_mapper.rs +761 -0
data/vendor/crates/spikard-core/tests/parameters_edge_cases.rs +106 -0
data/vendor/crates/spikard-core/tests/parameters_full.rs +701 -0
data/vendor/crates/spikard-core/tests/parameters_schema_and_formats.rs +301 -0
data/vendor/crates/spikard-core/tests/request_data_roundtrip.rs +67 -0
data/vendor/crates/spikard-core/tests/validation_coverage.rs +250 -0
data/vendor/crates/spikard-core/tests/validation_error_paths.rs +45 -0
data/vendor/crates/spikard-http/Cargo.toml +1 -1
data/vendor/crates/spikard-http/src/jsonrpc/http_handler.rs +502 -0
data/vendor/crates/spikard-http/src/jsonrpc/method_registry.rs +648 -0
data/vendor/crates/spikard-http/src/jsonrpc/mod.rs +58 -0
data/vendor/crates/spikard-http/src/jsonrpc/protocol.rs +1207 -0
data/vendor/crates/spikard-http/src/jsonrpc/router.rs +2262 -0
data/vendor/crates/spikard-http/src/testing/test_client.rs +155 -2
data/vendor/crates/spikard-http/src/testing.rs +171 -0
data/vendor/crates/spikard-http/src/websocket.rs +79 -6
data/vendor/crates/spikard-http/tests/auth_integration.rs +647 -0
data/vendor/crates/spikard-http/tests/common/test_builders.rs +633 -0
data/vendor/crates/spikard-http/tests/di_handler_error_responses.rs +162 -0
data/vendor/crates/spikard-http/tests/middleware_stack_integration.rs +389 -0
data/vendor/crates/spikard-http/tests/request_extraction_full.rs +513 -0
data/vendor/crates/spikard-http/tests/server_auth_middleware_behavior.rs +244 -0
data/vendor/crates/spikard-http/tests/server_configured_router_behavior.rs +200 -0
data/vendor/crates/spikard-http/tests/server_cors_preflight.rs +82 -0
data/vendor/crates/spikard-http/tests/server_handler_wrappers.rs +464 -0
data/vendor/crates/spikard-http/tests/server_method_router_additional_behavior.rs +286 -0
data/vendor/crates/spikard-http/tests/server_method_router_coverage.rs +118 -0
data/vendor/crates/spikard-http/tests/server_middleware_behavior.rs +99 -0
data/vendor/crates/spikard-http/tests/server_middleware_branches.rs +206 -0
data/vendor/crates/spikard-http/tests/server_openapi_jsonrpc_static.rs +281 -0
data/vendor/crates/spikard-http/tests/server_router_behavior.rs +121 -0
data/vendor/crates/spikard-http/tests/sse_full_behavior.rs +584 -0
data/vendor/crates/spikard-http/tests/sse_handler_behavior.rs +130 -0
data/vendor/crates/spikard-http/tests/test_client_requests.rs +167 -0
data/vendor/crates/spikard-http/tests/testing_helpers.rs +87 -0
data/vendor/crates/spikard-http/tests/testing_module_coverage.rs +156 -0
data/vendor/crates/spikard-http/tests/urlencoded_content_type.rs +82 -0
data/vendor/crates/spikard-http/tests/websocket_full_behavior.rs +440 -0
data/vendor/crates/spikard-http/tests/websocket_integration.rs +152 -0
data/vendor/crates/spikard-rb/Cargo.toml +1 -1
data/vendor/crates/spikard-rb/src/gvl.rs +80 -0
data/vendor/crates/spikard-rb/src/handler.rs +12 -9
data/vendor/crates/spikard-rb/src/lib.rs +137 -124
data/vendor/crates/spikard-rb/src/request.rs +342 -0
data/vendor/crates/spikard-rb/src/runtime/server_runner.rs +1 -8
data/vendor/crates/spikard-rb/src/server.rs +1 -8
data/vendor/crates/spikard-rb/src/testing/client.rs +168 -9
data/vendor/crates/spikard-rb/src/websocket.rs +119 -30
data/vendor/crates/spikard-rb-macros/Cargo.toml +14 -0
data/vendor/crates/spikard-rb-macros/src/lib.rs +52 -0
metadata +44 -1

data/vendor/crates/spikard-http/tests/test_client_requests.rs ADDED Viewed

@@ -0,0 +1,167 @@
+use axum::body::Body;
+use axum::http::{Request, StatusCode};
+use axum::response::IntoResponse;
+use axum::{Router, routing::any};
+use spikard_http::testing::{MultipartFilePart, TestClient};
+async fn echo(req: Request<Body>) -> axum::response::Response {
+    let method = req.method().to_string();
+    let uri = req.uri().to_string();
+    let headers = req
+        .headers()
+        .iter()
+        .fold(serde_json::Map::new(), |mut map, (key, value)| {
+            map.insert(
+                key.to_string(),
+                serde_json::Value::String(value.to_str().unwrap_or("").to_string()),
+            );
+            map
+        });
+    let bytes = axum::body::to_bytes(req.into_body(), usize::MAX).await.unwrap();
+    let body_text = String::from_utf8_lossy(&bytes).to_string();
+    let payload = serde_json::json!({
+        "method": method,
+        "uri": uri,
+        "headers": headers,
+        "body": body_text,
+    });
+    (StatusCode::OK, axum::Json(payload)).into_response()
+}
+#[tokio::test]
+async fn test_client_sends_query_headers_and_bodies() {
+    let app = Router::new().route("/{*path}", any(echo));
+    let client = TestClient::from_router(app).expect("client");
+    let snapshot = client
+        .get(
+            "/items",
+            Some(vec![("q".to_string(), "a b".to_string())]),
+            Some(vec![("x-test".to_string(), "1".to_string())]),
+        )
+        .await
+        .expect("get");
+    assert_eq!(snapshot.status, 200);
+    let json = snapshot.json().expect("json");
+    assert_eq!(json["method"], "GET");
+    assert!(json["uri"].as_str().unwrap().contains("/items?q=a%20b"));
+    assert_eq!(json["headers"]["x-test"], "1");
+    let snapshot = client
+        .post(
+            "/json",
+            Some(serde_json::json!({"hello":"world"})),
+            None,
+            None,
+            None,
+            None,
+        )
+        .await
+        .expect("post");
+    let json = snapshot.json().expect("json");
+    assert_eq!(json["method"], "POST");
+    assert!(json["body"].as_str().unwrap().contains("\"hello\":\"world\""));
+    let snapshot = client
+        .post(
+            "/form",
+            None,
+            Some(vec![("a".to_string(), "b".to_string())]),
+            None,
+            None,
+            None,
+        )
+        .await
+        .expect("post");
+    let json = snapshot.json().expect("json");
+    let body = json["body"].as_str().unwrap();
+    assert!(body.contains('a'));
+    assert!(body.contains('b'));
+    let snapshot = client
+        .post(
+            "/multipart",
+            None,
+            None,
+            Some((
+                vec![("field".to_string(), "value".to_string())],
+                vec![MultipartFilePart {
+                    field_name: "file".to_string(),
+                    filename: "hello.txt".to_string(),
+                    content_type: Some("text/plain".to_string()),
+                    content: b"hello".to_vec(),
+                }],
+            )),
+            None,
+            None,
+        )
+        .await
+        .expect("post");
+    let json = snapshot.json().expect("json");
+    assert!(
+        json["headers"]["content-type"]
+            .as_str()
+            .unwrap()
+            .contains("multipart/form-data")
+    );
+    assert!(json["body"].as_str().unwrap().contains("hello"));
+}
+#[tokio::test]
+async fn test_client_supports_other_http_methods_and_query_merging() {
+    let app = Router::new().route("/{*path}", any(echo));
+    let client = TestClient::from_router(app).expect("client");
+    let snapshot = client
+        .put(
+            "/put",
+            Some(serde_json::json!({"name":"spikard"})),
+            None,
+            Some(vec![("x-test".to_string(), "2".to_string())]),
+        )
+        .await
+        .expect("put");
+    let json = snapshot.json().expect("json");
+    assert_eq!(json["method"], "PUT");
+    assert_eq!(json["headers"]["x-test"], "2");
+    assert!(json["body"].as_str().unwrap().contains("\"name\":\"spikard\""));
+    let snapshot = client.delete("/delete", None, None).await.expect("delete");
+    assert_eq!(snapshot.json().expect("json")["method"], "DELETE");
+    let snapshot = client.options("/options", None, None).await.expect("options");
+    assert_eq!(snapshot.json().expect("json")["method"], "OPTIONS");
+    let snapshot = client.head("/head", None, None).await.expect("head");
+    assert_eq!(snapshot.status, 200);
+    assert!(snapshot.body.is_empty());
+    let snapshot = client.trace("/trace", None, None).await.expect("trace");
+    assert_eq!(snapshot.json().expect("json")["method"], "TRACE");
+    let snapshot = client
+        .get("/items?x=1", Some(vec![("y".to_string(), "2".to_string())]), None)
+        .await
+        .expect("get");
+    assert!(
+        snapshot.json().expect("json")["uri"]
+            .as_str()
+            .unwrap()
+            .contains("x=1&y=2")
+    );
+}
+#[tokio::test]
+async fn test_client_rejects_invalid_header_names() {
+    let app = Router::new().route("/{*path}", any(echo));
+    let client = TestClient::from_router(app).expect("client");
+    let error = client
+        .get("/items", None, Some(vec![("bad\n".to_string(), "1".to_string())]))
+        .await
+        .expect_err("invalid header");
+    let message = error.to_string();
+    assert!(message.contains("Invalid header name"));
+}

data/vendor/crates/spikard-http/tests/testing_helpers.rs ADDED Viewed

@@ -0,0 +1,87 @@
+use axum::http::HeaderValue;
+use axum::{Router, response::IntoResponse, routing::get};
+use brotli::CompressorWriter;
+use flate2::Compression;
+use flate2::write::GzEncoder;
+use spikard_http::testing::{MultipartFilePart, build_multipart_body, encode_urlencoded_body, snapshot_response};
+use std::io::Write;
+#[test]
+fn urlencoded_encoding_handles_scalars_and_objects() {
+    let s = serde_json::Value::String("a=b&c=d".to_string());
+    assert_eq!(encode_urlencoded_body(&s).unwrap(), b"a=b&c=d".to_vec());
+    let mut obj = serde_json::Map::new();
+    obj.insert("name".to_string(), serde_json::Value::String("Alice".to_string()));
+    obj.insert("tags".to_string(), serde_json::json!(["a", "b"]));
+    let value = serde_json::Value::Object(obj);
+    let encoded = String::from_utf8(encode_urlencoded_body(&value).unwrap()).unwrap();
+    assert!(encoded.contains("name=Alice"));
+    assert!(encoded.contains("tags"));
+}
+#[test]
+fn multipart_body_contains_fields_and_files() {
+    let (body, boundary) = build_multipart_body(
+        &[("field".to_string(), "value".to_string())],
+        &[MultipartFilePart {
+            field_name: "file".to_string(),
+            filename: "hello.txt".to_string(),
+            content_type: Some("text/plain".to_string()),
+            content: b"hello".to_vec(),
+        }],
+    );
+    let body_str = String::from_utf8_lossy(&body);
+    assert!(body_str.contains(&format!("--{boundary}")));
+    assert!(body_str.contains("name=\"field\""));
+    assert!(body_str.contains("value"));
+    assert!(body_str.contains("name=\"file\"; filename=\"hello.txt\""));
+    assert!(body_str.contains("Content-Type: text/plain"));
+    assert!(body_str.contains("hello"));
+}
+#[tokio::test]
+async fn snapshot_response_decodes_gzip_body() {
+    let app = Router::new().route(
+        "/gzip",
+        get(|| async move {
+            let raw = b"hello gzip".to_vec();
+            let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+            encoder.write_all(&raw).unwrap();
+            let compressed = encoder.finish().unwrap();
+            ([("content-encoding", HeaderValue::from_static("gzip"))], compressed).into_response()
+        }),
+    );
+    let server = axum_test::TestServer::new(app).unwrap();
+    let response = server.get("/gzip").await;
+    let snapshot = snapshot_response(response).await.expect("snapshot failed");
+    assert_eq!(snapshot.status, 200);
+    assert_eq!(snapshot.text().unwrap(), "hello gzip");
+}
+#[tokio::test]
+async fn snapshot_response_decodes_brotli_body() {
+    let app = Router::new().route(
+        "/br",
+        get(|| async move {
+            let raw = b"hello br".to_vec();
+            let mut writer = CompressorWriter::new(Vec::new(), 4096, 6, 22);
+            writer.write_all(&raw).unwrap();
+            writer.flush().unwrap();
+            let compressed = writer.into_inner();
+            ([("content-encoding", HeaderValue::from_static("br"))], compressed).into_response()
+        }),
+    );
+    let server = axum_test::TestServer::new(app).unwrap();
+    let response = server.get("/br").await;
+    let snapshot = snapshot_response(response).await.expect("snapshot failed");
+    assert_eq!(snapshot.status, 200);
+    assert_eq!(snapshot.text().unwrap(), "hello br");
+}

data/vendor/crates/spikard-http/tests/testing_module_coverage.rs ADDED Viewed

@@ -0,0 +1,156 @@
+use axum::body::Body;
+use axum::http::{HeaderValue, Request, StatusCode};
+use axum::response::IntoResponse;
+use axum::routing::get;
+use flate2::Compression;
+use flate2::write::GzEncoder;
+use spikard_http::testing::{SnapshotError, WebSocketMessage, call_test_server, connect_websocket, snapshot_response};
+use std::io::Write;
+#[tokio::test]
+async fn call_test_server_preserves_method_headers_query_and_body() {
+    let app = axum::Router::new().route(
+        "/echo",
+        get(|req: Request<Body>| async move {
+            let method = req.method().to_string();
+            let uri = req.uri().to_string();
+            let header = req
+                .headers()
+                .get("x-test")
+                .and_then(|v| v.to_str().ok())
+                .map_or_else(|| "<missing>".to_string(), str::to_string);
+            let bytes = axum::body::to_bytes(req.into_body(), usize::MAX).await.unwrap();
+            (StatusCode::OK, format!("{method} {uri} {header} {}", bytes.len())).into_response()
+        }),
+    );
+    let server = axum_test::TestServer::new(app).expect("server");
+    let request = Request::builder()
+        .method("GET")
+        .uri("/echo?q=1")
+        .header("x-test", "1")
+        .body(Body::from("abc"))
+        .expect("request");
+    let response = call_test_server(&server, request).await;
+    assert_eq!(response.status_code(), StatusCode::OK);
+    let text = response.text();
+    assert!(text.contains("GET"));
+    assert!(text.contains("/echo"));
+    assert!(text.contains("q=1"));
+}
+#[tokio::test]
+async fn snapshot_response_reports_invalid_headers_and_decompression_errors() {
+    let bad_header = HeaderValue::from_bytes(b"\xFF").expect("header value");
+    let app = axum::Router::new()
+        .route(
+            "/bad-header",
+            get(move || async move {
+                (
+                    StatusCode::OK,
+                    [(axum::http::header::HeaderName::from_static("x-bad"), bad_header.clone())],
+                    "ok",
+                )
+            }),
+        )
+        .route(
+            "/bad-gzip",
+            get(|| async move {
+                (
+                    StatusCode::OK,
+                    [(axum::http::header::CONTENT_ENCODING, "gzip")],
+                    vec![0_u8, 1, 2, 3],
+                )
+            }),
+        );
+    let server = axum_test::TestServer::new(app).expect("server");
+    let err = snapshot_response(server.get("/bad-header").await)
+        .await
+        .expect_err("invalid header");
+    assert!(matches!(err, SnapshotError::InvalidHeader(_)));
+    let err = snapshot_response(server.get("/bad-gzip").await)
+        .await
+        .expect_err("bad gzip");
+    assert!(matches!(err, SnapshotError::Decompression(_)));
+}
+#[tokio::test]
+async fn websocket_testing_wrappers_roundtrip_and_message_helpers() {
+    let app = axum::Router::new().route(
+        "/ws",
+        get(|ws: axum::extract::ws::WebSocketUpgrade| async move {
+            ws.on_upgrade(|mut socket| async move {
+                while let Some(msg) = socket.recv().await {
+                    match msg {
+                        Ok(axum::extract::ws::Message::Text(text)) => {
+                            let _ = socket.send(axum::extract::ws::Message::Text(text)).await;
+                        }
+                        Ok(axum::extract::ws::Message::Binary(data)) => {
+                            let _ = socket.send(axum::extract::ws::Message::Binary(data)).await;
+                        }
+                        Ok(axum::extract::ws::Message::Ping(data)) => {
+                            let _ = socket.send(axum::extract::ws::Message::Pong(data)).await;
+                        }
+                        Ok(axum::extract::ws::Message::Close(_)) | Err(_) => break,
+                        Ok(axum::extract::ws::Message::Pong(_)) => {}
+                    }
+                }
+            })
+        }),
+    );
+    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 ws = connect_websocket(&server, "/ws").await;
+    ws.send_text("hi").await;
+    let msg = ws.receive_message().await;
+    assert_eq!(msg.as_text(), Some("hi"));
+    assert!(msg.as_json().is_err());
+    ws.send_message(axum_test::WsMessage::Binary(bytes::Bytes::from_static(b"bin")))
+        .await;
+    let msg = ws.receive_message().await;
+    assert_eq!(msg.as_binary().expect("binary"), b"bin");
+    assert!(msg.as_json().is_err());
+    ws.send_message(axum_test::WsMessage::Ping(bytes::Bytes::from_static(b"ping")))
+        .await;
+    let msg = ws.receive_message().await;
+    assert!(matches!(msg, WebSocketMessage::Pong(_)));
+    ws.close().await;
+}
+#[tokio::test]
+async fn snapshot_response_decodes_gzip_body() {
+    let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+    encoder.write_all(b"hello gzip").expect("write");
+    let gzipped = encoder.finish().expect("finish");
+    let app = axum::Router::new().route(
+        "/gzip",
+        get(move || async move {
+            (
+                StatusCode::OK,
+                [(axum::http::header::CONTENT_ENCODING, "gzip")],
+                gzipped.clone(),
+            )
+        }),
+    );
+    let server = axum_test::TestServer::new(app).expect("server");
+    let snapshot = snapshot_response(server.get("/gzip").await).await.expect("snapshot");
+    assert_eq!(snapshot.text().expect("text"), "hello gzip");
+}

data/vendor/crates/spikard-http/tests/urlencoded_content_type.rs ADDED Viewed

@@ -0,0 +1,82 @@
+#![allow(clippy::pedantic, clippy::nursery, clippy::all)]
+//! Integration coverage for validate_content_type_middleware with urlencoded bodies.
+use axum::Router;
+use axum::extract::Extension;
+use axum::http::{HeaderMap, StatusCode};
+use axum::middleware;
+use axum::routing::post;
+use spikard_http::middleware::PreReadBody;
+use spikard_http::middleware::{RouteInfo, validate_content_type_middleware};
+/// Build a router with the content-type middleware and route configuration.
+fn build_router(route_info: RouteInfo) -> Router {
+    Router::new()
+        .route(
+            "/forms",
+            post(
+                |headers: HeaderMap, Extension(pre_read): Extension<PreReadBody>| async move {
+                    let content_type = headers
+                        .get(axum::http::header::CONTENT_TYPE)
+                        .and_then(|h| h.to_str().ok())
+                        .unwrap_or_default()
+                        .to_string();
+                    let body_str = String::from_utf8(pre_read.0.to_vec()).unwrap();
+                    (
+                        StatusCode::OK,
+                        axum::Json(serde_json::json!({ "content_type": content_type, "body": body_str })),
+                    )
+                },
+            ),
+        )
+        .layer(middleware::from_fn_with_state(
+            route_info,
+            validate_content_type_middleware,
+        ))
+}
+#[tokio::test]
+async fn urlencoded_body_is_transformed_to_json() {
+    let app = build_router(RouteInfo {
+        expects_json_body: true,
+    });
+    let server = axum_test::TestServer::new(app).expect("start test server");
+    let response = server
+        .post("/forms")
+        .text("name=alice&active=true&count=3&empty=")
+        .content_type("application/x-www-form-urlencoded")
+        .await;
+    assert_eq!(response.status_code(), StatusCode::OK);
+    let payload: serde_json::Value = response.json();
+    assert_eq!(payload["content_type"], "application/json");
+    let body_json: serde_json::Value =
+        serde_json::from_str(payload["body"].as_str().expect("body string")).expect("valid json");
+    assert_eq!(body_json["name"], "alice");
+    assert_eq!(body_json["active"], true);
+    assert_eq!(body_json["count"], 3);
+    assert_eq!(body_json["empty"], "");
+}
+#[tokio::test]
+async fn invalid_charset_on_json_returns_unsupported_media_type() {
+    let app = build_router(RouteInfo {
+        expects_json_body: true,
+    });
+    let server = axum_test::TestServer::new(app).expect("start test server");
+    let response = server
+        .post("/forms")
+        .text("{\"name\":\"alice\"}")
+        .content_type("application/json; charset=utf-16")
+        .await;
+    assert_eq!(response.status_code(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
+    let body: serde_json::Value = response.json();
+    assert_eq!(
+        body["type"],
+        serde_json::Value::String("https://spikard.dev/errors/unsupported-charset".to_string())
+    );
+}