minor: fix clippy

Author: patrickfreed

src/client/auth/mod.rs

@@ -454,7 +454,7 @@ pub(crate) enum ClientFirst {
 impl ClientFirst {
     pub(crate) fn to_document(&self) -> Document {
         match self {
-            Self::Scram(version, client_first) => client_first.to_command(&version).body,
+            Self::Scram(version, client_first) => client_first.to_command(version).body,
             Self::X509(command) => command.body.clone(),
         }
     }

src/client/mod.rs

@@ -285,7 +285,7 @@ impl Client {
                     message: self
                         .inner
                         .topology
-                        .server_selection_timeout_error_message(&criteria)
+                        .server_selection_timeout_error_message(criteria)
                         .await,
                 }
                 .into());

src/client/options/mod.rs

@@ -1190,7 +1190,7 @@ impl ClientOptionsParser {
                     credential.mechanism_properties = Some(doc);
                 }
 
-                mechanism.validate_credential(&credential)?;
+                mechanism.validate_credential(credential)?;
                 credential.mechanism = options.auth_mechanism.take();
             }
             None => {

src/cmap/conn/command.rs

@@ -113,7 +113,7 @@ impl CommandResponse {
     /// Returns whether this response indicates a success or not (i.e. if "ok: 1")
     pub(crate) fn is_success(&self) -> bool {
         match self.raw_response.get("ok") {
-            Some(ref b) => bson_util::get_int(b) == Some(1),
+            Some(b) => bson_util::get_int(b) == Some(1),
             _ => false,
         }
     }

src/cmap/test/event.rs

@@ -134,34 +134,40 @@ impl EventSubscriber<'_> {
 #[derive(Clone, Debug, Deserialize, From, PartialEq)]
 #[serde(tag = "type")]
 pub enum Event {
-    #[serde(deserialize_with = "self::deserialize_pool_created")]
-    ConnectionPoolCreated(PoolCreatedEvent),
-    ConnectionPoolClosed(PoolClosedEvent),
-    ConnectionPoolReady(PoolReadyEvent),
+    #[serde(
+        deserialize_with = "self::deserialize_pool_created",
+        rename = "ConnectionPoolCreated"
+    )]
+    PoolCreated(PoolCreatedEvent),
+    #[serde(rename = "ConnectionPoolClosed")]
+    PoolClosed(PoolClosedEvent),
+    #[serde(rename = "ConnectionPoolReady")]
+    PoolReady(PoolReadyEvent),
     ConnectionCreated(ConnectionCreatedEvent),
     ConnectionReady(ConnectionReadyEvent),
     ConnectionClosed(ConnectionClosedEvent),
     ConnectionCheckOutStarted(ConnectionCheckoutStartedEvent),
     #[serde(deserialize_with = "self::deserialize_checkout_failed")]
     ConnectionCheckOutFailed(ConnectionCheckoutFailedEvent),
     ConnectionCheckedOut(ConnectionCheckedOutEvent),
-    ConnectionPoolCleared(PoolClearedEvent),
+    #[serde(rename = "ConnectionPoolCleared")]
+    PoolCleared(PoolClearedEvent),
     ConnectionCheckedIn(ConnectionCheckedInEvent),
 }
 
 impl Event {
     pub fn name(&self) -> &'static str {
         match self {
-            Event::ConnectionPoolCreated(_) => "ConnectionPoolCreated",
-            Event::ConnectionPoolReady(_) => "ConnectionPoolReady",
-            Event::ConnectionPoolClosed(_) => "ConnectionPoolClosed",
+            Event::PoolCreated(_) => "ConnectionPoolCreated",
+            Event::PoolReady(_) => "ConnectionPoolReady",
+            Event::PoolClosed(_) => "ConnectionPoolClosed",
             Event::ConnectionCreated(_) => "ConnectionCreated",
             Event::ConnectionReady(_) => "ConnectionReady",
             Event::ConnectionClosed(_) => "ConnectionClosed",
             Event::ConnectionCheckOutStarted(_) => "ConnectionCheckOutStarted",
             Event::ConnectionCheckOutFailed(_) => "ConnectionCheckOutFailed",
             Event::ConnectionCheckedOut(_) => "ConnectionCheckedOut",
-            Event::ConnectionPoolCleared(_) => "ConnectionPoolCleared",
+            Event::PoolCleared(_) => "ConnectionPoolCleared",
             Event::ConnectionCheckedIn(_) => "ConnectionCheckedIn",
         }
     }

src/cmap/test/integration.rs

