RubyGems - spikard - Versions diffs - 0.3.6 → 0.6.1 - Mend

spikard 0.3.6 → 0.6.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 (142) hide show

checksums.yaml +4 -4
data/LICENSE +1 -1
data/README.md +674 -659
data/ext/spikard_rb/Cargo.toml +17 -17
data/ext/spikard_rb/extconf.rb +13 -10
data/ext/spikard_rb/src/lib.rs +6 -6
data/lib/spikard/app.rb +405 -386
data/lib/spikard/background.rb +27 -27
data/lib/spikard/config.rb +396 -396
data/lib/spikard/converters.rb +13 -13
data/lib/spikard/handler_wrapper.rb +113 -113
data/lib/spikard/provide.rb +214 -214
data/lib/spikard/response.rb +173 -173
data/lib/spikard/schema.rb +243 -243
data/lib/spikard/sse.rb +111 -111
data/lib/spikard/streaming_response.rb +44 -44
data/lib/spikard/testing.rb +256 -221
data/lib/spikard/upload_file.rb +131 -131
data/lib/spikard/version.rb +5 -5
data/lib/spikard/websocket.rb +59 -59
data/lib/spikard.rb +43 -43
data/sig/spikard.rbs +366 -366
data/vendor/crates/spikard-bindings-shared/Cargo.toml +63 -0
data/vendor/crates/spikard-bindings-shared/examples/config_extraction.rs +132 -0
data/vendor/crates/spikard-bindings-shared/src/config_extractor.rs +752 -0
data/vendor/crates/spikard-bindings-shared/src/conversion_traits.rs +194 -0
data/vendor/crates/spikard-bindings-shared/src/di_traits.rs +246 -0
data/vendor/crates/spikard-bindings-shared/src/error_response.rs +401 -0
data/vendor/crates/spikard-bindings-shared/src/handler_base.rs +238 -0
data/vendor/crates/spikard-bindings-shared/src/lib.rs +24 -0
data/vendor/crates/spikard-bindings-shared/src/lifecycle_base.rs +292 -0
data/vendor/crates/spikard-bindings-shared/src/lifecycle_executor.rs +616 -0
data/vendor/crates/spikard-bindings-shared/src/response_builder.rs +305 -0
data/vendor/crates/spikard-bindings-shared/src/test_client_base.rs +248 -0
data/vendor/crates/spikard-bindings-shared/src/validation_helpers.rs +351 -0
data/vendor/crates/spikard-bindings-shared/tests/comprehensive_coverage.rs +454 -0
data/vendor/crates/spikard-bindings-shared/tests/error_response_edge_cases.rs +383 -0
data/vendor/crates/spikard-bindings-shared/tests/handler_base_integration.rs +280 -0
data/vendor/crates/spikard-core/Cargo.toml +40 -40
data/vendor/crates/spikard-core/src/bindings/mod.rs +3 -3
data/vendor/crates/spikard-core/src/bindings/response.rs +133 -133
data/vendor/crates/spikard-core/src/debug.rs +127 -63
data/vendor/crates/spikard-core/src/di/container.rs +702 -726
data/vendor/crates/spikard-core/src/di/dependency.rs +273 -273
data/vendor/crates/spikard-core/src/di/error.rs +118 -118
data/vendor/crates/spikard-core/src/di/factory.rs +534 -538
data/vendor/crates/spikard-core/src/di/graph.rs +506 -545
data/vendor/crates/spikard-core/src/di/mod.rs +192 -192
data/vendor/crates/spikard-core/src/di/resolved.rs +405 -411
data/vendor/crates/spikard-core/src/di/value.rs +281 -283
data/vendor/crates/spikard-core/src/errors.rs +69 -39
data/vendor/crates/spikard-core/src/http.rs +415 -153
data/vendor/crates/spikard-core/src/lib.rs +29 -29
data/vendor/crates/spikard-core/src/lifecycle.rs +1186 -422
data/vendor/crates/spikard-core/src/metadata.rs +389 -0
data/vendor/crates/spikard-core/src/parameters.rs +2525 -722
data/vendor/crates/spikard-core/src/problem.rs +344 -310
data/vendor/crates/spikard-core/src/request_data.rs +1154 -189
data/vendor/crates/spikard-core/src/router.rs +510 -249
data/vendor/crates/spikard-core/src/schema_registry.rs +183 -183
data/vendor/crates/spikard-core/src/type_hints.rs +304 -304
data/vendor/crates/spikard-core/src/validation/error_mapper.rs +696 -0
data/vendor/crates/spikard-core/src/{validation.rs → validation/mod.rs} +457 -699
data/vendor/crates/spikard-http/Cargo.toml +62 -68
data/vendor/crates/spikard-http/examples/sse-notifications.rs +148 -0
data/vendor/crates/spikard-http/examples/websocket-chat.rs +92 -0
data/vendor/crates/spikard-http/src/auth.rs +296 -247
data/vendor/crates/spikard-http/src/background.rs +1860 -249
data/vendor/crates/spikard-http/src/bindings/mod.rs +3 -3
data/vendor/crates/spikard-http/src/bindings/response.rs +1 -1
data/vendor/crates/spikard-http/src/body_metadata.rs +8 -8
data/vendor/crates/spikard-http/src/cors.rs +1005 -490
data/vendor/crates/spikard-http/src/debug.rs +128 -63
data/vendor/crates/spikard-http/src/di_handler.rs +1668 -423
data/vendor/crates/spikard-http/src/handler_response.rs +901 -190
data/vendor/crates/spikard-http/src/handler_trait.rs +838 -228
data/vendor/crates/spikard-http/src/handler_trait_tests.rs +290 -284
data/vendor/crates/spikard-http/src/lib.rs +534 -529
data/vendor/crates/spikard-http/src/lifecycle/adapter.rs +230 -149
data/vendor/crates/spikard-http/src/lifecycle.rs +1193 -428
data/vendor/crates/spikard-http/src/middleware/mod.rs +560 -285
data/vendor/crates/spikard-http/src/middleware/multipart.rs +912 -86
data/vendor/crates/spikard-http/src/middleware/urlencoded.rs +513 -147
data/vendor/crates/spikard-http/src/middleware/validation.rs +768 -287
data/vendor/crates/spikard-http/src/openapi/mod.rs +309 -309
data/vendor/crates/spikard-http/src/openapi/parameter_extraction.rs +535 -190
data/vendor/crates/spikard-http/src/openapi/schema_conversion.rs +1363 -308
data/vendor/crates/spikard-http/src/openapi/spec_generation.rs +665 -195
data/vendor/crates/spikard-http/src/query_parser.rs +793 -369
data/vendor/crates/spikard-http/src/response.rs +720 -399
data/vendor/crates/spikard-http/src/server/handler.rs +1650 -87
data/vendor/crates/spikard-http/src/server/lifecycle_execution.rs +234 -98
data/vendor/crates/spikard-http/src/server/mod.rs +1593 -805
data/vendor/crates/spikard-http/src/server/request_extraction.rs +789 -119
data/vendor/crates/spikard-http/src/server/routing_factory.rs +629 -0
data/vendor/crates/spikard-http/src/sse.rs +1409 -447
data/vendor/crates/spikard-http/src/testing/form.rs +52 -14
data/vendor/crates/spikard-http/src/testing/multipart.rs +64 -60
data/vendor/crates/spikard-http/src/testing/test_client.rs +311 -285
data/vendor/crates/spikard-http/src/testing.rs +406 -377
data/vendor/crates/spikard-http/src/websocket.rs +1404 -324
data/vendor/crates/spikard-http/tests/background_behavior.rs +832 -0
data/vendor/crates/spikard-http/tests/common/handlers.rs +309 -0
data/vendor/crates/spikard-http/tests/common/mod.rs +26 -0
data/vendor/crates/spikard-http/tests/di_integration.rs +192 -0
data/vendor/crates/spikard-http/tests/doc_snippets.rs +5 -0
data/vendor/crates/spikard-http/tests/lifecycle_execution.rs +1093 -0
data/vendor/crates/spikard-http/tests/multipart_behavior.rs +656 -0
data/vendor/crates/spikard-http/tests/server_config_builder.rs +314 -0
data/vendor/crates/spikard-http/tests/sse_behavior.rs +620 -0
data/vendor/crates/spikard-http/tests/websocket_behavior.rs +663 -0
data/vendor/crates/spikard-rb/Cargo.toml +48 -42
data/vendor/crates/spikard-rb/build.rs +199 -8
data/vendor/crates/spikard-rb/src/background.rs +63 -63
data/vendor/crates/spikard-rb/src/config/mod.rs +5 -0
data/vendor/crates/spikard-rb/src/{config.rs → config/server_config.rs} +285 -294
data/vendor/crates/spikard-rb/src/conversion.rs +554 -453
data/vendor/crates/spikard-rb/src/di/builder.rs +100 -0
data/vendor/crates/spikard-rb/src/{di.rs → di/mod.rs} +375 -409
data/vendor/crates/spikard-rb/src/handler.rs +618 -625
data/vendor/crates/spikard-rb/src/integration/mod.rs +3 -0
data/vendor/crates/spikard-rb/src/lib.rs +1806 -2771
data/vendor/crates/spikard-rb/src/lifecycle.rs +275 -274
data/vendor/crates/spikard-rb/src/metadata/mod.rs +5 -0
data/vendor/crates/spikard-rb/src/metadata/route_extraction.rs +442 -0
data/vendor/crates/spikard-rb/src/runtime/mod.rs +5 -0
data/vendor/crates/spikard-rb/src/runtime/server_runner.rs +324 -0
data/vendor/crates/spikard-rb/src/server.rs +305 -283
data/vendor/crates/spikard-rb/src/sse.rs +231 -231
data/vendor/crates/spikard-rb/src/{test_client.rs → testing/client.rs} +538 -404
data/vendor/crates/spikard-rb/src/testing/mod.rs +7 -0
data/vendor/crates/spikard-rb/src/{test_sse.rs → testing/sse.rs} +143 -143
data/vendor/crates/spikard-rb/src/testing/websocket.rs +608 -0
data/vendor/crates/spikard-rb/src/websocket.rs +377 -233
metadata +60 -13
data/vendor/crates/spikard-http/src/parameters.rs +0 -1
data/vendor/crates/spikard-http/src/problem.rs +0 -1
data/vendor/crates/spikard-http/src/router.rs +0 -1
data/vendor/crates/spikard-http/src/schema_registry.rs +0 -1
data/vendor/crates/spikard-http/src/type_hints.rs +0 -1
data/vendor/crates/spikard-http/src/validation.rs +0 -1
data/vendor/crates/spikard-rb/src/test_websocket.rs +0 -221

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

