RUST-1967 Fix cloud provider test binaries (#1123)

Author: abr-egn

.evergreen/aws-ecs-test/src/main.rs

@@ -1,14 +1,17 @@
-use mongodb::{bson::Document, Client};
+use mongodb::{
+    bson::{doc, Document},
+    Client,
+};
 
 #[tokio::main]
 async fn main() {
     let uri = std::env::var("MONGODB_URI").expect("no URI given!");
     let client = Client::with_uri_str(&uri).await.unwrap();
-    
+
     client
         .database("aws")
         .collection::<Document>("somecoll")
-        .find_one(None, None)
+        .find_one(doc! {})
         .await
         .unwrap();
 }

.evergreen/aws-lambda-test/mongodb/src/main.rs

@@ -1,7 +1,12 @@
 use std::sync::Arc;
 
 use lambda_runtime::{run, service_fn, Error, LambdaEvent};
-use mongodb::{bson::doc, event::{cmap::CmapEvent, command::CommandEvent, sdam::SdamEvent, EventHandler}, options::ClientOptions, Client};
+use mongodb::{
+    bson::doc,
+    event::{cmap::CmapEvent, command::CommandEvent, sdam::SdamEvent, EventHandler},
+    options::ClientOptions,
+    Client,
+};
 use serde::{Deserialize, Serialize};
 use tokio::sync::OnceCell;
 
@@ -40,7 +45,8 @@ impl Stats {
             }
             SdamEvent::ServerHeartbeatFailed(ev) => {
                 assert!(!ev.awaited);
-                self.failed_heartbeat_durations_millis.push(ev.duration.as_millis());
+                self.failed_heartbeat_durations_millis
+                    .push(ev.duration.as_millis());
             }
             _ => (),
         }
@@ -49,10 +55,12 @@ impl Stats {
     fn handle_command(&mut self, event: &CommandEvent) {
         match event {
             CommandEvent::Succeeded(ev) => {
-                self.command_succeeded_durations_millis.push(ev.duration.as_millis());
+                self.command_succeeded_durations_millis
+                    .push(ev.duration.as_millis());
             }
             CommandEvent::Failed(ev) => {
-                self.command_failed_durations_millis.push(ev.duration.as_millis());
+                self.command_failed_durations_millis
+                    .push(ev.duration.as_millis());
             }
             _ => (),
         }
@@ -62,7 +70,8 @@ impl Stats {
         match event {
             CmapEvent::ConnectionCreated(_) => {
                 self.connections_open += 1;
-                self.max_connections_open = std::cmp::max(self.connections_open, self.max_connections_open);
+                self.max_connections_open =
+                    std::cmp::max(self.connections_open, self.max_connections_open);
             }
             CmapEvent::ConnectionClosed(_) => {
                 self.connections_open -= 1;
@@ -76,23 +85,31 @@ impl State {
     async fn new() -> Self {
         let uri = std::env::var("MONGODB_URI")
             .expect("MONGODB_URI must be set to the URI of the MongoDB deployment");
-        let mut options = ClientOptions::parse(uri).await.expect("Failed to parse URI");
+        let mut options = ClientOptions::parse(uri)
+            .await
+            .expect("Failed to parse URI");
         let stats = Arc::new(std::sync::Mutex::new(Stats::new()));
         {
             let stats = Arc::clone(&stats);
-            options.sdam_event_handler = Some(EventHandler::callback(move |ev| stats.lock().unwrap().handle_sdam(&ev)));
+            options.sdam_event_handler = Some(EventHandler::callback(move |ev| {
+                stats.lock().unwrap().handle_sdam(&ev)
+            }));
         }
         {
             let stats = Arc::clone(&stats);
-            options.command_event_handler = Some(EventHandler::callback(move |ev| stats.lock().unwrap().handle_command(&ev)));
+            options.command_event_handler = Some(EventHandler::callback(move |ev| {
+                stats.lock().unwrap().handle_command(&ev)
+            }));
         }
         {
             let stats = Arc::clone(&stats);
-            options.cmap_event_handler = Some(EventHandler::callback(move |ev| stats.lock().unwrap().handle_cmap(&ev)));
+            options.cmap_event_handler = Some(EventHandler::callback(move |ev| {
+                stats.lock().unwrap().handle_cmap(&ev)
+            }));
         }
 
         let client = Client::with_options(options).expect("Failed to create MongoDB Client");
-        
+
         Self { client, stats }
     }
 }
@@ -104,14 +121,13 @@ async fn get_state() -> &'static State {
 }
 
 #[derive(Deserialize)]
-struct Request {
-}
+struct Request {}
 
 async fn function_handler(_event: LambdaEvent<Request>) -> Result<Stats, Error> {
     let state = get_state().await;
     let coll = state.client.database("faas_test").collection("faas_test");
-    let id = coll.insert_one(doc! { }, None).await?.inserted_id;
-    coll.delete_one(doc! { "id": id }, None).await?;
+    let id = coll.insert_one(doc! {}).await?.inserted_id;
+    coll.delete_one(doc! { "id": id }).await?;
 
     let stats = {
         let mut guard = state.stats.lock().unwrap();
@@ -125,4 +141,4 @@ async fn function_handler(_event: LambdaEvent<Request>) -> Result<Stats, Error>
 #[tokio::main]
 async fn main() -> Result<(), Error> {
     run(service_fn(function_handler)).await
-}
+}

.evergreen/azure-kms-test/src/main.rs

@@ -1,7 +1,10 @@
 use mongodb::{
     bson::doc,
-    Client, client_encryption::{ClientEncryption, MasterKey}, mongocrypt::ctx::KmsProvider, Namespace,
+    client_encryption::{ClientEncryption, MasterKey},
     error::Result,
+    mongocrypt::ctx::KmsProvider,
+    Client,
+    Namespace,
 };
 
 use std::env;
@@ -19,11 +22,10 @@ async fn main() -> Result<()> {
         .expect("KEY_VAULT_ENDPOINT environment variable should be set");
 
     c.create_data_key(MasterKey::Azure {
-        key_vault_endpoint: key_vault_endpoint,
-        key_name: key_name,
+        key_vault_endpoint,
+        key_name,
         key_version: None,
     })
-    .run()
     .await?;
 
     println!("Azure KMS integration test passed!");