@@ -82,7 +82,7 @@ async fn concurrent_connections() {
     let client = TestClient::with_options(Some(options), true).await;
     let version = VersionReq::parse(">= 4.2.9").unwrap();
     // blockConnection failpoint option only supported in 4.2.9+.
-    if !version.matches(&client.server_version.as_ref().unwrap()) {
+    if !version.matches(client.server_version.as_ref().unwrap()) {
         println!(
             "skipping concurrent_connections test due to server not supporting failpoint option"
         );

src/cmap/test/mod.rs

@@ -309,9 +309,7 @@ impl Operation {
 
                 // wait for event to be emitted to ensure drop has completed.
                 subscriber
-                    .wait_for_event(EVENT_TIMEOUT, |e| {
-                        matches!(e, Event::ConnectionPoolClosed(_))
-                    })
+                    .wait_for_event(EVENT_TIMEOUT, |e| matches!(e, Event::PoolClosed(_)))
                     .await
                     .expect("did not receive ConnectionPoolClosed event after closing pool");
             }
@@ -356,7 +354,7 @@ impl Matchable for ConnectionPoolOptions {
 impl Matchable for Event {
     fn content_matches(&self, expected: &Event) -> bool {
         match (self, expected) {
-            (Event::ConnectionPoolCreated(actual), Event::ConnectionPoolCreated(ref expected)) => {
+            (Event::PoolCreated(actual), Event::PoolCreated(ref expected)) => {
                 actual.options.matches(&expected.options)
             }
             (Event::ConnectionCreated(actual), Event::ConnectionCreated(ref expected)) => {
@@ -380,9 +378,9 @@ impl Matchable for Event {
                 Event::ConnectionCheckOutFailed(ref expected),
             ) => actual.reason == expected.reason,
             (Event::ConnectionCheckOutStarted(_), Event::ConnectionCheckOutStarted(_)) => true,
-            (Event::ConnectionPoolCleared(_), Event::ConnectionPoolCleared(_)) => true,
-            (Event::ConnectionPoolReady(_), Event::ConnectionPoolReady(_)) => true,
-            (Event::ConnectionPoolClosed(_), Event::ConnectionPoolClosed(_)) => true,
+            (Event::PoolCleared(_), Event::PoolCleared(_)) => true,
+            (Event::PoolReady(_), Event::PoolReady(_)) => true,
+            (Event::PoolClosed(_), Event::PoolClosed(_)) => true,
             _ => false,
         }
     }
@@ -464,7 +462,7 @@ async fn redact_credential() {
 
     subscriber
         .wait_for_event(EVENT_TIMEOUT, |e| {
-            if let crate::test::Event::CmapEvent(CmapEvent::ConnectionPoolCreated(event)) = e {
+            if let crate::test::Event::CmapEvent(CmapEvent::PoolCreated(event)) = e {
                 let event_debug = format!("{:?}", event);
                 if let Some(ref pass) = credential.password {
                     assert!(!event_debug.contains(pass))

src/error.rs

@@ -97,7 +97,7 @@ impl Error {
         }
         match &self.kind.code_and_message() {
             Some((code, message)) => {
-                if RETRYABLE_READ_CODES.contains(&code) {
+                if RETRYABLE_READ_CODES.contains(code) {
                     return true;
                 }
                 if is_not_master(*code, message) || is_recovering(*code, message) {
@@ -125,7 +125,7 @@ impl Error {
             return true;
         }
         match &self.kind.code_and_message() {
-            Some((code, _)) => RETRYABLE_WRITE_CODES.contains(&code),
+            Some((code, _)) => RETRYABLE_WRITE_CODES.contains(code),
             None => false,
         }
     }

src/operation/insert/test.rs

@@ -73,12 +73,10 @@ async fn build() {
 
     for (original_doc, cmd_doc) in fixtures.documents.iter().zip(cmd_docs.iter_mut()) {
         assert!(cmd_doc.get("_id").is_some());
-        if original_doc.get("_id").is_some() {
-            assert_eq!(original_doc, cmd_doc);
-        } else {
+        if !original_doc.get("_id").is_some() {
             cmd_doc.remove("_id");
-            assert_eq!(original_doc, cmd_doc);
-        };
+        }
+        assert_eq!(original_doc, cmd_doc);
     }
 
     assert_eq!(

src/runtime/stream.rs

@@ -92,7 +92,7 @@ impl AsyncTcpStream {
         let socket = Socket::new(domain, Type::stream(), Some(Protocol::tcp()))?;
         socket.set_keepalive(Some(KEEPALIVE_TIME))?;
 
-        let address: SockAddr = address.clone().into();
+        let address: SockAddr = (*address).into();
         if connect_timeout == Duration::from_secs(0) {
             socket.connect(&address)?;
         } else {