@@ -0,0 +1,309 @@
+//! Standard mock handlers for testing
+//!
+//! This module provides reusable mock handler implementations that cover common
+//! test scenarios without requiring language bindings. All handlers implement the
+//! Handler trait and are suitable for integration testing.
+use axum::body::Body;
+use axum::http::{Request, Response, StatusCode};
+use serde_json::json;
+use spikard_http::{Handler, HandlerResult, RequestData};
+use std::future::Future;
+use std::pin::Pin;
+/// Handler that always returns 200 OK with plain text response
+///
+/// Useful for testing basic handler execution and middleware chains.
+///
+/// # Example
+///
+/// ```ignore
+/// let handler = SuccessHandler;
+/// assert_eq!(handler.call(request, request_data).await.is_ok(), true);
+/// ```
+pub struct SuccessHandler;
+impl Handler for SuccessHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        _request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        Box::pin(async move {
+            let response = Response::builder()
+                .status(StatusCode::OK)
+                .header("content-type", "text/plain")
+                .body(Body::from("OK"))
+                .unwrap();
+            Ok(response)
+        })
+    }
+}
+/// Handler that always returns 400 Bad Request with error message
+///
+/// Useful for testing error handling in middleware and response processing.
+///
+/// # Example
+///
+/// ```ignore
+/// let handler = ErrorHandler;
+/// assert_eq!(handler.call(request, request_data).await.is_err(), true);
+/// ```
+pub struct ErrorHandler;
+impl Handler for ErrorHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        _request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        Box::pin(async move { Err((StatusCode::BAD_REQUEST, "Bad Request".to_string())) })
+    }
+}
+/// Handler that intentionally panics during execution
+///
+/// Useful for testing panic recovery and error handling in the HTTP server.
+/// This handler demonstrates that panics in handlers should be caught and
+/// converted to HTTP error responses.
+///
+/// # Example
+///
+/// ```ignore
+/// let handler = PanicHandler;
+/// // This will panic, should be caught by server middleware
+/// ```
+pub struct PanicHandler;
+impl Handler for PanicHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        _request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        Box::pin(async move {
+            panic!("Intentional panic for testing");
+        })
+    }
+}
+/// Handler that echoes the request body back as response
+///
+/// Useful for testing request body parsing and serialization/deserialization.
+/// The response will be a JSON object containing the received body.
+///
+/// # Example
+///
+/// ```ignore
+/// let handler = EchoHandler;
+/// // Request with body {"key": "value"} returns same body
+/// ```
+pub 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 = Response::builder()
+                .status(StatusCode::OK)
+                .header("content-type", "application/json")
+                .body(Body::from(request_data.body.to_string()))
+                .unwrap();
+            Ok(response)
+        })
+    }
+}
+/// Handler that returns a JSON response with configurable status code and body
+///
+/// Useful for testing content negotiation and JSON serialization.
+/// The response body is configurable via the `body` field, and the status code
+/// via the `status_code` field.
+///
+/// # Example
+///
+/// ```ignore
+/// let handler = JsonHandler {
+///     status_code: StatusCode::CREATED,
+///     body: json!({"id": 1, "name": "test"}),
+/// };
+/// ```
+pub struct JsonHandler {
+    /// HTTP status code for the response
+    pub status_code: StatusCode,
+    /// JSON body to return in response
+    pub body: serde_json::Value,
+}
+impl JsonHandler {
+    /// Create a new JSON handler with given status code and body
+    pub fn new(status_code: StatusCode, body: serde_json::Value) -> Self {
+        Self { status_code, body }
+    }
+    /// Create a JSON handler with 200 OK status
+    pub fn ok(body: serde_json::Value) -> Self {
+        Self {
+            status_code: StatusCode::OK,
+            body,
+        }
+    }
+    /// Create a JSON handler with 201 Created status
+    pub fn created(body: serde_json::Value) -> Self {
+        Self {
+            status_code: StatusCode::CREATED,
+            body,
+        }
+    }
+    /// Create a JSON handler with 400 Bad Request status
+    pub fn bad_request(body: serde_json::Value) -> Self {
+        Self {
+            status_code: StatusCode::BAD_REQUEST,
+            body,
+        }
+    }
+    /// Create a JSON handler with 500 Internal Server Error status
+    pub fn server_error(body: serde_json::Value) -> Self {
+        Self {
+            status_code: StatusCode::INTERNAL_SERVER_ERROR,
+            body,
+        }
+    }
+}
+impl Handler for JsonHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        _request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        let status_code = self.status_code;
+        let body = self.body.clone();
+        Box::pin(async move {
+            let response = Response::builder()
+                .status(status_code)
+                .header("content-type", "application/json")
+                .body(Body::from(body.to_string()))
+                .unwrap();
+            Ok(response)
+        })
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+    use std::sync::Arc;
+    fn create_test_request_data() -> RequestData {
+        RequestData {
+            path_params: Arc::new(HashMap::new()),
+            query_params: serde_json::Value::Null,
+            validated_params: None,
+            raw_query_params: Arc::new(HashMap::new()),
+            body: json!({"test": "data"}),
+            raw_body: None,
+            headers: Arc::new(HashMap::new()),
+            cookies: Arc::new(HashMap::new()),
+            method: "GET".to_string(),
+            path: "/test".to_string(),
+            #[cfg(feature = "di")]
+            dependencies: None,
+        }
+    }
+    #[tokio::test]
+    async fn test_success_handler() {
+        let handler = SuccessHandler;
+        let request = Request::builder().body(Body::empty()).unwrap();
+        let request_data = create_test_request_data();
+        let result = handler.call(request, request_data).await;
+        assert!(result.is_ok());
+        let response = result.unwrap();
+        assert_eq!(response.status(), StatusCode::OK);
+    }
+    #[tokio::test]
+    async fn test_error_handler() {
+        let handler = ErrorHandler;
+        let request = Request::builder().body(Body::empty()).unwrap();
+        let request_data = create_test_request_data();
+        let result = handler.call(request, request_data).await;
+        assert!(result.is_err());
+        let (status, msg) = result.unwrap_err();
+        assert_eq!(status, StatusCode::BAD_REQUEST);
+        assert_eq!(msg, "Bad Request");
+    }
+    #[tokio::test]
+    async fn test_echo_handler() {
+        let handler = EchoHandler;
+        let request = Request::builder().body(Body::empty()).unwrap();
+        let request_data = create_test_request_data();
+        let result = handler.call(request, request_data.clone()).await;
+        assert!(result.is_ok());
+        let response = result.unwrap();
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(
+            response.headers().get("content-type").unwrap().to_str().unwrap(),
+            "application/json"
+        );
+    }
+    #[tokio::test]
+    async fn test_json_handler_ok() {
+        let body = json!({"id": 1, "name": "test"});
+        let handler = JsonHandler::ok(body.clone());
+        let request = Request::builder().body(Body::empty()).unwrap();
+        let request_data = create_test_request_data();
+        let result = handler.call(request, request_data).await;
+        assert!(result.is_ok());
+        let response = result.unwrap();
+        assert_eq!(response.status(), StatusCode::OK);
+    }
+    #[tokio::test]
+    async fn test_json_handler_created() {
+        let body = json!({"id": 1});
+        let handler = JsonHandler::created(body);
+        let request = Request::builder().body(Body::empty()).unwrap();
+        let request_data = create_test_request_data();
+        let result = handler.call(request, request_data).await;
+        assert!(result.is_ok());
+        let response = result.unwrap();
+        assert_eq!(response.status(), StatusCode::CREATED);
+    }
+    #[tokio::test]
+    async fn test_json_handler_custom() {
+        let body = json!({"error": "Custom error"});
+        let handler = JsonHandler::new(StatusCode::NOT_FOUND, body);
+        let request = Request::builder().body(Body::empty()).unwrap();
+        let request_data = create_test_request_data();
+        let result = handler.call(request, request_data).await;
+        assert!(result.is_ok());
+        let response = result.unwrap();
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+    }
+}

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

