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

spikard 0.6.2 → 0.7.2

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 +2 -2
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/server_middleware_branches.rs ADDED Viewed

@@ -0,0 +1,206 @@
+use axum::body::Body;
+use axum::http::{Request, StatusCode};
+use brotli::Decompressor;
+use spikard_http::server::build_router_with_handlers_and_config;
+use spikard_http::{
+    CompressionConfig, Handler, HandlerResult, Method, RateLimitConfig, RequestData, Route, ServerConfig,
+};
+use std::future::Future;
+use std::io::Read;
+use std::pin::Pin;
+use std::sync::Arc;
+use uuid::Uuid;
+struct PlainTextHandler {
+    body: String,
+}
+impl Handler for PlainTextHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        _request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        let body = self.body.clone();
+        Box::pin(async move {
+            Ok(axum::http::Response::builder()
+                .status(StatusCode::OK)
+                .header("content-type", "text/plain")
+                .body(Body::from(body))
+                .expect("response builder"))
+        })
+    }
+}
+fn basic_route(method: Method, path: &str, expects_json_body: bool) -> Route {
+    Route {
+        method,
+        path: path.to_string(),
+        handler_name: "plain".to_string(),
+        expects_json_body,
+        cors: None,
+        is_async: true,
+        file_params: None,
+        request_validator: None,
+        response_validator: None,
+        parameter_validator: None,
+        jsonrpc_method: None,
+        #[cfg(feature = "di")]
+        handler_dependencies: Vec::new(),
+    }
+}
+#[tokio::test]
+async fn request_id_is_generated_and_propagated() {
+    let route = basic_route(Method::Get, "/rid", false);
+    let config = ServerConfig {
+        enable_request_id: true,
+        ..Default::default()
+    };
+    let router = build_router_with_handlers_and_config(
+        vec![(
+            route,
+            Arc::new(PlainTextHandler { body: "ok".to_string() }) as Arc<dyn Handler>,
+        )],
+        config,
+        Vec::new(),
+    )
+    .expect("router");
+    let server = axum_test::TestServer::new(router).expect("server");
+    let response = server.get("/rid").await;
+    assert_eq!(response.status_code(), StatusCode::OK);
+    let header = response.header("x-request-id");
+    let request_id = header.to_str().expect("request id");
+    assert!(Uuid::parse_str(request_id).is_ok());
+    let response2 = server.get("/rid").add_header("x-request-id", "req-123").await;
+    assert_eq!(response2.status_code(), StatusCode::OK);
+    assert_eq!(
+        response2.header("x-request-id").to_str().expect("request id"),
+        "req-123"
+    );
+}
+#[tokio::test]
+async fn default_body_limit_can_be_disabled() {
+    let route = basic_route(Method::Post, "/upload", false);
+    let config = ServerConfig {
+        max_body_size: None,
+        ..Default::default()
+    };
+    let router = build_router_with_handlers_and_config(
+        vec![(
+            route,
+            Arc::new(PlainTextHandler { body: "ok".to_string() }) as Arc<dyn Handler>,
+        )],
+        config,
+        Vec::new(),
+    )
+    .expect("router");
+    let server = axum_test::TestServer::new(router).expect("server");
+    let payload = vec![b'a'; 1024 * 128];
+    let response = server.post("/upload").bytes(payload.into()).await;
+    assert_eq!(response.status_code(), StatusCode::OK);
+}
+#[tokio::test]
+async fn default_body_limit_allows_payloads_within_limit() {
+    let route = basic_route(Method::Post, "/upload", false);
+    let config = ServerConfig {
+        max_body_size: Some(16),
+        ..Default::default()
+    };
+    let router = build_router_with_handlers_and_config(
+        vec![(
+            route,
+            Arc::new(PlainTextHandler { body: "ok".to_string() }) as Arc<dyn Handler>,
+        )],
+        config,
+        Vec::new(),
+    )
+    .expect("router");
+    let server = axum_test::TestServer::new(router).expect("server");
+    let payload = vec![b'a'; 8];
+    let response = server.post("/upload").bytes(payload.into()).await;
+    assert_eq!(response.status_code(), StatusCode::OK);
+}
+#[tokio::test]
+async fn compression_br_is_applied_when_accepted() {
+    let original_body = "x".repeat(2048);
+    let route = basic_route(Method::Get, "/compressed", false);
+    let config = ServerConfig {
+        compression: Some(CompressionConfig {
+            gzip: false,
+            brotli: true,
+            min_size: 0,
+            quality: 3,
+        }),
+        ..Default::default()
+    };
+    let router = build_router_with_handlers_and_config(
+        vec![(
+            route,
+            Arc::new(PlainTextHandler {
+                body: original_body.clone(),
+            }) as Arc<dyn Handler>,
+        )],
+        config,
+        Vec::new(),
+    )
+    .expect("router");
+    let server = axum_test::TestServer::new(router).expect("server");
+    let response = server.get("/compressed").add_header("accept-encoding", "br").await;
+    assert_eq!(response.status_code(), StatusCode::OK);
+    assert_eq!(response.header("content-encoding").to_str().expect("encoding"), "br");
+    let mut decoder = Decompressor::new(response.as_bytes().as_ref(), 4096);
+    let mut decoded_body = String::new();
+    decoder.read_to_string(&mut decoded_body).expect("decompress");
+    assert_eq!(decoded_body, original_body);
+}
+#[tokio::test]
+async fn rate_limit_builder_covers_ip_and_global_key_extractors() {
+    let route = basic_route(Method::Get, "/rl", false);
+    let handler: Arc<dyn Handler> = Arc::new(PlainTextHandler { body: "ok".to_string() });
+    let ip_config = ServerConfig {
+        rate_limit: Some(RateLimitConfig {
+            per_second: 100,
+            burst: 10,
+            ip_based: true,
+        }),
+        ..Default::default()
+    };
+    let router_ip =
+        build_router_with_handlers_and_config(vec![(route.clone(), Arc::clone(&handler))], ip_config, Vec::new())
+            .expect("router");
+    let server_ip = axum_test::TestServer::new(router_ip.into_make_service_with_connect_info::<std::net::SocketAddr>())
+        .expect("server");
+    assert_eq!(server_ip.get("/rl").await.status_code(), StatusCode::OK);
+    let global_config = ServerConfig {
+        rate_limit: Some(RateLimitConfig {
+            per_second: 100,
+            burst: 10,
+            ip_based: false,
+        }),
+        ..Default::default()
+    };
+    let router_global =
+        build_router_with_handlers_and_config(vec![(route, handler)], global_config, Vec::new()).expect("router");
+    let server_global =
+        axum_test::TestServer::new(router_global.into_make_service_with_connect_info::<std::net::SocketAddr>())
+            .expect("server");
+    assert_eq!(server_global.get("/rl").await.status_code(), StatusCode::OK);
+}

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

