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/server_method_router_additional_behavior.rs ADDED Viewed

@@ -0,0 +1,286 @@
+use axum::body::Body;
+use axum::http::{Request, StatusCode};
+use http_body_util::BodyExt;
+use serde_json::json;
+use spikard_http::server::build_router_with_handlers_and_config;
+use spikard_http::{Handler, HandlerResult, Method, RequestData, Route, ServerConfig, StaticFilesConfig};
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::time::Duration;
+use tempfile::tempdir;
+use tokio::time::sleep;
+use tower::ServiceExt;
+struct EchoRequestDataHandler;
+impl Handler for EchoRequestDataHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        Box::pin(async move {
+            let payload = json!({
+                "method": request_data.method,
+                "path": request_data.path,
+                "path_params": request_data.path_params.as_ref(),
+                "query_params": request_data.query_params,
+                "body": request_data.body,
+            });
+            let bytes = serde_json::to_vec(&payload).expect("serialize");
+            Ok(axum::http::Response::builder()
+                .status(StatusCode::OK)
+                .header("content-type", "application/json")
+                .body(Body::from(bytes))
+                .expect("response"))
+        })
+    }
+}
+struct SlowHandler {
+    sleep_for: Duration,
+}
+impl Handler for SlowHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        _request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        let duration = self.sleep_for;
+        Box::pin(async move {
+            sleep(duration).await;
+            Ok(axum::http::Response::builder()
+                .status(StatusCode::OK)
+                .body(Body::from("ok"))
+                .expect("response"))
+        })
+    }
+}
+fn route(method: Method, path: &str, handler_name: &str) -> Route {
+    Route {
+        method,
+        path: path.to_string(),
+        handler_name: handler_name.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(),
+    }
+}
+async fn json_response(router: axum::Router, request: Request<Body>) -> serde_json::Value {
+    let response = router.oneshot(request).await.expect("response");
+    assert_eq!(response.status(), StatusCode::OK);
+    let bytes = response.into_body().collect().await.expect("collect body").to_bytes();
+    serde_json::from_slice(&bytes).expect("json")
+}
+#[tokio::test]
+async fn put_with_path_params_and_json_body_is_extracted() {
+    let router = build_router_with_handlers_and_config(
+        vec![(
+            route(Method::Put, "/items/{id}", "echo"),
+            Arc::new(EchoRequestDataHandler) as Arc<dyn Handler>,
+        )],
+        ServerConfig::default(),
+        Vec::new(),
+    )
+    .expect("router");
+    let payload = json!({"name":"widget"});
+    let request = Request::builder()
+        .method("PUT")
+        .uri("/items/123")
+        .header("content-type", "application/json")
+        .body(Body::from(serde_json::to_vec(&payload).expect("encode")))
+        .expect("request");
+    let body = json_response(router, request).await;
+    assert_eq!(body["method"], "PUT");
+    assert_eq!(body["path"], "/items/123");
+    assert_eq!(body["path_params"]["id"], "123");
+    assert_eq!(body["body"]["name"], "widget");
+}
+#[tokio::test]
+async fn patch_with_path_params_and_json_body_is_extracted() {
+    let router = build_router_with_handlers_and_config(
+        vec![(
+            route(Method::Patch, "/items/{id}", "echo"),
+            Arc::new(EchoRequestDataHandler) as Arc<dyn Handler>,
+        )],
+        ServerConfig::default(),
+        Vec::new(),
+    )
+    .expect("router");
+    let payload = json!({"active":true});
+    let request = Request::builder()
+        .method("PATCH")
+        .uri("/items/777")
+        .header("content-type", "application/json")
+        .body(Body::from(serde_json::to_vec(&payload).expect("encode")))
+        .expect("request");
+    let body = json_response(router, request).await;
+    assert_eq!(body["method"], "PATCH");
+    assert_eq!(body["path_params"]["id"], "777");
+    assert_eq!(body["body"]["active"], true);
+}
+#[tokio::test]
+async fn head_with_path_params_hits_handler() {
+    let router = build_router_with_handlers_and_config(
+        vec![(
+            route(Method::Head, "/health/{id}", "echo"),
+            Arc::new(EchoRequestDataHandler) as Arc<dyn Handler>,
+        )],
+        ServerConfig::default(),
+        Vec::new(),
+    )
+    .expect("router");
+    let request = Request::builder()
+        .method("HEAD")
+        .uri("/health/abc")
+        .body(Body::empty())
+        .expect("request");
+    let response = router.oneshot(request).await.expect("response");
+    assert_eq!(response.status(), StatusCode::OK);
+    assert_eq!(
+        response.headers().get("content-type").and_then(|h| h.to_str().ok()),
+        Some("application/json")
+    );
+    let bytes = response.into_body().collect().await.expect("collect body").to_bytes();
+    assert!(bytes.is_empty());
+}
+#[tokio::test]
+async fn trace_with_path_params_hits_handler() {
+    let router = build_router_with_handlers_and_config(
+        vec![(
+            route(Method::Trace, "/trace/{id}", "echo"),
+            Arc::new(EchoRequestDataHandler) as Arc<dyn Handler>,
+        )],
+        ServerConfig::default(),
+        Vec::new(),
+    )
+    .expect("router");
+    let request = Request::builder()
+        .method("TRACE")
+        .uri("/trace/xyz")
+        .body(Body::empty())
+        .expect("request");
+    let body = json_response(router, request).await;
+    assert_eq!(body["method"], "TRACE");
+    assert_eq!(body["path_params"]["id"], "xyz");
+}
+#[tokio::test]
+async fn options_with_path_params_hits_handler_when_no_cors_configured() {
+    let router = build_router_with_handlers_and_config(
+        vec![(
+            route(Method::Options, "/options/{id}", "echo"),
+            Arc::new(EchoRequestDataHandler) as Arc<dyn Handler>,
+        )],
+        ServerConfig::default(),
+        Vec::new(),
+    )
+    .expect("router");
+    let request = Request::builder()
+        .method("OPTIONS")
+        .uri("/options/1")
+        .body(Body::empty())
+        .expect("request");
+    let body = json_response(router, request).await;
+    assert_eq!(body["method"], "OPTIONS");
+    assert_eq!(body["path_params"]["id"], "1");
+}
+#[tokio::test]
+async fn request_timeout_returns_408() {
+    let config = ServerConfig {
+        request_timeout: Some(1),
+        ..Default::default()
+    };
+    let router = build_router_with_handlers_and_config(
+        vec![(
+            route(Method::Get, "/slow", "slow"),
+            Arc::new(SlowHandler {
+                sleep_for: Duration::from_secs(2),
+            }) as Arc<dyn Handler>,
+        )],
+        config,
+        Vec::new(),
+    )
+    .expect("router");
+    let response = router
+        .oneshot(
+            Request::builder()
+                .method("GET")
+                .uri("/slow")
+                .body(Body::empty())
+                .expect("request"),
+        )
+        .await
+        .expect("response");
+    assert_eq!(response.status(), StatusCode::REQUEST_TIMEOUT);
+}
+#[tokio::test]
+async fn static_files_cache_control_header_is_set_when_configured() {
+    let dir = tempdir().expect("temp dir");
+    let file_path = dir.path().join("hello.txt");
+    std::fs::write(&file_path, "hi").expect("write file");
+    let config = ServerConfig {
+        static_files: vec![StaticFilesConfig {
+            directory: dir.path().to_string_lossy().to_string(),
+            route_prefix: "/static".to_string(),
+            index_file: true,
+            cache_control: Some("max-age=60".to_string()),
+        }],
+        ..Default::default()
+    };
+    let router = build_router_with_handlers_and_config(Vec::new(), config, Vec::new()).expect("router");
+    let response = router
+        .oneshot(
+            Request::builder()
+                .method("GET")
+                .uri("/static/hello.txt")
+                .body(Body::empty())
+                .expect("request"),
+        )
+        .await
+        .expect("response");
+    assert_eq!(response.status(), StatusCode::OK);
+    assert_eq!(
+        response
+            .headers()
+            .get("cache-control")
+            .expect("cache-control")
+            .to_str()
+            .expect("header"),
+        "max-age=60"
+    );
+}

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

