spikard 0.3.6 → 0.5.0

data/vendor/crates/spikard-core/src/request_data.rs

@@ -29,6 +29,8 @@ pub struct RequestData {
     pub path_params: Arc<HashMap<String, String>>,
     /// Query parameters parsed as JSON
     pub query_params: Value,
+    /// Validated parameters produced by ParameterValidator (query/path/header/cookie combined).
+    pub validated_params: Option<Value>,
     /// Raw query parameters as key-value pairs
     pub raw_query_params: Arc<HashMap<String, Vec<String>>>,
     /// Parsed request body as JSON
@@ -57,9 +59,10 @@ impl Serialize for RequestData {
         S: serde::Serializer,
     {
         use serde::ser::SerializeStruct;
-        let mut state = serializer.serialize_struct("RequestData", 9)?;
+        let mut state = serializer.serialize_struct("RequestData", 10)?;
         state.serialize_field("path_params", &*self.path_params)?;
         state.serialize_field("query_params", &self.query_params)?;
+        state.serialize_field("validated_params", &self.validated_params)?;
         state.serialize_field("raw_query_params", &*self.raw_query_params)?;
         state.serialize_field("body", &self.body)?;
         #[cfg(feature = "di")]
@@ -84,6 +87,7 @@ impl<'de> Deserialize<'de> for RequestData {
         enum Field {
             PathParams,
             QueryParams,
+            ValidatedParams,
             RawQueryParams,
             Body,
             RawBody,
@@ -108,6 +112,7 @@ impl<'de> Deserialize<'de> for RequestData {
             {
                 let mut path_params = None;
                 let mut query_params = None;
+                let mut validated_params = None;
                 let mut raw_query_params = None;
                 let mut body = None;
                 let mut raw_body = None;
@@ -124,6 +129,9 @@ impl<'de> Deserialize<'de> for RequestData {
                         Field::QueryParams => {
                             query_params = Some(map.next_value()?);
                         }
+                        Field::ValidatedParams => {
+                            validated_params = Some(map.next_value()?);
+                        }
                         Field::RawQueryParams => {
                             raw_query_params = Some(Arc::new(map.next_value()?));
                         }
@@ -159,6 +167,7 @@ impl<'de> Deserialize<'de> for RequestData {
                 Ok(RequestData {
                     path_params: path_params.ok_or_else(|| serde::de::Error::missing_field("path_params"))?,
                     query_params: query_params.ok_or_else(|| serde::de::Error::missing_field("query_params"))?,
+                    validated_params,
                     raw_query_params: raw_query_params
                         .ok_or_else(|| serde::de::Error::missing_field("raw_query_params"))?,
                     body: body.ok_or_else(|| serde::de::Error::missing_field("body"))?,
@@ -176,6 +185,7 @@ impl<'de> Deserialize<'de> for RequestData {
         const FIELDS: &[&str] = &[
             "path_params",
             "query_params",
+            "validated_params",
             "raw_query_params",
             "body",
             "raw_body",
@@ -187,3 +197,958 @@ impl<'de> Deserialize<'de> for RequestData {
         deserializer.deserialize_struct("RequestData", FIELDS, RequestDataVisitor)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::{Value, json};
+
+    #[derive(Default)]
+    struct RequestDataCollections {
+        raw_query_params: HashMap<String, Vec<String>>,
+        headers: HashMap<String, String>,
+        cookies: HashMap<String, String>,
+        path_params: HashMap<String, String>,
+    }
+
+    fn create_request_data(
+        path: &str,
+        method: &str,
+        body: Value,
+        query_params: Value,
+        collections: RequestDataCollections,
+    ) -> RequestData {
+        RequestData {
+            path_params: Arc::new(collections.path_params),
+            query_params,
+            validated_params: None,
+            raw_query_params: Arc::new(collections.raw_query_params),
+            body,
+            raw_body: None,
+            headers: Arc::new(collections.headers),
+            cookies: Arc::new(collections.cookies),
+            method: method.to_string(),
+            path: path.to_string(),
+            #[cfg(feature = "di")]
+            dependencies: None,
+        }
+    }
+
+    #[test]
+    fn test_request_data_minimal() {
+        let data = create_request_data(
+            "/api/users",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections::default(),
+        );
+
+        assert_eq!(data.path, "/api/users");
+        assert_eq!(data.method, "GET");
+        assert_eq!(data.body, json!(null));
+    }
+
+    #[test]
+    fn test_request_data_with_json_body() {
+        let body = json!({
+            "name": "test_user",
+            "email": "test@example.com",
+            "age": 30
+        });
+
+        let data = create_request_data(
+            "/api/users",
+            "POST",
+            body.clone(),
+            json!({}),
+            RequestDataCollections::default(),
+        );
+
+        assert_eq!(data.body, body);
+        assert_eq!(data.body["name"], "test_user");
+        assert_eq!(data.body["email"], "test@example.com");
+        assert_eq!(data.body["age"], 30);
+    }
+
+    #[test]
+    fn test_request_data_with_query_params() {
+        let mut raw_query_params = HashMap::new();
+        raw_query_params.insert("page".to_string(), vec!["1".to_string()]);
+        raw_query_params.insert("limit".to_string(), vec!["10".to_string()]);
+        raw_query_params.insert("tags".to_string(), vec!["rust".to_string(), "web".to_string()]);
+
+        let query_params = json!({
+            "page": "1",
+            "limit": "10",
+            "tags": ["rust", "web"]
+        });
+
+        let data = create_request_data(
+            "/api/users",
+            "GET",
+            json!(null),
+            query_params,
+            RequestDataCollections {
+                raw_query_params,
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(data.raw_query_params.get("page"), Some(&vec!["1".to_string()]));
+        assert_eq!(data.raw_query_params.get("limit"), Some(&vec!["10".to_string()]));
+        assert_eq!(
+            data.raw_query_params.get("tags"),
+            Some(&vec!["rust".to_string(), "web".to_string()])
+        );
+    }
+
+    #[test]
+    fn test_request_data_with_headers() {
+        let mut headers = HashMap::new();
+        headers.insert("content-type".to_string(), "application/json".to_string());
+        headers.insert("authorization".to_string(), "Bearer token123".to_string());
+        headers.insert("user-agent".to_string(), "Mozilla/5.0".to_string());
+
+        let data = create_request_data(
+            "/api/users",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections {
+                headers,
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(data.headers.get("content-type"), Some(&"application/json".to_string()));
+        assert_eq!(data.headers.get("authorization"), Some(&"Bearer token123".to_string()));
+        assert_eq!(data.headers.get("user-agent"), Some(&"Mozilla/5.0".to_string()));
+    }
+
+    #[test]
+    fn test_request_data_with_cookies() {
+        let mut cookies = HashMap::new();
+        cookies.insert("session_id".to_string(), "abc123xyz".to_string());
+        cookies.insert("user_id".to_string(), "user_42".to_string());
+        cookies.insert("theme".to_string(), "dark".to_string());
+
+        let data = create_request_data(
+            "/api/users",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections {
+                cookies,
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(data.cookies.get("session_id"), Some(&"abc123xyz".to_string()));
+        assert_eq!(data.cookies.get("user_id"), Some(&"user_42".to_string()));
+        assert_eq!(data.cookies.get("theme"), Some(&"dark".to_string()));
+    }
+
+    #[test]
+    fn test_request_data_with_path_params() {
+        let mut path_params = HashMap::new();
+        path_params.insert("user_id".to_string(), "123".to_string());
+        path_params.insert("post_id".to_string(), "456".to_string());
+
+        let data = create_request_data(
+            "/api/users/123/posts/456",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections {
+                path_params,
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(data.path_params.get("user_id"), Some(&"123".to_string()));
+        assert_eq!(data.path_params.get("post_id"), Some(&"456".to_string()));
+    }
+
+    #[test]
+    fn test_request_data_all_fields_populated() {
+        let mut path_params = HashMap::new();
+        path_params.insert("id".to_string(), "user_99".to_string());
+
+        let mut raw_query_params = HashMap::new();
+        raw_query_params.insert("filter".to_string(), vec!["active".to_string()]);
+
+        let mut headers = HashMap::new();
+        headers.insert("content-type".to_string(), "application/json".to_string());
+
+        let mut cookies = HashMap::new();
+        cookies.insert("session".to_string(), "xyz789".to_string());
+
+        let body = json!({
+            "name": "John",
+            "email": "john@example.com"
+        });
+
+        let query_params = json!({
+            "filter": "active"
+        });
+
+        let data = create_request_data(
+            "/api/users/user_99",
+            "PUT",
+            body,
+            query_params,
+            RequestDataCollections {
+                raw_query_params,
+                headers,
+                cookies,
+                path_params,
+            },
+        );
+
+        assert_eq!(data.path, "/api/users/user_99");
+        assert_eq!(data.method, "PUT");
+        assert_eq!(data.path_params.get("id"), Some(&"user_99".to_string()));
+        assert_eq!(data.body["name"], "John");
+        assert_eq!(data.headers.get("content-type"), Some(&"application/json".to_string()));
+        assert_eq!(data.cookies.get("session"), Some(&"xyz789".to_string()));
+    }
+
+    #[test]
+    fn test_request_data_empty_collections() {
+        let data = create_request_data(
+            "/api/test",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections::default(),
+        );
+
+        assert!(data.path_params.is_empty());
+        assert!(data.raw_query_params.is_empty());
+        assert!(data.headers.is_empty());
+        assert!(data.cookies.is_empty());
+    }
+
+    #[test]
+    fn test_request_data_clone() {
+        let mut path_params = HashMap::new();
+        path_params.insert("id".to_string(), "123".to_string());
+
+        let data1 = create_request_data(
+            "/api/users/123",
+            "GET",
+            json!({"name": "test"}),
+            json!({}),
+            RequestDataCollections {
+                path_params,
+                ..Default::default()
+            },
+        );
+
+        let data2 = data1.clone();
+
+        assert_eq!(data1.path, data2.path);
+        assert_eq!(data1.method, data2.method);
+        assert_eq!(data1.body, data2.body);
+        assert_eq!(data1.path_params, data2.path_params);
+    }
+
+    #[test]
+    fn test_request_data_various_http_methods() {
+        let methods = vec!["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+
+        for method in methods {
+            let data = create_request_data(
+                "/api/test",
+                method,
+                json!(null),
+                json!({}),
+                RequestDataCollections::default(),
+            );
+
+            assert_eq!(data.method, method);
+        }
+    }
+
+    #[test]
+    fn test_request_data_raw_body_none() {
+        let data = create_request_data(
+            "/api/test",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections::default(),
+        );
+
+        assert!(data.raw_body.is_none());
+    }
+
+    #[cfg(not(feature = "di"))]
+    #[test]
+    fn test_request_data_raw_body_some() {
+        let raw_body_bytes = vec![1, 2, 3, 4, 5];
+        let mut data = create_request_data(
+            "/api/test",
+            "POST",
+            json!(null),
+            json!({}),
+            RequestDataCollections::default(),
+        );
+
+        data.raw_body = Some(raw_body_bytes.clone());
+        assert_eq!(data.raw_body, Some(raw_body_bytes));
+    }
+
+    #[cfg(not(feature = "di"))]
+    #[test]
+    fn request_data_serializes_and_deserializes() {
+        let mut headers = HashMap::new();
+        headers.insert("content-type".to_string(), "application/json".to_string());
+
+        let mut cookies = HashMap::new();
+        cookies.insert("session".to_string(), "abc".to_string());
+
+        let mut raw_query_params = HashMap::new();
+        raw_query_params.insert("tags".to_string(), vec!["rust".to_string(), "http".to_string()]);
+
+        let mut path_params = HashMap::new();
+        path_params.insert("id".to_string(), "123".to_string());
+
+        let mut data = create_request_data(
+            "/api/items/123",
+            "POST",
+            json!({"name": "demo"}),
+            json!({"tags": ["rust", "http"]}),
+            RequestDataCollections {
+                raw_query_params,
+                headers,
+                cookies,
+                path_params,
+            },
+        );
+        data.raw_body = Some(vec![9, 8, 7]);
+
+        let encoded = serde_json::to_string(&data).expect("serialize RequestData");
+        let decoded: RequestData = serde_json::from_str(&encoded).expect("deserialize RequestData");
+
+        assert_eq!(decoded.path, "/api/items/123");
+        assert_eq!(decoded.method, "POST");
+        assert_eq!(decoded.body["name"], "demo");
+        assert_eq!(decoded.query_params["tags"][0], "rust");
+        assert_eq!(
+            decoded.raw_query_params.get("tags").unwrap(),
+            &vec!["rust".to_string(), "http".to_string()]
+        );
+        assert_eq!(decoded.headers.get("content-type").unwrap(), "application/json");
+        assert_eq!(decoded.cookies.get("session").unwrap(), "abc");
+        assert_eq!(decoded.path_params.get("id").unwrap(), "123");
+        assert_eq!(decoded.raw_body, Some(vec![9, 8, 7]));
+    }
+
+    #[test]
+    fn test_request_data_multiple_query_param_values() {
+        let mut raw_query_params = HashMap::new();
+        raw_query_params.insert(
+            "colors".to_string(),
+            vec!["red".to_string(), "green".to_string(), "blue".to_string()],
+        );
+
+        let data = create_request_data(
+            "/api/items",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections {
+                raw_query_params,
+                ..Default::default()
+            },
+        );
+
+        let colors = data.raw_query_params.get("colors").unwrap();
+        assert_eq!(colors.len(), 3);
+        assert!(colors.contains(&"red".to_string()));
+        assert!(colors.contains(&"green".to_string()));
+        assert!(colors.contains(&"blue".to_string()));
+    }
+
+    #[test]
+    fn test_request_data_complex_json_body() {
+        let body = json!({
+            "user": {
+                "name": "Alice",
+                "profile": {
+                    "age": 28,
+                    "location": "San Francisco"
+                }
+            },
+            "tags": ["admin", "active"],
+            "metadata": {
+                "created_at": "2024-01-01",
+                "updated_at": "2024-12-01"
+            }
+        });
+
+        let data = create_request_data("/api/users", "POST", body, json!({}), RequestDataCollections::default());
+
+        assert_eq!(data.body["user"]["name"], "Alice");
+        assert_eq!(data.body["user"]["profile"]["age"], 28);
+        assert_eq!(data.body["tags"][0], "admin");
+        assert_eq!(data.body["metadata"]["created_at"], "2024-01-01");
+    }
+
+    #[test]
+    fn test_request_data_special_characters_in_paths() {
+        let data = create_request_data(
+            "/api/users/john@example.com/posts",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections::default(),
+        );
+
+        assert_eq!(data.path, "/api/users/john@example.com/posts");
+    }
+
+    #[test]
+    fn test_request_data_special_characters_in_params() {
+        let mut path_params = HashMap::new();
+        path_params.insert("email".to_string(), "test@example.com".to_string());
+        path_params.insert("slug".to_string(), "my-post-title".to_string());
+
+        let data = create_request_data(
+            "/api/users/test@example.com",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections {
+                path_params,
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(data.path_params.get("email"), Some(&"test@example.com".to_string()));
+        assert_eq!(data.path_params.get("slug"), Some(&"my-post-title".to_string()));
+    }
+
+    #[test]
+    fn test_request_data_null_and_empty_values() {
+        let body = json!({
+            "name": null,
+            "email": "",
+            "age": 0,
+            "active": false
+        });
+
+        let data = create_request_data("/api/users", "POST", body, json!({}), RequestDataCollections::default());
+
+        assert!(data.body["name"].is_null());
+        assert_eq!(data.body["email"], "");
+        assert_eq!(data.body["age"], 0);
+        assert_eq!(data.body["active"], false);
+    }
+
+    #[test]
+    fn test_request_data_serialization() {
+        let mut path_params = HashMap::new();
+        path_params.insert("id".to_string(), "123".to_string());
+
+        let mut headers = HashMap::new();
+        headers.insert("content-type".to_string(), "application/json".to_string());
+
+        let data = create_request_data(
+            "/api/users/123",
+            "GET",
+            json!({"name": "test"}),
+            json!({"page": "1"}),
+            RequestDataCollections {
+                headers,
+                path_params,
+                ..Default::default()
+            },
+        );
+
+        let serialized = serde_json::to_string(&data);
+        assert!(serialized.is_ok());
+    }
+
+    #[test]
+    fn test_request_data_delete_request() {
+        let mut path_params = HashMap::new();
+        path_params.insert("id".to_string(), "999".to_string());
+
+        let data = create_request_data(
+            "/api/users/999",
+            "DELETE",
+            json!(null),
+            json!({}),
+            RequestDataCollections {
+                path_params,
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(data.method, "DELETE");
+        assert_eq!(data.path_params.get("id"), Some(&"999".to_string()));
+    }
+
+    #[test]
+    fn test_request_data_array_body() {
+        let body = json!([
+            {"id": 1, "name": "item1"},
+            {"id": 2, "name": "item2"},
+            {"id": 3, "name": "item3"}
+        ]);
+
+        let data = create_request_data("/api/items", "POST", body, json!({}), RequestDataCollections::default());
+
+        assert!(data.body.is_array());
+        assert_eq!(data.body.as_array().unwrap().len(), 3);
+        assert_eq!(data.body[0]["id"], 1);
+        assert_eq!(data.body[2]["name"], "item3");
+    }
+
+    #[test]
+    fn test_request_data_case_sensitive_keys() {
+        let mut headers = HashMap::new();
+        headers.insert("Content-Type".to_string(), "application/json".to_string());
+        headers.insert("content-type".to_string(), "text/plain".to_string());
+
+        let data = create_request_data(
+            "/api/test",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections {
+                headers,
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(data.headers.get("Content-Type"), Some(&"application/json".to_string()));
+        assert_eq!(data.headers.get("content-type"), Some(&"text/plain".to_string()));
+    }
+
+    #[test]
+    fn test_request_data_serialization_with_all_fields() {
+        let mut path_params = HashMap::new();
+        path_params.insert("id".to_string(), "42".to_string());
+
+        let mut raw_query_params = HashMap::new();
+        raw_query_params.insert("page".to_string(), vec!["2".to_string()]);
+
+        let mut headers = HashMap::new();
+        headers.insert("authorization".to_string(), "Bearer xyz".to_string());
+
+        let mut cookies = HashMap::new();
+        cookies.insert("token".to_string(), "abc123".to_string());
+
+        let data = create_request_data(
+            "/api/resource/42",
+            "PUT",
+            json!({"status": "updated"}),
+            json!({"page": "2"}),
+            RequestDataCollections {
+                raw_query_params,
+                headers,
+                cookies,
+                path_params,
+            },
+        );
+
+        let serialized = serde_json::to_string(&data).expect("serialization failed");
+        assert!(!serialized.is_empty());
+        assert!(serialized.contains("\"id\":\"42\""));
+        assert!(serialized.contains("PUT"));
+    }
+
+    #[test]
+    fn test_request_data_deserialization() {
+        let json_str = r#"{
+            "path_params": {"user_id": "123"},
+            "query_params": {"page": "1"},
+            "raw_query_params": {"page": ["1"]},
+            "body": {"name": "test"},
+            "raw_body": null,
+            "headers": {"content-type": "application/json"},
+            "cookies": {"session": "abc"},
+            "method": "POST",
+            "path": "/api/users"
+        }"#;
+
+        let deserialized: RequestData = serde_json::from_str(json_str).expect("deserialization failed");
+
+        assert_eq!(deserialized.method, "POST");
+        assert_eq!(deserialized.path, "/api/users");
+        assert_eq!(deserialized.path_params.get("user_id"), Some(&"123".to_string()));
+        assert_eq!(deserialized.body["name"], "test");
+        assert_eq!(
+            deserialized.headers.get("content-type"),
+            Some(&"application/json".to_string())
+        );
+        assert_eq!(deserialized.cookies.get("session"), Some(&"abc".to_string()));
+    }
+
+    #[test]
+    fn test_request_data_roundtrip_serialization() {
+        let mut path_params = HashMap::new();
+        path_params.insert("item_id".to_string(), "789".to_string());
+
+        let mut raw_query_params = HashMap::new();
+        raw_query_params.insert("sort".to_string(), vec!["desc".to_string()]);
+
+        let mut headers = HashMap::new();
+        headers.insert("x-custom-header".to_string(), "value123".to_string());
+
+        let mut cookies = HashMap::new();
+        cookies.insert("prefer".to_string(), "dark_mode".to_string());
+
+        let original = create_request_data(
+            "/api/items/789",
+            "DELETE",
+            json!({"reason": "archived"}),
+            json!({"sort": "desc"}),
+            RequestDataCollections {
+                raw_query_params,
+                headers,
+                cookies,
+                path_params,
+            },
+        );
+
+        let serialized = serde_json::to_string(&original).expect("serialization failed");
+        let deserialized: RequestData = serde_json::from_str(&serialized).expect("deserialization failed");
+
+        assert_eq!(deserialized.method, original.method);
+        assert_eq!(deserialized.path, original.path);
+        assert_eq!(deserialized.body, original.body);
+        assert_eq!(deserialized.path_params, original.path_params);
+    }
+
+    #[test]
+    fn test_request_data_large_json_body() {
+        let mut large_obj = serde_json::Map::new();
+        for i in 0..100 {
+            large_obj.insert(
+                format!("field_{}", i),
+                json!({"value": i, "name": format!("item_{}", i)}),
+            );
+        }
+        let body = json!(large_obj);
+
+        let data = create_request_data(
+            "/api/batch",
+            "POST",
+            body.clone(),
+            json!({}),
+            RequestDataCollections::default(),
+        );
+
+        assert!(data.body.is_object());
+        assert_eq!(data.body.as_object().unwrap().len(), 100);
+    }
+
+    #[test]
+    fn test_request_data_deeply_nested_json() {
+        let body = json!({
+            "level1": {
+                "level2": {
+                    "level3": {
+                        "level4": {
+                            "level5": {
+                                "value": "deep"
+                            }
+                        }
+                    }
+                }
+            }
+        });
+
+        let data = create_request_data("/api/nested", "GET", body, json!({}), RequestDataCollections::default());
+
+        assert_eq!(
+            data.body["level1"]["level2"]["level3"]["level4"]["level5"]["value"],
+            "deep"
+        );
+    }
+
+    #[test]
+    fn test_request_data_unicode_in_fields() {
+        let mut path_params = HashMap::new();
+        path_params.insert("name".to_string(), "用户".to_string());
+
+        let mut cookies = HashMap::new();
+        cookies.insert("msg".to_string(), "こんにちは".to_string());
+
+        let body = json!({
+            "greeting": "مرحبا",
+            "emoji": "🚀"
+        });
+
+        let data = create_request_data(
+            "/api/users/用户",
+            "POST",
+            body,
+            json!({}),
+            RequestDataCollections {
+                cookies,
+                path_params,
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(data.path_params.get("name"), Some(&"用户".to_string()));
+        assert_eq!(data.cookies.get("msg"), Some(&"こんにちは".to_string()));
+        assert_eq!(data.body["emoji"], "🚀");
+    }
+
+    #[test]
+    fn test_request_data_multiple_headers_with_same_prefix() {
+        let mut headers = HashMap::new();
+        headers.insert("x-custom-1".to_string(), "value1".to_string());
+        headers.insert("x-custom-2".to_string(), "value2".to_string());
+        headers.insert("x-custom-3".to_string(), "value3".to_string());
+
+        let data = create_request_data(
+            "/api/test",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections {
+                headers,
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(data.headers.get("x-custom-1"), Some(&"value1".to_string()));
+        assert_eq!(data.headers.get("x-custom-2"), Some(&"value2".to_string()));
+        assert_eq!(data.headers.get("x-custom-3"), Some(&"value3".to_string()));
+        assert_eq!(data.headers.len(), 3);
+    }
+
+    #[test]
+    fn test_request_data_numeric_values_in_json() {
+        let body = json!({
+            "int": 42,
+            "float": 3.2,
+            "negative": -100,
+            "zero": 0,
+            "large": 9223372036854775807i64
+        });
+
+        let data = create_request_data(
+            "/api/numbers",
+            "POST",
+            body,
+            json!({}),
+            RequestDataCollections::default(),
+        );
+
+        assert_eq!(data.body["int"], 42);
+        assert_eq!(data.body["float"], 3.2);
+        assert_eq!(data.body["negative"], -100);
+        assert_eq!(data.body["zero"], 0);
+    }
+
+    #[test]
+    fn test_request_data_boolean_values_in_json() {
+        let body = json!({
+            "is_active": true,
+            "is_admin": false
+        });
+
+        let data = create_request_data("/api/config", "GET", body, json!({}), RequestDataCollections::default());
+
+        assert_eq!(data.body["is_active"], true);
+        assert_eq!(data.body["is_admin"], false);
+    }
+
+    #[test]
+    fn test_request_data_missing_optional_raw_body() {
+        let data = create_request_data(
+            "/api/test",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections::default(),
+        );
+
+        assert!(data.raw_body.is_none());
+    }
+
+    #[test]
+    fn test_request_data_path_with_query_string_format() {
+        let data = create_request_data(
+            "/api/search?q=test&limit=10",
+            "GET",
+            json!(null),
+            json!({"q": "test", "limit": "10"}),
+            RequestDataCollections::default(),
+        );
+
+        assert_eq!(data.path, "/api/search?q=test&limit=10");
+    }
+
+    #[test]
+    fn test_request_data_root_path() {
+        let data = create_request_data("/", "GET", json!(null), json!({}), RequestDataCollections::default());
+
+        assert_eq!(data.path, "/");
+    }
+
+    #[test]
+    fn test_request_data_empty_string_values() {
+        let mut headers = HashMap::new();
+        headers.insert("empty-header".to_string(), "".to_string());
+
+        let mut path_params = HashMap::new();
+        path_params.insert("id".to_string(), "".to_string());
+
+        let data = create_request_data(
+            "/api/test",
+            "GET",
+            json!(null),
+            json!({}),
+            RequestDataCollections {
+                headers,
+                path_params,
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(data.headers.get("empty-header"), Some(&"".to_string()));
+        assert_eq!(data.path_params.get("id"), Some(&"".to_string()));
+    }
+
+    #[test]
+    fn test_request_data_deserialization_missing_field() {
+        let json_str = r#"{
+            "path_params": {"user_id": "123"},
+            "query_params": {"page": "1"},
+            "raw_query_params": {"page": ["1"]},
+            "body": {"name": "test"},
+            "raw_body": null,
+            "headers": {"content-type": "application/json"},
+            "cookies": {"session": "abc"}
+        }"#;
+
+        let result: Result<RequestData, _> = serde_json::from_str(json_str);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_request_data_deserialization_extra_fields_rejected() {
+        let json_str = r#"{
+            "path_params": {"user_id": "123"},
+            "query_params": {"page": "1"},
+            "raw_query_params": {"page": ["1"]},
+            "body": {"name": "test"},
+            "raw_body": null,
+            "headers": {"content-type": "application/json"},
+            "cookies": {"session": "abc"},
+            "method": "GET",
+            "path": "/api/test",
+            "extra_field": "not allowed"
+        }"#;
+
+        let result: Result<RequestData, _> = serde_json::from_str(json_str);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_request_data_multiple_raw_body_values() {
+        let mut raw_query_params = HashMap::new();
+        raw_query_params.insert(
+            "data".to_string(),
+            vec!["val1".to_string(), "val2".to_string(), "val3".to_string()],
+        );
+
+        let data = create_request_data(
+            "/api/test",
+            "POST",
+            json!(null),
+            json!({}),
+            RequestDataCollections {
+                raw_query_params,
+                ..Default::default()
+            },
+        );
+
+        let values = data.raw_query_params.get("data").unwrap();
+        assert_eq!(values.len(), 3);
+        assert_eq!(values[0], "val1");
+        assert_eq!(values[1], "val2");
+        assert_eq!(values[2], "val3");
+    }
+
+    #[test]
+    fn test_request_data_debug_output() {
+        let data = create_request_data(
+            "/api/test",
+            "GET",
+            json!({"key": "value"}),
+            json!({}),
+            RequestDataCollections::default(),
+        );
+
+        let debug_str = format!("{:?}", data);
+        assert!(debug_str.contains("RequestData"));
+        assert!(debug_str.contains("/api/test"));
+    }
+
+    #[test]
+    fn test_request_data_clone_independence() {
+        let mut path_params1 = HashMap::new();
+        path_params1.insert("id".to_string(), "original".to_string());
+
+        let data1 = create_request_data(
+            "/api/users/1",
+            "GET",
+            json!({"name": "original"}),
+            json!({}),
+            RequestDataCollections {
+                path_params: path_params1,
+                ..Default::default()
+            },
+        );
+
+        let data2 = data1.clone();
+
+        assert_eq!(data1.path_params.get("id"), data2.path_params.get("id"));
+        assert_eq!(data1.body["name"], data2.body["name"]);
+    }
+
+    #[test]
+    fn deserialize_errors_on_missing_required_field() {
+        let value = json!({
+            "path_params": {},
+            "query_params": {},
+            "raw_query_params": {},
+            "body": null,
+            "raw_body": null,
+            "headers": {},
+            "cookies": {},
+            "method": "GET"
+        });
+
+        let err = serde_json::from_value::<RequestData>(value).unwrap_err();
+        assert!(err.to_string().contains("missing field"));
+    }
+
+    #[test]
+    fn deserialize_errors_on_invalid_raw_body_type() {
+        let value = json!({
+            "path_params": {},
+            "query_params": {},
+            "raw_query_params": {},
+            "body": null,
+            "raw_body": "not-bytes",
+            "headers": {},
+            "cookies": {},
+            "method": "GET",
+            "path": "/"
+        });
+
+        assert!(serde_json::from_value::<RequestData>(value).is_err());
+    }
+}