@@ -0,0 +1,26 @@
+//! Common test utilities for spikard-http tests
+//!
+//! This module provides reusable test fixtures and mock handlers that implement
+//! the Handler trait for testing various scenarios without requiring language bindings.
+//!
+//! # Examples
+//!
+//! ```ignore
+//! use common::handlers::SuccessHandler;
+//! use common::test_builders::{HandlerBuilder, RequestBuilder};
+//! use spikard_http::Handler;
+//!
+//! let handler = SuccessHandler;
+//! let fluent_handler = HandlerBuilder::new().status(200).build();
+//! // Use in tests...
+//! ```
+#![allow(dead_code)]
+pub mod handlers;
+pub mod test_builders;
+#[allow(unused_imports)]
+pub use handlers::{EchoHandler, ErrorHandler, JsonHandler, PanicHandler, SuccessHandler};
+#[allow(unused_imports)]
+pub use test_builders::{HandlerBuilder, RequestBuilder, assert_status, load_fixture, parse_json_body};

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

@@ -0,0 +1,192 @@
+#![allow(clippy::pedantic, clippy::nursery, clippy::all)]
+//! Integration tests for Dependency Injection system
+//!
+//! These tests verify that the DI system integrates correctly with the HTTP handler pipeline.
+//! More complex DI features (factories, dependencies, cleanup) are tested in unit tests.
+#![cfg(feature = "di")]
+mod common;
+use axum::body::Body;
+use axum::http::{Request, Response, StatusCode};
+use spikard_core::di::{DependencyContainer, ValueDependency};
+use spikard_http::{DependencyInjectingHandler, Handler, HandlerResult, RequestData};
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+/// Test handler that accesses injected dependencies
+struct DependencyAccessHandler {
+    dependency_name: String,
+}
+impl Handler for DependencyAccessHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        let dependency_name = self.dependency_name.clone();
+        Box::pin(async move {
+            if let Some(deps) = &request_data.dependencies {
+                if let Some(value) = deps.get::<String>(&dependency_name) {
+                    let response = Response::builder()
+                        .status(StatusCode::OK)
+                        .body(Body::from(format!("Dependency value: {}", *value)))
+                        .unwrap();
+                    Ok(response)
+                } else {
+                    Err((
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        format!("Dependency '{}' not found", dependency_name),
+                    ))
+                }
+            } else {
+                Err((
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "No dependencies attached".to_string(),
+                ))
+            }
+        })
+    }
+}
+#[tokio::test]
+async fn test_di_value_injection() {
+    let mut container = DependencyContainer::new();
+    container
+        .register(
+            "config".to_string(),
+            Arc::new(ValueDependency::new("config", "test_config_value".to_string())),
+        )
+        .unwrap();
+    let handler = Arc::new(DependencyAccessHandler {
+        dependency_name: "config".to_string(),
+    });
+    let di_handler = DependencyInjectingHandler::new(handler, Arc::new(container), vec!["config".to_string()]);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: serde_json::Value::Null,
+        validated_params: None,
+        raw_query_params: Arc::new(HashMap::new()),
+        body: serde_json::Value::Null,
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/".to_string(),
+        #[cfg(feature = "di")]
+        dependencies: None,
+    };
+    let result = di_handler.call(request, request_data).await;
+    let response = match result {
+        Ok(r) => r,
+        Err((status, msg)) => {
+            panic!("Expected Ok, got Err({:?}, {})", status, msg);
+        }
+    };
+    assert_eq!(response.status(), StatusCode::OK);
+    use http_body_util::BodyExt;
+    let body_bytes = response.into_body().collect().await.unwrap().to_bytes();
+    let body_str = String::from_utf8(body_bytes.to_vec()).unwrap();
+    assert_eq!(body_str, "Dependency value: test_config_value");
+}
+#[tokio::test]
+async fn test_di_missing_dependency_error() {
+    let container = DependencyContainer::new();
+    let handler = Arc::new(DependencyAccessHandler {
+        dependency_name: "database".to_string(),
+    });
+    let di_handler = DependencyInjectingHandler::new(handler, Arc::new(container), vec!["database".to_string()]);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: serde_json::Value::Null,
+        validated_params: None,
+        raw_query_params: Arc::new(HashMap::new()),
+        body: serde_json::Value::Null,
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/".to_string(),
+        #[cfg(feature = "di")]
+        dependencies: None,
+    };
+    let result = di_handler.call(request, request_data).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+}
+#[tokio::test]
+async fn test_di_multiple_value_dependencies() {
+    let mut container = DependencyContainer::new();
+    container
+        .register(
+            "config".to_string(),
+            Arc::new(ValueDependency::new("config", "config_value".to_string())),
+        )
+        .unwrap();
+    container
+        .register(
+            "cache_url".to_string(),
+            Arc::new(ValueDependency::new("cache_url", "redis://localhost".to_string())),
+        )
+        .unwrap();
+    let handler = Arc::new(DependencyAccessHandler {
+        dependency_name: "cache_url".to_string(),
+    });
+    let di_handler = DependencyInjectingHandler::new(handler, Arc::new(container), vec!["cache_url".to_string()]);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = RequestData {
+        path_params: Arc::new(HashMap::new()),
+        query_params: serde_json::Value::Null,
+        validated_params: None,
+        raw_query_params: Arc::new(HashMap::new()),
+        body: serde_json::Value::Null,
+        raw_body: None,
+        headers: Arc::new(HashMap::new()),
+        cookies: Arc::new(HashMap::new()),
+        method: "GET".to_string(),
+        path: "/".to_string(),
+        #[cfg(feature = "di")]
+        dependencies: None,
+    };
+    let result = di_handler.call(request, request_data).await;
+    let response = match result {
+        Ok(r) => r,
+        Err((status, msg)) => {
+            panic!("Expected Ok, got Err({:?}, {})", status, msg);
+        }
+    };
+    assert_eq!(response.status(), StatusCode::OK);
+    use http_body_util::BodyExt;
+    let body_bytes = response.into_body().collect().await.unwrap().to_bytes();
+    let body_str = String::from_utf8(body_bytes.to_vec()).unwrap();
+    assert_eq!(body_str, "Dependency value: redis://localhost");
+}

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

@@ -0,0 +1,5 @@
+#![allow(clippy::pedantic, clippy::nursery, clippy::all)]
+//! Ensure documented Rust DI snippet stays compiling.
+#[cfg(feature = "di")]
+doc_comment::doctest!("../../../docs/snippets/rust/dependency_injection.md");