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

spikard 0.5.0 → 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 (135) hide show

checksums.yaml +4 -4
data/LICENSE +1 -1
data/README.md +674 -674
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 -405
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 -256
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 -63
data/vendor/crates/spikard-bindings-shared/examples/config_extraction.rs +132 -132
data/vendor/crates/spikard-bindings-shared/src/config_extractor.rs +752 -752
data/vendor/crates/spikard-bindings-shared/src/conversion_traits.rs +194 -194
data/vendor/crates/spikard-bindings-shared/src/di_traits.rs +246 -246
data/vendor/crates/spikard-bindings-shared/src/error_response.rs +401 -401
data/vendor/crates/spikard-bindings-shared/src/handler_base.rs +238 -238
data/vendor/crates/spikard-bindings-shared/src/lib.rs +24 -24
data/vendor/crates/spikard-bindings-shared/src/lifecycle_base.rs +292 -292
data/vendor/crates/spikard-bindings-shared/src/lifecycle_executor.rs +616 -616
data/vendor/crates/spikard-bindings-shared/src/response_builder.rs +305 -305
data/vendor/crates/spikard-bindings-shared/src/test_client_base.rs +248 -248
data/vendor/crates/spikard-bindings-shared/src/validation_helpers.rs +351 -351
data/vendor/crates/spikard-bindings-shared/tests/comprehensive_coverage.rs +454 -454
data/vendor/crates/spikard-bindings-shared/tests/error_response_edge_cases.rs +383 -383
data/vendor/crates/spikard-bindings-shared/tests/handler_base_integration.rs +280 -280
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 -127
data/vendor/crates/spikard-core/src/di/container.rs +702 -702
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 -534
data/vendor/crates/spikard-core/src/di/graph.rs +506 -506
data/vendor/crates/spikard-core/src/di/mod.rs +192 -192
data/vendor/crates/spikard-core/src/di/resolved.rs +405 -405
data/vendor/crates/spikard-core/src/di/value.rs +281 -281
data/vendor/crates/spikard-core/src/errors.rs +69 -69
data/vendor/crates/spikard-core/src/http.rs +415 -415
data/vendor/crates/spikard-core/src/lib.rs +29 -29
data/vendor/crates/spikard-core/src/lifecycle.rs +1186 -1186
data/vendor/crates/spikard-core/src/metadata.rs +389 -389
data/vendor/crates/spikard-core/src/parameters.rs +2525 -2525
data/vendor/crates/spikard-core/src/problem.rs +344 -344
data/vendor/crates/spikard-core/src/request_data.rs +1154 -1154
data/vendor/crates/spikard-core/src/router.rs +510 -510
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 -688
data/vendor/crates/spikard-core/src/validation/mod.rs +457 -457
data/vendor/crates/spikard-http/Cargo.toml +62 -64
data/vendor/crates/spikard-http/examples/sse-notifications.rs +148 -148
data/vendor/crates/spikard-http/examples/websocket-chat.rs +92 -92
data/vendor/crates/spikard-http/src/auth.rs +296 -296
data/vendor/crates/spikard-http/src/background.rs +1860 -1860
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 -1005
data/vendor/crates/spikard-http/src/debug.rs +128 -128
data/vendor/crates/spikard-http/src/di_handler.rs +1668 -1668
data/vendor/crates/spikard-http/src/handler_response.rs +901 -901
data/vendor/crates/spikard-http/src/handler_trait.rs +838 -830
data/vendor/crates/spikard-http/src/handler_trait_tests.rs +290 -290
data/vendor/crates/spikard-http/src/lib.rs +534 -534
data/vendor/crates/spikard-http/src/lifecycle/adapter.rs +230 -230
data/vendor/crates/spikard-http/src/lifecycle.rs +1193 -1193
data/vendor/crates/spikard-http/src/middleware/mod.rs +560 -540
data/vendor/crates/spikard-http/src/middleware/multipart.rs +912 -912
data/vendor/crates/spikard-http/src/middleware/urlencoded.rs +513 -513
data/vendor/crates/spikard-http/src/middleware/validation.rs +768 -735
data/vendor/crates/spikard-http/src/openapi/mod.rs +309 -309
data/vendor/crates/spikard-http/src/openapi/parameter_extraction.rs +535 -535
data/vendor/crates/spikard-http/src/openapi/schema_conversion.rs +1363 -1363
data/vendor/crates/spikard-http/src/openapi/spec_generation.rs +665 -665
data/vendor/crates/spikard-http/src/query_parser.rs +793 -793
data/vendor/crates/spikard-http/src/response.rs +720 -720
data/vendor/crates/spikard-http/src/server/handler.rs +1650 -1650
data/vendor/crates/spikard-http/src/server/lifecycle_execution.rs +234 -234
data/vendor/crates/spikard-http/src/server/mod.rs +1593 -1502
data/vendor/crates/spikard-http/src/server/request_extraction.rs +789 -770
data/vendor/crates/spikard-http/src/server/routing_factory.rs +629 -599
data/vendor/crates/spikard-http/src/sse.rs +1409 -1409
data/vendor/crates/spikard-http/src/testing/form.rs +52 -52
data/vendor/crates/spikard-http/src/testing/multipart.rs +64 -60
data/vendor/crates/spikard-http/src/testing/test_client.rs +311 -283
data/vendor/crates/spikard-http/src/testing.rs +406 -377
data/vendor/crates/spikard-http/src/websocket.rs +1404 -1375
data/vendor/crates/spikard-http/tests/background_behavior.rs +832 -832
data/vendor/crates/spikard-http/tests/common/handlers.rs +309 -309
data/vendor/crates/spikard-http/tests/common/mod.rs +26 -26
data/vendor/crates/spikard-http/tests/di_integration.rs +192 -192
data/vendor/crates/spikard-http/tests/doc_snippets.rs +5 -5
data/vendor/crates/spikard-http/tests/lifecycle_execution.rs +1093 -1093
data/vendor/crates/spikard-http/tests/multipart_behavior.rs +656 -656
data/vendor/crates/spikard-http/tests/server_config_builder.rs +314 -314
data/vendor/crates/spikard-http/tests/sse_behavior.rs +620 -620
data/vendor/crates/spikard-http/tests/websocket_behavior.rs +663 -663
data/vendor/crates/spikard-rb/Cargo.toml +48 -48
data/vendor/crates/spikard-rb/build.rs +199 -199
data/vendor/crates/spikard-rb/src/background.rs +63 -63
data/vendor/crates/spikard-rb/src/config/mod.rs +5 -5
data/vendor/crates/spikard-rb/src/config/server_config.rs +285 -285
data/vendor/crates/spikard-rb/src/conversion.rs +554 -554
data/vendor/crates/spikard-rb/src/di/builder.rs +100 -100
data/vendor/crates/spikard-rb/src/di/mod.rs +375 -375
data/vendor/crates/spikard-rb/src/handler.rs +618 -618
data/vendor/crates/spikard-rb/src/integration/mod.rs +3 -3
data/vendor/crates/spikard-rb/src/lib.rs +1806 -1810
data/vendor/crates/spikard-rb/src/lifecycle.rs +275 -275
data/vendor/crates/spikard-rb/src/metadata/mod.rs +5 -5
data/vendor/crates/spikard-rb/src/metadata/route_extraction.rs +442 -447
data/vendor/crates/spikard-rb/src/runtime/mod.rs +5 -5
data/vendor/crates/spikard-rb/src/runtime/server_runner.rs +324 -324
data/vendor/crates/spikard-rb/src/server.rs +305 -308
data/vendor/crates/spikard-rb/src/sse.rs +231 -231
data/vendor/crates/spikard-rb/src/testing/client.rs +538 -551
data/vendor/crates/spikard-rb/src/testing/mod.rs +7 -7
data/vendor/crates/spikard-rb/src/testing/sse.rs +143 -143
data/vendor/crates/spikard-rb/src/testing/websocket.rs +608 -635
data/vendor/crates/spikard-rb/src/websocket.rs +377 -374
metadata +15 -1

