spikard 0.12.0 → 0.15.2

data/vendor/crates/spikard-http/src/jsonrpc/router.rs

@@ -1,2262 +0,0 @@
-//! JSON-RPC request router for handling single and batch requests
-//!
-//! This module provides the core routing logic for JSON-RPC 2.0 requests, including
-//! support for batch processing with configurable size limits. The router matches
-//! incoming requests to registered method handlers and returns appropriately formatted
-//! responses according to the JSON-RPC 2.0 specification.
-//!
-//! # Features
-//!
-//! - Single request routing to registered handlers
-//! - Batch request processing with size validation
-//! - Notification handling (requests without IDs)
-//! - Comprehensive error handling for all JSON-RPC error codes
-//! - Thread-safe access via Arc<JsonRpcMethodRegistry>
-//! - Method name validation at routing time (defense in depth)
-//!
-//! # Validation
-//!
-//! Method names are validated at two points:
-//! 1. During request parsing in `parse_request()` - validates method names when requests are deserialized
-//! 2. During routing in `route_single()` - provides defense-in-depth validation even for programmatically created requests
-//!
-//! Invalid method names return a JSON-RPC error with code -32600 (Invalid Request) as per the JSON-RPC 2.0 spec.
-//!
-//! # Example
-//!
-//! ```ignore
-//! use spikard_http::jsonrpc::{JsonRpcRouter, JsonRpcMethodRegistry, JsonRpcRequest};
-//! use std::sync::Arc;
-//! use serde_json::json;
-//!
-//! let registry = Arc::new(JsonRpcMethodRegistry::new());
-//! let router = JsonRpcRouter::new(registry, true, 50);
-//!
-//! // Route a single request
-//! let request = JsonRpcRequest::new("user.getById", Some(json!({"id": "123"})), Some(json!(1)));
-//! let response = router.route_single(request).await;
-//! ```
-
-use super::method_registry::JsonRpcMethodRegistry;
-use super::protocol::*;
-use crate::handler_trait::RequestData;
-use axum::body::Body;
-use axum::http::Request;
-use serde_json::Value;
-use std::sync::Arc;
-
-/// JSON-RPC router for handling single and batch requests
-///
-/// Manages request routing to registered method handlers with support for
-/// batch processing, notifications, and comprehensive error handling.
-pub struct JsonRpcRouter {
-    /// Registry of available methods and their handlers
-    registry: Arc<JsonRpcMethodRegistry>,
-    /// Whether batch requests are enabled
-    enable_batch: bool,
-    /// Maximum number of requests allowed in a single batch
-    max_batch_size: usize,
-}
-
-impl JsonRpcRouter {
-    /// Creates a new JSON-RPC router
-    ///
-    /// # Arguments
-    ///
-    /// * `registry` - The method registry containing registered handlers
-    /// * `enable_batch` - Whether to allow batch requests
-    /// * `max_batch_size` - Maximum number of requests per batch
-    ///
-    /// # Example
-    ///
-    /// ```ignore
-    /// use spikard_http::jsonrpc::{JsonRpcRouter, JsonRpcMethodRegistry};
-    /// use std::sync::Arc;
-    ///
-    /// let registry = Arc::new(JsonRpcMethodRegistry::new());
-    /// let router = JsonRpcRouter::new(registry, true, 100);
-    /// ```
-    pub fn new(registry: Arc<JsonRpcMethodRegistry>, enable_batch: bool, max_batch_size: usize) -> Self {
-        Self {
-            registry,
-            enable_batch,
-            max_batch_size,
-        }
-    }
-
-    /// Routes a single JSON-RPC request to its handler
-    ///
-    /// Processes a single request by:
-    /// 1. Checking if the method exists in the registry
-    /// 2. Handling notifications (requests without IDs)
-    /// 3. Invoking the handler with the HTTP request context
-    /// 4. Converting handler responses to JSON-RPC format
-    /// 5. Returning appropriately formatted responses
-    ///
-    /// For notifications, the server MUST NOT send a response.
-    /// The response is still generated but marked as not-to-be-sent by the caller.
-    ///
-    /// # Arguments
-    ///
-    /// * `request` - The JSON-RPC request to route
-    /// * `http_request` - The HTTP request context (headers, method, etc.)
-    /// * `request_data` - Reference to extracted request data (params, body, etc.)
-    ///
-    /// # Returns
-    ///
-    /// A `JsonRpcResponseType` containing either a success response with the
-    /// handler's result or an error response if the method is not found or
-    /// the handler fails
-    pub async fn route_single(
-        &self,
-        request: JsonRpcRequest,
-        http_request: Request<Body>,
-        request_data: &RequestData,
-    ) -> JsonRpcResponseType {
-        if let Err(validation_error) = super::protocol::validate_method_name(&request.method) {
-            let id = request.id.unwrap_or(Value::Null);
-            return JsonRpcResponseType::Error(JsonRpcErrorResponse::error(
-                error_codes::INVALID_REQUEST,
-                format!("Invalid method name: {}", validation_error),
-                id,
-            ));
-        }
-
-        let handler = match self.registry.get(&request.method) {
-            Ok(Some(h)) => h,
-            Ok(None) => {
-                let id = request.id.unwrap_or(Value::Null);
-                return JsonRpcResponseType::Error(JsonRpcErrorResponse::error(
-                    error_codes::METHOD_NOT_FOUND,
-                    "Method not found",
-                    id,
-                ));
-            }
-            Err(e) => {
-                let id = request.id.unwrap_or(Value::Null);
-                return JsonRpcResponseType::Error(JsonRpcErrorResponse::error(
-                    error_codes::INTERNAL_ERROR,
-                    format!("Internal error: {}", e),
-                    id,
-                ));
-            }
-        };
-
-        let _is_notification = request.is_notification();
-
-        let handler_result = handler.call(http_request, request_data.clone()).await;
-
-        match handler_result {
-            Ok(response) => {
-                let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
-                    .await
-                    .unwrap_or_default();
-
-                let result = if body_bytes.is_empty() {
-                    Value::Null
-                } else {
-                    match serde_json::from_slice::<Value>(&body_bytes) {
-                        Ok(json_val) => json_val,
-                        Err(_) => Value::String(
-                            String::from_utf8(body_bytes.to_vec()).unwrap_or_else(|_| "[binary data]".to_string()),
-                        ),
-                    }
-                };
-
-                let id = request.id.unwrap_or(Value::Null);
-                JsonRpcResponseType::Success(JsonRpcResponse::success(result, id))
-            }
-            Err((_status, error_msg)) => {
-                let id = request.id.unwrap_or(Value::Null);
-                let error_data = serde_json::json!({
-                    "details": error_msg
-                });
-                JsonRpcResponseType::Error(JsonRpcErrorResponse::error_with_data(
-                    error_codes::INTERNAL_ERROR,
-                    "Internal error from handler",
-                    error_data,
-                    id,
-                ))
-            }
-        }
-    }
-
-    /// Routes a batch of JSON-RPC requests
-    ///
-    /// Processes a batch of requests by:
-    /// 1. Checking if batch processing is enabled
-    /// 2. Validating batch size doesn't exceed the limit
-    /// 3. Ensuring batch is not empty
-    /// 4. Routing each request in sequence
-    /// 5. Filtering out notification responses
-    ///
-    /// According to JSON-RPC 2.0 spec, the server SHOULD process all requests
-    /// in the batch and return a JSON array of responses. Responses for
-    /// notifications (requests without IDs) are not included in the result.
-    ///
-    /// # Arguments
-    ///
-    /// * `batch` - A vector of JSON-RPC requests
-    /// * `http_request` - The HTTP request context (shared for all batch requests)
-    /// * `request_data` - Extracted request data (shared for all batch requests)
-    ///
-    /// # Returns
-    ///
-    /// * `Ok(Vec<JsonRpcResponseType>)` - Array of responses for all non-notification requests
-    /// * `Err(JsonRpcErrorResponse)` - Single error if batch validation fails
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if:
-    /// - Batch requests are not enabled
-    /// - Batch size exceeds the configured maximum
-    /// - Batch is empty
-    pub async fn route_batch(
-        &self,
-        batch: Vec<JsonRpcRequest>,
-        http_request: Request<Body>,
-        request_data: &RequestData,
-    ) -> Result<Vec<JsonRpcResponseType>, JsonRpcErrorResponse> {
-        if !self.enable_batch {
-            return Err(JsonRpcErrorResponse::error(
-                error_codes::INVALID_REQUEST,
-                "Batch requests not enabled",
-                Value::Null,
-            ));
-        }
-
-        if batch.len() > self.max_batch_size {
-            return Err(JsonRpcErrorResponse::error(
-                error_codes::INVALID_REQUEST,
-                format!("Batch size {} exceeds maximum {}", batch.len(), self.max_batch_size),
-                Value::Null,
-            ));
-        }
-
-        if batch.is_empty() {
-            return Err(JsonRpcErrorResponse::error(
-                error_codes::INVALID_REQUEST,
-                "Batch request cannot be empty",
-                Value::Null,
-            ));
-        }
-
-        let (base_parts, _body) = http_request.into_parts();
-
-        let mut responses = Vec::with_capacity(batch.len());
-        for request in batch {
-            let is_notification = request.is_notification();
-
-            let req_for_handler = Request::from_parts(base_parts.clone(), Body::empty());
-
-            let response = self.route_single(request, req_for_handler, request_data).await;
-
-            if !is_notification {
-                responses.push(response);
-            }
-        }
-
-        Ok(responses)
-    }
-
-    /// Parses a JSON string into either a single request or a batch
-    ///
-    /// Attempts to deserialize the input as a single JSON-RPC request first,
-    /// then tries batch parsing if that fails. Returns a parse error if both
-    /// attempts fail.
-    ///
-    /// # Arguments
-    ///
-    /// * `body` - The raw JSON request body as a string
-    ///
-    /// # Returns
-    ///
-    /// * `Ok(JsonRpcRequestOrBatch::Single(req))` - Parsed single request
-    /// * `Ok(JsonRpcRequestOrBatch::Batch(requests))` - Parsed batch request
-    /// * `Err(JsonRpcErrorResponse)` - Parse error
-    ///
-    /// # Example
-    ///
-    /// ```ignore
-    /// let single_json = r#"{"jsonrpc":"2.0","method":"test","id":1}"#;
-    /// let parsed = JsonRpcRouter::parse_request(single_json);
-    /// assert!(parsed.is_ok());
-    ///
-    /// let batch_json = r#"[{"jsonrpc":"2.0","method":"test","id":1}]"#;
-    /// let parsed = JsonRpcRouter::parse_request(batch_json);
-    /// assert!(parsed.is_ok());
-    /// ```
-    pub fn parse_request(body: &str) -> Result<JsonRpcRequestOrBatch, Box<JsonRpcErrorResponse>> {
-        if let Ok(request) = serde_json::from_str::<JsonRpcRequest>(body) {
-            if let Err(validation_error) = super::protocol::validate_method_name(&request.method) {
-                let id = request.id.unwrap_or(Value::Null);
-                return Err(Box::new(JsonRpcErrorResponse::error(
-                    error_codes::INVALID_REQUEST,
-                    format!("Invalid method name: {}", validation_error),
-                    id,
-                )));
-            }
-            return Ok(JsonRpcRequestOrBatch::Single(request));
-        }
-
-        if let Ok(batch) = serde_json::from_str::<Vec<JsonRpcRequest>>(body) {
-            for request in &batch {
-                if let Err(validation_error) = super::protocol::validate_method_name(&request.method) {
-                    let id = request.id.clone().unwrap_or(Value::Null);
-                    return Err(Box::new(JsonRpcErrorResponse::error(
-                        error_codes::INVALID_REQUEST,
-                        format!("Invalid method name: {}", validation_error),
-                        id,
-                    )));
-                }
-            }
-            return Ok(JsonRpcRequestOrBatch::Batch(batch));
-        }
-
-        Err(Box::new(JsonRpcErrorResponse::error(
-            error_codes::PARSE_ERROR,
-            "Parse error",
-            Value::Null,
-        )))
-    }
-}
-
-/// Represents either a single JSON-RPC request or a batch of requests
-///
-/// Used to distinguish between single and batch requests after parsing,
-/// allowing different routing logic for each case.
-#[derive(Debug)]
-pub enum JsonRpcRequestOrBatch {
-    /// A single JSON-RPC request
-    Single(JsonRpcRequest),
-    /// A batch (array) of JSON-RPC requests
-    Batch(Vec<JsonRpcRequest>),
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::handler_trait::{Handler, HandlerResult, RequestData};
-    use crate::jsonrpc::MethodMetadata;
-    use axum::body::Body;
-    use axum::http::Request;
-    use serde_json::json;
-    use std::collections::HashMap;
-    use std::sync::Arc;
-
-    /// Helper function to create minimal RequestData for tests
-    fn create_test_request_data() -> RequestData {
-        RequestData {
-            path_params: Arc::new(HashMap::new()),
-            query_params: Arc::new(Value::Object(serde_json::Map::new())),
-            validated_params: None,
-            raw_query_params: Arc::new(HashMap::new()),
-            body: Arc::new(Value::Null),
-            raw_body: None,
-            headers: Arc::new(HashMap::new()),
-            cookies: Arc::new(HashMap::new()),
-            method: "POST".to_string(),
-            path: "/rpc".to_string(),
-            #[cfg(feature = "di")]
-            dependencies: None,
-        }
-    }
-
-    /// Helper function to create a test HTTP request
-    fn create_test_http_request() -> Request<Body> {
-        Request::builder()
-            .method("POST")
-            .uri("/rpc")
-            .body(Body::empty())
-            .unwrap()
-    }
-
-    /// Mock handler that returns success with JSON
-    struct MockSuccessHandler;
-
-    impl Handler for MockSuccessHandler {
-        fn call(
-            &self,
-            _request: Request<Body>,
-            _request_data: RequestData,
-        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = HandlerResult> + Send + '_>> {
-            Box::pin(async {
-                use axum::response::Response;
-                let response = Response::builder()
-                    .status(200)
-                    .header("content-type", "application/json")
-                    .body(Body::from(r#"{"result":"success"}"#))
-                    .unwrap();
-                Ok(response)
-            })
-        }
-    }
-
-    /// Mock handler that returns an error
-    struct MockErrorHandler;
-
-    impl Handler for MockErrorHandler {
-        fn call(
-            &self,
-            _request: Request<Body>,
-            _request_data: RequestData,
-        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = HandlerResult> + Send + '_>> {
-            Box::pin(async {
-                Err((
-                    axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-                    "Handler error".to_string(),
-                ))
-            })
-        }
-    }
-
-    /// Mock handler that returns success with non-JSON UTF-8 text
-    struct MockTextHandler;
-
-    impl Handler for MockTextHandler {
-        fn call(
-            &self,
-            _request: Request<Body>,
-            _request_data: RequestData,
-        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = HandlerResult> + Send + '_>> {
-            Box::pin(async {
-                use axum::response::Response;
-                let response = Response::builder()
-                    .status(200)
-                    .header("content-type", "text/plain")
-                    .body(Body::from("hello"))
-                    .unwrap();
-                Ok(response)
-            })
-        }
-    }
-
-    /// Mock handler that returns success with non-UTF-8 bytes
-    struct MockBinaryHandler;
-
-    impl Handler for MockBinaryHandler {
-        fn call(
-            &self,
-            _request: Request<Body>,
-            _request_data: RequestData,
-        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = HandlerResult> + Send + '_>> {
-            Box::pin(async {
-                use axum::response::Response;
-                let response = Response::builder()
-                    .status(200)
-                    .header("content-type", "application/octet-stream")
-                    .body(Body::from(vec![0xff, 0xfe, 0xfd]))
-                    .unwrap();
-                Ok(response)
-            })
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_invalid_method_name_empty() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-                assert!(err.error.message.contains("Invalid method name"));
-                assert_eq!(err.id, json!(1));
-            }
-            _ => panic!("Expected error response for invalid method name"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_invalid_method_name_with_space() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("method name", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-                assert!(err.error.message.contains("Invalid method name"));
-                assert_eq!(err.id, json!(1));
-            }
-            _ => panic!("Expected error response for invalid method name"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_success_non_json_utf8_body_returns_string() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        registry
-            .register("echo", Arc::new(MockTextHandler), MethodMetadata::new("echo"))
-            .unwrap();
-
-        let router = JsonRpcRouter::new(registry, true, 100);
-        let request = JsonRpcRequest::new("echo", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-        match response {
-            JsonRpcResponseType::Success(ok) => {
-                assert_eq!(ok.result, Value::String("hello".to_string()));
-            }
-            other => panic!("Expected success response, got: {:?}", other),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_success_non_utf8_body_returns_placeholder_string() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        registry
-            .register("bin", Arc::new(MockBinaryHandler), MethodMetadata::new("bin"))
-            .unwrap();
-
-        let router = JsonRpcRouter::new(registry, true, 100);
-        let request = JsonRpcRequest::new("bin", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-        match response {
-            JsonRpcResponseType::Success(ok) => {
-                assert_eq!(ok.result, Value::String("[binary data]".to_string()));
-            }
-            other => panic!("Expected success response, got: {:?}", other),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_invalid_method_name_control_char() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("method\nname", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-                assert!(err.error.message.contains("Invalid method name"));
-                assert_eq!(err.id, json!(1));
-            }
-            _ => panic!("Expected error response for invalid method name"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_invalid_method_name_special_char() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("method@name", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-                assert!(err.error.message.contains("Invalid method name"));
-                assert_eq!(err.id, json!(1));
-            }
-            _ => panic!("Expected error response for invalid method name"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_invalid_method_name_too_long() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let long_method = "a".repeat(256);
-        let request = JsonRpcRequest::new(long_method, None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-                assert!(err.error.message.contains("Invalid method name"));
-                assert_eq!(err.id, json!(1));
-            }
-            _ => panic!("Expected error response for invalid method name"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_method_not_found() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("unknown_method", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::METHOD_NOT_FOUND);
-                assert_eq!(err.id, json!(1));
-            }
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_notification() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("notify_method");
-        registry.register("notify_method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let request = JsonRpcRequest::new("notify_method", None, None);
-        assert!(request.is_notification());
-
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Success(resp) => {
-                assert_eq!(resp.id, Value::Null);
-            }
-            _ => panic!("Expected success response for notification"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_with_handler_success() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("test_method");
-        registry.register("test_method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let request = JsonRpcRequest::new("test_method", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Success(resp) => {
-                assert_eq!(resp.result, json!({"result":"success"}));
-                assert_eq!(resp.id, json!(1));
-            }
-            _ => panic!("Expected success response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_single_with_handler_error() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockErrorHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("error_method");
-        registry.register("error_method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let request = JsonRpcRequest::new("error_method", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::INTERNAL_ERROR);
-                assert_eq!(err.id, json!(1));
-                assert!(err.error.data.is_some());
-            }
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_route_batch_disabled() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, false, 100);
-
-        let batch = vec![JsonRpcRequest::new("method", None, Some(json!(1)))];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-    }
-
-    #[tokio::test]
-    async fn test_route_batch_empty() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let batch = vec![];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-    }
-
-    #[tokio::test]
-    async fn test_route_batch_size_exceeded() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 5);
-
-        let batch = (1..=10)
-            .map(|i| JsonRpcRequest::new("method", None, Some(json!(i))))
-            .collect();
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-    }
-
-    #[tokio::test]
-    async fn test_route_batch_filters_notifications() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method", None, Some(json!(1))),
-            JsonRpcRequest::new("method", None, None),
-            JsonRpcRequest::new("method", None, Some(json!(2))),
-        ];
-
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-        assert!(result.is_ok());
-
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 2);
-    }
-
-    #[test]
-    fn test_parse_request_single() {
-        let json = r#"{"jsonrpc":"2.0","method":"test","id":1}"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_ok());
-        match parsed.unwrap() {
-            JsonRpcRequestOrBatch::Single(req) => {
-                assert_eq!(req.method, "test");
-                assert_eq!(req.id, Some(json!(1)));
-            }
-            _ => panic!("Expected single request"),
-        }
-    }
-
-    #[test]
-    fn test_parse_request_batch() {
-        let json = r#"[{"jsonrpc":"2.0","method":"test","id":1},{"jsonrpc":"2.0","method":"test2","id":2}]"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_ok());
-        match parsed.unwrap() {
-            JsonRpcRequestOrBatch::Batch(batch) => {
-                assert_eq!(batch.len(), 2);
-                assert_eq!(batch[0].method, "test");
-                assert_eq!(batch[1].method, "test2");
-            }
-            _ => panic!("Expected batch request"),
-        }
-    }
-
-    #[test]
-    fn test_parse_request_invalid() {
-        let json = r#"{"invalid":"json"}"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::PARSE_ERROR);
-    }
-
-    #[test]
-    fn test_parse_request_notification() {
-        let json = r#"{"jsonrpc":"2.0","method":"notify"}"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_ok());
-        match parsed.unwrap() {
-            JsonRpcRequestOrBatch::Single(req) => {
-                assert!(req.is_notification());
-                assert_eq!(req.method, "notify");
-            }
-            _ => panic!("Expected single request"),
-        }
-    }
-
-    #[test]
-    fn test_parse_request_with_params() {
-        let json = r#"{"jsonrpc":"2.0","method":"subtract","params":{"subtrahend":23,"minuend":42},"id":3}"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_ok());
-        match parsed.unwrap() {
-            JsonRpcRequestOrBatch::Single(req) => {
-                assert_eq!(req.method, "subtract");
-                assert!(req.params.is_some());
-                let params = req.params.unwrap();
-                assert_eq!(params["subtrahend"], 23);
-                assert_eq!(params["minuend"], 42);
-            }
-            _ => panic!("Expected single request"),
-        }
-    }
-
-    #[test]
-    fn test_parse_request_invalid_method_name_empty() {
-        let json = r#"{"jsonrpc":"2.0","method":"","id":1}"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("Invalid method name"));
-    }
-
-    #[test]
-    fn test_parse_request_invalid_method_name_leading_space() {
-        let json = r#"{"jsonrpc":"2.0","method":" method","id":1}"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("Invalid method name"));
-    }
-
-    #[test]
-    fn test_parse_request_invalid_method_name_trailing_space() {
-        let json = r#"{"jsonrpc":"2.0","method":"method ","id":1}"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("Invalid method name"));
-    }
-
-    #[test]
-    fn test_parse_request_invalid_method_name_with_space() {
-        let json = r#"{"jsonrpc":"2.0","method":"method name","id":1}"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("Invalid method name"));
-    }
-
-    #[test]
-    fn test_parse_request_invalid_method_name_special_char() {
-        let json = r#"{"jsonrpc":"2.0","method":"method@name","id":1}"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("Invalid method name"));
-    }
-
-    #[test]
-    fn test_parse_request_invalid_method_name_too_long() {
-        let long_method = "a".repeat(256);
-        let json = format!(r#"{{"jsonrpc":"2.0","method":"{}","id":1}}"#, long_method);
-        let parsed = JsonRpcRouter::parse_request(&json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("Invalid method name"));
-    }
-
-    #[test]
-    fn test_parse_request_batch_valid_method_names() {
-        let json = r#"[
-            {"jsonrpc":"2.0","method":"test.method","id":1},
-            {"jsonrpc":"2.0","method":"another_method","id":2}
-        ]"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_ok());
-        match parsed.unwrap() {
-            JsonRpcRequestOrBatch::Batch(batch) => {
-                assert_eq!(batch.len(), 2);
-                assert_eq!(batch[0].method, "test.method");
-                assert_eq!(batch[1].method, "another_method");
-            }
-            _ => panic!("Expected batch request"),
-        }
-    }
-
-    #[test]
-    fn test_parse_request_batch_invalid_first_method_name() {
-        let json = r#"[
-            {"jsonrpc":"2.0","method":" invalid","id":1},
-            {"jsonrpc":"2.0","method":"valid","id":2}
-        ]"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("Invalid method name"));
-    }
-
-    #[test]
-    fn test_parse_request_batch_invalid_second_method_name() {
-        let json = r#"[
-            {"jsonrpc":"2.0","method":"valid","id":1},
-            {"jsonrpc":"2.0","method":"invalid#method","id":2}
-        ]"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("Invalid method name"));
-    }
-
-    #[test]
-    fn test_parse_request_batch_notification_invalid_method_name() {
-        let json = r#"[
-            {"jsonrpc":"2.0","method":"valid","id":1},
-            {"jsonrpc":"2.0","method":"invalid method"}
-        ]"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("Invalid method name"));
-    }
-
-    #[test]
-    fn test_parse_request_method_name_dos_prevention() {
-        let json = format!(r#"{{"jsonrpc":"2.0","method":"{}","id":1}}"#, "a".repeat(10000));
-        let parsed = JsonRpcRouter::parse_request(&json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("Invalid method name"));
-    }
-
-    #[test]
-    fn test_parse_request_valid_method_names_complex() {
-        let json = r#"{"jsonrpc":"2.0","method":"user.getById_v1-2","id":1}"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_ok());
-        match parsed.unwrap() {
-            JsonRpcRequestOrBatch::Single(req) => {
-                assert_eq!(req.method, "user.getById_v1-2");
-            }
-            _ => panic!("Expected single request"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_error_code_parse_error_invalid_json() {
-        let json = r#"{"invalid json"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_err());
-        let err = parsed.unwrap_err();
-        assert_eq!(err.error.code, error_codes::PARSE_ERROR);
-        assert_eq!(err.error.code, -32700);
-    }
-
-    #[tokio::test]
-    async fn test_error_code_method_not_found() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("nonexistent_method", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::METHOD_NOT_FOUND);
-                assert_eq!(err.error.code, -32601);
-                assert_eq!(err.id, json!(1));
-            }
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_error_code_invalid_request_empty_method() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-                assert_eq!(err.error.code, -32600);
-                assert_eq!(err.id, json!(1));
-            }
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_error_code_internal_error_from_handler() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockErrorHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("error_method");
-        registry.register("error_method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let request = JsonRpcRequest::new("error_method", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::INTERNAL_ERROR);
-                assert_eq!(err.error.code, -32603);
-                assert_eq!(err.id, json!(1));
-            }
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_error_code_server_error_custom_range() {
-        assert!(error_codes::is_server_error(-32000));
-        assert!(error_codes::is_server_error(-32050));
-        assert!(error_codes::is_server_error(-32099));
-        assert!(!error_codes::is_server_error(-31999));
-        assert!(!error_codes::is_server_error(-32100));
-    }
-
-    #[tokio::test]
-    async fn test_error_response_always_has_code() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("nonexistent", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert!(err.error.code != 0);
-                assert!(err.error.code < 0);
-            }
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_error_response_always_has_message() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("nonexistent", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert!(!err.error.message.is_empty());
-                assert!(err.jsonrpc == "2.0");
-            }
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_error_response_data_optional() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("nonexistent", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.error.code, error_codes::METHOD_NOT_FOUND);
-            }
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_error_response_id_matches_request() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let test_id = json!(42);
-        let request = JsonRpcRequest::new("nonexistent", None, Some(test_id.clone()));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert_eq!(err.id, test_id);
-            }
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_error_response_no_result_field() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let request = JsonRpcRequest::new("nonexistent", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(_) => {}
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_error_data_includes_details() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockErrorHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("error_method");
-        registry.register("error_method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let request = JsonRpcRequest::new("error_method", None, Some(json!(1)));
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let response = router.route_single(request, http_request, &request_data).await;
-
-        match response {
-            JsonRpcResponseType::Error(err) => {
-                assert!(err.error.data.is_some());
-                let data = err.error.data.unwrap();
-                assert!(data.get("details").is_some());
-            }
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_single_request() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("test");
-        registry.register("test", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![JsonRpcRequest::new("test", None, Some(json!(1)))];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 1);
-    }
-
-    #[tokio::test]
-    async fn test_batch_three_requests_all_succeed() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("test");
-        registry.register("test", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("test", None, Some(json!(1))),
-            JsonRpcRequest::new("test", None, Some(json!(2))),
-            JsonRpcRequest::new("test", None, Some(json!(3))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 3);
-        for resp in &responses {
-            match resp {
-                JsonRpcResponseType::Success(_) => {}
-                _ => panic!("Expected all success responses"),
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_mixed_success_and_errors() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("valid");
-        registry.register("valid", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("valid", None, Some(json!(1))),
-            JsonRpcRequest::new("invalid", None, Some(json!(2))),
-            JsonRpcRequest::new("valid", None, Some(json!(3))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 3);
-
-        match &responses[0] {
-            JsonRpcResponseType::Success(_) => {}
-            _ => panic!("Expected success at index 0"),
-        }
-        match &responses[1] {
-            JsonRpcResponseType::Error(_) => {}
-            _ => panic!("Expected error at index 1"),
-        }
-        match &responses[2] {
-            JsonRpcResponseType::Success(_) => {}
-            _ => panic!("Expected success at index 2"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_all_errors() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("nonexistent1", None, Some(json!(1))),
-            JsonRpcRequest::new("nonexistent2", None, Some(json!(2))),
-            JsonRpcRequest::new("nonexistent3", None, Some(json!(3))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 3);
-        for resp in &responses {
-            match resp {
-                JsonRpcResponseType::Error(_) => {}
-                _ => panic!("Expected all error responses"),
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_exceeds_max_size() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 5);
-
-        let batch = (1..=10)
-            .map(|i| JsonRpcRequest::new("method", None, Some(json!(i))))
-            .collect();
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-    }
-
-    #[tokio::test]
-    async fn test_batch_empty_array() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, true, 100);
-
-        let batch = vec![];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-    }
-
-    #[tokio::test]
-    async fn test_batch_disabled_error() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let router = JsonRpcRouter::new(registry, false, 100);
-
-        let batch = vec![JsonRpcRequest::new("method", None, Some(json!(1)))];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-    }
-
-    #[tokio::test]
-    async fn test_notification_no_response_generated() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("notify");
-        registry.register("notify", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("notify", None, Some(json!(1))),
-            JsonRpcRequest::new("notify", None, None),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 1);
-    }
-
-    #[tokio::test]
-    async fn test_batch_mixed_notifications_responses() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method", None, Some(json!(1))),
-            JsonRpcRequest::new("method", None, None),
-            JsonRpcRequest::new("method", None, Some(json!(2))),
-            JsonRpcRequest::new("method", None, None),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 2);
-    }
-
-    #[tokio::test]
-    async fn test_batch_all_notifications_empty_response() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method", None, None),
-            JsonRpcRequest::new("method", None, None),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 0);
-    }
-
-    #[tokio::test]
-    async fn test_notification_error_still_not_responded() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("nonexistent", None, Some(json!(1))),
-            JsonRpcRequest::new("nonexistent", None, None),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 1);
-        match &responses[0] {
-            JsonRpcResponseType::Error(_) => {}
-            _ => panic!("Expected error response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_requests_independent_state() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("test");
-        registry.register("test", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("test", None, Some(json!(1))),
-            JsonRpcRequest::new("test", None, Some(json!(2))),
-            JsonRpcRequest::new("test", None, Some(json!(3))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 3);
-        for (i, resp) in responses.iter().enumerate() {
-            match resp {
-                JsonRpcResponseType::Success(s) => {
-                    assert_eq!(s.id, json!(i + 1));
-                }
-                _ => panic!("Expected success response"),
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_error_preserves_request_order() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("valid");
-        registry.register("valid", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("valid", None, Some(json!("first"))),
-            JsonRpcRequest::new("invalid", None, Some(json!("second"))),
-            JsonRpcRequest::new("valid", None, Some(json!("third"))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 3);
-
-        match &responses[0] {
-            JsonRpcResponseType::Success(s) => {
-                assert_eq!(s.id, json!("first"));
-                assert_eq!(s.jsonrpc, "2.0");
-            }
-            _ => panic!("Expected success at index 0"),
-        }
-        match &responses[1] {
-            JsonRpcResponseType::Error(e) => {
-                assert_eq!(e.id, json!("second"));
-                assert_eq!(e.error.code, error_codes::METHOD_NOT_FOUND);
-            }
-            _ => panic!("Expected error at index 1"),
-        }
-        match &responses[2] {
-            JsonRpcResponseType::Success(s) => {
-                assert_eq!(s.id, json!("third"));
-                assert_eq!(s.jsonrpc, "2.0");
-            }
-            _ => panic!("Expected success at index 2"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_handler_execution_order() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method1");
-        registry.register("method1", handler.clone(), metadata).unwrap();
-
-        let metadata = super::super::method_registry::MethodMetadata::new("method2");
-        registry.register("method2", handler.clone(), metadata).unwrap();
-
-        let metadata = super::super::method_registry::MethodMetadata::new("method3");
-        registry.register("method3", handler.clone(), metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method1", None, Some(json!(1))),
-            JsonRpcRequest::new("method2", None, Some(json!(2))),
-            JsonRpcRequest::new("method3", None, Some(json!(3))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 3);
-        for resp in &responses {
-            match resp {
-                JsonRpcResponseType::Success(_) => {}
-                _ => panic!("Expected all success responses"),
-            }
-        }
-    }
-
-    #[test]
-    fn test_parse_batch_single_request_in_array() {
-        let json = r#"[{"jsonrpc":"2.0","method":"test","id":1}]"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_ok());
-        match parsed.unwrap() {
-            JsonRpcRequestOrBatch::Batch(batch) => {
-                assert_eq!(batch.len(), 1);
-                assert_eq!(batch[0].method, "test");
-            }
-            _ => panic!("Expected batch request"),
-        }
-    }
-
-    #[test]
-    fn test_parse_batch_three_requests() {
-        let json = r#"[
-            {"jsonrpc":"2.0","method":"test1","id":1},
-            {"jsonrpc":"2.0","method":"test2","id":2},
-            {"jsonrpc":"2.0","method":"test3","id":3}
-        ]"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_ok());
-        match parsed.unwrap() {
-            JsonRpcRequestOrBatch::Batch(batch) => {
-                assert_eq!(batch.len(), 3);
-                assert_eq!(batch[0].method, "test1");
-                assert_eq!(batch[1].method, "test2");
-                assert_eq!(batch[2].method, "test3");
-            }
-            _ => panic!("Expected batch request"),
-        }
-    }
-
-    #[test]
-    fn test_parse_batch_mixed_notifications() {
-        let json = r#"[
-            {"jsonrpc":"2.0","method":"method","id":1},
-            {"jsonrpc":"2.0","method":"method"},
-            {"jsonrpc":"2.0","method":"method","id":2}
-        ]"#;
-        let parsed = JsonRpcRouter::parse_request(json);
-
-        assert!(parsed.is_ok());
-        match parsed.unwrap() {
-            JsonRpcRequestOrBatch::Batch(batch) => {
-                assert_eq!(batch.len(), 3);
-                assert!(!batch[0].is_notification());
-                assert!(batch[1].is_notification());
-                assert!(!batch[2].is_notification());
-            }
-            _ => panic!("Expected batch request"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_max_size_boundary_exactly_at_limit() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let max_size = 10;
-        let router = JsonRpcRouter::new(registry, true, max_size);
-
-        let batch: Vec<JsonRpcRequest> = (1..=max_size)
-            .map(|i| JsonRpcRequest::new("method", None, Some(json!(i))))
-            .collect();
-
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), max_size);
-    }
-
-    #[tokio::test]
-    async fn test_batch_max_size_boundary_one_over_limit() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-        let max_size = 10;
-        let router = JsonRpcRouter::new(registry, true, max_size);
-
-        let batch: Vec<JsonRpcRequest> = (1..=max_size + 1)
-            .map(|i| JsonRpcRequest::new("method", None, Some(json!(i))))
-            .collect();
-
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert_eq!(err.error.code, error_codes::INVALID_REQUEST);
-        assert!(err.error.message.contains("exceeds maximum"));
-    }
-
-    #[tokio::test]
-    async fn test_batch_notification_with_numeric_id_zero() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method", None, Some(json!(0))),
-            JsonRpcRequest::new("method", None, Some(json!(1))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 2);
-        match &responses[0] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!(0)),
-            _ => panic!("Expected success response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_mixed_id_types_string_and_number() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method", None, Some(json!("string_id"))),
-            JsonRpcRequest::new("method", None, Some(json!(42))),
-            JsonRpcRequest::new("method", None, Some(json!("another_string"))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 3);
-
-        match &responses[0] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!("string_id")),
-            _ => panic!("Expected success response"),
-        }
-        match &responses[1] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!(42)),
-            _ => panic!("Expected success response"),
-        }
-        match &responses[2] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!("another_string")),
-            _ => panic!("Expected success response"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_all_notifications_truly_empty_response() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        for i in 1..=5 {
-            let handler = Arc::new(MockSuccessHandler);
-            let method_name = format!("method{}", i);
-            let metadata = super::super::method_registry::MethodMetadata::new(&method_name);
-            registry.register(&method_name, handler, metadata).unwrap();
-        }
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method1", None, None),
-            JsonRpcRequest::new("method2", None, None),
-            JsonRpcRequest::new("method3", None, None),
-            JsonRpcRequest::new("method4", None, None),
-            JsonRpcRequest::new("method5", None, None),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 0);
-        assert!(responses.is_empty());
-    }
-
-    #[tokio::test]
-    async fn test_batch_single_notification_among_requests() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method", None, Some(json!(1))),
-            JsonRpcRequest::new("method", None, None),
-            JsonRpcRequest::new("method", None, Some(json!(2))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 2);
-
-        match &responses[0] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!(1)),
-            _ => panic!("Expected success at index 0"),
-        }
-        match &responses[1] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!(2)),
-            _ => panic!("Expected success at index 1"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_error_one_request_fails_others_succeed() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("success");
-        registry.register("success", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("success", None, Some(json!(1))),
-            JsonRpcRequest::new("failing_method", None, Some(json!(2))),
-            JsonRpcRequest::new("success", None, Some(json!(3))),
-            JsonRpcRequest::new("failing_method", None, Some(json!(4))),
-            JsonRpcRequest::new("success", None, Some(json!(5))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 5);
-
-        match &responses[0] {
-            JsonRpcResponseType::Success(s) => {
-                assert_eq!(s.id, json!(1));
-            }
-            _ => panic!("Expected success at index 0"),
-        }
-        match &responses[1] {
-            JsonRpcResponseType::Error(e) => {
-                assert_eq!(e.id, json!(2));
-                assert_eq!(e.error.code, error_codes::METHOD_NOT_FOUND);
-            }
-            _ => panic!("Expected error at index 1"),
-        }
-        match &responses[2] {
-            JsonRpcResponseType::Success(s) => {
-                assert_eq!(s.id, json!(3));
-            }
-            _ => panic!("Expected success at index 2"),
-        }
-        match &responses[3] {
-            JsonRpcResponseType::Error(e) => {
-                assert_eq!(e.id, json!(4));
-                assert_eq!(e.error.code, error_codes::METHOD_NOT_FOUND);
-            }
-            _ => panic!("Expected error at index 3"),
-        }
-        match &responses[4] {
-            JsonRpcResponseType::Success(s) => {
-                assert_eq!(s.id, json!(5));
-            }
-            _ => panic!("Expected success at index 4"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_response_order_with_complex_id_types() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method", None, Some(json!("alpha"))),
-            JsonRpcRequest::new("method", None, Some(json!(999))),
-            JsonRpcRequest::new("method", None, Some(json!(null))),
-            JsonRpcRequest::new("method", None, Some(json!("beta"))),
-            JsonRpcRequest::new("method", None, Some(json!(0))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 5);
-
-        match &responses[0] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!("alpha")),
-            _ => panic!("Expected success at index 0"),
-        }
-        match &responses[1] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!(999)),
-            _ => panic!("Expected success at index 1"),
-        }
-        match &responses[2] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!(null)),
-            _ => panic!("Expected success at index 2"),
-        }
-        match &responses[3] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!("beta")),
-            _ => panic!("Expected success at index 3"),
-        }
-        match &responses[4] {
-            JsonRpcResponseType::Success(s) => assert_eq!(s.id, json!(0)),
-            _ => panic!("Expected success at index 4"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_handler_error_does_not_stop_batch() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let error_handler = Arc::new(MockErrorHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("failing");
-        registry.register("failing", error_handler, metadata).unwrap();
-
-        let success_handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("success");
-        registry.register("success", success_handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("success", None, Some(json!(1))),
-            JsonRpcRequest::new("failing", None, Some(json!(2))),
-            JsonRpcRequest::new("success", None, Some(json!(3))),
-            JsonRpcRequest::new("failing", None, Some(json!(4))),
-            JsonRpcRequest::new("success", None, Some(json!(5))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 5);
-
-        for resp in &responses {
-            match resp {
-                JsonRpcResponseType::Success(s) => {
-                    assert_eq!(s.jsonrpc, "2.0");
-                    assert!(s.id != Value::Null);
-                }
-                JsonRpcResponseType::Error(e) => {
-                    assert_eq!(e.error.code, error_codes::INTERNAL_ERROR);
-                    assert!(e.id != Value::Null);
-                }
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_large_batch_within_limits() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch: Vec<JsonRpcRequest> = (1..=50)
-            .map(|i| JsonRpcRequest::new("method", None, Some(json!(i))))
-            .collect();
-
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 50);
-        for resp in &responses {
-            match resp {
-                JsonRpcResponseType::Success(_) => {}
-                _ => panic!("Expected all success responses"),
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_id_preservation_with_duplicates() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method", None, Some(json!(1))),
-            JsonRpcRequest::new("method", None, Some(json!(1))),
-            JsonRpcRequest::new("method", None, Some(json!(2))),
-            JsonRpcRequest::new("method", None, Some(json!(1))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 4);
-
-        assert_eq!(responses[0].id(), json!(1));
-        assert_eq!(responses[1].id(), json!(1));
-        assert_eq!(responses[2].id(), json!(2));
-        assert_eq!(responses[3].id(), json!(1));
-    }
-
-    #[tokio::test]
-    async fn test_batch_different_methods_in_sequence() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        for method_name in &["user.getById", "post.create", "comment.delete", "admin.stats"] {
-            let handler = Arc::new(MockSuccessHandler);
-            let metadata = super::super::method_registry::MethodMetadata::new(method_name.to_string());
-            registry.register(method_name.to_string(), handler, metadata).unwrap();
-        }
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("user.getById", None, Some(json!(1))),
-            JsonRpcRequest::new("post.create", None, Some(json!(2))),
-            JsonRpcRequest::new("comment.delete", None, Some(json!(3))),
-            JsonRpcRequest::new("admin.stats", None, Some(json!(4))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 4);
-        for resp in &responses {
-            match resp {
-                JsonRpcResponseType::Success(_) => {}
-                _ => panic!("Expected all success responses"),
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_mixed_valid_and_method_not_found_errors() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("exists");
-        registry.register("exists", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("exists", None, Some(json!(1))),
-            JsonRpcRequest::new("not_exists", None, Some(json!(2))),
-            JsonRpcRequest::new("exists", None, Some(json!(3))),
-            JsonRpcRequest::new("not_exists", None, Some(json!(4))),
-            JsonRpcRequest::new("not_exists", None, Some(json!(5))),
-            JsonRpcRequest::new("exists", None, Some(json!(6))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 6);
-
-        match &responses[0] {
-            JsonRpcResponseType::Success(_) => {}
-            _ => panic!("Expected success at index 0"),
-        }
-        for i in [1, 3, 4] {
-            match &responses[i] {
-                JsonRpcResponseType::Error(e) => {
-                    assert_eq!(e.error.code, error_codes::METHOD_NOT_FOUND);
-                }
-                _ => panic!("Expected error at index {}", i),
-            }
-        }
-        match &responses[2] {
-            JsonRpcResponseType::Success(_) => {}
-            _ => panic!("Expected success at index 2"),
-        }
-        match &responses[5] {
-            JsonRpcResponseType::Success(_) => {}
-            _ => panic!("Expected success at index 5"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_request_data_shared_correctly() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method", None, Some(json!(1))),
-            JsonRpcRequest::new("method", None, Some(json!(2))),
-            JsonRpcRequest::new("method", None, Some(json!(3))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 3);
-
-        for resp in &responses {
-            match resp {
-                JsonRpcResponseType::Success(s) => {
-                    assert_eq!(s.jsonrpc, "2.0");
-                    assert!(s.result != Value::Null);
-                }
-                _ => panic!("Expected success response"),
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_response_contains_required_fields() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let handler = Arc::new(MockSuccessHandler);
-        let metadata = super::super::method_registry::MethodMetadata::new("method");
-        registry.register("method", handler, metadata).unwrap();
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("method", None, Some(json!(1))),
-            JsonRpcRequest::new("method", None, Some(json!(2))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-
-        for resp in &responses {
-            match resp {
-                JsonRpcResponseType::Success(s) => {
-                    assert_eq!(s.jsonrpc, "2.0");
-                    assert!(!s.result.is_null());
-                    assert!(!s.id.is_null());
-                }
-                _ => panic!("Expected success response"),
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_error_response_required_fields() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("not_found", None, Some(json!(1))),
-            JsonRpcRequest::new("also_not_found", None, Some(json!(2))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-
-        for resp in &responses {
-            match resp {
-                JsonRpcResponseType::Error(e) => {
-                    assert_eq!(e.jsonrpc, "2.0");
-                    assert!(e.error.code < 0);
-                    assert!(!e.error.message.is_empty());
-                    assert!(!e.id.is_null());
-                }
-                _ => panic!("Expected error response"),
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_notification_errors_still_not_responded() {
-        let registry = Arc::new(JsonRpcMethodRegistry::new());
-
-        let router = JsonRpcRouter::new(registry.clone(), true, 100);
-
-        let batch = vec![
-            JsonRpcRequest::new("not_found", None, Some(json!(1))),
-            JsonRpcRequest::new("not_found", None, None),
-            JsonRpcRequest::new("not_found", None, Some(json!(2))),
-        ];
-        let http_request = create_test_http_request();
-        let request_data = create_test_request_data();
-
-        let result = router.route_batch(batch, http_request, &request_data).await;
-
-        assert!(result.is_ok());
-        let responses = result.unwrap();
-        assert_eq!(responses.len(), 2);
-
-        match &responses[0] {
-            JsonRpcResponseType::Error(e) => {
-                assert_eq!(e.id, json!(1));
-            }
-            _ => panic!("Expected error at index 0"),
-        }
-        match &responses[1] {
-            JsonRpcResponseType::Error(e) => {
-                assert_eq!(e.id, json!(2));
-            }
-            _ => panic!("Expected error at index 1"),
-        }
-    }
-
-    impl JsonRpcResponseType {
-        fn id(&self) -> Value {
-            match self {
-                JsonRpcResponseType::Success(s) => s.id.clone(),
-                JsonRpcResponseType::Error(e) => e.id.clone(),
-            }
-        }
-    }
-}