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

spikard 0.3.6 → 0.5.0

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 (113) hide show

checksums.yaml +4 -4
data/README.md +21 -6
data/ext/spikard_rb/Cargo.toml +2 -2
data/lib/spikard/app.rb +33 -14
data/lib/spikard/testing.rb +47 -12
data/lib/spikard/version.rb +1 -1
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 +4 -4
data/vendor/crates/spikard-core/src/debug.rs +64 -0
data/vendor/crates/spikard-core/src/di/container.rs +3 -27
data/vendor/crates/spikard-core/src/di/factory.rs +1 -5
data/vendor/crates/spikard-core/src/di/graph.rs +8 -47
data/vendor/crates/spikard-core/src/di/mod.rs +1 -1
data/vendor/crates/spikard-core/src/di/resolved.rs +1 -7
data/vendor/crates/spikard-core/src/di/value.rs +2 -4
data/vendor/crates/spikard-core/src/errors.rs +30 -0
data/vendor/crates/spikard-core/src/http.rs +262 -0
data/vendor/crates/spikard-core/src/lib.rs +1 -1
data/vendor/crates/spikard-core/src/lifecycle.rs +764 -0
data/vendor/crates/spikard-core/src/metadata.rs +389 -0
data/vendor/crates/spikard-core/src/parameters.rs +1962 -159
data/vendor/crates/spikard-core/src/problem.rs +34 -0
data/vendor/crates/spikard-core/src/request_data.rs +966 -1
data/vendor/crates/spikard-core/src/router.rs +263 -2
data/vendor/crates/spikard-core/src/validation/error_mapper.rs +688 -0
data/vendor/crates/spikard-core/src/{validation.rs → validation/mod.rs} +26 -268
data/vendor/crates/spikard-http/Cargo.toml +12 -16
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 +65 -16
data/vendor/crates/spikard-http/src/background.rs +1614 -3
data/vendor/crates/spikard-http/src/cors.rs +515 -0
data/vendor/crates/spikard-http/src/debug.rs +65 -0
data/vendor/crates/spikard-http/src/di_handler.rs +1322 -77
data/vendor/crates/spikard-http/src/handler_response.rs +711 -0
data/vendor/crates/spikard-http/src/handler_trait.rs +607 -5
data/vendor/crates/spikard-http/src/handler_trait_tests.rs +6 -0
data/vendor/crates/spikard-http/src/lib.rs +33 -28
data/vendor/crates/spikard-http/src/lifecycle/adapter.rs +81 -0
data/vendor/crates/spikard-http/src/lifecycle.rs +765 -0
data/vendor/crates/spikard-http/src/middleware/mod.rs +372 -117
data/vendor/crates/spikard-http/src/middleware/multipart.rs +836 -10
data/vendor/crates/spikard-http/src/middleware/urlencoded.rs +409 -43
data/vendor/crates/spikard-http/src/middleware/validation.rs +513 -65
data/vendor/crates/spikard-http/src/openapi/parameter_extraction.rs +345 -0
data/vendor/crates/spikard-http/src/openapi/schema_conversion.rs +1055 -0
data/vendor/crates/spikard-http/src/openapi/spec_generation.rs +473 -3
data/vendor/crates/spikard-http/src/query_parser.rs +455 -31
data/vendor/crates/spikard-http/src/response.rs +321 -0
data/vendor/crates/spikard-http/src/server/handler.rs +1572 -9
data/vendor/crates/spikard-http/src/server/lifecycle_execution.rs +136 -0
data/vendor/crates/spikard-http/src/server/mod.rs +875 -178
data/vendor/crates/spikard-http/src/server/request_extraction.rs +674 -23
data/vendor/crates/spikard-http/src/server/routing_factory.rs +599 -0
data/vendor/crates/spikard-http/src/sse.rs +983 -21
data/vendor/crates/spikard-http/src/testing/form.rs +38 -0
data/vendor/crates/spikard-http/src/testing/test_client.rs +0 -2
data/vendor/crates/spikard-http/src/testing.rs +7 -7
data/vendor/crates/spikard-http/src/websocket.rs +1055 -4
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 +10 -4
data/vendor/crates/spikard-rb/build.rs +196 -5
data/vendor/crates/spikard-rb/src/config/mod.rs +5 -0
data/vendor/crates/spikard-rb/src/{config.rs → config/server_config.rs} +100 -109
data/vendor/crates/spikard-rb/src/conversion.rs +121 -20
data/vendor/crates/spikard-rb/src/di/builder.rs +100 -0
data/vendor/crates/spikard-rb/src/{di.rs → di/mod.rs} +12 -46
data/vendor/crates/spikard-rb/src/handler.rs +100 -107
data/vendor/crates/spikard-rb/src/integration/mod.rs +3 -0
data/vendor/crates/spikard-rb/src/lib.rs +467 -1428
data/vendor/crates/spikard-rb/src/lifecycle.rs +1 -0
data/vendor/crates/spikard-rb/src/metadata/mod.rs +5 -0
data/vendor/crates/spikard-rb/src/metadata/route_extraction.rs +447 -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 +47 -22
data/vendor/crates/spikard-rb/src/{test_client.rs → testing/client.rs} +187 -40
data/vendor/crates/spikard-rb/src/testing/mod.rs +7 -0
data/vendor/crates/spikard-rb/src/testing/websocket.rs +635 -0
data/vendor/crates/spikard-rb/src/websocket.rs +178 -37
metadata +46 -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-rb/src/{test_sse.rs → testing/sse.rs} +0 -0