@@ -0,0 +1,118 @@
+use axum::body::Body;
+use axum::http::{Method as AxumMethod, Request, StatusCode};
+use serde_json::Value;
+use spikard_http::server::build_router_with_handlers_and_config;
+use spikard_http::{Handler, HandlerResult, Method, RequestData, Route, ServerConfig};
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+struct EchoMethodHandler;
+impl Handler for EchoMethodHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        Box::pin(async move {
+            let body_len = request_data.raw_body.as_ref().map_or(0, bytes::Bytes::len);
+            let response_json = serde_json::json!({
+                "method": request_data.method,
+                "path": request_data.path,
+                "path_params": &*request_data.path_params,
+                "raw_body_len": body_len,
+            });
+            Ok(axum::http::Response::builder()
+                .status(StatusCode::OK)
+                .header("content-type", "application/json")
+                .body(Body::from(response_json.to_string()))
+                .expect("response builder"))
+        })
+    }
+}
+fn route(method: Method, path: &str, expects_json_body: bool) -> Route {
+    Route {
+        method,
+        path: path.to_string(),
+        handler_name: "echo_method".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(),
+    }
+}
+async fn assert_method(server: &axum_test::TestServer, method: AxumMethod, path: &str) {
+    let response = server.method(method.clone(), path).await;
+    assert_eq!(response.status_code(), StatusCode::OK);
+    if method == AxumMethod::HEAD {
+        return;
+    }
+    let json: Value = serde_json::from_str(&response.text()).expect("json");
+    assert_eq!(json["method"], method.as_str());
+}
+#[tokio::test]
+async fn router_covers_all_http_methods_with_and_without_path_params() {
+    let handler: Arc<dyn Handler> = Arc::new(EchoMethodHandler);
+    let route_entries = vec![
+        route(Method::Get, "/m", false),
+        route(Method::Delete, "/m", false),
+        route(Method::Head, "/m", false),
+        route(Method::Trace, "/m", false),
+        route(Method::Options, "/m", false),
+        route(Method::Post, "/m", false),
+        route(Method::Put, "/m", false),
+        route(Method::Patch, "/m", false),
+        route(Method::Get, "/params/{id}", false),
+        route(Method::Delete, "/params/{id}", false),
+        route(Method::Head, "/params/{id}", false),
+        route(Method::Trace, "/params/{id}", false),
+        route(Method::Options, "/params/{id}", false),
+        route(Method::Post, "/params/{id}", false),
+        route(Method::Put, "/params/{id}", false),
+        route(Method::Patch, "/params/{id}", false),
+    ]
+    .into_iter()
+    .map(|r| (r, Arc::clone(&handler)))
+    .collect();
+    let app_router =
+        build_router_with_handlers_and_config(route_entries, ServerConfig::default(), Vec::new()).expect("router");
+    let server = axum_test::TestServer::new(app_router).expect("server");
+    assert_method(&server, AxumMethod::GET, "/m").await;
+    assert_method(&server, AxumMethod::DELETE, "/m").await;
+    assert_method(&server, AxumMethod::HEAD, "/m").await;
+    assert_method(&server, AxumMethod::TRACE, "/m").await;
+    assert_method(&server, AxumMethod::OPTIONS, "/m").await;
+    let post = server.post("/m").bytes(Vec::from("body").into()).await;
+    let post_json: Value = serde_json::from_str(&post.text()).expect("json");
+    assert_eq!(post_json["method"], "POST");
+    assert_eq!(post_json["raw_body_len"], 4);
+    let put = server.put("/m").bytes(Vec::from("body").into()).await;
+    let put_json: Value = serde_json::from_str(&put.text()).expect("json");
+    assert_eq!(put_json["method"], "PUT");
+    assert_eq!(put_json["raw_body_len"], 4);
+    let patch = server.patch("/m").bytes(Vec::from("body").into()).await;
+    let patch_json: Value = serde_json::from_str(&patch.text()).expect("json");
+    assert_eq!(patch_json["method"], "PATCH");
+    assert_eq!(patch_json["raw_body_len"], 4);
+    assert_method(&server, AxumMethod::GET, "/params/123").await;
+    let response = server.method(AxumMethod::DELETE, "/params/123").await;
+    assert_eq!(response.status_code(), StatusCode::OK);
+    let json: Value = serde_json::from_str(&response.text()).expect("json");
+    assert_eq!(json["path_params"]["id"], "123");
+}

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