data/vendor/crates/spikard-http/tests/lifecycle_execution.rs CHANGED Viewed

@@ -1,1093 +1,1093 @@
-#![allow(clippy::pedantic, clippy::nursery, clippy::all)]
-//! Comprehensive tests for lifecycle hooks execution
-//!
-//! Tests the execute_with_lifecycle_hooks function covering:
-//! - No hooks and empty hooks fast path
-//! - Hook execution order and continuation
-//! - Short-circuit behavior
-//! - Error handling and onError transformation
-//! - Success path with onResponse
-//! - Response modifications
-mod common;
-use axum::body::Body;
-use axum::http::{Request, Response, StatusCode};
-use serde_json::json;
-use spikard_http::lifecycle::HookResult;
-use spikard_http::server::lifecycle_execution::execute_with_lifecycle_hooks;
-use spikard_http::{Handler, HandlerResult, RequestData};
-use std::collections::HashMap;
-use std::future::Future;
-use std::pin::Pin;
-use std::sync::Arc;
-/// Test request data factory
-fn 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,
-    }
-}
-/// Handler that returns 200 OK with custom body
-struct OkHandler;
-impl Handler for OkHandler {
-    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)
-                .body(Body::from("OK"))
-                .unwrap();
-            Ok(response)
-        })
-    }
-}
-/// Handler that returns 400 Bad Request error
-struct BadRequestHandler;
-impl Handler for BadRequestHandler {
-    fn call(
-        &self,
-        _request: Request<Body>,
-        _request_data: RequestData,
-    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
-        Box::pin(async move { Err((StatusCode::BAD_REQUEST, "{\"error\": \"Bad Request\"}".to_string())) })
-    }
-}
-#[tokio::test]
-async fn test_no_hooks_none_variant() {
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, None).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::OK);
-}
-#[tokio::test]
-async fn test_empty_hooks_list() {
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let hooks = Arc::new(spikard_http::lifecycle::LifecycleHooks::new());
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(hooks)).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::OK);
-}
-#[tokio::test]
-async fn test_pre_validation_hook_continues() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
-        "continue_hook",
-        |req| async move { Ok(HookResult::Continue(req)) },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::OK);
-}
-#[tokio::test]
-async fn test_pre_validation_hook_short_circuits() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
-        "short_circuit",
-        |_req| async move {
-            let response = Response::builder()
-                .status(StatusCode::UNAUTHORIZED)
-                .body(Body::from("{\"error\": \"Unauthorized\"}"))
-                .unwrap();
-            Ok(HookResult::ShortCircuit(response))
-        },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
-}
-#[tokio::test]
-async fn test_pre_validation_hook_error_calls_on_error() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
-        "failing_hook",
-        |_req| async move { Err("Validation failed".to_string()) },
-    ));
-    hooks.add_on_error(spikard_http::lifecycle::response_hook(
-        "error_handler",
-        |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-Error-Handled", axum::http::HeaderValue::from_static("true"));
-            Ok(HookResult::Continue(resp))
-        },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
-    assert_eq!(
-        response.headers().get("X-Error-Handled").map(|v| v.to_str().unwrap()),
-        Some("true")
-    );
-}
-#[tokio::test]
-async fn test_pre_handler_hook_continues() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_handler(spikard_http::lifecycle::request_hook(
-        "continue_hook",
-        |req| async move { Ok(HookResult::Continue(req)) },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::OK);
-}
-#[tokio::test]
-async fn test_pre_handler_hook_short_circuits() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_handler(spikard_http::lifecycle::request_hook(
-        "short_circuit",
-        |_req| async move {
-            let response = Response::builder()
-                .status(StatusCode::FORBIDDEN)
-                .body(Body::from("{\"error\": \"Forbidden\"}"))
-                .unwrap();
-            Ok(HookResult::ShortCircuit(response))
-        },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::FORBIDDEN);
-}
-#[tokio::test]
-async fn test_pre_handler_hook_error_calls_on_error() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_handler(spikard_http::lifecycle::request_hook(
-        "failing_hook",
-        |_req| async move { Err("Handler preparation failed".to_string()) },
-    ));
-    hooks.add_on_error(spikard_http::lifecycle::response_hook(
-        "error_handler",
-        |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-PreHandler-Error", axum::http::HeaderValue::from_static("caught"));
-            Ok(HookResult::Continue(resp))
-        },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
-    assert_eq!(
-        response
-            .headers()
-            .get("X-PreHandler-Error")
-            .map(|v| v.to_str().unwrap()),
-        Some("caught")
-    );
-}
-#[tokio::test]
-async fn test_handler_error_calls_on_error() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_error(spikard_http::lifecycle::response_hook(
-        "error_logger",
-        |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-Handler-Error", axum::http::HeaderValue::from_static("logged"));
-            Ok(HookResult::Continue(resp))
-        },
-    ));
-    let handler = Arc::new(BadRequestHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
-    assert_eq!(
-        response.headers().get("X-Handler-Error").map(|v| v.to_str().unwrap()),
-        Some("logged")
-    );
-}
-#[tokio::test]
-async fn test_success_handler_calls_on_response() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "response_modifier",
-        |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-Response-Modified", axum::http::HeaderValue::from_static("yes"));
-            Ok(HookResult::Continue(resp))
-        },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::OK);
-    assert_eq!(
-        response
-            .headers()
-            .get("X-Response-Modified")
-            .map(|v| v.to_str().unwrap()),
-        Some("yes")
-    );
-}
-#[tokio::test]
-async fn test_on_response_hook_error_returns_500() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "failing_response_hook",
-        |_resp| async move { Err("Response processing failed".to_string()) },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
-}
-#[tokio::test]
-async fn test_on_error_hook_fails_fallback_500() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
-        "failing_validation",
-        |_req| async move { Err("Validation error".to_string()) },
-    ));
-    hooks.add_on_error(spikard_http::lifecycle::response_hook(
-        "failing_error_hook",
-        |_resp| async move { Err("Error hook failed".to_string()) },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
-}
-#[tokio::test]
-async fn test_hook_execution_order_preserved() {
-    use std::sync::Mutex;
-    let execution_log = Arc::new(Mutex::new(Vec::new()));
-    let execution_log_clone1 = execution_log.clone();
-    let execution_log_clone2 = execution_log.clone();
-    let execution_log_clone3 = execution_log.clone();
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_validation(spikard_http::lifecycle::request_hook("pre_validation", move |req| {
-        let log = execution_log_clone1.clone();
-        async move {
-            log.lock().unwrap().push("pre_validation");
-            Ok(HookResult::Continue(req))
-        }
-    }));
-    hooks.add_pre_handler(spikard_http::lifecycle::request_hook("pre_handler", move |req| {
-        let log = execution_log_clone2.clone();
-        async move {
-            log.lock().unwrap().push("pre_handler");
-            Ok(HookResult::Continue(req))
-        }
-    }));
-    hooks.add_on_response(spikard_http::lifecycle::response_hook("on_response", move |resp| {
-        let log = execution_log_clone3.clone();
-        async move {
-            log.lock().unwrap().push("on_response");
-            Ok(HookResult::Continue(resp))
-        }
-    }));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let log = execution_log.lock().unwrap();
-    assert_eq!(log.as_slice(), &["pre_validation", "pre_handler", "on_response"]);
-}
-#[tokio::test]
-async fn test_pre_validation_short_circuit_skips_handler_and_on_response() {
-    use std::sync::Mutex;
-    let handler_called = Arc::new(Mutex::new(false));
-    let response_hook_called = Arc::new(Mutex::new(false));
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
-        "short_circuit",
-        |_req| async move {
-            let response = Response::builder()
-                .status(StatusCode::UNAUTHORIZED)
-                .body(Body::from("Unauthorized"))
-                .unwrap();
-            Ok(HookResult::ShortCircuit(response))
-        },
-    ));
-    let response_hook_called_clone = response_hook_called.clone();
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "response_tracker",
-        move |resp| {
-            let flag = response_hook_called_clone.clone();
-            async move {
-                *flag.lock().unwrap() = true;
-                Ok(HookResult::Continue(resp))
-            }
-        },
-    ));
-    struct TrackingHandler {
-        called: Arc<Mutex<bool>>,
-    }
-    impl Handler for TrackingHandler {
-        fn call(
-            &self,
-            _request: Request<Body>,
-            _request_data: RequestData,
-        ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
-            let called = self.called.clone();
-            Box::pin(async move {
-                *called.lock().unwrap() = true;
-                let response = Response::builder()
-                    .status(StatusCode::OK)
-                    .body(Body::from("OK"))
-                    .unwrap();
-                Ok(response)
-            })
-        }
-    }
-    let handler = Arc::new(TrackingHandler {
-        called: handler_called.clone(),
-    });
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    assert!(!*handler_called.lock().unwrap(), "Handler should not be called");
-    assert!(
-        !*response_hook_called.lock().unwrap(),
-        "on_response should not be called"
-    );
-}
-#[tokio::test]
-async fn test_multiple_hooks_same_phase_executed_in_order() {
-    use std::sync::Mutex;
-    let execution_log = Arc::new(Mutex::new(Vec::new()));
-    let log1 = execution_log.clone();
-    let log2 = execution_log.clone();
-    let log3 = execution_log.clone();
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_response(spikard_http::lifecycle::response_hook("first_hook", move |resp| {
-        let log = log1.clone();
-        async move {
-            log.lock().unwrap().push("first");
-            Ok(HookResult::Continue(resp))
-        }
-    }));
-    hooks.add_on_response(spikard_http::lifecycle::response_hook("second_hook", move |resp| {
-        let log = log2.clone();
-        async move {
-            log.lock().unwrap().push("second");
-            Ok(HookResult::Continue(resp))
-        }
-    }));
-    hooks.add_on_response(spikard_http::lifecycle::response_hook("third_hook", move |resp| {
-        let log = log3.clone();
-        async move {
-            log.lock().unwrap().push("third");
-            Ok(HookResult::Continue(resp))
-        }
-    }));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let log = execution_log.lock().unwrap();
-    assert_eq!(log.as_slice(), &["first", "second", "third"]);
-}
-#[tokio::test]
-async fn test_hook_can_modify_request() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_handler(spikard_http::lifecycle::request_hook(
-        "add_header",
-        |mut req| async move {
-            req.headers_mut()
-                .insert("X-Added-By-Hook", axum::http::HeaderValue::from_static("hook-value"));
-            Ok(HookResult::Continue(req))
-        },
-    ));
-    struct HeaderCheckHandler;
-    impl Handler for HeaderCheckHandler {
-        fn call(
-            &self,
-            request: Request<Body>,
-            _request_data: RequestData,
-        ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
-            Box::pin(async move {
-                let has_header = request.headers().contains_key("X-Added-By-Hook");
-                let body = if has_header { "Header found" } else { "Header not found" };
-                let response = Response::builder()
-                    .status(StatusCode::OK)
-                    .body(Body::from(body))
-                    .unwrap();
-                Ok(response)
-            })
-        }
-    }
-    let handler = Arc::new(HeaderCheckHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::OK);
-}
-#[tokio::test]
-async fn test_error_response_contains_hook_error_message() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
-        "failing_hook",
-        |_req| async move { Err("Custom validation error".to_string()) },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
-    let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
-    let body_str = String::from_utf8(body_bytes.to_vec()).unwrap();
-    assert!(body_str.contains("Custom validation error"));
-}
-#[tokio::test]
-async fn test_chained_hook_modifications() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "add_header_1",
-        |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-Header-1", axum::http::HeaderValue::from_static("value1"));
-            Ok(HookResult::Continue(resp))
-        },
-    ));
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "add_header_2",
-        |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-Header-2", axum::http::HeaderValue::from_static("value2"));
-            Ok(HookResult::Continue(resp))
-        },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(
-        response.headers().get("X-Header-1").map(|v| v.to_str().unwrap()),
-        Some("value1")
-    );
-    assert_eq!(
-        response.headers().get("X-Header-2").map(|v| v.to_str().unwrap()),
-        Some("value2")
-    );
-}
-#[tokio::test]
-async fn test_on_response_not_called_when_handler_fails() {
-    use std::sync::Mutex;
-    let response_hook_called = Arc::new(Mutex::new(false));
-    let response_hook_called_clone = response_hook_called.clone();
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "response_tracker",
-        move |resp| {
-            let flag = response_hook_called_clone.clone();
-            async move {
-                *flag.lock().unwrap() = true;
-                Ok(HookResult::Continue(resp))
-            }
-        },
-    ));
-    let handler = Arc::new(BadRequestHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    assert!(
-        !*response_hook_called.lock().unwrap(),
-        "on_response should NOT be called when handler fails"
-    );
-}
-#[tokio::test]
-async fn test_on_error_called_when_handler_fails() {
-    use std::sync::Mutex;
-    let error_hook_called = Arc::new(Mutex::new(false));
-    let error_hook_called_clone = error_hook_called.clone();
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_error(spikard_http::lifecycle::response_hook("error_tracker", move |resp| {
-        let flag = error_hook_called_clone.clone();
-        async move {
-            *flag.lock().unwrap() = true;
-            Ok(HookResult::Continue(resp))
-        }
-    }));
-    let handler = Arc::new(BadRequestHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    assert!(
-        *error_hook_called.lock().unwrap(),
-        "on_error should be called when handler fails"
-    );
-}
-#[tokio::test]
-async fn test_on_error_hook_preserves_original_handler_error_status() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_error(spikard_http::lifecycle::response_hook(
-        "error_checker",
-        |resp| async move {
-            if resp.status() == StatusCode::BAD_REQUEST {
-                Ok(HookResult::Continue(resp))
-            } else {
-                Err("Expected 400 status".to_string())
-            }
-        },
-    ));
-    let handler = Arc::new(BadRequestHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
-}
-#[tokio::test]
-async fn test_all_three_error_paths_call_on_error() {
-    use std::sync::Mutex;
-    let error_hook_count = Arc::new(Mutex::new(0));
-    {
-        let error_hook_count_clone = error_hook_count.clone();
-        let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-        hooks.add_pre_validation(spikard_http::lifecycle::request_hook("failing", |_req| async move {
-            Err("preValidation error".to_string())
-        }));
-        hooks.add_on_error(spikard_http::lifecycle::response_hook("counter", move |resp| {
-            let count = error_hook_count_clone.clone();
-            async move {
-                *count.lock().unwrap() += 1;
-                Ok(HookResult::Continue(resp))
-            }
-        }));
-        let handler = Arc::new(OkHandler);
-        let request = Request::builder().body(Body::empty()).unwrap();
-        let request_data = test_request_data();
-        let _result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    }
-    assert_eq!(
-        *error_hook_count.lock().unwrap(),
-        1,
-        "on_error called for preValidation error"
-    );
-    *error_hook_count.lock().unwrap() = 0;
-    {
-        let error_hook_count_clone = error_hook_count.clone();
-        let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-        hooks.add_pre_handler(spikard_http::lifecycle::request_hook("failing", |_req| async move {
-            Err("preHandler error".to_string())
-        }));
-        hooks.add_on_error(spikard_http::lifecycle::response_hook("counter", move |resp| {
-            let count = error_hook_count_clone.clone();
-            async move {
-                *count.lock().unwrap() += 1;
-                Ok(HookResult::Continue(resp))
-            }
-        }));
-        let handler = Arc::new(OkHandler);
-        let request = Request::builder().body(Body::empty()).unwrap();
-        let request_data = test_request_data();
-        let _result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    }
-    assert_eq!(
-        *error_hook_count.lock().unwrap(),
-        1,
-        "on_error called for preHandler error"
-    );
-}
-#[tokio::test]
-async fn test_on_error_fallback_response_when_error_hook_fails() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
-        "failing_validation",
-        |_req| async move { Err("Validation error".to_string()) },
-    ));
-    hooks.add_on_error(spikard_http::lifecycle::response_hook(
-        "failing_error_hook",
-        |_resp| async move { Err("on_error itself failed".to_string()) },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
-    let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
-    let body_str = String::from_utf8(body_bytes.to_vec()).unwrap();
-    assert!(body_str.contains("Hook execution failed"));
-}
-#[tokio::test]
-async fn test_full_hook_chain_with_success() {
-    use std::sync::Mutex;
-    let execution_log = Arc::new(Mutex::new(Vec::new()));
-    let log1 = execution_log.clone();
-    let log2 = execution_log.clone();
-    let log3 = execution_log.clone();
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_validation(spikard_http::lifecycle::request_hook("pv", move |req| {
-        let log = log1.clone();
-        async move {
-            log.lock().unwrap().push("preValidation");
-            Ok(HookResult::Continue(req))
-        }
-    }));
-    hooks.add_pre_handler(spikard_http::lifecycle::request_hook("ph", move |req| {
-        let log = log2.clone();
-        async move {
-            log.lock().unwrap().push("preHandler");
-            Ok(HookResult::Continue(req))
-        }
-    }));
-    hooks.add_on_response(spikard_http::lifecycle::response_hook("or", move |resp| {
-        let log = log3.clone();
-        async move {
-            log.lock().unwrap().push("onResponse");
-            Ok(HookResult::Continue(resp))
-        }
-    }));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let log = execution_log.lock().unwrap();
-    assert_eq!(log.as_slice(), &["preValidation", "preHandler", "onResponse"]);
-}
-#[tokio::test]
-async fn test_pre_handler_short_circuit_skips_on_response() {
-    use std::sync::Mutex;
-    let response_hook_called = Arc::new(Mutex::new(false));
-    let response_hook_called_clone = response_hook_called.clone();
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_handler(spikard_http::lifecycle::request_hook(
-        "short_circuit",
-        |_req| async move {
-            let response = Response::builder()
-                .status(StatusCode::FORBIDDEN)
-                .body(Body::from("Forbidden"))
-                .unwrap();
-            Ok(HookResult::ShortCircuit(response))
-        },
-    ));
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "response_tracker",
-        move |resp| {
-            let flag = response_hook_called_clone.clone();
-            async move {
-                *flag.lock().unwrap() = true;
-                Ok(HookResult::Continue(resp))
-            }
-        },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::FORBIDDEN);
-    assert!(
-        !*response_hook_called.lock().unwrap(),
-        "on_response should not be called"
-    );
-}
-#[tokio::test]
-async fn test_on_response_hook_can_transform_success_response() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "transform",
-        |_old_resp| async move {
-            let new_response = Response::builder()
-                .status(StatusCode::CREATED)
-                .header("X-Transformed", "yes")
-                .body(Body::from("Transformed"))
-                .unwrap();
-            Ok(HookResult::Continue(new_response))
-        },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::CREATED);
-    assert_eq!(
-        response.headers().get("X-Transformed").map(|v| v.to_str().unwrap()),
-        Some("yes")
-    );
-}
-#[tokio::test]
-async fn test_error_response_body_contains_correct_hook_context() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_handler(spikard_http::lifecycle::request_hook("failing", |_req| async move {
-        Err("Specific handler setup error".to_string())
-    }));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
-    let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
-    let body_str = String::from_utf8(body_bytes.to_vec()).unwrap();
-    assert!(body_str.contains("preHandler"));
-    assert!(body_str.contains("Specific handler setup error"));
-}
-#[tokio::test]
-async fn test_multiple_error_hooks_execute_in_sequence() {
-    use std::sync::Mutex;
-    let execution_log = Arc::new(Mutex::new(Vec::new()));
-    let log1 = execution_log.clone();
-    let log2 = execution_log.clone();
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_pre_validation(spikard_http::lifecycle::request_hook("failing", |_req| async move {
-        Err("Validation failed".to_string())
-    }));
-    hooks.add_on_error(spikard_http::lifecycle::response_hook("error_handler_1", move |resp| {
-        let log = log1.clone();
-        async move {
-            log.lock().unwrap().push("error_handler_1");
-            Ok(HookResult::Continue(resp))
-        }
-    }));
-    hooks.add_on_error(spikard_http::lifecycle::response_hook("error_handler_2", move |resp| {
-        let log = log2.clone();
-        async move {
-            log.lock().unwrap().push("error_handler_2");
-            Ok(HookResult::Continue(resp))
-        }
-    }));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let log = execution_log.lock().unwrap();
-    assert_eq!(log.as_slice(), &["error_handler_1", "error_handler_2"]);
-}
-#[tokio::test]
-async fn test_handler_result_error_becomes_500_with_on_error_handling() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_error(spikard_http::lifecycle::response_hook(
-        "error_modifier",
-        |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-Error-Detected", axum::http::HeaderValue::from_static("true"));
-            Ok(HookResult::Continue(resp))
-        },
-    ));
-    let handler = Arc::new(BadRequestHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
-    assert_eq!(
-        response.headers().get("X-Error-Detected").map(|v| v.to_str().unwrap()),
-        Some("true")
-    );
-}
-#[tokio::test]
-async fn test_on_response_with_multiple_sequential_transforms() {
-    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "add_header_1",
-        |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-Step-1", axum::http::HeaderValue::from_static("done"));
-            Ok(HookResult::Continue(resp))
-        },
-    ));
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "add_header_2",
-        |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-Step-2", axum::http::HeaderValue::from_static("done"));
-            Ok(HookResult::Continue(resp))
-        },
-    ));
-    hooks.add_on_response(spikard_http::lifecycle::response_hook(
-        "add_header_3",
-        |mut resp| async move {
-            resp.headers_mut()
-                .insert("X-Step-3", axum::http::HeaderValue::from_static("done"));
-            Ok(HookResult::Continue(resp))
-        },
-    ));
-    let handler = Arc::new(OkHandler);
-    let request = Request::builder().body(Body::empty()).unwrap();
-    let request_data = test_request_data();
-    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
-    assert!(result.is_ok());
-    let response = result.unwrap();
-    assert_eq!(
-        response.headers().get("X-Step-1").map(|v| v.to_str().unwrap()),
-        Some("done")
-    );
-    assert_eq!(
-        response.headers().get("X-Step-2").map(|v| v.to_str().unwrap()),
-        Some("done")
-    );
-    assert_eq!(
-        response.headers().get("X-Step-3").map(|v| v.to_str().unwrap()),
-        Some("done")
-    );
-}
+#![allow(clippy::pedantic, clippy::nursery, clippy::all)]
+//! Comprehensive tests for lifecycle hooks execution
+//!
+//! Tests the execute_with_lifecycle_hooks function covering:
+//! - No hooks and empty hooks fast path
+//! - Hook execution order and continuation
+//! - Short-circuit behavior
+//! - Error handling and onError transformation
+//! - Success path with onResponse
+//! - Response modifications
+mod common;
+use axum::body::Body;
+use axum::http::{Request, Response, StatusCode};
+use serde_json::json;
+use spikard_http::lifecycle::HookResult;
+use spikard_http::server::lifecycle_execution::execute_with_lifecycle_hooks;
+use spikard_http::{Handler, HandlerResult, RequestData};
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+/// Test request data factory
+fn 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,
+    }
+}
+/// Handler that returns 200 OK with custom body
+struct OkHandler;
+impl Handler for OkHandler {
+    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)
+                .body(Body::from("OK"))
+                .unwrap();
+            Ok(response)
+        })
+    }
+}
+/// Handler that returns 400 Bad Request error
+struct BadRequestHandler;
+impl Handler for BadRequestHandler {
+    fn call(
+        &self,
+        _request: Request<Body>,
+        _request_data: RequestData,
+    ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+        Box::pin(async move { Err((StatusCode::BAD_REQUEST, "{\"error\": \"Bad Request\"}".to_string())) })
+    }
+}
+#[tokio::test]
+async fn test_no_hooks_none_variant() {
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, None).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+}
+#[tokio::test]
+async fn test_empty_hooks_list() {
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let hooks = Arc::new(spikard_http::lifecycle::LifecycleHooks::new());
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(hooks)).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+}
+#[tokio::test]
+async fn test_pre_validation_hook_continues() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
+        "continue_hook",
+        |req| async move { Ok(HookResult::Continue(req)) },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+}
+#[tokio::test]
+async fn test_pre_validation_hook_short_circuits() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
+        "short_circuit",
+        |_req| async move {
+            let response = Response::builder()
+                .status(StatusCode::UNAUTHORIZED)
+                .body(Body::from("{\"error\": \"Unauthorized\"}"))
+                .unwrap();
+            Ok(HookResult::ShortCircuit(response))
+        },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+}
+#[tokio::test]
+async fn test_pre_validation_hook_error_calls_on_error() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
+        "failing_hook",
+        |_req| async move { Err("Validation failed".to_string()) },
+    ));
+    hooks.add_on_error(spikard_http::lifecycle::response_hook(
+        "error_handler",
+        |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-Error-Handled", axum::http::HeaderValue::from_static("true"));
+            Ok(HookResult::Continue(resp))
+        },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    assert_eq!(
+        response.headers().get("X-Error-Handled").map(|v| v.to_str().unwrap()),
+        Some("true")
+    );
+}
+#[tokio::test]
+async fn test_pre_handler_hook_continues() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_handler(spikard_http::lifecycle::request_hook(
+        "continue_hook",
+        |req| async move { Ok(HookResult::Continue(req)) },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+}
+#[tokio::test]
+async fn test_pre_handler_hook_short_circuits() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_handler(spikard_http::lifecycle::request_hook(
+        "short_circuit",
+        |_req| async move {
+            let response = Response::builder()
+                .status(StatusCode::FORBIDDEN)
+                .body(Body::from("{\"error\": \"Forbidden\"}"))
+                .unwrap();
+            Ok(HookResult::ShortCircuit(response))
+        },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::FORBIDDEN);
+}
+#[tokio::test]
+async fn test_pre_handler_hook_error_calls_on_error() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_handler(spikard_http::lifecycle::request_hook(
+        "failing_hook",
+        |_req| async move { Err("Handler preparation failed".to_string()) },
+    ));
+    hooks.add_on_error(spikard_http::lifecycle::response_hook(
+        "error_handler",
+        |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-PreHandler-Error", axum::http::HeaderValue::from_static("caught"));
+            Ok(HookResult::Continue(resp))
+        },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    assert_eq!(
+        response
+            .headers()
+            .get("X-PreHandler-Error")
+            .map(|v| v.to_str().unwrap()),
+        Some("caught")
+    );
+}
+#[tokio::test]
+async fn test_handler_error_calls_on_error() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_error(spikard_http::lifecycle::response_hook(
+        "error_logger",
+        |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-Handler-Error", axum::http::HeaderValue::from_static("logged"));
+            Ok(HookResult::Continue(resp))
+        },
+    ));
+    let handler = Arc::new(BadRequestHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    assert_eq!(
+        response.headers().get("X-Handler-Error").map(|v| v.to_str().unwrap()),
+        Some("logged")
+    );
+}
+#[tokio::test]
+async fn test_success_handler_calls_on_response() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "response_modifier",
+        |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-Response-Modified", axum::http::HeaderValue::from_static("yes"));
+            Ok(HookResult::Continue(resp))
+        },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+    assert_eq!(
+        response
+            .headers()
+            .get("X-Response-Modified")
+            .map(|v| v.to_str().unwrap()),
+        Some("yes")
+    );
+}
+#[tokio::test]
+async fn test_on_response_hook_error_returns_500() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "failing_response_hook",
+        |_resp| async move { Err("Response processing failed".to_string()) },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+}
+#[tokio::test]
+async fn test_on_error_hook_fails_fallback_500() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
+        "failing_validation",
+        |_req| async move { Err("Validation error".to_string()) },
+    ));
+    hooks.add_on_error(spikard_http::lifecycle::response_hook(
+        "failing_error_hook",
+        |_resp| async move { Err("Error hook failed".to_string()) },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+}
+#[tokio::test]
+async fn test_hook_execution_order_preserved() {
+    use std::sync::Mutex;
+    let execution_log = Arc::new(Mutex::new(Vec::new()));
+    let execution_log_clone1 = execution_log.clone();
+    let execution_log_clone2 = execution_log.clone();
+    let execution_log_clone3 = execution_log.clone();
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_validation(spikard_http::lifecycle::request_hook("pre_validation", move |req| {
+        let log = execution_log_clone1.clone();
+        async move {
+            log.lock().unwrap().push("pre_validation");
+            Ok(HookResult::Continue(req))
+        }
+    }));
+    hooks.add_pre_handler(spikard_http::lifecycle::request_hook("pre_handler", move |req| {
+        let log = execution_log_clone2.clone();
+        async move {
+            log.lock().unwrap().push("pre_handler");
+            Ok(HookResult::Continue(req))
+        }
+    }));
+    hooks.add_on_response(spikard_http::lifecycle::response_hook("on_response", move |resp| {
+        let log = execution_log_clone3.clone();
+        async move {
+            log.lock().unwrap().push("on_response");
+            Ok(HookResult::Continue(resp))
+        }
+    }));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let log = execution_log.lock().unwrap();
+    assert_eq!(log.as_slice(), &["pre_validation", "pre_handler", "on_response"]);
+}
+#[tokio::test]
+async fn test_pre_validation_short_circuit_skips_handler_and_on_response() {
+    use std::sync::Mutex;
+    let handler_called = Arc::new(Mutex::new(false));
+    let response_hook_called = Arc::new(Mutex::new(false));
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
+        "short_circuit",
+        |_req| async move {
+            let response = Response::builder()
+                .status(StatusCode::UNAUTHORIZED)
+                .body(Body::from("Unauthorized"))
+                .unwrap();
+            Ok(HookResult::ShortCircuit(response))
+        },
+    ));
+    let response_hook_called_clone = response_hook_called.clone();
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "response_tracker",
+        move |resp| {
+            let flag = response_hook_called_clone.clone();
+            async move {
+                *flag.lock().unwrap() = true;
+                Ok(HookResult::Continue(resp))
+            }
+        },
+    ));
+    struct TrackingHandler {
+        called: Arc<Mutex<bool>>,
+    }
+    impl Handler for TrackingHandler {
+        fn call(
+            &self,
+            _request: Request<Body>,
+            _request_data: RequestData,
+        ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+            let called = self.called.clone();
+            Box::pin(async move {
+                *called.lock().unwrap() = true;
+                let response = Response::builder()
+                    .status(StatusCode::OK)
+                    .body(Body::from("OK"))
+                    .unwrap();
+                Ok(response)
+            })
+        }
+    }
+    let handler = Arc::new(TrackingHandler {
+        called: handler_called.clone(),
+    });
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    assert!(!*handler_called.lock().unwrap(), "Handler should not be called");
+    assert!(
+        !*response_hook_called.lock().unwrap(),
+        "on_response should not be called"
+    );
+}
+#[tokio::test]
+async fn test_multiple_hooks_same_phase_executed_in_order() {
+    use std::sync::Mutex;
+    let execution_log = Arc::new(Mutex::new(Vec::new()));
+    let log1 = execution_log.clone();
+    let log2 = execution_log.clone();
+    let log3 = execution_log.clone();
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_response(spikard_http::lifecycle::response_hook("first_hook", move |resp| {
+        let log = log1.clone();
+        async move {
+            log.lock().unwrap().push("first");
+            Ok(HookResult::Continue(resp))
+        }
+    }));
+    hooks.add_on_response(spikard_http::lifecycle::response_hook("second_hook", move |resp| {
+        let log = log2.clone();
+        async move {
+            log.lock().unwrap().push("second");
+            Ok(HookResult::Continue(resp))
+        }
+    }));
+    hooks.add_on_response(spikard_http::lifecycle::response_hook("third_hook", move |resp| {
+        let log = log3.clone();
+        async move {
+            log.lock().unwrap().push("third");
+            Ok(HookResult::Continue(resp))
+        }
+    }));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let log = execution_log.lock().unwrap();
+    assert_eq!(log.as_slice(), &["first", "second", "third"]);
+}
+#[tokio::test]
+async fn test_hook_can_modify_request() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_handler(spikard_http::lifecycle::request_hook(
+        "add_header",
+        |mut req| async move {
+            req.headers_mut()
+                .insert("X-Added-By-Hook", axum::http::HeaderValue::from_static("hook-value"));
+            Ok(HookResult::Continue(req))
+        },
+    ));
+    struct HeaderCheckHandler;
+    impl Handler for HeaderCheckHandler {
+        fn call(
+            &self,
+            request: Request<Body>,
+            _request_data: RequestData,
+        ) -> Pin<Box<dyn Future<Output = HandlerResult> + Send + '_>> {
+            Box::pin(async move {
+                let has_header = request.headers().contains_key("X-Added-By-Hook");
+                let body = if has_header { "Header found" } else { "Header not found" };
+                let response = Response::builder()
+                    .status(StatusCode::OK)
+                    .body(Body::from(body))
+                    .unwrap();
+                Ok(response)
+            })
+        }
+    }
+    let handler = Arc::new(HeaderCheckHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+}
+#[tokio::test]
+async fn test_error_response_contains_hook_error_message() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
+        "failing_hook",
+        |_req| async move { Err("Custom validation error".to_string()) },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
+    let body_str = String::from_utf8(body_bytes.to_vec()).unwrap();
+    assert!(body_str.contains("Custom validation error"));
+}
+#[tokio::test]
+async fn test_chained_hook_modifications() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "add_header_1",
+        |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-Header-1", axum::http::HeaderValue::from_static("value1"));
+            Ok(HookResult::Continue(resp))
+        },
+    ));
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "add_header_2",
+        |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-Header-2", axum::http::HeaderValue::from_static("value2"));
+            Ok(HookResult::Continue(resp))
+        },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(
+        response.headers().get("X-Header-1").map(|v| v.to_str().unwrap()),
+        Some("value1")
+    );
+    assert_eq!(
+        response.headers().get("X-Header-2").map(|v| v.to_str().unwrap()),
+        Some("value2")
+    );
+}
+#[tokio::test]
+async fn test_on_response_not_called_when_handler_fails() {
+    use std::sync::Mutex;
+    let response_hook_called = Arc::new(Mutex::new(false));
+    let response_hook_called_clone = response_hook_called.clone();
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "response_tracker",
+        move |resp| {
+            let flag = response_hook_called_clone.clone();
+            async move {
+                *flag.lock().unwrap() = true;
+                Ok(HookResult::Continue(resp))
+            }
+        },
+    ));
+    let handler = Arc::new(BadRequestHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    assert!(
+        !*response_hook_called.lock().unwrap(),
+        "on_response should NOT be called when handler fails"
+    );
+}
+#[tokio::test]
+async fn test_on_error_called_when_handler_fails() {
+    use std::sync::Mutex;
+    let error_hook_called = Arc::new(Mutex::new(false));
+    let error_hook_called_clone = error_hook_called.clone();
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_error(spikard_http::lifecycle::response_hook("error_tracker", move |resp| {
+        let flag = error_hook_called_clone.clone();
+        async move {
+            *flag.lock().unwrap() = true;
+            Ok(HookResult::Continue(resp))
+        }
+    }));
+    let handler = Arc::new(BadRequestHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    assert!(
+        *error_hook_called.lock().unwrap(),
+        "on_error should be called when handler fails"
+    );
+}
+#[tokio::test]
+async fn test_on_error_hook_preserves_original_handler_error_status() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_error(spikard_http::lifecycle::response_hook(
+        "error_checker",
+        |resp| async move {
+            if resp.status() == StatusCode::BAD_REQUEST {
+                Ok(HookResult::Continue(resp))
+            } else {
+                Err("Expected 400 status".to_string())
+            }
+        },
+    ));
+    let handler = Arc::new(BadRequestHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+}
+#[tokio::test]
+async fn test_all_three_error_paths_call_on_error() {
+    use std::sync::Mutex;
+    let error_hook_count = Arc::new(Mutex::new(0));
+    {
+        let error_hook_count_clone = error_hook_count.clone();
+        let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+        hooks.add_pre_validation(spikard_http::lifecycle::request_hook("failing", |_req| async move {
+            Err("preValidation error".to_string())
+        }));
+        hooks.add_on_error(spikard_http::lifecycle::response_hook("counter", move |resp| {
+            let count = error_hook_count_clone.clone();
+            async move {
+                *count.lock().unwrap() += 1;
+                Ok(HookResult::Continue(resp))
+            }
+        }));
+        let handler = Arc::new(OkHandler);
+        let request = Request::builder().body(Body::empty()).unwrap();
+        let request_data = test_request_data();
+        let _result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    }
+    assert_eq!(
+        *error_hook_count.lock().unwrap(),
+        1,
+        "on_error called for preValidation error"
+    );
+    *error_hook_count.lock().unwrap() = 0;
+    {
+        let error_hook_count_clone = error_hook_count.clone();
+        let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+        hooks.add_pre_handler(spikard_http::lifecycle::request_hook("failing", |_req| async move {
+            Err("preHandler error".to_string())
+        }));
+        hooks.add_on_error(spikard_http::lifecycle::response_hook("counter", move |resp| {
+            let count = error_hook_count_clone.clone();
+            async move {
+                *count.lock().unwrap() += 1;
+                Ok(HookResult::Continue(resp))
+            }
+        }));
+        let handler = Arc::new(OkHandler);
+        let request = Request::builder().body(Body::empty()).unwrap();
+        let request_data = test_request_data();
+        let _result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    }
+    assert_eq!(
+        *error_hook_count.lock().unwrap(),
+        1,
+        "on_error called for preHandler error"
+    );
+}
+#[tokio::test]
+async fn test_on_error_fallback_response_when_error_hook_fails() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_validation(spikard_http::lifecycle::request_hook(
+        "failing_validation",
+        |_req| async move { Err("Validation error".to_string()) },
+    ));
+    hooks.add_on_error(spikard_http::lifecycle::response_hook(
+        "failing_error_hook",
+        |_resp| async move { Err("on_error itself failed".to_string()) },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
+    let body_str = String::from_utf8(body_bytes.to_vec()).unwrap();
+    assert!(body_str.contains("Hook execution failed"));
+}
+#[tokio::test]
+async fn test_full_hook_chain_with_success() {
+    use std::sync::Mutex;
+    let execution_log = Arc::new(Mutex::new(Vec::new()));
+    let log1 = execution_log.clone();
+    let log2 = execution_log.clone();
+    let log3 = execution_log.clone();
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_validation(spikard_http::lifecycle::request_hook("pv", move |req| {
+        let log = log1.clone();
+        async move {
+            log.lock().unwrap().push("preValidation");
+            Ok(HookResult::Continue(req))
+        }
+    }));
+    hooks.add_pre_handler(spikard_http::lifecycle::request_hook("ph", move |req| {
+        let log = log2.clone();
+        async move {
+            log.lock().unwrap().push("preHandler");
+            Ok(HookResult::Continue(req))
+        }
+    }));
+    hooks.add_on_response(spikard_http::lifecycle::response_hook("or", move |resp| {
+        let log = log3.clone();
+        async move {
+            log.lock().unwrap().push("onResponse");
+            Ok(HookResult::Continue(resp))
+        }
+    }));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let log = execution_log.lock().unwrap();
+    assert_eq!(log.as_slice(), &["preValidation", "preHandler", "onResponse"]);
+}
+#[tokio::test]
+async fn test_pre_handler_short_circuit_skips_on_response() {
+    use std::sync::Mutex;
+    let response_hook_called = Arc::new(Mutex::new(false));
+    let response_hook_called_clone = response_hook_called.clone();
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_handler(spikard_http::lifecycle::request_hook(
+        "short_circuit",
+        |_req| async move {
+            let response = Response::builder()
+                .status(StatusCode::FORBIDDEN)
+                .body(Body::from("Forbidden"))
+                .unwrap();
+            Ok(HookResult::ShortCircuit(response))
+        },
+    ));
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "response_tracker",
+        move |resp| {
+            let flag = response_hook_called_clone.clone();
+            async move {
+                *flag.lock().unwrap() = true;
+                Ok(HookResult::Continue(resp))
+            }
+        },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::FORBIDDEN);
+    assert!(
+        !*response_hook_called.lock().unwrap(),
+        "on_response should not be called"
+    );
+}
+#[tokio::test]
+async fn test_on_response_hook_can_transform_success_response() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "transform",
+        |_old_resp| async move {
+            let new_response = Response::builder()
+                .status(StatusCode::CREATED)
+                .header("X-Transformed", "yes")
+                .body(Body::from("Transformed"))
+                .unwrap();
+            Ok(HookResult::Continue(new_response))
+        },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::CREATED);
+    assert_eq!(
+        response.headers().get("X-Transformed").map(|v| v.to_str().unwrap()),
+        Some("yes")
+    );
+}
+#[tokio::test]
+async fn test_error_response_body_contains_correct_hook_context() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_handler(spikard_http::lifecycle::request_hook("failing", |_req| async move {
+        Err("Specific handler setup error".to_string())
+    }));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
+    let body_str = String::from_utf8(body_bytes.to_vec()).unwrap();
+    assert!(body_str.contains("preHandler"));
+    assert!(body_str.contains("Specific handler setup error"));
+}
+#[tokio::test]
+async fn test_multiple_error_hooks_execute_in_sequence() {
+    use std::sync::Mutex;
+    let execution_log = Arc::new(Mutex::new(Vec::new()));
+    let log1 = execution_log.clone();
+    let log2 = execution_log.clone();
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_pre_validation(spikard_http::lifecycle::request_hook("failing", |_req| async move {
+        Err("Validation failed".to_string())
+    }));
+    hooks.add_on_error(spikard_http::lifecycle::response_hook("error_handler_1", move |resp| {
+        let log = log1.clone();
+        async move {
+            log.lock().unwrap().push("error_handler_1");
+            Ok(HookResult::Continue(resp))
+        }
+    }));
+    hooks.add_on_error(spikard_http::lifecycle::response_hook("error_handler_2", move |resp| {
+        let log = log2.clone();
+        async move {
+            log.lock().unwrap().push("error_handler_2");
+            Ok(HookResult::Continue(resp))
+        }
+    }));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let log = execution_log.lock().unwrap();
+    assert_eq!(log.as_slice(), &["error_handler_1", "error_handler_2"]);
+}
+#[tokio::test]
+async fn test_handler_result_error_becomes_500_with_on_error_handling() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_error(spikard_http::lifecycle::response_hook(
+        "error_modifier",
+        |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-Error-Detected", axum::http::HeaderValue::from_static("true"));
+            Ok(HookResult::Continue(resp))
+        },
+    ));
+    let handler = Arc::new(BadRequestHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    assert_eq!(
+        response.headers().get("X-Error-Detected").map(|v| v.to_str().unwrap()),
+        Some("true")
+    );
+}
+#[tokio::test]
+async fn test_on_response_with_multiple_sequential_transforms() {
+    let mut hooks = spikard_http::lifecycle::LifecycleHooks::new();
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "add_header_1",
+        |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-Step-1", axum::http::HeaderValue::from_static("done"));
+            Ok(HookResult::Continue(resp))
+        },
+    ));
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "add_header_2",
+        |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-Step-2", axum::http::HeaderValue::from_static("done"));
+            Ok(HookResult::Continue(resp))
+        },
+    ));
+    hooks.add_on_response(spikard_http::lifecycle::response_hook(
+        "add_header_3",
+        |mut resp| async move {
+            resp.headers_mut()
+                .insert("X-Step-3", axum::http::HeaderValue::from_static("done"));
+            Ok(HookResult::Continue(resp))
+        },
+    ));
+    let handler = Arc::new(OkHandler);
+    let request = Request::builder().body(Body::empty()).unwrap();
+    let request_data = test_request_data();
+    let result = execute_with_lifecycle_hooks(request, request_data, handler, Some(Arc::new(hooks))).await;
+    assert!(result.is_ok());
+    let response = result.unwrap();
+    assert_eq!(
+        response.headers().get("X-Step-1").map(|v| v.to_str().unwrap()),
+        Some("done")
+    );
+    assert_eq!(
+        response.headers().get("X-Step-2").map(|v| v.to_str().unwrap()),
+        Some("done")
+    );
+    assert_eq!(
+        response.headers().get("X-Step-3").map(|v| v.to_str().unwrap()),
+        Some("done")
+    );
+}