RUST-928 Respect serverless clauses in crud v1 tests

src/test/spec/crud_v1/aggregate.rs

@@ -2,11 +2,11 @@ use futures::stream::TryStreamExt;
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{AggregateOptions, Collation},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -94,5 +94,5 @@ async fn run_aggregate_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "read"], run_aggregate_test).await;
+    run_crud_v1_test(&["crud", "v1", "read"], run_aggregate_test).await;
 }

src/test/spec/crud_v1/count.rs

@@ -1,11 +1,11 @@
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, CountOptions},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -76,5 +76,5 @@ async fn run_count_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "read"], run_count_test).await;
+    run_crud_v1_test(&["crud", "v1", "read"], run_count_test).await;
 }

src/test/spec/crud_v1/delete_many.rs

@@ -1,11 +1,11 @@
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, DeleteOptions},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -88,5 +88,5 @@ async fn run_delete_many_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "write"], run_delete_many_test).await;
+    run_crud_v1_test(&["crud", "v1", "write"], run_delete_many_test).await;
 }

src/test/spec/crud_v1/delete_one.rs

@@ -1,11 +1,11 @@
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, DeleteOptions},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -88,5 +88,5 @@ async fn run_delete_one_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "write"], run_delete_one_test).await;
+    run_crud_v1_test(&["crud", "v1", "write"], run_delete_one_test).await;
 }

src/test/spec/crud_v1/distinct.rs

@@ -1,11 +1,11 @@
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, DistinctOptions},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -64,5 +64,5 @@ async fn run_distinct_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "read"], run_distinct_test).await;
+    run_crud_v1_test(&["crud", "v1", "read"], run_distinct_test).await;
 }

src/test/spec/crud_v1/find.rs

@@ -2,11 +2,11 @@ use futures::stream::TryStreamExt;
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, FindOptions},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -75,5 +75,5 @@ async fn run_find_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "read"], run_find_test).await;
+    run_crud_v1_test(&["crud", "v1", "read"], run_find_test).await;
 }

src/test/spec/crud_v1/find_one_and_delete.rs

@@ -1,11 +1,11 @@
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, FindOneAndDeleteOptions},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -81,5 +81,5 @@ async fn run_find_one_and_delete_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "write"], run_find_one_and_delete_test).await;
+    run_crud_v1_test(&["crud", "v1", "write"], run_find_one_and_delete_test).await;
 }

src/test/spec/crud_v1/find_one_and_replace.rs

@@ -3,11 +3,11 @@ use std::cmp;
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, FindOneAndReplaceOptions, ReturnDocument},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -100,5 +100,5 @@ async fn run_find_one_and_replace_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "write"], run_find_one_and_replace_test).await;
+    run_crud_v1_test(&["crud", "v1", "write"], run_find_one_and_replace_test).await;
 }

src/test/spec/crud_v1/find_one_and_update.rs

@@ -3,11 +3,11 @@ use std::cmp;
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, FindOneAndUpdateOptions, ReturnDocument},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -103,5 +103,5 @@ async fn run_find_one_and_update_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "write"], run_find_one_and_update_test).await;
+    run_crud_v1_test(&["crud", "v1", "write"], run_find_one_and_update_test).await;
 }

src/test/spec/crud_v1/insert_many.rs

@@ -1,11 +1,11 @@
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::InsertManyOptions,
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -106,5 +106,5 @@ async fn run_insert_many_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "write"], run_insert_many_test).await;
+    run_crud_v1_test(&["crud", "v1", "write"], run_insert_many_test).await;
 }

src/test/spec/crud_v1/insert_one.rs

@@ -1,10 +1,10 @@
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -79,5 +79,5 @@ async fn run_insert_one_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "write"], run_insert_one_test).await;
+    run_crud_v1_test(&["crud", "v1", "write"], run_insert_one_test).await;
 }

src/test/spec/crud_v1/mod.rs

@@ -13,14 +13,21 @@ mod replace_one;
 mod update_many;
 mod update_one;
 
