cleanup

Author: isabelatkinson

src/gridfs.rs

@@ -328,6 +328,7 @@ impl GridFsBucket {
             .read_concern(self.read_concern().cloned())
             .selection_criteria(self.selection_criteria().cloned())
             .build();
+
         let file = match self
             .inner
             .files
@@ -342,6 +343,7 @@ impl GridFsBucket {
                 .into());
             }
         };
+
         self.download_to_tokio_writer_common(file, destination)
             .await
     }
@@ -392,8 +394,6 @@ impl GridFsBucket {
         let mut n = 0;
         while cursor.advance().await? {
             let chunk = cursor.deserialize_current()?;
-            dbg!("{}", &chunk);
-            dbg!("{}", &file);
             if chunk.n != n {
                 return Err(ErrorKind::GridFS {
                     message: format!("missing chunk {} in file", n),
@@ -414,7 +414,7 @@ impl GridFsBucket {
                 .into());
             }
 
-            destination.write(&chunk.data.bytes).await?;
+            destination.write_all(&chunk.data.bytes).await?;
             n += 1;
         }
 

src/test/spec/gridfs.rs

@@ -2,10 +2,10 @@ use crate::test::{run_spec_test_with_path, LOCK};
 
 use super::{run_unified_format_test_filtered, unified_runner::TestCase};
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test(flavor = "multi_thread"))] // multi_thread required for FailPoint
+#[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    let _guard = LOCK.run_exclusively().await;
+    let _guard = LOCK.run_concurrently().await;
     run_spec_test_with_path(&["gridfs"], |path, f| {
         run_unified_format_test_filtered(path, f, test_predicate)
     })

src/test/spec/unified_runner/matcher.rs

@@ -315,12 +315,23 @@ fn special_operator_matches(
             let id = value.as_str().unwrap();
             entity_matches(id, actual, entities.unwrap())
         }
-        "$$matchesHexBytes" => {
-            let expected = value.as_str().unwrap().to_string().to_lowercase();
-            let actual = actual.unwrap().as_str().unwrap().to_string().to_lowercase();
-            assert_eq!(actual, expected);
-            Ok(())
-        }
+        "$$matchesHexBytes" => match (actual, value) {
+            (Some(Bson::String(actual)), Bson::String(expected)) => {
+                if actual.to_lowercase() == expected.to_lowercase() {
+                    Ok(())
+                } else {
+                    Err(format!(
+                        "hex bytes do not match: expected {:?} but got {:?}",
+                        actual, expected
+                    ))
+                }
+            }
+            (actual, expected) => Err(format!(
+                "actual and expected should both be BSON strings but got: actual {:?}, expected \
+                 {:?}",
+                actual, expected
+            )),
+        },
         "$$sessionLsid" => match entities {
             Some(entity_map) => {
                 let session_id = value.as_str().unwrap();

src/test/spec/unified_runner/operation.rs

@@ -2661,8 +2661,8 @@ impl TestOperation for Download {
             bucket
                 .download_to_futures_0_3_writer(self.id.clone(), &mut buf)
                 .await?;
-            let writer_data = hex::encode(buf);
-            Ok(Some(Entity::Bson(writer_data.into())))
+            let data = hex::encode(buf);
+            Ok(Some(Entity::Bson(data.into())))
         }
         .boxed()
     }