RUST-824 Add Snapshot variant to ReadConcernLevel (#345)

Author: isabelatkinson

src/concern/mod.rs

@@ -52,6 +52,12 @@ impl ReadConcern {
         ReadConcernLevel::Available.into()
     }
 
+    /// Creates a read concern with level "snapshot".
+    /// See the specific documentation for this read concern level [here](https://docs.mongodb.com/manual/reference/read-concern-snapshot/).
+    pub fn snapshot() -> Self {
+        ReadConcernLevel::Snapshot.into()
+    }
+
     /// Creates a read concern with a custom read concern level. This is present to provide forwards
     /// compatibility with any future read concerns which may be added to new versions of
     /// MongoDB.
@@ -85,6 +91,9 @@ pub enum ReadConcernLevel {
     /// See the specific documentation for this read concern level [here](https://docs.mongodb.com/manual/reference/read-concern-available/).
     Available,
 
+    /// See the specific documentation for this read concern level [here](https://docs.mongodb.com/manual/reference/read-concern-snapshot/).
+    Snapshot,
+
     /// Specify a custom read concern level. This is present to provide forwards compatibility with
     /// any future read concerns which may be added to new versions of MongoDB.
     Custom(String),
@@ -97,6 +106,7 @@ impl ReadConcernLevel {
             "majority" => ReadConcernLevel::Majority,
             "linearizable" => ReadConcernLevel::Linearizable,
             "available" => ReadConcernLevel::Available,
+            "snapshot" => ReadConcernLevel::Snapshot,
             s => ReadConcernLevel::Custom(s.to_string()),
         }
     }
@@ -108,6 +118,7 @@ impl ReadConcernLevel {
             ReadConcernLevel::Majority => "majority",
             ReadConcernLevel::Linearizable => "linearizable",
             ReadConcernLevel::Available => "available",
+            ReadConcernLevel::Snapshot => "snapshot",
             ReadConcernLevel::Custom(ref s) => s,
         }
     }

src/concern/test.rs

@@ -2,10 +2,17 @@ use std::time::Duration;
 use tokio::sync::RwLockReadGuard;
 
 use crate::{
-    bson::{doc, Bson},
+    bson::{doc, Bson, Document},
     error::ErrorKind,
-    options::{Acknowledgment, InsertOneOptions, WriteConcern},
-    test::{TestClient, LOCK},
+    options::{
+        Acknowledgment,
+        FindOneOptions,
+        InsertOneOptions,
+        ReadConcern,
+        TransactionOptions,
+        WriteConcern,
+    },
+    test::{EventClient, TestClient, LOCK},
 };
 
 #[test]
@@ -144,3 +151,62 @@ async fn unacknowledged_write_concern_rejected() {
         .expect_err("insert should fail");
     assert!(matches!(*error.kind, ErrorKind::InvalidArgument { .. }));
 }
+
+#[cfg_attr(feature = "tokio-runtime", tokio::test)]
+#[cfg_attr(feature = "async-std-runtime", async_std::test)]
+#[function_name::named]
+async fn snapshot_read_concern() {
+    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
+
+    let client = EventClient::new().await;
+    // snapshot read concern was introduced in 4.0
+    if client.server_version_lt(4, 0) {
+        return;
+    }
+
+    let coll = client
+        .database(function_name!())
+        .collection::<Document>(function_name!());
+
+    // TODO RUST-122 run this test on sharded clusters
+    if client.is_replica_set() && client.server_version_gte(4, 0) {
+        let mut session = client.start_session(None).await.unwrap();
+        let options = TransactionOptions::builder()
+            .read_concern(ReadConcern::snapshot())
+            .build();
+        session.start_transaction(options).await.unwrap();
+        let result = coll.find_one_with_session(None, None, &mut session).await;
+        assert!(result.is_ok());
+        assert_event_contains_read_concern(&client).await;
+    }
+
+    if client.server_version_lt(4, 9) {
+        let options = FindOneOptions::builder()
+            .read_concern(ReadConcern::snapshot())
+            .build();
+        let error = coll
+            .find_one(None, options)
+            .await
+            .expect_err("non-transaction find one with snapshot read concern should fail");
+        // ensure that an error from the server is returned
+        assert!(matches!(*error.kind, ErrorKind::Command(_)));
+        assert_event_contains_read_concern(&client).await;
+    }
+}
+
+async fn assert_event_contains_read_concern(client: &EventClient) {
+    let event = client
+        .get_command_started_events(&["find"])
+        .into_iter()
+        .next()
+        .unwrap();
+    assert_eq!(
+        event
+            .command
+            .get_document("readConcern")
+            .unwrap()
+            .get_str("level")
+            .unwrap(),
+        "snapshot"
+    );
+}

src/lib.rs

@@ -82,7 +82,6 @@
 )]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![cfg_attr(test, type_length_limit = "80000000")]
-
 #![doc(html_root_url = "https://docs.rs/mongodb/2.0.0-beta")]
 
 macro_rules! define_if_single_runtime_enabled {

src/srv.rs

@@ -77,7 +77,10 @@ impl SrvResolver {
             .map(|record| {
                 let hostname = record.target().to_utf8();
                 let port = Some(record.port());
-                ServerAddress::Tcp { host: hostname, port }
+                ServerAddress::Tcp {
+                    host: hostname,
+                    port,
+                }
             })
             .collect();
 
@@ -112,7 +115,10 @@ impl SrvResolver {
 
             // The spec tests list the seeds without the trailing '.', so we remove it by
             // joining the parts we split rather than manipulating the string.
-            address = ServerAddress::Tcp { host: hostname_parts.join("."), port: address.port() };
+            address = ServerAddress::Tcp {
+                host: hostname_parts.join("."),
+                port: address.port(),
+            };
 
             Ok(address)
         });

src/test/spec/json/read-write-concern/README.rst

@@ -52,6 +52,25 @@ array of test case objects, each of which have the following keys:
 - ``isServerDefault:`` Indicates whether the read or write concern is considered the server's default.
 - ``isAcknowledged:`` Indicates if the write concern should be considered acknowledged.
 
+Operation
+~~~~~~~~~
+
+These tests check that the default write concern is omitted in operations.
+
+The spec test format is an extension of `transactions spec tests <https://github.com/mongodb/specifications/blob/master/source/transactions/tests/README.rst>`_ with the following additions:
+
+- ``writeConcern`` in the ``databaseOptions`` or ``collectionOptions`` may be an empty document to indicate a `server default write concern <https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.rst#servers-default-writeconcern>`_. For example, in libmongoc:
+
+    .. code:: c
+
+       /* Create a default write concern, and set on a collection object. */
+       mongoc_write_concern_t *wc = mongoc_write_concern_new ();
+       mongoc_collection_set_write_concern (collection, wc);
+
+    If the driver has no way to explicitly set a default write concern on a database or collection, ignore the empty ``writeConcern`` document and continue with the test.
+- The operations ``createIndex``, ``dropIndex`` are introduced.
+
+
 Use as unit tests
 =================