+use std::future::Future;
+
 use futures::stream::TryStreamExt;
 use serde::Deserialize;
 
 use crate::{bson::Document, Collection};
 
+use super::{run_spec_test, Serverless};
+
 #[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
 pub struct TestFile {
     pub data: Vec<Document>,
+    pub min_server_version: Option<String>,
+    pub(crate) serverless: Option<Serverless>,
     pub tests: Vec<TestCase>,
 }
 
@@ -58,3 +65,20 @@ pub async fn find_all(coll: &Collection<Document>) -> Vec<Document> {
         .await
         .unwrap()
 }
+
+pub async fn run_crud_v1_test<F, G>(spec: &[&str], run_test_file: F)
+where
+    F: Fn(TestFile) -> G,
+    G: Future<Output = ()>,
+{
+    run_spec_test(spec, |t: TestFile| async {
+        if let Some(ref serverless) = t.serverless {
+            if !serverless.can_run() {
+                return;
+            }
+        }
+
+        run_test_file(t).await
+    })
+    .await
+}

src/test/spec/crud_v1/replace_one.rs

@@ -1,11 +1,11 @@
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, ReplaceOptions},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -111,5 +111,5 @@ async fn run_replace_one_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "write"], run_replace_one_test).await;
+    run_crud_v1_test(&["crud", "v1", "write"], run_replace_one_test).await;
 }

src/test/spec/crud_v1/update_many.rs

@@ -1,11 +1,11 @@
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, UpdateOptions},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -112,5 +112,5 @@ async fn run_update_many_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "write"], run_update_many_test).await;
+    run_crud_v1_test(&["crud", "v1", "write"], run_update_many_test).await;
 }

src/test/spec/crud_v1/update_one.rs

@@ -1,11 +1,11 @@
 use serde::Deserialize;
 use tokio::sync::RwLockReadGuard;
 
-use super::{Outcome, TestFile};
+use super::{run_crud_v1_test, Outcome, TestFile};
 use crate::{
     bson::{Bson, Document},
     options::{Collation, UpdateOptions},
-    test::{run_spec_test, util::TestClient, LOCK},
+    test::{util::TestClient, LOCK},
 };
 
 #[derive(Debug, Deserialize)]
@@ -112,5 +112,5 @@ async fn run_update_one_test(test_file: TestFile) {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {
-    run_spec_test(&["crud", "v1", "write"], run_update_one_test).await;
+    run_crud_v1_test(&["crud", "v1", "write"], run_update_one_test).await;
 }

src/test/spec/mod.rs

@@ -42,7 +42,7 @@ pub use self::{
 use serde::{de::DeserializeOwned, Deserialize};
 use serde_json::Value;
 
-use crate::bson::Bson;
+use crate::{bson::Bson, test::SERVERLESS};
 
 pub(crate) async fn run_spec_test<T, F, G>(spec: &[&str], run_test_file: F)
 where
@@ -118,3 +118,13 @@ pub(crate) enum Serverless {
     Forbid,
     Allow,
 }
+
+impl Serverless {
+    pub(crate) fn can_run(&self) -> bool {
+        match self {
+            Self::Forbid if *SERVERLESS => false,
+            Self::Require if !*SERVERLESS => false,
+            _ => true,
+        }
+    }
+}

src/test/spec/unified_runner/test_file.rs

@@ -20,7 +20,7 @@ use crate::{
         SelectionCriteria,
         WriteConcern,
     },
-    test::{Serverless, TestClient, DEFAULT_URI, SERVERLESS},
+    test::{Serverless, TestClient, DEFAULT_URI},
 };
 
 #[derive(Debug, Deserialize)]
@@ -107,10 +107,8 @@ impl RunOnRequirement {
             }
         }
         if let Some(ref serverless) = self.serverless {
-            match serverless {
-                Serverless::Forbid if *SERVERLESS => return false,
-                Serverless::Require if !*SERVERLESS => return false,
-                _ => (),
+            if !serverless.can_run() {
+                return false;
             }
         }
         if let Some(ref auth) = self.auth {