spikard 0.8.2 → 0.10.1

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

@@ -69,6 +69,9 @@ impl ParameterValidator {
     ///
     /// The schema should describe all parameters with their types and constraints.
     /// Each property MUST have a "source" field indicating where the parameter comes from.
+    ///
+    /// # Errors
+    /// Returns an error if the schema is invalid or malformed.
     pub fn new(schema: Value) -> Result<Self, String> {
         let parameter_defs = Self::extract_parameter_defs(&schema)?;
         let validation_schema = Self::create_validation_schema(&schema);
@@ -88,6 +91,7 @@ impl ParameterValidator {
     }
 
     /// Whether this validator needs access to request headers.
+    #[must_use]
     pub fn requires_headers(&self) -> bool {
         self.inner
             .parameter_defs
@@ -96,6 +100,7 @@ impl ParameterValidator {
     }
 
     /// Whether this validator needs access to request cookies.
+    #[must_use]
     pub fn requires_cookies(&self) -> bool {
         self.inner
             .parameter_defs
@@ -104,6 +109,7 @@ impl ParameterValidator {
     }
 
     /// Whether the validator has any parameter definitions.
+    #[must_use]
     pub fn has_params(&self) -> bool {
         !self.inner.parameter_defs.is_empty()
     }
@@ -125,12 +131,22 @@ impl ParameterValidator {
 
             for (key, child) in obj {
                 match key.as_str() {
-                    // Structural keywords we support in the coercion pass.
-                    "type" | "format" | "properties" | "required" | "items" | "additionalProperties" => {}
-
-                    // Metadata keywords which don't affect validation semantics.
-                    "title" | "description" | "default" | "examples" | "deprecated" | "readOnly" | "writeOnly"
-                    | "$schema" | "$id" => {}
+                    // Structural keywords we support in the coercion pass, and metadata keywords.
+                    "type"
+                    | "format"
+                    | "properties"
+                    | "required"
+                    | "items"
+                    | "additionalProperties"
+                    | "title"
+                    | "description"
+                    | "default"
+                    | "examples"
+                    | "deprecated"
+                    | "readOnly"
+                    | "writeOnly"
+                    | "$schema"
+                    | "$id" => {}
 
                     // Anything else may impose constraints we don't enforce manually.
                     _ => return true,
@@ -166,15 +182,14 @@ impl ParameterValidator {
         for (name, prop) in properties {
             let source_str = prop.get("source").and_then(|s| s.as_str()).ok_or_else(|| {
                 anyhow::anyhow!("Invalid parameter schema")
-                    .context(format!("Parameter '{}' missing required 'source' field", name))
+                    .context(format!("Parameter '{name}' missing required 'source' field"))
                     .to_string()
             })?;
 
             let source = ParameterSource::from_str(source_str).ok_or_else(|| {
                 anyhow::anyhow!("Invalid parameter schema")
                     .context(format!(
-                        "Invalid source '{}' for parameter '{}' (expected: query, path, header, or cookie)",
-                        source_str, name
+                        "Invalid source '{source_str}' for parameter '{name}' (expected: query, path, header, or cookie)"
                     ))
                     .to_string()
             })?;
@@ -182,7 +197,10 @@ impl ParameterValidator {
             let expected_type = prop.get("type").and_then(|t| t.as_str()).map(String::from);
             let format = prop.get("format").and_then(|f| f.as_str()).map(String::from);
 
-            let is_optional = prop.get("optional").and_then(|v| v.as_bool()).unwrap_or(false);
+            let is_optional = prop
+                .get("optional")
+                .and_then(serde_json::Value::as_bool)
+                .unwrap_or(false);
             let required = required_list.contains(&name.as_str()) && !is_optional;
 
             let (lookup_key, error_key) = if source == ParameterSource::Header {
@@ -207,6 +225,7 @@ impl ParameterValidator {
     }
 
     /// Get the underlying JSON Schema
+    #[must_use]
     pub fn schema(&self) -> &Value {
         &self.inner.schema
     }
@@ -217,6 +236,10 @@ impl ParameterValidator {
     /// It performs type coercion (e.g., "123" → 123) based on the schema.
     ///
     /// Returns the validated JSON object that can be directly converted to Python kwargs.
+    ///
+    /// # Errors
+    /// Returns a validation error if parameter validation fails.
+    #[allow(clippy::too_many_lines)]
     pub fn validate_and_extract(
         &self,
         query_params: &Value,
@@ -279,11 +302,11 @@ impl ParameterValidator {
                                             "Input should be a valid boolean, unable to interpret input".to_string()
                                         }
                                         Some("string") => match item_format {
-                                            Some("uuid") => format!("Input should be a valid UUID, {}", e),
-                                            Some("date") => format!("Input should be a valid date, {}", e),
-                                            Some("date-time") => format!("Input should be a valid datetime, {}", e),
-                                            Some("time") => format!("Input should be a valid time, {}", e),
-                                            Some("duration") => format!("Input should be a valid duration, {}", e),
+                                            Some("uuid") => format!("Input should be a valid UUID, {e}"),
+                                            Some("date") => format!("Input should be a valid date, {e}"),
+                                            Some("date-time") => format!("Input should be a valid datetime, {e}"),
+                                            Some("time") => format!("Input should be a valid time, {e}"),
+                                            Some("duration") => format!("Input should be a valid duration, {e}"),
                                             _ => e,
                                         },
                                         _ => e,
@@ -303,6 +326,7 @@ impl ParameterValidator {
                     };
                     let (item_type, item_format) = self.array_item_type_and_format(&param_def.name);
 
+                    #[allow(clippy::option_if_let_else)]
                     let coerced_items = match array_value.as_array() {
                         Some(items) => {
                             let mut out = Vec::with_capacity(items.len());
@@ -332,11 +356,11 @@ impl ParameterValidator {
                                                     Some("number") => "Input should be a valid number, unable to parse string as a number".to_string(),
                                                     Some("boolean") => "Input should be a valid boolean, unable to interpret input".to_string(),
                                                     Some("string") => match item_format {
-                                                        Some("uuid") => format!("Input should be a valid UUID, {}", e),
-                                                        Some("date") => format!("Input should be a valid date, {}", e),
-                                                        Some("date-time") => format!("Input should be a valid datetime, {}", e),
-                                                        Some("time") => format!("Input should be a valid time, {}", e),
-                                                        Some("duration") => format!("Input should be a valid duration, {}", e),
+                                                        Some("uuid") => format!("Input should be a valid UUID, {e}"),
+                                                        Some("date") => format!("Input should be a valid date, {e}"),
+                                                        Some("date-time") => format!("Input should be a valid datetime, {e}"),
+                                                        Some("time") => format!("Input should be a valid time, {e}"),
+                                                        Some("duration") => format!("Input should be a valid duration, {e}"),
                                                         _ => e.clone(),
                                                     },
                                                     _ => e.clone(),
@@ -410,19 +434,19 @@ impl ParameterValidator {
                                     "Input should be a valid boolean, unable to interpret input".to_string(),
                                 ),
                                 (Some("string"), Some("uuid")) => {
-                                    ("uuid_parsing", format!("Input should be a valid UUID, {}", e))
+                                    ("uuid_parsing", format!("Input should be a valid UUID, {e}"))
                                 }
                                 (Some("string"), Some("date")) => {
-                                    ("date_parsing", format!("Input should be a valid date, {}", e))
+                                    ("date_parsing", format!("Input should be a valid date, {e}"))
                                 }
                                 (Some("string"), Some("date-time")) => {
-                                    ("datetime_parsing", format!("Input should be a valid datetime, {}", e))
+                                    ("datetime_parsing", format!("Input should be a valid datetime, {e}"))
                                 }
                                 (Some("string"), Some("time")) => {
-                                    ("time_parsing", format!("Input should be a valid time, {}", e))
+                                    ("time_parsing", format!("Input should be a valid time, {e}"))
                                 }
                                 (Some("string"), Some("duration")) => {
-                                    ("duration_parsing", format!("Input should be a valid duration, {}", e))
+                                    ("duration_parsing", format!("Input should be a valid duration, {e}"))
                                 }
                                 _ => ("type_error", e),
                             };
@@ -445,7 +469,7 @@ impl ParameterValidator {
         let params_json = Value::Object(params_map);
         if let Some(schema_validator) = &self.inner.schema_validator {
             match schema_validator.validate(&params_json) {
-                Ok(_) => Ok(params_json),
+                Ok(()) => Ok(params_json),
                 Err(mut validation_err) => {
                     for error in &mut validation_err.errors {
                         if error.loc.len() >= 2 && error.loc[0] == "body" {
@@ -459,7 +483,7 @@ impl ParameterValidator {
                                 };
                                 error.loc[0] = source_str.to_string();
                                 if param_def.source == ParameterSource::Header {
-                                    error.loc[1] = param_def.error_key.clone();
+                                    error.loc[1].clone_from(&param_def.error_key);
                                 }
                                 if let Some(raw_value) =
                                     self.raw_value_for_error(param_def, raw_query_params, path_params, headers, cookies)
@@ -477,6 +501,7 @@ impl ParameterValidator {
         }
     }
 
+    #[allow(clippy::unused_self)]
     fn raw_value_for_error<'a>(
         &self,
         param_def: &ParameterDef,
@@ -485,6 +510,7 @@ impl ParameterValidator {
         headers: &'a HashMap<String, String>,
         cookies: &'a HashMap<String, String>,
     ) -> Option<&'a str> {
+        #[allow(clippy::too_many_arguments)]
         match param_def.source {
             ParameterSource::Query => raw_query_params
                 .get(&param_def.lookup_key)
@@ -548,11 +574,11 @@ impl ParameterValidator {
             Some("integer") => value
                 .parse::<i64>()
                 .map(|i| json!(i))
-                .map_err(|e| format!("Invalid integer: {}", e)),
+                .map_err(|e| format!("Invalid integer: {e}")),
             Some("number") => value
                 .parse::<f64>()
                 .map(|f| json!(f))
-                .map_err(|e| format!("Invalid number: {}", e)),
+                .map_err(|e| format!("Invalid number: {e}")),
             Some("boolean") => {
                 if value.is_empty() {
                     return Ok(json!(false));
@@ -563,7 +589,7 @@ impl ParameterValidator {
                 } else if value_lower == "false" || value == "0" {
                     Ok(json!(false))
                 } else {
-                    Err(format!("Invalid boolean: {}", value))
+                    Err(format!("Invalid boolean: {value}"))
                 }
             }
             _ => Ok(json!(value)),
@@ -574,7 +600,7 @@ impl ParameterValidator {
     fn validate_date_format(value: &str) -> Result<(), String> {
         jiff::civil::Date::strptime("%Y-%m-%d", value)
             .map(|_| ())
-            .map_err(|e| format!("Invalid date format: {}", e))
+            .map_err(|e| format!("Invalid date format: {e}"))
     }
 
     /// Validate ISO 8601 datetime format
@@ -582,7 +608,7 @@ impl ParameterValidator {
         use std::str::FromStr;
         jiff::Timestamp::from_str(value)
             .map(|_| ())
-            .map_err(|e| format!("Invalid datetime format: {}", e))
+            .map_err(|e| format!("Invalid datetime format: {e}"))
     }
 
     /// Validate ISO 8601 time format: HH:MM:SS or HH:MM:SS.ffffff
@@ -608,7 +634,7 @@ impl ParameterValidator {
         };
 
         let base_time = time_part.split('.').next().unwrap_or(time_part);
-        jiff::civil::Time::strptime("%H:%M:%S", base_time).map_err(|e| format!("Invalid time format: {}", e))?;
+        jiff::civil::Time::strptime("%H:%M:%S", base_time).map_err(|e| format!("Invalid time format: {e}"))?;
 
         if let Some((_, frac)) = time_part.split_once('.')
             && (frac.is_empty() || frac.len() > 9 || !frac.chars().all(|c| c.is_ascii_digit()))
@@ -648,7 +674,7 @@ impl ParameterValidator {
         use std::str::FromStr;
         jiff::Span::from_str(value)
             .map(|_| ())
-            .map_err(|e| format!("Invalid duration format: {}", e))
+            .map_err(|e| format!("Invalid duration format: {e}"))
     }
 
     /// Validate UUID format
@@ -671,7 +697,7 @@ impl ParameterValidator {
             for (name, prop) in properties.iter_mut() {
                 if let Some(obj) = prop.as_object_mut() {
                     obj.remove("source");
-                    if obj.get("optional").and_then(|v| v.as_bool()) == Some(true) {
+                    if obj.get("optional").and_then(serde_json::Value::as_bool) == Some(true) {
                         optional_fields.push(name.clone());
                     }
                     obj.remove("optional");
@@ -798,7 +824,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed: {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed: {result:?}");
 
         let params = result.unwrap();
         assert_eq!(params, json!({"item_id": "foobar"}));
@@ -832,9 +858,9 @@ mod tests {
             &HashMap::new(),
         );
         if result.is_err() {
-            eprintln!("Error for 'True': {:?}", result);
+            eprintln!("Error for 'True': {result:?}");
         }
-        assert!(result.is_ok(), "Validation should succeed for 'True': {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for 'True': {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"value": true}));
 
@@ -847,7 +873,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed for '1': {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for '1': {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"value": true}));
 
@@ -860,7 +886,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed for 'false': {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for 'false': {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"value": false}));
 
@@ -873,7 +899,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed for 'TRUE': {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for 'TRUE': {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"value": true}));
     }
@@ -904,7 +930,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed for integer 1: {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for integer 1: {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"flag": true}));
 
@@ -918,7 +944,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(result.is_ok(), "Validation should succeed for integer 0: {:?}", result);
+        assert!(result.is_ok(), "Validation should succeed for integer 0: {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"flag": false}));
 
@@ -932,11 +958,7 @@ mod tests {
             &HashMap::new(),
             &HashMap::new(),
         );
-        assert!(
-            result.is_ok(),
-            "Validation should succeed for boolean true: {:?}",
-            result
-        );
+        assert!(result.is_ok(), "Validation should succeed for boolean true: {result:?}");
         let params = result.unwrap();
         assert_eq!(params, json!({"flag": true}));
 
@@ -952,8 +974,7 @@ mod tests {
         );
         assert!(
             result.is_ok(),
-            "Validation should succeed for boolean false: {:?}",
-            result
+            "Validation should succeed for boolean false: {result:?}"
         );
         let params = result.unwrap();
         assert_eq!(params, json!({"flag": false}));
@@ -1165,7 +1186,7 @@ mod tests {
 
         let validator = ParameterValidator::new(schema).unwrap();
         let mut raw_query_params: HashMap<String, Vec<String>> = HashMap::new();
-        raw_query_params.insert("flag".to_string(), vec!["".to_string()]);
+        raw_query_params.insert("flag".to_string(), vec![String::new()]);
 
         let result = validator
             .validate_and_extract(
@@ -1323,7 +1344,7 @@ mod tests {
 
         let validator = ParameterValidator::new(schema).unwrap();
         let mut raw_query_params: HashMap<String, Vec<String>> = HashMap::new();
-        raw_query_params.insert("flag".to_string(), vec!["".to_string()]);
+        raw_query_params.insert("flag".to_string(), vec![String::new()]);
 
         let result = validator.validate_and_extract(
             &json!({"flag": ""}),
@@ -1767,7 +1788,7 @@ mod tests {
             &HashMap::new(),
         );
 
-        assert!(result.is_ok(), "String parameter should pass: {:?}", result);
+        assert!(result.is_ok(), "String parameter should pass: {result:?}");
         let extracted = result.unwrap();
         assert_eq!(extracted["start_time"], json!(time_string));
     }
@@ -2360,7 +2381,7 @@ mod tests {
 
         let validator = ParameterValidator::new(schema).unwrap();
         let mut raw_query_params: HashMap<String, Vec<String>> = HashMap::new();
-        raw_query_params.insert("flag".to_string(), vec!["".to_string()]);
+        raw_query_params.insert("flag".to_string(), vec![String::new()]);
 
         let result = validator.validate_and_extract(
             &json!({"flag": ""}),

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

@@ -82,7 +82,8 @@ impl ProblemDetails {
     /// Standard type URI for bad request (400)
     pub const TYPE_BAD_REQUEST: &'static str = "https://spikard.dev/errors/bad-request";
 
-    /// Create a new ProblemDetails with required fields
+    /// Create a new `ProblemDetails` with required fields
+    #[must_use]
     pub fn new(type_uri: impl Into<String>, title: impl Into<String>, status: StatusCode) -> Self {
         Self {
             type_uri: type_uri.into(),
@@ -95,24 +96,29 @@ impl ProblemDetails {
     }
 
     /// Set the detail field
+    #[must_use]
     pub fn with_detail(mut self, detail: impl Into<String>) -> Self {
         self.detail = Some(detail.into());
         self
     }
 
     /// Set the instance field
+    #[must_use]
     pub fn with_instance(mut self, instance: impl Into<String>) -> Self {
         self.instance = Some(instance.into());
         self
     }
 
     /// Add an extension field
+    #[must_use]
     pub fn with_extension(mut self, key: impl Into<String>, value: Value) -> Self {
         self.extensions.insert(key.into(), value);
         self
     }
 
     /// Add all extensions from a JSON object
+    #[must_use]
+    #[allow(clippy::needless_pass_by_value)]
     pub fn with_extensions(mut self, extensions: Value) -> Self {
         if let Some(obj) = extensions.as_object() {
             for (key, value) in obj {
@@ -122,20 +128,21 @@ impl ProblemDetails {
         self
     }
 
-    /// Create a validation error Problem Details from ValidationError
+    /// Create a validation error Problem Details from `ValidationError`
     ///
     /// This converts the FastAPI-style validation errors to RFC 9457 format:
-    /// - `type`: "https://spikard.dev/errors/validation-error"
+    /// - `type`: <https://spikard.dev/errors/validation-error>
     /// - `title`: "Request Validation Failed"
     /// - `status`: 422
     /// - `detail`: Summary of error count
     /// - `errors`: Array of validation error details (as extension field)
+    #[must_use]
     pub fn from_validation_error(error: &ValidationError) -> Self {
         let error_count = error.errors.len();
         let detail = if error_count == 1 {
             "1 validation error in request".to_string()
         } else {
-            format!("{} validation errors in request", error_count)
+            format!("{error_count} validation errors in request")
         };
 
         let errors_json = serde_json::to_value(&error.errors).unwrap_or_else(|_| serde_json::Value::Array(vec![]));
@@ -201,16 +208,23 @@ impl ProblemDetails {
     }
 
     /// Get the HTTP status code
+    #[must_use]
     pub fn status_code(&self) -> StatusCode {
         StatusCode::from_u16(self.status).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
     }
 
     /// Serialize to JSON string
+    ///
+    /// # Errors
+    /// Returns an error if the serialization fails.
     pub fn to_json(&self) -> Result<String, serde_json::Error> {
         serde_json::to_string(self)
     }
 
     /// Serialize to pretty JSON string
+    ///
+    /// # Errors
+    /// Returns an error if the serialization fails.
     pub fn to_json_pretty(&self) -> Result<String, serde_json::Error> {
         serde_json::to_string_pretty(self)
     }
@@ -233,7 +247,7 @@ mod tests {
                     error_type: "missing".to_string(),
                     loc: vec!["body".to_string(), "username".to_string()],
                     msg: "Field required".to_string(),
-                    input: Value::String("".to_string()),
+                    input: Value::String(String::new()),
                     ctx: None,
                 },
                 ValidationErrorDetail {

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

@@ -17,19 +17,19 @@ use bytes::Bytes;
 ///
 /// This is the language-agnostic representation passed to handlers.
 ///
-/// Uses Arc for HashMaps to enable cheap cloning without duplicating data.
-/// When RequestData is cloned, only the Arc pointers are cloned, not the underlying data.
+/// Uses `Arc` for `HashMap`s to enable cheap cloning without duplicating data.
+/// When `RequestData` is cloned, only the `Arc` pointers are cloned, not the underlying data.
 ///
-/// Performance optimization: raw_body stores the unparsed request body bytes.
-/// Language bindings should use raw_body when possible to avoid double-parsing.
-/// The body field is lazily parsed only when needed for validation.
+/// Performance optimization: `raw_body` stores the unparsed request body bytes.
+/// Language bindings should use `raw_body` when possible to avoid double-parsing.
+/// The `body` field is lazily parsed only when needed for validation.
 #[derive(Debug, Clone)]
 pub struct RequestData {
     /// Path parameters extracted from the URL path
     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).
+    /// 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>>>,
@@ -66,7 +66,7 @@ impl Serialize for RequestData {
         state.serialize_field("raw_query_params", &*self.raw_query_params)?;
         state.serialize_field("body", &self.body)?;
         #[cfg(feature = "di")]
-        state.serialize_field("raw_body", &self.raw_body.as_ref().map(|b| b.as_ref()))?;
+        state.serialize_field("raw_body", &self.raw_body.as_ref().map(AsRef::as_ref))?;
         #[cfg(not(feature = "di"))]
         state.serialize_field("raw_body", &self.raw_body)?;
         state.serialize_field("headers", &*self.headers)?;
@@ -78,6 +78,7 @@ impl Serialize for RequestData {
 }
 
 impl<'de> Deserialize<'de> for RequestData {
+    #[allow(clippy::too_many_lines)]
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -829,20 +830,11 @@ mod tests {
     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)}),
-            );
+            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(),
-        );
+        let data = create_request_data("/api/batch", "POST", body, json!({}), RequestDataCollections::default());
 
         assert!(data.body.is_object());
         assert_eq!(data.body.as_object().unwrap().len(), 100);
@@ -933,7 +925,7 @@ mod tests {
             "float": 3.2,
             "negative": -100,
             "zero": 0,
-            "large": 9223372036854775807i64
+            "large": 9_223_372_036_854_775_807i64
         });
 
         let data = create_request_data(
@@ -999,10 +991,10 @@ mod tests {
     #[test]
     fn test_request_data_empty_string_values() {
         let mut headers = HashMap::new();
-        headers.insert("empty-header".to_string(), "".to_string());
+        headers.insert("empty-header".to_string(), String::new());
 
         let mut path_params = HashMap::new();
-        path_params.insert("id".to_string(), "".to_string());
+        path_params.insert("id".to_string(), String::new());
 
         let data = create_request_data(
             "/api/test",
@@ -1016,8 +1008,8 @@ mod tests {
             },
         );
 
-        assert_eq!(data.headers.get("empty-header"), Some(&"".to_string()));
-        assert_eq!(data.path_params.get("id"), Some(&"".to_string()));
+        assert_eq!(data.headers.get("empty-header"), Some(&String::new()));
+        assert_eq!(data.path_params.get("id"), Some(&String::new()));
     }
 
     #[test]
@@ -1091,7 +1083,7 @@ mod tests {
             RequestDataCollections::default(),
         );
 
-        let debug_str = format!("{:?}", data);
+        let debug_str = format!("{data:?}");
         assert!(debug_str.contains("RequestData"));
         assert!(debug_str.contains("/api/test"));
     }