@@ -0,0 +1,99 @@
+use axum::body::Body;
+use http_body_util::BodyExt;
+use spikard_http::handler_trait::{Handler, HandlerResult, RequestData};
+use spikard_http::{CompressionConfig, Method, Route, Server, ServerConfig};
+use std::pin::Pin;
+use std::sync::Arc;
+use tower::ServiceExt;
+use uuid::Uuid;
+struct LargeJsonHandler;
+impl Handler for LargeJsonHandler {
+    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 big_value = "x".repeat(2048);
+            let body = format!(r#"{{"payload":"{big_value}"}}"#);
+            Ok(axum::http::Response::builder()
+                .status(200)
+                .header("content-type", "application/json")
+                .body(Body::from(body))
+                .unwrap())
+        })
+    }
+}
+fn route(path: &str) -> Route {
+    Route {
+        path: path.to_string(),
+        method: Method::Get,
+        handler_name: "large".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: None,
+        #[cfg(feature = "di")]
+        handler_dependencies: vec![],
+    }
+}
+#[tokio::test]
+async fn server_applies_request_id_and_gzip_compression_when_configured() {
+    let config = ServerConfig {
+        compression: Some(CompressionConfig {
+            gzip: true,
+            brotli: false,
+            min_size: 0,
+            quality: 6,
+        }),
+        enable_request_id: true,
+        ..Default::default()
+    };
+    let handler: Arc<dyn Handler> = Arc::new(LargeJsonHandler);
+    let app = Server::with_handlers(config, vec![(route("/data"), handler)]).unwrap();
+    let response = app
+        .oneshot(
+            axum::http::Request::builder()
+                .method("GET")
+                .uri("/data")
+                .header("accept-encoding", "gzip")
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    let request_id = response
+        .headers()
+        .get("x-request-id")
+        .expect("x-request-id header missing")
+        .to_str()
+        .unwrap();
+    assert!(
+        Uuid::parse_str(request_id).is_ok(),
+        "x-request-id is not a UUID: {request_id}"
+    );
+    assert_eq!(
+        response
+            .headers()
+            .get("content-encoding")
+            .expect("content-encoding missing")
+            .to_str()
+            .unwrap(),
+        "gzip"
+    );
+    let bytes = response.into_body().collect().await.unwrap().to_bytes();
+    assert!(!bytes.is_empty());
+}