data/vendor/crates/spikard-bindings-shared/src/lifecycle_executor.rs ADDED Viewed

@@ -0,0 +1,616 @@
+//! Shared lifecycle hook executor infrastructure
+//!
+//! This module provides a language-agnostic abstraction for executing lifecycle hooks.
+//! It extracts ~960 lines of duplicated logic from Python, Node.js, Ruby, and PHP bindings
+//! into reusable trait-based components.
+//!
+//! # Design
+//!
+//! The executor uses a trait-based pattern where language bindings implement
+//! `LanguageLifecycleHook` to provide language-specific hook invocation, while
+//! `LifecycleExecutor` handles the common logic:
+//!
+//! - Hook result type handling (Continue vs ShortCircuit)
+//! - Response/Request building from hook results
+//! - Error handling and conversion
+//!
+//! # Example
+//!
+//! ```ignore
+//! struct MyLanguageHook { ... }
+//!
+//! impl LanguageLifecycleHook for MyLanguageHook {
+//!     fn prepare_hook_data(&self, req: &Request<Body>) -> Result<Self::HookData, String> {
+//!         // Convert Request<Body> to language-specific representation
+//!     }
+//!
+//!     async fn invoke_hook(&self, data: Self::HookData) -> Result<HookResultData, String> {
+//!         // Call language function and return structured result
+//!     }
+//! }
+//! ```
+use axum::{
+    body::Body,
+    http::{Request, Response, StatusCode},
+};
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+/// Data returned from language-specific hook invocation
+///
+/// This is a normalized representation of hook results that abstracts away
+/// language-specific details. Bindings convert their native hook results
+/// into this common format.
+#[derive(Debug, Clone)]
+pub struct HookResultData {
+    /// Whether to continue execution (true) or short-circuit (false)
+    pub continue_execution: bool,
+    /// Optional status code for short-circuit responses
+    pub status_code: Option<u16>,
+    /// Optional headers to include in response
+    pub headers: Option<HashMap<String, String>>,
+    /// Optional body bytes for response
+    pub body: Option<Vec<u8>>,
+    /// Optional request modifications (method, path, headers, body)
+    pub request_modifications: Option<RequestModifications>,
+}
+/// Modifications to apply to a request
+#[derive(Debug, Clone)]
+pub struct RequestModifications {
+    /// New HTTP method (e.g., "GET", "POST")
+    pub method: Option<String>,
+    /// New request path
+    pub path: Option<String>,
+    /// New or updated headers
+    pub headers: Option<HashMap<String, String>>,
+    /// New request body
+    pub body: Option<Vec<u8>>,
+}
+impl HookResultData {
+    /// Create a Continue result (pass through)
+    pub fn continue_execution() -> Self {
+        Self {
+            continue_execution: true,
+            status_code: None,
+            headers: None,
+            body: None,
+            request_modifications: None,
+        }
+    }
+    /// Create a short-circuit response result
+    pub fn short_circuit(status_code: u16, body: Vec<u8>, headers: Option<HashMap<String, String>>) -> Self {
+        Self {
+            continue_execution: false,
+            status_code: Some(status_code),
+            headers,
+            body: Some(body),
+            request_modifications: None,
+        }
+    }
+    /// Create a request modification result
+    pub fn modify_request(modifications: RequestModifications) -> Self {
+        Self {
+            continue_execution: true,
+            status_code: None,
+            headers: None,
+            body: None,
+            request_modifications: Some(modifications),
+        }
+    }
+}
+/// Trait for language-specific lifecycle hook implementations
+///
+/// Each language binding implements this trait to provide language-specific
+/// hook invocation while delegating common logic to `LifecycleExecutor`.
+pub trait LanguageLifecycleHook: Send + Sync {
+    /// Language-specific hook data type
+    type HookData: Send;
+    /// Prepare hook data from the incoming request/response
+    ///
+    /// This should convert axum HTTP types to language-specific representations.
+    fn prepare_hook_data(&self, req: &Request<Body>) -> Result<Self::HookData, String>;
+    /// Invoke the language hook and return normalized result data
+    ///
+    /// This should call the language function and convert its result to `HookResultData`.
+    fn invoke_hook(&self, data: Self::HookData)
+    -> Pin<Box<dyn Future<Output = Result<HookResultData, String>> + Send>>;
+}
+/// Executor that handles common lifecycle hook logic
+///
+/// This executor is generic over any language binding that implements
+/// `LanguageLifecycleHook`. It provides common logic for:
+/// - Executing request hooks and handling short-circuits
+/// - Executing response hooks and building modified responses
+/// - Converting hook results to axum Request/Response types
+pub struct LifecycleExecutor<L: LanguageLifecycleHook> {
+    hook: Arc<L>,
+}
+impl<L: LanguageLifecycleHook> LifecycleExecutor<L> {
+    /// Create a new executor for the given hook
+    pub fn new(hook: Arc<L>) -> Self {
+        Self { hook }
+    }
+    /// Execute a request hook, handling Continue/ShortCircuit semantics
+    ///
+    /// Returns either the modified request or a short-circuit response.
+    pub async fn execute_request_hook(
+        &self,
+        req: Request<Body>,
+    ) -> Result<Result<Request<Body>, Response<Body>>, String> {
+        let hook_data = self.hook.prepare_hook_data(&req)?;
+        let result = self.hook.invoke_hook(hook_data).await?;
+        if !result.continue_execution {
+            let response = self.build_response_from_hook_result(&result)?;
+            return Ok(Err(response));
+        }
+        if let Some(modifications) = result.request_modifications {
+            let modified_req = self.apply_request_modifications(req, modifications)?;
+            Ok(Ok(modified_req))
+        } else {
+            Ok(Ok(req))
+        }
+    }
+    /// Execute a response hook, handling response modification
+    ///
+    /// Response hooks can only continue or modify the response,
+    /// never short-circuit.
+    pub async fn execute_response_hook(&self, resp: Response<Body>) -> Result<Response<Body>, String> {
+        let (parts, body) = resp.into_parts();
+        let body_bytes = extract_body(body).await?;
+        let dummy_req = Request::builder()
+            .method("GET")
+            .uri("/")
+            .body(Body::empty())
+            .map_err(|e| format!("Failed to build dummy request: {}", e))?;
+        let hook_data = self.hook.prepare_hook_data(&dummy_req)?;
+        let result = self.hook.invoke_hook(hook_data).await?;
+        if let Some(modifications) = result.request_modifications {
+            let mut builder = Response::builder().status(parts.status);
+            let header_mod_keys: Vec<String> = modifications
+                .headers
+                .as_ref()
+                .map(|mods| mods.keys().map(|k| k.to_lowercase()).collect())
+                .unwrap_or_default();
+            if let Some(header_mods) = modifications.headers {
+                for (key, value) in header_mods {
+                    builder = builder.header(&key, &value);
+                }
+            }
+            for (name, value) in parts.headers.iter() {
+                let key_str = name.as_str().to_lowercase();
+                if !header_mod_keys.contains(&key_str) {
+                    builder = builder.header(name, value);
+                }
+            }
+            let body = modifications.body.unwrap_or(body_bytes);
+            return builder
+                .body(Body::from(body))
+                .map_err(|e| format!("Failed to build modified response: {}", e));
+        }
+        let mut builder = Response::builder().status(parts.status);
+        for (name, value) in parts.headers {
+            if let Some(name) = name {
+                builder = builder.header(name, value);
+            }
+        }
+        builder
+            .body(Body::from(body_bytes))
+            .map_err(|e| format!("Failed to rebuild response: {}", e))
+    }
+    /// Build an axum Response from hook result data
+    fn build_response_from_hook_result(&self, result: &HookResultData) -> Result<Response<Body>, String> {
+        let status_code = result.status_code.unwrap_or(200);
+        let status =
+            StatusCode::from_u16(status_code).map_err(|e| format!("Invalid status code {}: {}", status_code, e))?;
+        let mut builder = Response::builder().status(status);
+        if let Some(ref headers) = result.headers {
+            for (key, value) in headers {
+                builder = builder.header(key, value);
+            }
+        }
+        if !builder
+            .headers_ref()
+            .map(|h| h.contains_key("content-type"))
+            .unwrap_or(false)
+        {
+            builder = builder.header("content-type", "application/json");
+        }
+        let body = result.body.clone().unwrap_or_else(|| b"{}".to_vec());
+        builder
+            .body(Body::from(body))
+            .map_err(|e| format!("Failed to build response: {}", e))
+    }
+    /// Apply request modifications to a request
+    fn apply_request_modifications(
+        &self,
+        req: Request<Body>,
+        mods: RequestModifications,
+    ) -> Result<Request<Body>, String> {
+        let (mut parts, body) = req.into_parts();
+        if let Some(method) = &mods.method {
+            parts.method = method
+                .parse()
+                .map_err(|e| format!("Invalid method '{}': {}", method, e))?;
+        }
+        if let Some(path) = &mods.path {
+            parts.uri = path.parse().map_err(|e| format!("Invalid path '{}': {}", path, e))?;
+        }
+        if let Some(new_headers) = &mods.headers {
+            for (key, value) in new_headers {
+                let header_name: http::header::HeaderName =
+                    key.parse().map_err(|_| format!("Invalid header name: {}", key))?;
+                let header_value: http::header::HeaderValue = value
+                    .parse()
+                    .map_err(|_| format!("Invalid header value for {}: {}", key, value))?;
+                parts.headers.insert(header_name, header_value);
+            }
+        }
+        let body = if let Some(new_body) = mods.body {
+            Body::from(new_body)
+        } else {
+            body
+        };
+        Ok(Request::from_parts(parts, body))
+    }
+}
+/// Extract body bytes from an axum Body
+///
+/// This is a helper used by lifecycle executors to read response bodies.
+pub async fn extract_body(body: Body) -> Result<Vec<u8>, String> {
+    use http_body_util::BodyExt;
+    let bytes = body
+        .collect()
+        .await
+        .map_err(|e| format!("Failed to read body: {}", e))?
+        .to_bytes();
+    Ok(bytes.to_vec())
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_hook_result_data_continue() {
+        let result = HookResultData::continue_execution();
+        assert!(result.continue_execution);
+        assert_eq!(result.status_code, None);
+        assert_eq!(result.body, None);
+    }
+    #[test]
+    fn test_hook_result_data_short_circuit() {
+        let body = b"error".to_vec();
+        let mut headers = HashMap::new();
+        headers.insert("x-error".to_string(), "true".to_string());
+        let result = HookResultData::short_circuit(400, body.clone(), Some(headers.clone()));
+        assert!(!result.continue_execution);
+        assert_eq!(result.status_code, Some(400));
+        assert_eq!(result.body, Some(body));
+        assert_eq!(result.headers, Some(headers));
+    }
+    #[test]
+    fn test_hook_result_data_modify_request() {
+        let mods = RequestModifications {
+            method: Some("POST".to_string()),
+            path: Some("/new-path".to_string()),
+            headers: None,
+            body: None,
+        };
+        let result = HookResultData::modify_request(mods.clone());
+        assert!(result.continue_execution);
+        assert_eq!(result.status_code, None);
+        assert_eq!(
+            result.request_modifications.as_ref().unwrap().method,
+            Some("POST".to_string())
+        );
+        assert_eq!(
+            result.request_modifications.as_ref().unwrap().path,
+            Some("/new-path".to_string())
+        );
+    }
+    #[test]
+    fn test_request_modifications_creation() {
+        let mods = RequestModifications {
+            method: Some("PUT".to_string()),
+            path: Some("/api/resource".to_string()),
+            headers: None,
+            body: Some(b"data".to_vec()),
+        };
+        assert_eq!(mods.method, Some("PUT".to_string()));
+        assert_eq!(mods.path, Some("/api/resource".to_string()));
+        assert_eq!(mods.body, Some(b"data".to_vec()));
+    }
+    struct MockHook {
+        result: HookResultData,
+    }
+    impl LanguageLifecycleHook for MockHook {
+        type HookData = ();
+        fn prepare_hook_data(&self, _req: &Request<Body>) -> Result<Self::HookData, String> {
+            Ok(())
+        }
+        fn invoke_hook(
+            &self,
+            _data: Self::HookData,
+        ) -> Pin<Box<dyn Future<Output = Result<HookResultData, String>> + Send>> {
+            let result = self.result.clone();
+            Box::pin(async move { Ok(result) })
+        }
+    }
+    #[tokio::test]
+    async fn test_execute_request_hook_continue() {
+        let hook = Arc::new(MockHook {
+            result: HookResultData::continue_execution(),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = executor.execute_request_hook(req).await.unwrap();
+        assert!(result.is_ok());
+    }
+    #[tokio::test]
+    async fn test_execute_request_hook_short_circuit() {
+        let hook = Arc::new(MockHook {
+            result: HookResultData::short_circuit(403, b"Forbidden".to_vec(), None),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = executor.execute_request_hook(req).await.unwrap();
+        assert!(result.is_err());
+        let response = result.unwrap_err();
+        assert_eq!(response.status(), StatusCode::FORBIDDEN);
+    }
+    #[tokio::test]
+    async fn test_execute_request_hook_modify_request() {
+        let mods = RequestModifications {
+            method: Some("POST".to_string()),
+            path: Some("/new-path".to_string()),
+            headers: None,
+            body: Some(b"new body".to_vec()),
+        };
+        let hook = Arc::new(MockHook {
+            result: HookResultData::modify_request(mods),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let req = Request::builder()
+            .method("GET")
+            .uri("/old-path")
+            .body(Body::empty())
+            .unwrap();
+        let result = executor.execute_request_hook(req).await.unwrap();
+        assert!(result.is_ok());
+        let modified_req = result.unwrap();
+        assert_eq!(modified_req.method(), "POST");
+        assert_eq!(modified_req.uri().path(), "/new-path");
+    }
+    #[tokio::test]
+    async fn test_execute_response_hook_with_modifications() {
+        let mods = RequestModifications {
+            method: None,
+            path: None,
+            headers: Some({
+                let mut h = HashMap::new();
+                h.insert("X-Modified".to_string(), "true".to_string());
+                h
+            }),
+            body: Some(b"modified response".to_vec()),
+        };
+        let hook = Arc::new(MockHook {
+            result: HookResultData::modify_request(mods),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let resp = Response::builder().status(200).body(Body::from("original")).unwrap();
+        let result = executor.execute_response_hook(resp).await.unwrap();
+        assert_eq!(result.status(), StatusCode::OK);
+        assert_eq!(result.headers().get("X-Modified").unwrap().to_str().unwrap(), "true");
+    }
+    #[tokio::test]
+    async fn test_build_response_from_hook_result_with_headers() {
+        let mut headers = HashMap::new();
+        headers.insert("X-Custom".to_string(), "value".to_string());
+        let result = HookResultData::short_circuit(201, b"Created".to_vec(), Some(headers));
+        let hook = Arc::new(MockHook {
+            result: HookResultData::continue_execution(),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let response = executor.build_response_from_hook_result(&result).unwrap();
+        assert_eq!(response.status(), StatusCode::CREATED);
+        assert_eq!(response.headers().get("X-Custom").unwrap().to_str().unwrap(), "value");
+    }
+    #[tokio::test]
+    async fn test_build_response_from_hook_result_default_content_type() {
+        let result = HookResultData::short_circuit(200, b"{}".to_vec(), None);
+        let hook = Arc::new(MockHook {
+            result: HookResultData::continue_execution(),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let response = executor.build_response_from_hook_result(&result).unwrap();
+        assert_eq!(
+            response.headers().get("content-type").unwrap().to_str().unwrap(),
+            "application/json"
+        );
+    }
+    #[tokio::test]
+    async fn test_apply_request_modifications_method() {
+        let mods = RequestModifications {
+            method: Some("PATCH".to_string()),
+            path: None,
+            headers: None,
+            body: None,
+        };
+        let hook = Arc::new(MockHook {
+            result: HookResultData::continue_execution(),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let req = Request::builder().method("GET").body(Body::empty()).unwrap();
+        let modified = executor.apply_request_modifications(req, mods).unwrap();
+        assert_eq!(modified.method(), "PATCH");
+    }
+    #[tokio::test]
+    async fn test_apply_request_modifications_path() {
+        let mods = RequestModifications {
+            method: None,
+            path: Some("/api/v2/users".to_string()),
+            headers: None,
+            body: None,
+        };
+        let hook = Arc::new(MockHook {
+            result: HookResultData::continue_execution(),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let req = Request::builder().uri("/api/v1/users").body(Body::empty()).unwrap();
+        let modified = executor.apply_request_modifications(req, mods).unwrap();
+        assert_eq!(modified.uri().path(), "/api/v2/users");
+    }
+    #[tokio::test]
+    async fn test_apply_request_modifications_headers() {
+        let mut new_headers = HashMap::new();
+        new_headers.insert("Authorization".to_string(), "Bearer token".to_string());
+        let mods = RequestModifications {
+            method: None,
+            path: None,
+            headers: Some(new_headers),
+            body: None,
+        };
+        let hook = Arc::new(MockHook {
+            result: HookResultData::continue_execution(),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let modified = executor.apply_request_modifications(req, mods).unwrap();
+        assert_eq!(
+            modified.headers().get("Authorization").unwrap().to_str().unwrap(),
+            "Bearer token"
+        );
+    }
+    #[tokio::test]
+    async fn test_apply_request_modifications_body() {
+        let new_body = b"modified body".to_vec();
+        let mods = RequestModifications {
+            method: None,
+            path: None,
+            headers: None,
+            body: Some(new_body.clone()),
+        };
+        let hook = Arc::new(MockHook {
+            result: HookResultData::continue_execution(),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let req = Request::builder().body(Body::from("original body")).unwrap();
+        let modified = executor.apply_request_modifications(req, mods).unwrap();
+        let body_bytes = extract_body(modified.into_body()).await.unwrap();
+        assert_eq!(body_bytes, new_body);
+    }
+    #[tokio::test]
+    async fn test_apply_request_modifications_invalid_method() {
+        let mods = RequestModifications {
+            method: Some("".to_string()),
+            path: None,
+            headers: None,
+            body: None,
+        };
+        let hook = Arc::new(MockHook {
+            result: HookResultData::continue_execution(),
+        });
+        let executor = LifecycleExecutor::new(hook);
+        let req = Request::builder().body(Body::empty()).unwrap();
+        let result = executor.apply_request_modifications(req, mods);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid method"));
+    }
+    #[tokio::test]
+    async fn test_extract_body_helper() {
+        let body = Body::from("test data");
+        let bytes = extract_body(body).await.unwrap();
+        assert_eq!(bytes, b"test data");
+    }
+    #[tokio::test]
+    async fn test_extract_body_empty() {
+        let body = Body::empty();
+        let bytes = extract_body(body).await.unwrap();
+        assert_eq!(bytes.len(), 0);
+    }
+}