fix: resolve remaining clippy warnings in tests and examples

Author: raffaelschneider

examples/memory_profile.rs

@@ -10,7 +10,7 @@ use zentinel_agent_waf::{WafConfig, WafEngine};
 fn separator(char: char, width: usize) {
     println!(
         "{}",
-        std::iter::repeat(char).take(width).collect::<String>()
+        std::iter::repeat_n(char, width).collect::<String>()
     );
 }
 

src/bot/mod.rs

@@ -333,7 +333,7 @@ mod tests {
         let mut detector = BotDetector::new(BotConfig::default());
         let headers = HashMap::new();
 
-        let (classification, detections) = detector.analyze(Some(""), &headers, None, None);
+        let (_classification, detections) = detector.analyze(Some(""), &headers, None, None);
         assert!(!detections.is_empty());
     }
 

src/federated/mod.rs

@@ -568,7 +568,7 @@ mod tests {
         let output = fl.forward(&model, &features);
 
         // Output should be between 0 and 1 (sigmoid)
-        assert!(output >= 0.0 && output <= 1.0);
+        assert!((0.0..=1.0).contains(&output));
     }
 
     #[test]

src/federated/privacy.rs

@@ -394,7 +394,7 @@ mod tests {
         assert_eq!(shares.len(), 3);
 
         // Sum of shares should equal original
-        let mut sum = vec![0.0; 3];
+        let mut sum = [0.0; 3];
         for share in &shares {
             for (i, &v) in share.iter().enumerate() {
                 sum[i] += v;

tests/crs_compatibility.rs

@@ -13,8 +13,10 @@ fn create_engine() -> WafEngine {
 }
 
 fn create_paranoid_engine(level: u8) -> WafEngine {
-    let mut config = WafConfig::default();
-    config.paranoia_level = level;
+    let config = WafConfig {
+        paranoia_level: level,
+        ..Default::default()
+    };
     WafEngine::new(config).expect("Failed to create engine")
 }
 

tests/integration_tests.rs

@@ -336,7 +336,7 @@ mod api_security {
         let deep_json =
             r#"{"a":{"b":{"c":{"d":{"e":{"f":{"g":{"h":{"i":{"j":{"k":"deep"}}}}}}}}}}}"#;
 
-        let detections = engine.check(deep_json, "body");
+        let _detections = engine.check(deep_json, "body");
         // Detection depends on JSON parsing in check flow
     }
 }

tests/websocket_tests.rs

@@ -10,26 +10,32 @@ use zentinel_agent_waf::{WafAgent, WafConfig, WebSocketConfig};
 
 /// Create a WebSocket-enabled agent for testing
 fn create_websocket_agent() -> WafAgent {
-    let mut config = WafConfig::default();
-    config.websocket = WebSocketConfig {
-        enabled: true,
-        inspect_text_frames: true,
-        inspect_binary_frames: false,
-        max_frame_size: 65536,
-        block_mode: true,
-        accumulate_fragments: true,
-        max_message_size: 1048576,
-        block_close_code: 1008,
-        block_close_reason: "WAF policy violation".to_string(),
+    let config = WafConfig {
+        websocket: WebSocketConfig {
+            enabled: true,
+            inspect_text_frames: true,
+            inspect_binary_frames: false,
+            max_frame_size: 65536,
+            block_mode: true,
+            accumulate_fragments: true,
+            max_message_size: 1048576,
+            block_close_code: 1008,
+            block_close_reason: "WAF policy violation".to_string(),
+        },
+        ..Default::default()
     };
     WafAgent::new(config).expect("Failed to create agent")
 }
 
 /// Create a WebSocket agent with custom config
 fn create_websocket_agent_with_config(f: impl FnOnce(&mut WebSocketConfig)) -> WafAgent {
-    let mut config = WafConfig::default();
-    config.websocket = WebSocketConfig::default();
-    config.websocket.enabled = true;
+    let mut config = WafConfig {
+        websocket: WebSocketConfig {
+            enabled: true,
+            ..Default::default()
+        },
+        ..Default::default()
+    };
     f(&mut config.websocket);
     WafAgent::new(config).expect("Failed to create agent")
 }
@@ -88,20 +94,18 @@ fn continuation_frame(
 
 /// Check if response indicates a block (close connection)
 fn is_blocked(response: &AgentResponse) -> bool {
-    match &response.websocket_decision {
-        Some(WebSocketDecision::Close { .. }) => true,
-        Some(WebSocketDecision::Drop) => true,
-        _ => false,
-    }
+    matches!(
+        &response.websocket_decision,
+        Some(WebSocketDecision::Close { .. }) | Some(WebSocketDecision::Drop)
+    )
 }
 
 /// Check if response indicates allow
 fn is_allowed(response: &AgentResponse) -> bool {
-    match &response.websocket_decision {
-        Some(WebSocketDecision::Allow) => true,
-        None => true, // Default is allow
-        _ => false,
-    }
+    matches!(
+        &response.websocket_decision,
+        Some(WebSocketDecision::Allow) | None
+    )
 }
 
 // =============================================================================