minor: fix clippy

Author: isabelatkinson

src/client/auth/plain.rs

@@ -46,9 +46,7 @@ pub(crate) async fn authenticate_stream(
 }
 
 fn payload_bytes(username: &str, password: &str) -> Vec<u8> {
-    let mut bytes = Vec::new();
-
-    bytes.push(0);
+    let mut bytes = vec![0];
     bytes.extend(username.as_bytes());
 
     bytes.push(0);

src/sdam/description/topology/server_selection/test/mod.rs

@@ -120,11 +120,16 @@ struct LastWriteDate {
 enum TestServerType {
     Standalone,
     Mongos,
-    RSPrimary,
-    RSSecondary,
-    RSArbiter,
-    RSOther,
-    RSGhost,
+    #[serde(rename = "RSPrimary")]
+    RsPrimary,
+    #[serde(rename = "RSSecondary")]
+    RsSecondary,
+    #[serde(rename = "RSArbiter")]
+    RsArbiter,
+    #[serde(rename = "RSOther")]
+    RsOther,
+    #[serde(rename = "RSGhost")]
+    RsGhost,
     Unknown,
     PossiblePrimary,
 }
@@ -134,11 +139,11 @@ impl TestServerType {
         match self {
             TestServerType::Standalone => Some(ServerType::Standalone),
             TestServerType::Mongos => Some(ServerType::Mongos),
-            TestServerType::RSPrimary => Some(ServerType::RsPrimary),
-            TestServerType::RSSecondary => Some(ServerType::RsSecondary),
-            TestServerType::RSArbiter => Some(ServerType::RsArbiter),
-            TestServerType::RSOther => Some(ServerType::RsOther),
-            TestServerType::RSGhost => Some(ServerType::RsGhost),
+            TestServerType::RsPrimary => Some(ServerType::RsPrimary),
+            TestServerType::RsSecondary => Some(ServerType::RsSecondary),
+            TestServerType::RsArbiter => Some(ServerType::RsArbiter),
+            TestServerType::RsOther => Some(ServerType::RsOther),
+            TestServerType::RsGhost => Some(ServerType::RsGhost),
             TestServerType::Unknown => Some(ServerType::Unknown),
             TestServerType::PossiblePrimary => None,
         }

src/selection_criteria.rs

@@ -78,7 +78,9 @@ impl<'de> Deserialize<'de> for SelectionCriteria {
     where
         D: Deserializer<'de>,
     {
-        Ok(SelectionCriteria::ReadPreference(ReadPreference::deserialize(deserializer)?))
+        Ok(SelectionCriteria::ReadPreference(
+            ReadPreference::deserialize(deserializer)?,
+        ))
     }
 }
 
@@ -131,11 +133,22 @@ impl<'de> Deserialize<'de> for ReadPreference {
 
         match preference.mode.as_str() {
             "Primary" => Ok(ReadPreference::Primary),
-            "Secondary" => Ok(ReadPreference::Secondary { options: preference.options }),
-            "PrimaryPreferred" => Ok(ReadPreference::PrimaryPreferred { options: preference.options }),
-            "SecondaryPreferred" => Ok(ReadPreference::SecondaryPreferred { options: preference.options }),
-            "Nearest" => Ok(ReadPreference::Nearest { options: preference.options }),
-            other => Err(D::Error::custom(format!("Unknown read preference mode: {}", other))),
+            "Secondary" => Ok(ReadPreference::Secondary {
+                options: preference.options,
+            }),
+            "PrimaryPreferred" => Ok(ReadPreference::PrimaryPreferred {
+                options: preference.options,
+            }),
+            "SecondaryPreferred" => Ok(ReadPreference::SecondaryPreferred {
+                options: preference.options,
+            }),
+            "Nearest" => Ok(ReadPreference::Nearest {
+                options: preference.options,
+            }),
+            other => Err(D::Error::custom(format!(
+                "Unknown read preference mode: {}",
+                other
+            ))),
         }
     }
 }
@@ -157,7 +170,10 @@ pub struct ReadPreferenceOptions {
     /// `max_staleness` must be at least 90 seconds. If a `max_staleness` less than 90 seconds is
     /// specified for an operation, the operation will return an error.
     #[builder(default)]
-    #[serde(rename = "maxStalenessSeconds", deserialize_with = "deserialize_duration_from_u64_seconds")]
+    #[serde(
+        rename = "maxStalenessSeconds",
+        deserialize_with = "deserialize_duration_from_u64_seconds"
+    )]
     pub max_staleness: Option<Duration>,
 
     /// Specifies hedging behavior for reads. These options only apply to sharded clusters on

src/test/spec/auth.rs

@@ -22,16 +22,16 @@ struct TestCredential {
     pub mechanism_properties: Option<Document>,
 }
 
-impl Into<Credential> for TestCredential {
-    fn into(self) -> Credential {
-        Credential {
-            username: self.username,
-            password: self.password,
-            source: self.source,
-            mechanism: self
+impl From<TestCredential> for Credential {
+    fn from(test_credential: TestCredential) -> Self {
+        Self {
+            username: test_credential.username,
+            password: test_credential.password,
+            source: test_credential.source,
+            mechanism: test_credential
                 .mechanism
                 .and_then(|s| AuthMechanism::from_str(s.as_str()).ok()),
-            mechanism_properties: self.mechanism_properties,
+            mechanism_properties: test_credential.mechanism_properties,
         }
     }
 }

src/test/spec/initial_dns_seedlist_discovery.rs

@@ -60,7 +60,7 @@ async fn run() {
         };
 
         if let Some(true) = test_file.error {
-            assert!(matches!(result, Err(_)), test_file.comment.unwrap());
+            assert!(matches!(result, Err(_)), "{}", test_file.comment.unwrap());
             return;
         }
 

src/test/spec/mod.rs

@@ -76,7 +76,7 @@ where
         run_test_file(
             bson::from_bson(
                 Bson::try_from(json)
-                    .unwrap_or_else(|_| panic!(test_file_full_path.display().to_string())),
+                    .unwrap_or_else(|_| panic!("{}", test_file_full_path.display().to_string())),
             )
             .unwrap_or_else(|e| panic!("{}: {}", test_file_full_path.display().to_string(), e)),
         )

src/test/spec/unified_runner/matcher.rs

@@ -273,12 +273,14 @@ async fn array_matching() {
         None,
     ));
 
-    let mut actual: Vec<Bson> = Vec::new();
-    actual.push(Bson::Document(doc! { "x": 1, "y": 1 }));
-    actual.push(Bson::Document(doc! { "x": 2, "y": 2 }));
-    let mut expected: Vec<Bson> = Vec::new();
-    expected.push(Bson::Document(doc! { "x": 1 }));
-    expected.push(Bson::Document(doc! { "x": 2 }));
+    let actual = vec![
+        Bson::Document(doc! { "x": 1, "y": 1 }),
+        Bson::Document(doc! { "x": 2, "y": 2 }),
+    ];
+    let expected = vec![
+        Bson::Document(doc! { "x": 1 }),
+        Bson::Document(doc! { "x": 2 }),
+    ];
     assert!(!results_match(
         Some(&Bson::Array(actual)),
         &Bson::Array(expected),