RUST-485 Unified test runner (#249)

Author: isabelatkinson

src/bson_util/mod.rs

@@ -86,6 +86,16 @@ where
     Ok(millis.map(Duration::from_millis))
 }
 
+pub(crate) fn deserialize_duration_from_u64_seconds<'de, D>(
+    deserializer: D,
+) -> std::result::Result<Option<Duration>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let millis = Option::<u64>::deserialize(deserializer)?;
+    Ok(millis.map(Duration::from_secs))
+}
+
 #[allow(clippy::trivially_copy_pass_by_ref)]
 pub(crate) fn serialize_u32_as_i32<S: Serializer>(
     val: &Option<u32>,

src/coll/options.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use serde::{Deserialize, Serialize, Serializer};
+use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
 use serde_with::skip_serializing_none;
 use typed_builder::TypedBuilder;
 
@@ -40,7 +40,7 @@ pub struct CollectionOptions {
 /// [`Collection::find_one_and_replace`](../struct.Collection.html#method.find_one_and_replace) and
 /// [`Collection::find_one_and_update`](../struct.Collection.html#method.find_one_and_update)
 /// operation should return the document before or after modification.
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug)]
 #[non_exhaustive]
 pub enum ReturnDocument {
     /// Return the document after modification.
@@ -49,6 +49,20 @@ pub enum ReturnDocument {
     Before,
 }
 
+impl<'de> Deserialize<'de> for ReturnDocument {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> std::result::Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        match s.to_lowercase().as_str() {
+            "after" => Ok(ReturnDocument::After),
+            "before" => Ok(ReturnDocument::Before),
+            other => Err(D::Error::custom(format!(
+                "Unknown return document value: {}",
+                other
+            ))),
+        }
+    }
+}
+
 /// Specifies the index to use for an operation.
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(untagged)]
@@ -288,6 +302,7 @@ pub struct DeleteOptions {
 /// [`Collection::find_one_and_delete`](../struct.Collection.html#method.find_one_and_delete)
 /// operation.
 #[derive(Clone, Debug, Default, Deserialize, TypedBuilder)]
+#[serde(rename_all = "camelCase")]
 #[non_exhaustive]
 pub struct FindOneAndDeleteOptions {
     /// The maximum amount of time to allow the query to run.
@@ -326,6 +341,7 @@ pub struct FindOneAndDeleteOptions {
 /// [`Collection::find_one_and_replace`](../struct.Collection.html#method.find_one_and_replace)
 /// operation.
 #[derive(Clone, Debug, Default, Deserialize, TypedBuilder)]
+#[serde(rename_all = "camelCase")]
 #[non_exhaustive]
 pub struct FindOneAndReplaceOptions {
     /// Opt out of document-level validation.
@@ -376,6 +392,7 @@ pub struct FindOneAndReplaceOptions {
 /// [`Collection::find_one_and_update`](../struct.Collection.html#method.find_one_and_update)
 /// operation.
 #[derive(Clone, Debug, Default, Deserialize, TypedBuilder)]
+#[serde(rename_all = "camelCase")]
 #[non_exhaustive]
 pub struct FindOneAndUpdateOptions {
     /// A set of filters specifying to which array elements an update should apply.

src/error.rs

@@ -368,7 +368,7 @@ impl ErrorKind {
 
     /// Gets the code/message tuple from this error, if applicable. In the case of write errors, the
     /// code and message are taken from the write concern error, if there is one.
-    fn code_and_message(&self) -> Option<(i32, &str)> {
+    pub(crate) fn code_and_message(&self) -> Option<(i32, &str)> {
         match self {
             ErrorKind::CommandError(ref cmd_err) => Some((cmd_err.code, cmd_err.message.as_str())),
             ErrorKind::WriteError(WriteFailure::WriteConcernError(ref wc_err)) => {
@@ -382,6 +382,22 @@ impl ErrorKind {
         }
     }
 
+    /// Gets the code name from this error, if applicable.
+    #[cfg(test)]
+    pub(crate) fn code_name(&self) -> Option<&str> {
+        match self {
+            ErrorKind::CommandError(ref cmd_err) => Some(cmd_err.code_name.as_str()),
+            ErrorKind::WriteError(ref failure) => {
+                match failure {
+                    WriteFailure::WriteConcernError(ref wce) => Some(wce.code_name.as_str()),
+                    WriteFailure::WriteError(ref we) => we.code_name.as_deref(),
+                }
+            }
+            ErrorKind::BulkWriteError(ref bwe) => bwe.write_concern_error.as_ref().map(|wce| wce.code_name.as_str()),
+            _ => None,
+        }
+    }
+
     /// If this error corresponds to a "not master" error as per the SDAM spec.
     pub(crate) fn is_not_master(&self) -> bool {
         self.code_and_message()

src/selection_criteria.rs

@@ -1,33 +1,30 @@
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
 use derivative::Derivative;
-use serde::Deserialize;
+use serde::{de::Error, Deserialize, Deserializer};
 use typed_builder::TypedBuilder;
 
 use crate::{
     bson::{doc, Bson, Document},
+    bson_util::deserialize_duration_from_u64_seconds,
     error::{ErrorKind, Result},
     options::StreamAddress,
     sdam::public::ServerInfo,
 };
 
 /// Describes which servers are suitable for a given operation.
-#[derive(Clone, Derivative, Deserialize)]
+#[derive(Clone, Derivative)]
 #[derivative(Debug)]
-#[serde(untagged)]
 #[non_exhaustive]
 pub enum SelectionCriteria {
     /// A read preference that describes the suitable servers based on the server type, max
     /// staleness, and server tags.
     ///
     /// See the documentation [here](https://docs.mongodb.com/manual/core/read-preference/) for more details.
-    // TODO RUST-495: unskip for deserialization
-    #[serde(skip)]
     ReadPreference(ReadPreference),
 
     /// A predicate used to filter servers that are considered suitable. A `server` will be
     /// considered suitable by a `predicate` if `predicate(server)` returns true.
-    #[serde(skip)]
     Predicate(#[derivative(Debug = "ignore")] Predicate),
 }
 
@@ -75,6 +72,15 @@ impl SelectionCriteria {
     }
 }
 
+impl<'de> Deserialize<'de> for SelectionCriteria {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(SelectionCriteria::ReadPreference(ReadPreference::deserialize(deserializer)?))
+    }
+}
+
 /// A predicate used to filter servers that are considered suitable.
 pub type Predicate = Arc<dyn Send + Sync + Fn(&ServerInfo) -> bool>;
 
@@ -87,7 +93,6 @@ pub type Predicate = Arc<dyn Send + Sync + Fn(&ServerInfo) -> bool>;
 ///
 /// See the [MongoDB docs](https://docs.mongodb.com/manual/core/read-preference) for more details.
 #[derive(Clone, Debug, PartialEq)]
-// TODO RUST-495: implement Deserialize for ReadPreference
 pub enum ReadPreference {
     /// Only route this operation to the primary.
     Primary,
@@ -106,8 +111,34 @@ pub enum ReadPreference {
     Nearest { options: ReadPreferenceOptions },
 }
 
+impl<'de> Deserialize<'de> for ReadPreference {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        #[serde(rename_all = "camelCase", deny_unknown_fields)]
+        struct ReadPreferenceHelper {
+            mode: String,
+            #[serde(flatten)]
+            options: ReadPreferenceOptions,
+        }
+        let preference = ReadPreferenceHelper::deserialize(deserializer)?;
+
+        match preference.mode.as_str() {
+            "Primary" => Ok(ReadPreference::Primary),
+            "Secondary" => Ok(ReadPreference::Secondary { options: preference.options }),
+            "PrimaryPreferred" => Ok(ReadPreference::PrimaryPreferred { options: preference.options }),
+            "SecondaryPreferred" => Ok(ReadPreference::SecondaryPreferred { options: preference.options }),
+            "Nearest" => Ok(ReadPreference::Nearest { options: preference.options }),
+            other => Err(D::Error::custom(format!("Unknown read preference mode: {}", other))),
+        }
+    }
+}
+
 /// Specifies read preference options for non-primary read preferences.
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, TypedBuilder)]
+#[serde(rename_all = "camelCase")]
 #[non_exhaustive]
 pub struct ReadPreferenceOptions {
     /// Specifies which replica set members should be considered for operations. Each tag set will
@@ -119,9 +150,10 @@ pub struct ReadPreferenceOptions {
     /// considered for the given operation. Any secondaries lagging behind more than
     /// `max_staleness` will not be considered for the operation.
     ///
-    /// `max_stalesness` must be at least 90 seconds. If a `max_stalness` less than 90 seconds is
+    /// `max_staleness` must be at least 90 seconds. If a `max_staleness` less than 90 seconds is
     /// specified for an operation, the operation will return an error.
     #[builder(default)]
+    #[serde(rename = "maxStalenessSeconds", deserialize_with = "deserialize_duration_from_u64_seconds")]
     pub max_staleness: Option<Duration>,
 
     /// Specifies hedging behavior for reads. These options only apply to sharded clusters on

src/test/mod.rs

@@ -10,7 +10,15 @@ mod spec;
 mod util;
 
 pub(crate) use self::{
-    spec::{run_spec_test, run_v2_test, AnyTestOperation, OperationObject, RunOn, TestEvent},
+    spec::{
+        run_spec_test,
+        run_v2_test,
+        AnyTestOperation,
+        OperationObject,
+        RunOn,
+        TestEvent,
+        Topology,
+    },
     util::{
         assert_matches,
         CommandEvent,
@@ -32,12 +40,13 @@ const MAX_POOL_SIZE: u32 = 100;
 
 lazy_static! {
     pub(crate) static ref CLIENT_OPTIONS: ClientOptions = {
-        let uri = std::env::var("MONGODB_URI")
-            .unwrap_or_else(|_| "mongodb://localhost:27017".to_string());
+        let uri = DEFAULT_URI.clone();
         let mut options = ClientOptions::parse_without_srv_resolution(&uri).unwrap();
         options.max_pool_size = Some(MAX_POOL_SIZE);
 
         options
     };
     pub(crate) static ref LOCK: TestLock = TestLock::new();
+    pub(crate) static ref DEFAULT_URI: String =
+        std::env::var("MONGODB_URI").unwrap_or_else(|_| "mongodb://localhost:27017".to_string());
 }

src/test/spec/json/unified-runner-examples/example-insertOne.json

@@ -0,0 +1,100 @@
+{
+    "description": "example-insertOne",
+    "schemaVersion": "1.0",
+    "runOnRequirements": [
+      {
+        "minServerVersion": "2.6"
+      }
+    ],
+    "createEntities": [
+      {
+        "client": {
+          "id": "client0",
+          "observeEvents": [
+            "commandStartedEvent"
+          ]
+        }
+      },
+      {
+        "database": {
+          "id": "database0",
+          "client": "client0",
+          "databaseName": "test"
+        }
+      },
+      {
+        "collection": {
+          "id": "collection0",
+          "database": "database0",
+          "collectionName": "coll"
+        }
+      }
+    ],
+    "initialData": [
+      {
+        "collectionName": "coll",
+        "databaseName": "test",
+        "documents": [
+          {
+            "_id": 1
+          }
+        ]
+      }
+    ],
+    "tests": [
+      {
+        "description": "insertOne",
+        "operations": [
+          {
+            "object": "collection0",
+            "name": "insertOne",
+            "arguments": {
+              "document": {
+                "_id": 2
+              }
+            },
+            "expectResult": {
+              "insertedId": {
+                "$$unsetOrMatches": 2
+              }
+            }
+          }
+        ],
+        "expectEvents": [
+          {
+            "client": "client0",
+            "events": [
+              {
+                "commandStartedEvent": {
+                  "commandName": "insert",
+                  "databaseName": "test",
+                  "command": {
+                    "insert": "coll",
+                    "documents": [
+                      {
+                        "_id": 2
+                      }
+                    ]
+                  }
+                }
+              }
+            ]
+          }
+        ],
+        "outcome": [
+          {
+            "collectionName": "coll",
+            "databaseName": "test",
+            "documents": [
+              {
+                "_id": 1
+              },
+              {
+                "_id": 2
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }