spikard 0.6.2 → 0.7.1

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

@@ -0,0 +1,2262 @@
+//! 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: Value::Object(serde_json::Map::new()),
+            validated_params: None,
+            raw_query_params: Arc::new(HashMap::new()),
+            body: 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(),
+            }
+        }
+    }
+}