update tests

Author: isabelatkinson

src/action/bulk_write/results.rs

@@ -3,13 +3,15 @@
 use std::{collections::HashMap, fmt::Debug};
 
 use serde::Serialize;
+use serde_with::skip_serializing_none;
 
 use crate::{
     results::{DeleteResult, InsertOneResult, UpdateResult},
     serde_util::serialize_indexed_map,
 };
 
-#[derive(Clone, Debug, Default, Serialize)]
+#[skip_serializing_none]
+#[derive(Clone, Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 #[non_exhaustive]
 pub struct BulkWriteResult {
@@ -19,24 +21,43 @@ pub struct BulkWriteResult {
     pub modified_count: i64,
     pub deleted_count: i64,
     #[serde(serialize_with = "serialize_indexed_map")]
-    pub insert_results: HashMap<usize, InsertOneResult>,
+    pub insert_results: Option<HashMap<usize, InsertOneResult>>,
     #[serde(serialize_with = "serialize_indexed_map")]
-    pub update_results: HashMap<usize, UpdateResult>,
+    pub update_results: Option<HashMap<usize, UpdateResult>>,
     #[serde(serialize_with = "serialize_indexed_map")]
-    pub delete_results: HashMap<usize, DeleteResult>,
+    pub delete_results: Option<HashMap<usize, DeleteResult>>,
 }
 
 impl BulkWriteResult {
+    pub(crate) fn new(verbose: bool) -> Self {
+        Self {
+            inserted_count: 0,
+            upserted_count: 0,
+            matched_count: 0,
+            modified_count: 0,
+            deleted_count: 0,
+            insert_results: verbose.then(HashMap::new),
+            update_results: verbose.then(HashMap::new),
+            delete_results: verbose.then(HashMap::new),
+        }
+    }
+
     pub(crate) fn add_insert_result(&mut self, index: usize, insert_result: InsertOneResult) {
-        self.insert_results.insert(index, insert_result);
+        self.insert_results
+            .get_or_insert_with(Default::default)
+            .insert(index, insert_result);
     }
 
     pub(crate) fn add_update_result(&mut self, index: usize, update_result: UpdateResult) {
-        self.update_results.insert(index, update_result);
+        self.update_results
+            .get_or_insert_with(Default::default)
+            .insert(index, update_result);
     }
 
     pub(crate) fn add_delete_result(&mut self, index: usize, delete_result: DeleteResult) {
-        self.delete_results.insert(index, delete_result);
+        self.delete_results
+            .get_or_insert_with(Default::default)
+            .insert(index, delete_result);
     }
 
     pub(crate) fn merge(&mut self, other: Self) {
@@ -45,8 +66,20 @@ impl BulkWriteResult {
         self.matched_count += other.matched_count;
         self.modified_count += other.modified_count;
         self.deleted_count += other.deleted_count;
-        self.insert_results.extend(other.insert_results);
-        self.update_results.extend(other.update_results);
-        self.delete_results.extend(other.delete_results);
+        if let Some(insert_results) = other.insert_results {
+            self.insert_results
+                .get_or_insert_with(Default::default)
+                .extend(insert_results);
+        }
+        if let Some(update_results) = other.update_results {
+            self.update_results
+                .get_or_insert_with(Default::default)
+                .extend(update_results);
+        }
+        if let Some(delete_results) = other.delete_results {
+            self.delete_results
+                .get_or_insert_with(Default::default)
+                .extend(delete_results);
+        }
     }
 }

src/coll.rs

@@ -781,17 +781,9 @@ impl<'de> Deserialize<'de> for Namespace {
     where
         D: Deserializer<'de>,
     {
-        #[derive(Deserialize)]
-        #[serde(untagged)]
-        enum NamespaceHelper {
-            String(String),
-            Object { db: String, coll: String },
-        }
-        match NamespaceHelper::deserialize(deserializer)? {
-            NamespaceHelper::String(string) => Self::from_str(&string)
-                .ok_or_else(|| D::Error::custom("Missing one or more fields in namespace")),
-            NamespaceHelper::Object { db, coll } => Ok(Self { db, coll }),
-        }
+        let s: String = Deserialize::deserialize(deserializer)?;
+        Self::from_str(&s)
+            .ok_or_else(|| D::Error::custom("Missing one or more fields in namespace"))
     }
 }
 

src/operation/bulk_write.rs

@@ -69,6 +69,13 @@ impl<'a> BulkWrite<'a> {
         }
     }
 
+    fn is_verbose(&self) -> bool {
+        self.options
+            .as_ref()
+            .and_then(|o| o.verbose_results)
+            .unwrap_or(false)
+    }
+
     async fn iterate_results_cursor(
         &self,
         mut stream: impl TryStream<Ok = SingleOperationResponse, Error = Error> + Unpin,
@@ -90,7 +97,7 @@ impl<'a> BulkWrite<'a> {
                             let inserted_id = self.get_inserted_id(result_index)?;
                             let insert_result = InsertOneResult { inserted_id };
                             result
-                                .get_or_insert_with(Default::default)
+                                .get_or_insert_with(|| BulkWriteResult::new(self.is_verbose()))
                                 .add_insert_result(result_index, insert_result);
                         }
                         OperationType::Update => {
@@ -106,13 +113,13 @@ impl<'a> BulkWrite<'a> {
                                 upserted_id: upserted.map(|upserted| upserted.id),
                             };
                             result
-                                .get_or_insert_with(Default::default)
+                                .get_or_insert_with(|| BulkWriteResult::new(self.is_verbose()))
                                 .add_update_result(result_index, update_result);
                         }
                         OperationType::Delete => {
                             let delete_result = DeleteResult { deleted_count: n };
                             result
-                                .get_or_insert_with(Default::default)
+                                .get_or_insert_with(|| BulkWriteResult::new(self.is_verbose()))
                                 .add_delete_result(result_index, delete_result);
                         }
                     }
@@ -283,7 +290,7 @@ impl<'a> OperationWithDefaults for BulkWrite<'a> {
                 if response.summary.n_errors < self.n_attempted as i64 {
                     bulk_write_error
                         .partial_result
-                        .get_or_insert_with(Default::default)
+                        .get_or_insert_with(|| BulkWriteResult::new(self.is_verbose()))
                         .populate_summary_info(&response.summary);
                 }
 
@@ -322,7 +329,9 @@ impl<'a> OperationWithDefaults for BulkWrite<'a> {
                         if bulk_write_error.write_errors.is_empty()
                             && bulk_write_error.write_concern_errors.is_empty()
                         {
-                            Ok(bulk_write_error.partial_result.unwrap_or_default())
+                            Ok(bulk_write_error
+                                .partial_result
+                                .unwrap_or_else(|| BulkWriteResult::new(self.is_verbose())))
                         } else {
                             let error = Error::new(
                                 ErrorKind::ClientBulkWrite(bulk_write_error),

src/serde_util.rs

@@ -196,14 +196,18 @@ where
 }
 
 pub(crate) fn serialize_indexed_map<S: Serializer, T: Serialize>(
-    map: &HashMap<usize, T>,
+    map: &Option<HashMap<usize, T>>,
     serializer: S,
 ) -> std::result::Result<S::Ok, S::Error> {
-    let string_map: BTreeMap<_, _> = map
-        .iter()
-        .map(|(index, result)| (index.to_string(), result))
-        .collect();
-    string_map.serialize(serializer)
+    if let Some(map) = map {
+        let string_map: BTreeMap<_, _> = map
+            .iter()
+            .map(|(index, result)| (index.to_string(), result))
+            .collect();
+        string_map.serialize(serializer)
+    } else {
+        serializer.serialize_none()
+    }
 }
 
 #[cfg(test)]

src/test/bulk_write.rs

@@ -3,7 +3,7 @@ use std::{sync::Arc, time::Duration};
 use crate::{
     action::bulk_write::write_models::WriteModel,
     bson::doc,
-    test::{spec::unified_runner::run_unified_tests, EventHandler},
+    test::{log_uncaptured, spec::unified_runner::run_unified_tests, EventHandler},
     Client,
     Namespace,
 };
@@ -22,6 +22,11 @@ async fn max_write_batch_size_batching() {
         .await;
     let mut subscriber = handler.subscribe();
 
+    if client.server_version_lt(8, 0) {
+        log_uncaptured("skipping max_write_batch_size_batching: bulkWrite requires 8.0+");
+        return;
+    }
+
     let max_write_batch_size = client.server_info.max_write_batch_size.unwrap() as usize;
 
     let model = WriteModel::InsertOne {
@@ -57,6 +62,13 @@ async fn max_bson_object_size_with_document_sequences() {
         .await;
     let mut subscriber = handler.subscribe();
 
+    if client.server_version_lt(8, 0) {
+        log_uncaptured(
+            "skipping max_bson_object_size_with_document_sequences: bulkWrite requires 8.0+",
+        );
+        return;
+    }
+
     let max_bson_object_size = client.server_info.max_bson_object_size as usize;
 
     let document = doc! { "a": "b".repeat(max_bson_object_size / 2) };
@@ -86,6 +98,11 @@ async fn max_message_size_bytes_batching() {
         .await;
     let mut subscriber = handler.subscribe();
 
+    if client.server_version_lt(8, 0) {
+        log_uncaptured("skipping max_message_size_bytes_batching: bulkWrite requires 8.0+");
+        return;
+    }
+
     let max_bson_object_size = client.server_info.max_bson_object_size as usize;
     let max_message_size_bytes = client.server_info.max_message_size_bytes as usize;