@@ -0,0 +1,281 @@
+use axum::body::Body;
+use axum::http::{Request, StatusCode};
+use serde_json::Value;
+use spikard_core::router::JsonRpcMethodInfo;
+use spikard_http::server::build_router_with_handlers_and_config;
+use spikard_http::{
+    Handler, HandlerResult, JsonRpcConfig, Method, OpenApiConfig, RateLimitConfig, RequestData, Route, RouteMetadata,
+    ServerConfig, StaticFilesConfig,
+};
+use std::future::Future;
+use std::path::Path;
+use std::pin::Pin;
+use std::sync::Arc;
+struct EchoHandler;
+impl Handler for EchoHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        Box::pin(async move {
+            let response_json = serde_json::json!({
+                "method": request_data.method,
+                "path": request_data.path,
+                "path_params": &*request_data.path_params,
+                "body": request_data.body,
+                "raw_body_json": request_data
+                    .raw_body
+                    .as_ref()
+                    .and_then(|bytes| serde_json::from_slice::<Value>(bytes.as_ref()).ok()),
+            });
+            Ok(axum::http::Response::builder()
+                .status(StatusCode::OK)
+                .header("content-type", "application/json")
+                .body(Body::from(response_json.to_string()))
+                .expect("response builder"))
+        })
+    }
+}
+fn api_items_path() -> String {
+    ["api/items/", "{", "id:uuid", "}"].concat()
+}
+fn build_routes(path: &str) -> Vec<(Route, Arc<dyn Handler>)> {
+    vec![
+        (
+            Route {
+                method: Method::Get,
+                path: path.to_string(),
+                handler_name: "echo_get".to_string(),
+                expects_json_body: false,
+                cors: None,
+                is_async: true,
+                file_params: None,
+                request_validator: None,
+                response_validator: None,
+                parameter_validator: None,
+                jsonrpc_method: Some(JsonRpcMethodInfo {
+                    method_name: "spikard.test.echo".to_string(),
+                    description: Some("Echo JSON-RPC".to_string()),
+                    params_schema: None,
+                    result_schema: None,
+                    deprecated: false,
+                    tags: vec!["test".to_string()],
+                }),
+                #[cfg(feature = "di")]
+                handler_dependencies: Vec::new(),
+            },
+            Arc::new(EchoHandler) as Arc<dyn Handler>,
+        ),
+        (
+            Route {
+                method: Method::Post,
+                path: path.to_string(),
+                handler_name: "echo_post".to_string(),
+                expects_json_body: true,
+                cors: None,
+                is_async: true,
+                file_params: None,
+                request_validator: None,
+                response_validator: None,
+                parameter_validator: None,
+                jsonrpc_method: None,
+                #[cfg(feature = "di")]
+                handler_dependencies: Vec::new(),
+            },
+            Arc::new(EchoHandler) as Arc<dyn Handler>,
+        ),
+    ]
+}
+fn build_route_metadata(path: &str) -> Vec<RouteMetadata> {
+    let request_schema = serde_json::json!({
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"}
+        },
+        "required": ["name"]
+    });
+    let response_schema = serde_json::json!({
+        "type": "object",
+        "properties": {
+            "ok": {"type": "boolean"}
+        },
+        "required": ["ok"]
+    });
+    vec![
+        RouteMetadata {
+            method: "GET".to_string(),
+            path: path.to_string(),
+            handler_name: "echo_get".to_string(),
+            request_schema: None,
+            response_schema: None,
+            parameter_schema: None,
+            file_params: None,
+            is_async: true,
+            cors: None,
+            body_param_name: None,
+            #[cfg(feature = "di")]
+            handler_dependencies: None,
+            jsonrpc_method: Some(
+                serde_json::to_value(JsonRpcMethodInfo {
+                    method_name: "spikard.test.echo".to_string(),
+                    description: Some("Echo JSON-RPC".to_string()),
+                    params_schema: None,
+                    result_schema: None,
+                    deprecated: false,
+                    tags: vec!["test".to_string()],
+                })
+                .expect("jsonrpc method info"),
+            ),
+        },
+        RouteMetadata {
+            method: "POST".to_string(),
+            path: path.to_string(),
+            handler_name: "echo_post".to_string(),
+            request_schema: Some(request_schema),
+            response_schema: Some(response_schema),
+            parameter_schema: None,
+            file_params: None,
+            is_async: true,
+            cors: None,
+            body_param_name: Some("body".to_string()),
+            #[cfg(feature = "di")]
+            handler_dependencies: None,
+            jsonrpc_method: None,
+        },
+    ]
+}
+fn build_config(static_dir: &Path) -> ServerConfig {
+    ServerConfig {
+        openapi: Some(OpenApiConfig {
+            enabled: true,
+            title: "Spikard Test API".to_string(),
+            version: "0.1.0".to_string(),
+            ..OpenApiConfig::default()
+        }),
+        jsonrpc: Some(JsonRpcConfig::default()),
+        static_files: vec![StaticFilesConfig {
+            directory: static_dir.to_string_lossy().into_owned(),
+            route_prefix: "/static".to_string(),
+            index_file: true,
+            cache_control: Some("public, max-age=60".to_string()),
+        }],
+        rate_limit: Some(RateLimitConfig {
+            per_second: 100,
+            burst: 10,
+            ip_based: false,
+        }),
+        ..Default::default()
+    }
+}
+async fn assert_openapi_docs_and_redoc(server: &axum_test::TestServer) {
+    let openapi_response = server.get("/openapi.json").await;
+    assert_eq!(openapi_response.status_code(), StatusCode::OK);
+    let openapi: Value = serde_json::from_str(&openapi_response.text()).expect("openapi json");
+    assert!(openapi.get("openapi").is_some());
+    assert!(openapi.get("paths").is_some());
+    let swagger_html = server.get("/docs").await;
+    assert_eq!(swagger_html.status_code(), StatusCode::OK);
+    assert!(swagger_html.text().contains("SwaggerUIBundle"));
+    assert!(swagger_html.text().contains("/openapi.json"));
+    let redoc_html = server.get("/redoc").await;
+    assert_eq!(redoc_html.status_code(), StatusCode::OK);
+    assert!(redoc_html.text().contains("<redoc"));
+    assert!(redoc_html.text().contains("/openapi.json"));
+}
+async fn assert_static_files(server: &axum_test::TestServer) {
+    let static_index = server.get("/static/").await;
+    assert_eq!(static_index.status_code(), StatusCode::OK);
+    assert!(static_index.text().contains("static index"));
+    assert_eq!(
+        static_index.header("cache-control").to_str().expect("cache-control"),
+        "public, max-age=60"
+    );
+    let static_file = server.get("/static/hello.txt").await;
+    assert_eq!(static_file.status_code(), StatusCode::OK);
+    assert_eq!(static_file.text(), "hello world");
+    assert_eq!(
+        static_file.header("cache-control").to_str().expect("cache-control"),
+        "public, max-age=60"
+    );
+}
+async fn assert_jsonrpc_and_http_routes(server: &axum_test::TestServer) {
+    let rpc_request = serde_json::json!({
+        "jsonrpc": "2.0",
+        "method": "spikard.test.echo",
+        "params": {"any": "thing"},
+        "id": 1
+    });
+    let rpc_response = server.post("/rpc").json(&rpc_request).await;
+    assert_eq!(rpc_response.status_code(), StatusCode::OK);
+    let rpc_json: Value = serde_json::from_str(&rpc_response.text()).expect("jsonrpc response");
+    assert_eq!(rpc_json["jsonrpc"], "2.0");
+    assert_eq!(rpc_json["id"], 1);
+    assert_eq!(rpc_json["result"]["path"], "/rpc");
+    assert_eq!(rpc_json["result"]["method"], "POST");
+    let ok_get = server.get("/api/items/550e8400-e29b-41d4-a716-446655440000").await;
+    assert_eq!(ok_get.status_code(), StatusCode::OK);
+    let ok_get_json: Value = serde_json::from_str(&ok_get.text()).expect("get json");
+    assert_eq!(ok_get_json["path_params"]["id"], "550e8400-e29b-41d4-a716-446655440000");
+    let ok_post = server
+        .post("/api/items/550e8400-e29b-41d4-a716-446655440000")
+        .json(&serde_json::json!({"name": "spikard"}))
+        .await;
+    assert_eq!(ok_post.status_code(), StatusCode::OK);
+    let ok_post_json: Value = serde_json::from_str(&ok_post.text()).expect("post json");
+    assert_eq!(ok_post_json["raw_body_json"]["name"], "spikard");
+}
+#[tokio::test]
+async fn router_supports_openapi_jsonrpc_and_static_files_in_one_config() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    std::fs::write(dir.path().join("index.html"), "<h1>static index</h1>").expect("write index.html");
+    std::fs::write(dir.path().join("hello.txt"), "hello world").expect("write hello.txt");
+    let api_items_path = api_items_path();
+    let route_entries = build_routes(&api_items_path);
+    let route_metadata = build_route_metadata(&api_items_path);
+    let config = build_config(dir.path());
+    let app_router = build_router_with_handlers_and_config(route_entries, config, route_metadata).expect("router");
+    let server = axum_test::TestServer::new(app_router).expect("test server");
+    assert_openapi_docs_and_redoc(&server).await;
+    assert_static_files(&server).await;
+    assert_jsonrpc_and_http_routes(&server).await;
+}
+#[test]
+fn router_returns_error_for_invalid_cache_control_header_value() {
+    let routes: Vec<(Route, Arc<dyn Handler>)> = Vec::new();
+    let config = ServerConfig {
+        static_files: vec![StaticFilesConfig {
+            directory: "/tmp".to_string(),
+            route_prefix: "/static".to_string(),
+            index_file: true,
+            cache_control: Some("\n".to_string()),
+        }],
+        ..Default::default()
+    };
+    let err = build_router_with_handlers_and_config(routes, config, Vec::new()).expect_err("invalid header");
+    assert!(err.contains("Invalid cache-control header"));
+}

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

