RUST-1401 Additional GridFS API (#763)

Author: isabelatkinson

src/gridfs.rs

@@ -17,8 +17,8 @@ use crate::{
     bson::{doc, oid::ObjectId, Bson, DateTime, Document, RawBinaryRef},
     concern::{ReadConcern, WriteConcern},
     cursor::Cursor,
-    error::Result,
-    options::SelectionCriteria,
+    error::{ErrorKind, GridFsErrorKind, GridFsFileIdentifier, Result},
+    options::{CollectionOptions, FindOptions, SelectionCriteria},
     Collection,
     Database,
 };
@@ -171,8 +171,19 @@ impl GridFsBucket {
             .as_deref()
             .unwrap_or(DEFAULT_BUCKET_NAME);
 
-        let files = db.collection::<FilesCollectionDocument>(&format!("{}.files", bucket_name));
-        let chunks = db.collection::<Chunk>(&format!("{}.chunks", bucket_name));
+        let collection_options = CollectionOptions::builder()
+            .read_concern(options.read_concern.clone())
+            .write_concern(options.write_concern.clone())
+            .selection_criteria(options.selection_criteria.clone())
+            .build();
+        let files = db.collection_with_options::<FilesCollectionDocument>(
+            &format!("{}.files", bucket_name),
+            collection_options.clone(),
+        );
+        let chunks = db.collection_with_options::<Chunk>(
+            &format!("{}.chunks", bucket_name),
+            collection_options,
+        );
 
         GridFsBucket {
             inner: Arc::new(GridFsBucketInner {
@@ -318,28 +329,58 @@ impl GridFsBucket {
         todo!()
     }
 
-    /// Given an `id`, deletes the stored file's files collection document and
-    /// associated chunks from a [`GridFsBucket`].
-    pub async fn delete(&self, id: Bson) {
-        todo!()
+    /// Deletes the [`FilesCollectionDocument`] with the given `id `and its associated chunks from
+    /// this bucket.
+    pub async fn delete(&self, id: Bson) -> Result<()> {
+        let delete_result = self
+            .files()
+            .delete_one(doc! { "_id": id.clone() }, None)
+            .await?;
+        // Delete chunks regardless of whether a file was found. This will remove any possibly
+        // orphaned chunks.
+        self.chunks()
+            .delete_many(doc! { "files_id": id.clone() }, None)
+            .await?;
+
+        if delete_result.deleted_count == 0 {
+            return Err(ErrorKind::GridFs(GridFsErrorKind::FileNotFound {
+                identifier: GridFsFileIdentifier::Id(id),
+            })
+            .into());
+        }
+
+        Ok(())
     }
 
-    /// Finds and returns the files collection documents that match the filter.
+    /// Finds and returns the [`FilesCollectionDocument`]s within this bucket that match the given
+    /// filter.
     pub async fn find(
         &self,
         filter: Document,
-        options: impl Into<Option<GridFsBucketOptions>>,
+        options: impl Into<Option<GridFsFindOptions>>,
     ) -> Result<Cursor<FilesCollectionDocument>> {
-        todo!()
+        let find_options = options.into().map(FindOptions::from);
+        self.files().find(filter, find_options).await
     }
 
-    /// Renames the stored file with the specified `id`.
-    pub async fn rename(&self, id: Bson, new_filename: String) {
-        todo!()
+    /// Renames the file with the given 'id' to the provided `new_filename`.
+    pub async fn rename(&self, id: Bson, new_filename: impl AsRef<str>) -> Result<()> {
+        self.files()
+            .update_one(
+                doc! { "_id": id },
+                doc! { "$set": { "filename": new_filename.as_ref() } },
+                None,
+            )
+            .await?;
+
+        Ok(())
     }
 
-    /// Drops the files associated with this bucket.
-    pub async fn drop(&self) {
-        todo!()
+    /// Drops all of the files and their associated chunks in this bucket.
+    pub async fn drop(&self) -> Result<()> {
+        self.files().drop(None).await?;
+        self.chunks().drop(None).await?;
+
+        Ok(())
     }
 }

src/gridfs/options.rs

@@ -1,12 +1,12 @@
 use std::time::Duration;
 
+use serde::Deserialize;
+use typed_builder::TypedBuilder;
+
 use crate::{
     bson::Document,
-    concern::{ReadConcern, WriteConcern},
-    selection_criteria::SelectionCriteria,
+    options::{FindOptions, ReadConcern, SelectionCriteria, WriteConcern},
 };
-use serde::Deserialize;
-use typed_builder::TypedBuilder;
 
 /// Contains the options for creating a [`GridFsBucket`].
 #[derive(Clone, Debug, Default, Deserialize, TypedBuilder)]
@@ -88,3 +88,17 @@ pub struct GridFsFindOptions {
     /// The order by which to sort results. Defaults to not sorting.
     pub sort: Option<Document>,
 }
+
+impl From<GridFsFindOptions> for FindOptions {
+    fn from(options: GridFsFindOptions) -> Self {
+        Self {
+            allow_disk_use: options.allow_disk_use,
+            batch_size: options.batch_size,
+            limit: options.limit,
+            max_time: options.max_time,
+            skip: options.skip,
+            sort: options.sort,
+            ..Default::default()
+        }
+    }
+}

src/test/spec/unified_runner/operation.rs

@@ -341,6 +341,7 @@ impl<'de> Deserialize<'de> for Operation {
             "createEntities" => deserialize_op::<CreateEntities>(definition.arguments),
             "download" => deserialize_op::<Download>(definition.arguments),
             "downloadByName" => deserialize_op::<DownloadByName>(definition.arguments),
+            "delete" => deserialize_op::<Delete>(definition.arguments),
             _ => Ok(Box::new(UnimplementedOperation) as Box<dyn TestOperation>),
         }
         .map_err(|e| serde::de::Error::custom(format!("{}", e)))?;
@@ -2699,6 +2700,27 @@ impl TestOperation for DownloadByName {
     }
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub(super) struct Delete {
+    id: Bson,
+}
+
+impl TestOperation for Delete {
+    fn execute_entity_operation<'a>(
+        &'a self,
+        id: &'a str,
+        test_runner: &'a TestRunner,
+    ) -> BoxFuture<'a, Result<Option<Entity>>> {
+        async move {
+            let bucket = test_runner.get_bucket(id).await;
+            bucket.delete(self.id.clone()).await?;
+            Ok(None)
+        }
+        .boxed()
+    }
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct UnimplementedOperation;
 

src/test/spec/unified_runner/test_runner.rs

@@ -57,7 +57,6 @@ use super::{
 const SKIPPED_OPERATIONS: &[&str] = &[
     "bulkWrite",
     "count",
-    "delete",
     "listCollectionObjects",
     "listDatabaseObjects",
     "mapReduce",