spikard 0.8.2 → 0.10.1

data/vendor/crates/spikard-bindings-shared/src/test_client_base.rs

@@ -23,13 +23,15 @@ impl TestClientConfig {
     }
 
     /// Set the timeout in milliseconds
-    pub fn with_timeout(mut self, timeout_ms: u64) -> Self {
+    #[must_use]
+    pub const fn with_timeout(mut self, timeout_ms: u64) -> Self {
         self.timeout_ms = timeout_ms;
         self
     }
 
     /// Set whether to follow redirects
-    pub fn with_follow_redirects(mut self, follow_redirects: bool) -> Self {
+    #[must_use]
+    pub const fn with_follow_redirects(mut self, follow_redirects: bool) -> Self {
         self.follow_redirects = follow_redirects;
         self
     }
@@ -60,7 +62,13 @@ pub struct TestResponseMetadata {
 
 impl TestResponseMetadata {
     /// Create a new test response metadata
-    pub fn new(status_code: u16, headers: HashMap<String, String>, body_size: usize, response_time_ms: u64) -> Self {
+    #[must_use]
+    pub const fn new(
+        status_code: u16,
+        headers: HashMap<String, String>,
+        body_size: usize,
+        response_time_ms: u64,
+    ) -> Self {
         Self {
             status_code,
             headers,
@@ -70,6 +78,7 @@ impl TestResponseMetadata {
     }
 
     /// Get a header value by name (case-insensitive)
+    #[must_use]
     pub fn get_header(&self, name: &str) -> Option<&String> {
         let lower_name = name.to_lowercase();
         self.headers
@@ -79,17 +88,20 @@ impl TestResponseMetadata {
     }
 
     /// Check if response was successful (2xx status code)
-    pub fn is_success(&self) -> bool {
+    #[must_use]
+    pub const fn is_success(&self) -> bool {
         self.status_code >= 200 && self.status_code < 300
     }
 
     /// Check if response was a client error (4xx status code)
-    pub fn is_client_error(&self) -> bool {
+    #[must_use]
+    pub const fn is_client_error(&self) -> bool {
         self.status_code >= 400 && self.status_code < 500
     }
 
     /// Check if response was a server error (5xx status code)
-    pub fn is_server_error(&self) -> bool {
+    #[must_use]
+    pub const fn is_server_error(&self) -> bool {
         self.status_code >= 500 && self.status_code < 600
     }
 }
@@ -194,7 +206,7 @@ mod tests {
         let metadata_204 = TestResponseMetadata::new(204, headers.clone(), 0, 50);
         let metadata_299 = TestResponseMetadata::new(299, headers.clone(), 100, 50);
         let metadata_300 = TestResponseMetadata::new(300, headers.clone(), 100, 50);
-        let metadata_400 = TestResponseMetadata::new(400, headers.clone(), 100, 50);
+        let metadata_400 = TestResponseMetadata::new(400, headers, 100, 50);
 
         assert!(metadata_200.is_success());
         assert!(metadata_201.is_success());
@@ -211,7 +223,7 @@ mod tests {
         let metadata_400 = TestResponseMetadata::new(400, headers.clone(), 100, 50);
         let metadata_404 = TestResponseMetadata::new(404, headers.clone(), 100, 50);
         let metadata_499 = TestResponseMetadata::new(499, headers.clone(), 100, 50);
-        let metadata_500 = TestResponseMetadata::new(500, headers.clone(), 100, 50);
+        let metadata_500 = TestResponseMetadata::new(500, headers, 100, 50);
 
         assert!(!metadata_399.is_client_error());
         assert!(metadata_400.is_client_error());
@@ -227,7 +239,7 @@ mod tests {
         let metadata_500 = TestResponseMetadata::new(500, headers.clone(), 100, 50);
         let metadata_502 = TestResponseMetadata::new(502, headers.clone(), 100, 50);
         let metadata_599 = TestResponseMetadata::new(599, headers.clone(), 100, 50);
-        let metadata_600 = TestResponseMetadata::new(600, headers.clone(), 100, 50);
+        let metadata_600 = TestResponseMetadata::new(600, headers, 100, 50);
 
         assert!(!metadata_499.is_server_error());
         assert!(metadata_500.is_server_error());
@@ -240,7 +252,7 @@ mod tests {
     fn test_response_metadata_debug() {
         let headers = HashMap::new();
         let metadata = TestResponseMetadata::new(200, headers, 100, 50);
-        let debug_str = format!("{:?}", metadata);
+        let debug_str = format!("{metadata:?}");
         assert!(debug_str.contains("200"));
         assert!(debug_str.contains("100"));
         assert!(debug_str.contains("50"));

data/vendor/crates/spikard-bindings-shared/src/validation_helpers.rs

@@ -7,29 +7,37 @@ pub struct HeaderValidator;
 
 impl HeaderValidator {
     /// Validate that required headers are present
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if required headers are missing.
     pub fn validate_required(headers: &[(String, String)], required: &[&str]) -> Result<(), String> {
         let header_names: std::collections::HashSet<_> = headers.iter().map(|(k, _)| k.to_lowercase()).collect();
 
         for req in required {
             if !header_names.contains(&req.to_lowercase()) {
-                return Err(format!("Missing required header: {}", req));
+                return Err(format!("Missing required header: {req}"));
             }
         }
         Ok(())
     }
 
     /// Validate header format
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the header format is invalid.
     pub fn validate_format(key: &str, value: &str, format: HeaderFormat) -> Result<(), String> {
         match format {
             HeaderFormat::Bearer => {
                 if !value.starts_with("Bearer ") {
-                    return Err(format!("{}: must start with 'Bearer '", key));
+                    return Err(format!("{key}: must start with 'Bearer '"));
                 }
                 Ok(())
             }
             HeaderFormat::Json => {
                 if !value.starts_with("application/json") {
-                    return Err(format!("{}: must be 'application/json'", key));
+                    return Err(format!("{key}: must be 'application/json'"));
                 }
                 Ok(())
             }
@@ -38,6 +46,7 @@ impl HeaderValidator {
 }
 
 /// Header validation formats
+#[derive(Copy, Clone)]
 pub enum HeaderFormat {
     /// Bearer token format
     Bearer,
@@ -50,6 +59,10 @@ pub struct BodyValidator;
 
 impl BodyValidator {
     /// Validate that required fields are present in a JSON object
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if required fields are missing.
     pub fn validate_required_fields(body: &Value, required: &[&str]) -> Result<(), String> {
         let obj = body
             .as_object()
@@ -57,44 +70,48 @@ impl BodyValidator {
 
         for field in required {
             if !obj.contains_key(*field) {
-                return Err(format!("Missing required field: {}", field));
+                return Err(format!("Missing required field: {field}"));
             }
         }
         Ok(())
     }
 
     /// Validate field type
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the field type doesn't match.
     pub fn validate_field_type(body: &Value, field: &str, expected_type: FieldType) -> Result<(), String> {
         let obj = body
             .as_object()
             .ok_or_else(|| "Body must be a JSON object".to_string())?;
 
-        let value = obj.get(field).ok_or_else(|| format!("Field not found: {}", field))?;
+        let value = obj.get(field).ok_or_else(|| format!("Field not found: {field}"))?;
 
         match expected_type {
             FieldType::String => {
                 if !value.is_string() {
-                    return Err(format!("{}: expected string", field));
+                    return Err(format!("{field}: expected string"));
                 }
             }
             FieldType::Number => {
                 if !value.is_number() {
-                    return Err(format!("{}: expected number", field));
+                    return Err(format!("{field}: expected number"));
                 }
             }
             FieldType::Boolean => {
                 if !value.is_boolean() {
-                    return Err(format!("{}: expected boolean", field));
+                    return Err(format!("{field}: expected boolean"));
                 }
             }
             FieldType::Object => {
                 if !value.is_object() {
-                    return Err(format!("{}: expected object", field));
+                    return Err(format!("{field}: expected object"));
                 }
             }
             FieldType::Array => {
                 if !value.is_array() {
-                    return Err(format!("{}: expected array", field));
+                    return Err(format!("{field}: expected array"));
                 }
             }
         }
@@ -103,6 +120,7 @@ impl BodyValidator {
 }
 
 /// Field types for validation
+#[derive(Copy, Clone)]
 pub enum FieldType {
     String,
     Number,

data/vendor/crates/spikard-bindings-shared/tests/config_extractor_behavior.rs

@@ -7,6 +7,7 @@ struct JsonSource {
 }
 
 impl JsonSource {
+    #[allow(clippy::missing_const_for_fn)]
     fn new(value: serde_json::Value) -> Self {
         Self { value }
     }
@@ -44,7 +45,7 @@ impl ConfigSource for JsonSource {
 
     fn get_nested(&self, key: &str) -> Option<Box<dyn ConfigSource + '_>> {
         let nested = self.get(key)?.as_object()?;
-        Some(Box::new(JsonSource {
+        Some(Box::new(Self {
             value: serde_json::Value::Object(nested.clone()),
         }))
     }
@@ -60,7 +61,7 @@ impl ConfigSource for JsonSource {
     fn get_array_element(&self, key: &str, index: usize) -> Option<Box<dyn ConfigSource + '_>> {
         let array = self.get(key)?.as_array()?;
         let element = array.get(index)?.as_object()?;
-        Some(Box::new(JsonSource {
+        Some(Box::new(Self {
             value: serde_json::Value::Object(element.clone()),
         }))
     }

data/vendor/crates/spikard-bindings-shared/tests/error_response_edge_cases.rs

@@ -2,6 +2,12 @@
 //!
 //! These tests cover serialization edge cases and ensure fallback
 //! behavior works correctly when serialization fails.
+#![allow(
+    clippy::redundant_clone,
+    clippy::uninlined_format_args,
+    clippy::doc_markdown,
+    reason = "Edge case tests for error handling"
+)]
 
 use axum::http::StatusCode;
 use pretty_assertions::assert_eq;
@@ -99,7 +105,7 @@ fn test_from_structured_error_with_details() {
         json!({"field": "username", "reason": "already_exists"}),
     );
 
-    let (status, body) = ErrorResponseBuilder::from_structured_error(error);
+    let (status, body) = ErrorResponseBuilder::from_structured_error(&error);
     assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
     let parsed: Value = serde_json::from_str(&body).unwrap();
     assert_eq!(parsed["code"], "custom_error");
@@ -201,23 +207,17 @@ fn test_all_convenience_methods_return_valid_json() {
     ];
 
     for (status, body) in test_cases {
-        let parsed: Value = serde_json::from_str(&body)
-            .unwrap_or_else(|_| panic!("Failed to parse JSON for status {}: {}", status, body));
+        let parsed: Value =
+            serde_json::from_str(&body).unwrap_or_else(|_| panic!("Failed to parse JSON for status {status}: {body}"));
 
         assert!(
             parsed.get("error").is_some(),
-            "Missing 'error' field for status {}",
-            status
-        );
-        assert!(
-            parsed.get("code").is_some(),
-            "Missing 'code' field for status {}",
-            status
+            "Missing 'error' field for status {status}"
         );
+        assert!(parsed.get("code").is_some(), "Missing 'code' field for status {status}");
         assert!(
             parsed.get("details").is_some(),
-            "Missing 'details' field for status {}",
-            status
+            "Missing 'details' field for status {status}"
         );
     }
 }
@@ -336,7 +336,7 @@ fn test_error_message_types() {
     let (_, body) = ErrorResponseBuilder::bad_request("test");
     assert!(body.contains("test"));
 
-    let (_, body) = ErrorResponseBuilder::bad_request(format!("Error: {}", 123));
+    let (_, body) = ErrorResponseBuilder::bad_request(format!("Error: {0}", 123));
     assert!(body.contains("Error: 123"));
 }
 

data/vendor/crates/spikard-bindings-shared/tests/{comprehensive_coverage.rs → full_coverage.rs}

@@ -2,6 +2,13 @@
 //!
 //! This test file ensures full code coverage across all modules in the crate,
 //! testing edge cases, error paths, and integration scenarios.
+#![allow(
+    clippy::doc_markdown,
+    clippy::items_after_statements,
+    clippy::uninlined_format_args,
+    clippy::redundant_clone,
+    reason = "Integration test with many coverage scenarios"
+)]
 
 use axum::http::{Request, StatusCode};
 use pretty_assertions::assert_eq;
@@ -201,12 +208,10 @@ fn test_lifecycle_hook_types() {
     }
 
     let continue_result = HookResult::Continue;
-    let cloned_continue = continue_result.clone();
-    assert!(matches!(cloned_continue, HookResult::Continue));
+    assert!(matches!(continue_result.clone(), HookResult::Continue));
 
     let short_circuit = HookResult::ShortCircuit(json!({"status": "error"}));
-    let cloned_short = short_circuit.clone();
-    assert!(matches!(cloned_short, HookResult::ShortCircuit(_)));
+    assert!(matches!(short_circuit.clone(), HookResult::ShortCircuit(_)));
 }
 
 #[test]
@@ -413,7 +418,7 @@ fn test_conversion_traits_comprehensive() {
         fn from_any(value: &(dyn std::any::Any + Send + Sync)) -> Result<Self, Self::Error> {
             value
                 .downcast_ref::<i32>()
-                .map(|&v| CustomType { value: v })
+                .map(|&v| Self { value: v })
                 .ok_or_else(|| "Type mismatch".to_string())
         }
     }

data/vendor/crates/spikard-bindings-shared/tests/handler_base_integration.rs

@@ -1,4 +1,4 @@
-//! Integration tests for handler_base module
+//! Integration tests for `handler_base` module
 //!
 //! These tests cover the validation paths and error handling that aren't
 //! covered by unit tests in the module itself.
@@ -41,7 +41,7 @@ impl LanguageHandler for MockHandler {
             if should_fail {
                 Err(HandlerError::Execution("Handler failed".to_string()))
             } else {
-                Ok(format!("output:{}", input))
+                Ok(format!("output:{input}"))
             }
         })
     }
@@ -81,10 +81,10 @@ async fn test_handler_executor_with_validation_error() {
     let request = Request::builder().body(Body::empty()).unwrap();
     let request_data = RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: json!({}),
+        query_params: Arc::new(json!({})),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: json!({"username": "john"}),
+        body: Arc::new(json!({"username": "john"})),
         raw_body: None,
         headers: Arc::new(HashMap::new()),
         cookies: Arc::new(HashMap::new()),
@@ -110,10 +110,10 @@ async fn test_handler_executor_prepare_failure() {
     let request = Request::builder().body(Body::empty()).unwrap();
     let request_data = RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: json!({}),
+        query_params: Arc::new(json!({})),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: json!({}),
+        body: Arc::new(json!({})),
         raw_body: None,
         headers: Arc::new(HashMap::new()),
         cookies: Arc::new(HashMap::new()),
@@ -139,10 +139,10 @@ async fn test_handler_executor_invoke_failure() {
     let request = Request::builder().body(Body::empty()).unwrap();
     let request_data = RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: json!({}),
+        query_params: Arc::new(json!({})),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: json!({}),
+        body: Arc::new(json!({})),
         raw_body: None,
         headers: Arc::new(HashMap::new()),
         cookies: Arc::new(HashMap::new()),
@@ -168,10 +168,10 @@ async fn test_handler_executor_interpret_failure() {
     let request = Request::builder().body(Body::empty()).unwrap();
     let request_data = RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: json!({}),
+        query_params: Arc::new(json!({})),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: json!({}),
+        body: Arc::new(json!({})),
         raw_body: None,
         headers: Arc::new(HashMap::new()),
         cookies: Arc::new(HashMap::new()),
@@ -210,10 +210,10 @@ async fn test_handler_executor_with_request_validator() {
 
     let request_data = RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: json!({}),
+        query_params: Arc::new(json!({})),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: json!({"name": "test"}),
+        body: Arc::new(json!({"name": "test"})),
         raw_body: None,
         headers: Arc::new(headers),
         cookies: Arc::new(HashMap::new()),
@@ -263,10 +263,10 @@ async fn test_handler_executor_builder_pattern() {
     let request = Request::builder().body(Body::empty()).unwrap();
     let request_data = RequestData {
         path_params: Arc::new(HashMap::new()),
-        query_params: json!({}),
+        query_params: Arc::new(json!({})),
         validated_params: None,
         raw_query_params: Arc::new(HashMap::new()),
-        body: json!({"email": "test@example.com"}),
+        body: Arc::new(json!({"email": "test@example.com"})),
         raw_body: None,
         headers: Arc::new(HashMap::new()),
         cookies: Arc::new(HashMap::new()),