Fix client test helper lint findings

src/client/tests/helpers.rs

@@ -233,9 +233,9 @@ where
     let count = counter.clone();
 
     let increment = move |value: T| {
-        let count = count.clone();
+        let callback_count = count.clone();
         Box::pin(async move {
-            count.fetch_add(1, Ordering::SeqCst);
+            callback_count.fetch_add(1, Ordering::SeqCst);
             value
         }) as Pin<Box<dyn Future<Output = T> + Send>>
     };

src/client/tests/messaging.rs

@@ -216,9 +216,9 @@ async fn call_correlated_invokes_error_hook_on_mismatch() {
 
     let mut client = WireframeClient::builder()
         .on_error(move |_err| {
-            let count = count.clone();
+            let callback_count = count.clone();
             async move {
-                count.fetch_add(1, Ordering::SeqCst);
+                callback_count.fetch_add(1, Ordering::SeqCst);
             }
         })
         .connect(addr)

src/client/tests/pool_handle.rs

@@ -162,7 +162,7 @@ async fn handle_acquire_dropped_waiter_does_not_leak_capacity(
     tokio::time::sleep(Duration::from_millis(25)).await;
 
     waiter1_task.abort();
-    let _ = waiter1_task.await;
+    drop(waiter1_task.await);
 
     drop(held_lease);
 

src/client/tests/request_hooks_support.rs

@@ -120,13 +120,13 @@ where
     ) -> std::pin::Pin<Box<dyn std::future::Future<Output = TestResult> + 'a>>,
     S: Future<Output = TestResult<(SocketAddr, tokio::task::JoinHandle<std::io::Result<R>>)>>,
 {
-    let (addr, server) = server.await?;
+    let (addr, server_task) = server.await?;
 
     match drive_client(addr, configure_hooks, test_body).await {
-        Ok(()) => Ok(server.await??),
+        Ok(()) => Ok(server_task.await??),
         Err(error) => {
-            server.abort();
-            let _ = server.await;
+            server_task.abort();
+            drop(server_task.await);
             Err(error)
         }
     }

src/client/tests/send_streaming_infra.rs

@@ -125,7 +125,7 @@ pub(super) async fn spawn_dropping_server()
         };
         // Shut down the write side to trigger a deterministic transport
         // error when the client attempts to write.
-        let _ = tcp.shutdown().await;
+        drop(tcp.shutdown().await);
         notify.notify_one();
     });
 
@@ -191,9 +191,9 @@ pub(super) async fn create_send_client_with_error_hook(
     let flag = hook_invoked.clone();
     let client = WireframeClient::builder()
         .on_error(move |_err| {
-            let flag = flag.clone();
+            let callback_flag = flag.clone();
             async move {
-                flag.store(true, Ordering::SeqCst);
+                callback_flag.store(true, Ordering::SeqCst);
             }
         })
         .connect(addr)

src/client/tests/streaming.rs

@@ -325,13 +325,13 @@ async fn call_streaming_auto_generates_correlation_id()
                 let Ok(encoded) = BincodeSerializer.serialize(&data) else {
                     return;
                 };
-                let _ = transport.send(Bytes::from(encoded)).await;
+                drop(transport.send(Bytes::from(encoded)).await);
 
                 let term = TestStreamEnvelope::terminator(CorrelationId::new(cid));
                 let Ok(encoded) = BincodeSerializer.serialize(&term) else {
                     return;
                 };
-                let _ = transport.send(Bytes::from(encoded)).await;
+                drop(transport.send(Bytes::from(encoded)).await);
             }
         }),
     );

src/client/tests/streaming_infra.rs

@@ -227,7 +227,7 @@ pub(super) async fn spawn_mismatch_server(
         let Ok(encoded) = serialize_envelope(&bad_frame) else {
             return;
         };
-        let _ = transport.send(encoded).await;
+        drop(transport.send(encoded).await);
     });
 
     Ok(TestServer { addr, handle })
@@ -253,7 +253,7 @@ pub(super) async fn spawn_malformed_server()
 
         // Send truncated/invalid bytes that cannot be decoded.
         let invalid_bytes = Bytes::from_static(b"\xff\xff\xff");
-        let _ = transport.send(invalid_bytes).await;
+        drop(transport.send(invalid_bytes).await);
     });
 
     Ok(TestServer { addr, handle })