fix(ci): restore workspace lint compatibility (#6460)

rustfs/src/admin/handlers/cluster_snapshot.rs

@@ -1358,7 +1358,7 @@ mod tests {
         assert_eq!(component.last_usage_save_result, "success");
         assert_eq!(component.last_success_unix_secs, Some(450));
 
-        let mut legacy_snapshot = snapshot.clone();
+        let mut legacy_snapshot = snapshot;
         legacy_snapshot.usage_freshness.last_durable_success_unix_secs = 0;
         let legacy_component = super::summarize_usage_freshness(&legacy_snapshot);
         assert_eq!(legacy_component.last_success_unix_secs, Some(456));

rustfs/src/connect/inventory.rs

@@ -659,6 +659,10 @@ mod tests {
 
     use super::*;
 
+    fn create_directory(path: &Path) -> io::Result<()> {
+        fs::create_dir(path)
+    }
+
     #[test]
     fn inventory_directory_creation_is_synced_before_state_can_be_committed() {
         let temp = tempfile::tempdir().expect("tempdir");
@@ -699,7 +703,7 @@ mod tests {
         fs::create_dir(&root).expect("state root");
         let directory = root.join("inventory");
         let state = directory.join("state.json");
-        let error = prepare_inventory_directory_with(&directory, fs::create_dir, |path| {
+        let error = prepare_inventory_directory_with(&directory, create_directory, |path| {
             if path == directory {
                 Err(io::Error::other("injected leaf sync failure"))
             } else {
@@ -710,7 +714,7 @@ mod tests {
         assert!(matches!(error, InventoryError::StateIo { path, .. } if path == directory));
         assert!(!state.exists());
 
-        let error = prepare_inventory_directory_with(&directory, fs::create_dir, |path| {
+        let error = prepare_inventory_directory_with(&directory, create_directory, |path| {
             if path == root {
                 Err(io::Error::other("injected parent sync failure"))
             } else {
@@ -722,7 +726,7 @@ mod tests {
         assert!(!state.exists());
 
         let mut synced = Vec::new();
-        prepare_inventory_directory_with(&directory, fs::create_dir, |path| {
+        prepare_inventory_directory_with(&directory, create_directory, |path| {
             synced.push(path.to_path_buf());
             Ok(())
         })
@@ -737,7 +741,7 @@ mod tests {
         let directory = root.join("inventory");
 
         assert!(matches!(
-            prepare_inventory_directory_with(&directory, fs::create_dir, |_| Ok(())),
+            prepare_inventory_directory_with(&directory, create_directory, |_| Ok(())),
             Err(InventoryError::StateIo { path, .. }) if path == root
         ));
         assert!(!directory.exists());

rustfs/src/connect/offline/redaction.rs

@@ -173,7 +173,6 @@ pub enum RedactionError {
     NotRepresentable,
 }
 
-#[must_use]
 pub(super) fn redact(source: RedactionSource, document: &Map<String, Value>) -> Result<RedactionResult, RedactionError> {
     let encoded = serde_json::to_vec(document).map_err(|_| RedactionError::NotRepresentable)?;
     if encoded.len() > MAX_INPUT_BYTES {

rustfs/tests/connect_registration_bootstrap.rs

@@ -158,6 +158,15 @@ impl Drop for TestServer {
     }
 }
 
+fn assert_reused_pending_requests(server: &TestServer) {
+    let requests = server.seen.lock().expect("seen lock");
+    assert_eq!(requests.len(), 4);
+    for request in &requests[1..] {
+        assert_eq!(request["requestId"], requests[0]["requestId"]);
+        assert_eq!(request["certificateRequest"], requests[0]["certificateRequest"]);
+    }
+}
+
 async fn server(state_directory: &std::path::Path, replies: Vec<Reply>) -> TestServer {
     let pki = Arc::new(TestPki::new());
     let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind test server");
@@ -375,7 +384,7 @@ async fn production_command_never_echoes_a_remote_reason() {
 async fn response_loss_reuses_the_pending_request_and_existing_credential_is_idempotent() {
     let temp = secure_tempdir();
     let state = temp.path().join("state");
-    let server = server(
+    let flaky_server = server(
         &state,
         vec![
             Reply::DropConnection,
@@ -385,27 +394,21 @@ async fn response_loss_reuses_the_pending_request_and_existing_credential_is_ide
         ],
     )
     .await;
-    let (root, token) = prepare_inputs(&temp, &server.root_pem);
+    let (root, token) = prepare_inputs(&temp, &flaky_server.root_pem);
 
-    while server.seen.lock().expect("seen lock").len() < 3 {
-        let error = register_from_protected_input(&server.endpoint, &root, &state, Some(&token))
+    while flaky_server.seen.lock().expect("seen lock").len() < 3 {
+        let error = register_from_protected_input(&flaky_server.endpoint, &root, &state, Some(&token))
             .await
             .expect_err("lost response must leave a retryable failure");
         assert!(!error.to_string().contains(TOKEN_SECRET));
         assert!(state.join("credential/registration.pending.json").is_file());
     }
 
-    let registered = register_from_protected_input(&server.endpoint, &root, &state, Some(&token))
+    let registered = register_from_protected_input(&flaky_server.endpoint, &root, &state, Some(&token))
         .await
         .expect("retry registration");
     assert_eq!(registered.device_uid, DEVICE_UID);
-    let requests = server.seen.lock().expect("seen lock");
-    assert_eq!(requests.len(), 4);
-    for request in &requests[1..] {
-        assert_eq!(request["requestId"], requests[0]["requestId"]);
-        assert_eq!(request["certificateRequest"], requests[0]["certificateRequest"]);
-    }
-    drop(requests);
+    assert_reused_pending_requests(&flaky_server);
 
     let idle = server(&state, vec![]).await;
     let idempotent = register_from_protected_input(&idle.endpoint, &root, &state, Some(&token))