Fix a number of lints raised by clippy when running tests.

grahambinns · grahambinns · commit 399816d3203d · 2025-10-30T12:11:16.000Z
diff --git a/examples/ha_producer.rs b/examples/ha_producer.rs
@@ -101,7 +101,7 @@ impl MyHAProducer {
                 ProducerPublishError::Timeout | ProducerPublishError::Closed => {
                     Box::pin(self.send_with_confirm(message)).await
                 }
-                _ => return Err(e),
+                _ => Err(e),
             },
         }
     }
@@ -114,14 +114,12 @@ async fn ensure_stream_exists(environment: &Environment, stream: &str) -> Rabbit
         .create(stream)
         .await;
 
-    if let Err(e) = create_response {
-        if let StreamCreateError::Create { stream, status } = e {
-            match status {
-                // we can ignore this error because the stream already exists
-                ResponseCode::StreamAlreadyExists => {}
-                err => {
-                    panic!("Error creating stream: {:?} {:?}", stream, err);
-                }
+    if let Err(StreamCreateError::Create { stream, status }) = create_response {
+        match status {
+            // we can ignore this error because the stream already exists
+            ResponseCode::StreamAlreadyExists => {}
+            err => {
+                panic!("Error creating stream: {:?} {:?}", stream, err);
             }
         }
     }
diff --git a/examples/send_async.rs b/examples/send_async.rs
@@ -35,14 +35,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .create(stream)
         .await;
 
-    if let Err(e) = create_response {
-        if let StreamCreateError::Create { stream, status } = e {
-            match status {
-                // we can ignore this error because the stream already exists
-                ResponseCode::StreamAlreadyExists => {}
-                err => {
-                    println!("Error creating stream: {:?} {:?}", stream, err);
-                }
+    if let Err(StreamCreateError::Create { stream, status }) = create_response {
+        match status {
+            // we can ignore this error because the stream already exists
+            ResponseCode::StreamAlreadyExists => {}
+            err => {
+                println!("Error creating stream: {:?} {:?}", stream, err);
             }
         }
     }
diff --git a/examples/send_with_confirm.rs b/examples/send_with_confirm.rs
@@ -13,14 +13,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .create(stream)
         .await;
 
-    if let Err(e) = create_response {
-        if let StreamCreateError::Create { stream, status } = e {
-            match status {
-                // we can ignore this error because the stream already exists
-                ResponseCode::StreamAlreadyExists => {}
-                err => {
-                    println!("Error creating stream: {:?} {:?}", stream, err);
-                }
+    if let Err(StreamCreateError::Create { stream, status }) = create_response {
+        match status {
+            // we can ignore this error because the stream already exists
+            ResponseCode::StreamAlreadyExists => {}
+            err => {
+                println!("Error creating stream: {:?} {:?}", stream, err);
             }
         }
     }
diff --git a/examples/simple-consumer.rs b/examples/simple-consumer.rs
@@ -14,14 +14,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .create(stream)
         .await;
 
-    if let Err(e) = create_response {
-        if let StreamCreateError::Create { stream, status } = e {
-            match status {
-                // we can ignore this error because the stream already exists
-                ResponseCode::StreamAlreadyExists => {}
-                err => {
-                    println!("Error creating stream: {:?} {:?}", stream, err);
-                }
+    if let Err(StreamCreateError::Create { stream, status }) = create_response {
+        match status {
+            // we can ignore this error because the stream already exists
+            ResponseCode::StreamAlreadyExists => {}
+            err => {
+                println!("Error creating stream: {:?} {:?}", stream, err);
             }
         }
     }
diff --git a/examples/superstreams/receive_super_stream.rs b/examples/superstreams/receive_super_stream.rs
@@ -17,14 +17,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .create_super_stream(super_stream, 3, None)
         .await;
 
-    if let Err(e) = create_response {
-        if let StreamCreateError::Create { stream, status } = e {
-            match status {
-                // we can ignore this error because the stream already exists
-                ResponseCode::StreamAlreadyExists => {}
-                err => {
-                    println!("Error creating stream: {:?} {:?}", stream, err);
-                }
+    if let Err(StreamCreateError::Create { stream, status }) = create_response {
+        match status {
+            // we can ignore this error because the stream already exists
+            ResponseCode::StreamAlreadyExists => {}
+            err => {
+                println!("Error creating stream: {:?} {:?}", stream, err);
             }
         }
     }
diff --git a/examples/superstreams/send_super_stream.rs b/examples/superstreams/send_super_stream.rs
@@ -52,14 +52,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .create_super_stream(super_stream, 3, None)
         .await;
 
-    if let Err(e) = create_response {
-        if let StreamCreateError::Create { stream, status } = e {
-            match status {
-                // we can ignore this error because the stream already exists
-                ResponseCode::StreamAlreadyExists => {}
-                err => {
-                    println!("Error creating stream: {:?} {:?}", stream, err);
-                }
+    if let Err(StreamCreateError::Create { stream, status }) = create_response {
+        match status {
+            // we can ignore this error because the stream already exists
+            ResponseCode::StreamAlreadyExists => {}
+            err => {
+                println!("Error creating stream: {:?} {:?}", stream, err);
             }
         }
     }
diff --git a/examples/superstreams/send_super_stream_hash.rs b/examples/superstreams/send_super_stream_hash.rs
@@ -54,14 +54,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .create_super_stream(super_stream, 3, None)
         .await;
 
-    if let Err(e) = create_response {
-        if let StreamCreateError::Create { stream, status } = e {
-            match status {
-                // we can ignore this error because the stream already exists
-                ResponseCode::StreamAlreadyExists => {}
-                err => {
-                    println!("Error creating stream: {:?} {:?}", stream, err);
-                }
+    if let Err(StreamCreateError::Create { stream, status }) = create_response {
+        match status {
+            // we can ignore this error because the stream already exists
+            ResponseCode::StreamAlreadyExists => {}
+            err => {
+                println!("Error creating stream: {:?} {:?}", stream, err);
             }
         }
     }
diff --git a/examples/superstreams/send_super_stream_routing_key.rs b/examples/superstreams/send_super_stream_routing_key.rs
@@ -54,14 +54,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .create_super_stream(super_stream, 3, Some(routing_key))
         .await;
 
-    if let Err(e) = create_response {
-        if let StreamCreateError::Create { stream, status } = e {
-            match status {
-                // we can ignore this error because the stream already exists
-                ResponseCode::StreamAlreadyExists => {}
-                err => {
-                    println!("Error creating stream: {:?} {:?}", stream, err);
-                }
+    if let Err(StreamCreateError::Create { stream, status }) = create_response {
+        match status {
+            // we can ignore this error because the stream already exists
+            ResponseCode::StreamAlreadyExists => {}
+            err => {
+                println!("Error creating stream: {:?} {:?}", stream, err);
             }
         }
     }
diff --git a/examples/tls_producer.rs b/examples/tls_producer.rs
@@ -50,10 +50,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-async fn start_publisher(
-    env: Environment,
-    stream: &String,
-) -> Result<(), Box<dyn std::error::Error>> {
+async fn start_publisher(env: Environment, stream: &str) -> Result<(), Box<dyn std::error::Error>> {
     let _ = env.stream_creator().create(stream).await;
 
     let producer = env.producer().batch_size(BATCH_SIZE).build(stream).await?;
diff --git a/src/stream_creator.rs b/src/stream_creator.rs
@@ -41,18 +41,11 @@ impl StreamCreator {
         binding_keys: Option<Vec<String>>,
     ) -> Result<(), StreamCreateError> {
         let mut partitions_names = Vec::with_capacity(number_of_partitions);
-        let mut new_binding_keys: Vec<String> = Vec::with_capacity(number_of_partitions);
+        let new_binding_keys = binding_keys
+            .unwrap_or_else(|| (0..number_of_partitions).map(|i| i.to_string()).collect());
 
-        if binding_keys.is_none() {
-            for i in 0..number_of_partitions {
-                new_binding_keys.push(i.to_string());
-                partitions_names.push(super_stream.to_owned() + "-" + i.to_string().as_str())
-            }
-        } else {
-            new_binding_keys = binding_keys.unwrap();
-            for binding_key in new_binding_keys.iter() {
-                partitions_names.push(super_stream.to_owned() + "-" + binding_key)
-            }
+        for binding_key in new_binding_keys.iter() {
+            partitions_names.push(super_stream.to_owned() + "-" + binding_key)
         }
 
         let client = self.env.create_client().await?;
diff --git a/tests/common.rs b/tests/common.rs
@@ -8,6 +8,7 @@ use rabbitmq_stream_protocol::ResponseCode;
 use serde::Deserialize;
 use tokio::sync::Semaphore;
 
+#[allow(unused)]
 pub struct TestClient {
     pub client: Client,
     pub stream: String,
@@ -24,6 +25,7 @@ impl Drop for Countdown {
     }
 }
 
+#[allow(unused)]
 impl Countdown {
     pub fn new(n: u32) -> (Self, impl Future + Send) {
         let sem = Arc::new(Semaphore::new(0));
@@ -41,14 +43,17 @@ pub struct TestEnvironment {
     pub env: Environment,
     pub stream: String,
     pub super_stream: String,
+    #[allow(unused)]
     pub partitions: Vec<String>,
 }
 
 impl TestClient {
+    #[allow(unused)]
     pub async fn create() -> TestClient {
         Self::create_with_option(ClientOptions::default()).await
     }
 
+    #[allow(unused)]
     pub async fn create_with_option(options: ClientOptions) -> TestClient {
         let stream: String = Faker.fake();
         let client = Client::connect(options).await.unwrap();
@@ -64,6 +69,7 @@ impl TestClient {
         }
     }
 
+    #[allow(unused)]
     pub async fn create_super_stream() -> TestClient {
         let super_stream: String = Faker.fake();
         let client = Client::connect(ClientOptions::default()).await.unwrap();
@@ -104,6 +110,7 @@ impl Drop for TestClient {
     }
 }
 
+#[allow(unused)]
 impl TestEnvironment {
     pub async fn create() -> TestEnvironment {
         let stream: String = Faker.fake();
@@ -203,6 +210,7 @@ pub async fn list_http_connection() -> Vec<RabbitConnection> {
         .unwrap()
 }
 
+#[allow(unused)]
 pub async fn wait_for_named_connection(connection_name: String) -> RabbitConnection {
     let mut max = 10;
     while max > 0 {
@@ -219,6 +227,7 @@ pub async fn wait_for_named_connection(connection_name: String) -> RabbitConnect
     panic!("Connection not found. timeout");
 }
 
+#[allow(unused)]
 pub async fn drop_connection(connection: RabbitConnection) {
     reqwest::Client::new()
         .delete(format!(
diff --git a/tests/consumer_test.rs b/tests/consumer_test.rs
@@ -107,7 +107,7 @@ async fn super_stream_consumer_test() {
     let mut received_messages = 0;
     let handle = super_stream_consumer.handle();
 
-    while let Some(_) = super_stream_consumer.next().await {
+    while super_stream_consumer.next().await.is_some() {
         received_messages += 1;
         if received_messages == 10 {
             break;
@@ -481,7 +481,7 @@ async fn consumer_test_with_filtering() {
         .lock()
         .await
         .iter()
-        .filter(|item| item == &&"filtering")
+        .filter(|item| item == &"filtering")
         .collect::<Vec<_>>()
         .len();
 
@@ -562,7 +562,7 @@ async fn super_stream_consumer_test_with_filtering() {
         .lock()
         .await
         .iter()
-        .filter(|item| item == &&"filtering")
+        .filter(|item| item == &"filtering")
         .collect::<Vec<_>>()
         .len();
 
@@ -654,7 +654,7 @@ async fn consumer_test_with_filtering_match_unfiltered() {
         .lock()
         .await
         .iter()
-        .filter(|item| item == &&"1")
+        .filter(|item| item == &"1")
         .collect::<Vec<_>>()
         .len();
 
@@ -728,7 +728,7 @@ async fn super_stream_single_active_consumer_test() {
     task::spawn(async move {
         let received_messages_int = received_message_outer.clone();
         let notify_received_messages_inner = notify_received_messages_outer.clone();
-        while let Some(_) = super_stream_consumer.next().await {
+        while super_stream_consumer.next().await.is_some() {
             let rec_msg = received_messages_int.fetch_add(1, Ordering::Relaxed);
             if message_count == rec_msg {
                 notify_received_messages_inner.notify_one();
@@ -742,7 +742,7 @@ async fn super_stream_single_active_consumer_test() {
     task::spawn(async move {
         let received_messages_int = received_message_outer.clone();
         let notify_received_messages_inner = notify_received_messages_outer.clone();
-        while let Some(_) = super_stream_consumer_2.next().await {
+        while super_stream_consumer_2.next().await.is_some() {
             let rec_msg = received_messages_int.fetch_add(1, Ordering::Relaxed);
             if message_count == rec_msg {
                 notify_received_messages_inner.notify_one();
@@ -756,7 +756,7 @@ async fn super_stream_single_active_consumer_test() {
     task::spawn(async move {
         let received_messages_int = received_message_outer.clone();
         let notify_received_messages_inner = notify_received_messages_outer.clone();
-        while let Some(_) = super_stream_consumer_3.next().await {
+        while super_stream_consumer_3.next().await.is_some() {
             let rec_msg = received_messages_int.fetch_add(1, Ordering::Relaxed);
             if message_count == rec_msg {
                 notify_received_messages_inner.notify_one();
@@ -887,7 +887,7 @@ async fn super_stream_single_active_consumer_test_with_callback() {
     task::spawn(async move {
         let received_messages_int = received_message_outer.clone();
         let notify_received_messages_inner = notify_received_messages_outer.clone();
-        while let Some(_) = super_stream_consumer.next().await {
+        while super_stream_consumer.next().await.is_some() {
             let rec_msg = received_messages_int.fetch_add(1, Ordering::Relaxed);
             if message_count == rec_msg {
                 notify_received_messages_inner.notify_one();
@@ -901,7 +901,7 @@ async fn super_stream_single_active_consumer_test_with_callback() {
     task::spawn(async move {
         let received_messages_int = received_message_outer.clone();
         let notify_received_messages_inner = notify_received_messages_outer.clone();
-        while let Some(_) = super_stream_consumer_2.next().await {
+        while super_stream_consumer_2.next().await.is_some() {
             let rec_msg = received_messages_int.fetch_add(1, Ordering::Relaxed);
             if message_count == rec_msg {
                 notify_received_messages_inner.notify_one();
@@ -915,7 +915,7 @@ async fn super_stream_single_active_consumer_test_with_callback() {
     task::spawn(async move {
         let received_messages_int = received_message_outer.clone();
         let notify_received_messages_inner = notify_received_messages_outer.clone();
-        while let Some(_) = super_stream_consumer_3.next().await {
+        while super_stream_consumer_3.next().await.is_some() {
             let rec_msg = received_messages_int.fetch_add(1, Ordering::Relaxed);
             if message_count == rec_msg {
                 notify_received_messages_inner.notify_one();
diff --git a/tests/producer_test.rs b/tests/producer_test.rs
@@ -251,7 +251,12 @@ async fn producer_send_with_callback_can_drop() {
     // A non copy structure
     struct Foo;
 
-    let f = Foo;
+    // Implement Drop for the sake of silencing clippy below.
+    impl Drop for Foo {
+        fn drop(&mut self) {}
+    }
+
+    let f = Foo {};
     producer
         .send(
             Message::builder().body(b"message".to_vec()).build(),
@@ -676,11 +681,7 @@ async fn super_stream_producer_send_filtering_message() {
         .build();
 
     let closed = super_stream_producer.send(message, |_| async move {}).await;
-
-    match closed {
-        Ok(_) => assert!(true),
-        Err(_) => assert!(false),
-    }
+    assert!(closed.is_ok())
 }
 
 #[tokio::test(flavor = "multi_thread")]

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ impl MyHAProducer {`
`101`	`101`	`ProducerPublishError::Timeout \| ProducerPublishError::Closed => {`
`102`	`102`	`Box::pin(self.send_with_confirm(message)).await`
`103`	`103`	`}`
`104`		`- _ => return Err(e),`
	`104`	`+ _ => Err(e),`
`105`	`105`	`},`
`106`	`106`	`}`
`107`	`107`	`}`
`@@ -114,14 +114,12 @@ async fn ensure_stream_exists(environment: &Environment, stream: &str) -> Rabbit`
`114`	`114`	`.create(stream)`
`115`	`115`	`.await;`
`116`	`116`
`117`		`- if let Err(e) = create_response {`
`118`		`- if let StreamCreateError::Create { stream, status } = e {`
`119`		`- match status {`
`120`		`- // we can ignore this error because the stream already exists`
`121`		`- ResponseCode::StreamAlreadyExists => {}`
`122`		`- err => {`
`123`		`- panic!("Error creating stream: {:?} {:?}", stream, err);`
`124`		`- }`
	`117`	`+ if let Err(StreamCreateError::Create { stream, status }) = create_response {`
	`118`	`+ match status {`
	`119`	`+ // we can ignore this error because the stream already exists`
	`120`	`+ ResponseCode::StreamAlreadyExists => {}`
	`121`	`+ err => {`
	`122`	`+ panic!("Error creating stream: {:?} {:?}", stream, err);`
`125`	`123`	`}`
`126`	`124`	`}`
`127`	`125`	`}`