@@ -0,0 +1,121 @@
+use axum::body::Body;
+use http_body_util::BodyExt;
+use spikard_http::handler_trait::{Handler, HandlerResult, RequestData};
+use spikard_http::server::build_router_with_handlers;
+use spikard_http::{Method, Route};
+use std::pin::Pin;
+use std::sync::{Arc, Mutex};
+use tower::ServiceExt;
+#[cfg(feature = "di")]
+fn build_app(routes: Vec<(Route, Arc<dyn Handler>)>) -> axum::Router {
+    build_router_with_handlers(routes, None, None).unwrap()
+}
+#[cfg(not(feature = "di"))]
+fn build_app(routes: Vec<(Route, Arc<dyn Handler>)>) -> axum::Router {
+    build_router_with_handlers(routes, None).unwrap()
+}
+struct CaptureHandler {
+    tx: Mutex<Option<tokio::sync::oneshot::Sender<RequestData>>>,
+}
+impl CaptureHandler {
+    const fn new(tx: tokio::sync::oneshot::Sender<RequestData>) -> Self {
+        Self {
+            tx: Mutex::new(Some(tx)),
+        }
+    }
+}
+impl Handler for CaptureHandler {
+    fn call(
+        &self,
+        _request: axum::http::Request<Body>,
+        request_data: RequestData,
+    ) -> Pin<Box<dyn std::future::Future<Output = HandlerResult> + Send + '_>> {
+        Box::pin(async move {
+            let maybe_tx = self.tx.lock().expect("lock").take();
+            if let Some(tx) = maybe_tx {
+                let _ = tx.send(request_data);
+            }
+            Ok(axum::http::Response::builder().status(200).body(Body::empty()).unwrap())
+        })
+    }
+}
+fn route(path: &str, method: Method) -> Route {
+    Route {
+        path: path.to_string(),
+        method,
+        handler_name: "capture".to_string(),
+        expects_json_body: true,
+        cors: None,
+        is_async: true,
+        file_params: None,
+        request_validator: None,
+        response_validator: None,
+        parameter_validator: None,
+        jsonrpc_method: None,
+        #[cfg(feature = "di")]
+        handler_dependencies: vec![],
+    }
+}
+#[tokio::test]
+async fn post_route_with_path_params_extracts_raw_body_and_path_params() {
+    let (tx, rx) = tokio::sync::oneshot::channel();
+    let handler: Arc<dyn Handler> = Arc::new(CaptureHandler::new(tx));
+    let path = ["/items/", "{", "id:int", "}"].concat();
+    let app = build_app(vec![(route(&path, Method::Post), handler)]);
+    let response = app
+        .oneshot(
+            axum::http::Request::builder()
+                .method("POST")
+                .uri("/items/123")
+                .header("content-type", "application/json")
+                .body(Body::from(r#"{"ok":true}"#))
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(response.status(), 200);
+    let _ = response.into_body().collect().await.unwrap();
+    let captured = rx.await.expect("handler should send request_data");
+    assert_eq!(captured.method, "POST");
+    assert_eq!(captured.path, "/items/123");
+    assert_eq!(captured.path_params.get("id").map(String::as_str), Some("123"));
+    assert_eq!(captured.raw_body.as_deref(), Some(&br#"{"ok":true}"#[..]));
+}
+#[tokio::test]
+async fn get_route_without_body_does_not_set_raw_body() {
+    let (tx, rx) = tokio::sync::oneshot::channel();
+    let handler: Arc<dyn Handler> = Arc::new(CaptureHandler::new(tx));
+    let app = build_app(vec![(route("/health", Method::Get), handler)]);
+    let response = app
+        .oneshot(
+            axum::http::Request::builder()
+                .method("GET")
+                .uri("/health?x=1")
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(response.status(), 200);
+    let _ = response.into_body().collect().await.unwrap();
+    let captured = rx.await.expect("handler should send request_data");
+    assert_eq!(captured.method, "GET");
+    assert_eq!(captured.path, "/health");
+    assert!(captured.raw_body.is_none());
+}