RUST-768 Test that versioned API options are passed to transaction-continuing commands (#342)

Author: isabelatkinson

src/sync/test.rs

@@ -187,12 +187,10 @@ fn typed_collection() {
 #[test]
 #[function_name::named]
 fn transactions() {
-    let (should_skip, should_create_collection) = RUNTIME.block_on(async {
+    let should_skip = RUNTIME.block_on(async {
         let test_client = AsyncTestClient::new().await;
         // TODO RUST-122: Unskip this test on sharded clusters
-        let should_skip = !test_client.is_replica_set() || test_client.server_version_lt(4, 0);
-        let should_create_collection = test_client.server_version_lt(4, 4);
-        (should_skip, should_create_collection)
+        !test_client.is_replica_set() || test_client.server_version_lt(4, 0)
     });
     if should_skip {
         return;
@@ -205,12 +203,10 @@ fn transactions() {
         .expect("session creation should succeed");
     let coll = init_db_and_typed_coll(&client, function_name!(), function_name!());
 
-    if should_create_collection {
-        client
-            .database(function_name!())
-            .create_collection(function_name!(), None)
-            .expect("create collection should succeed");
-    }
+    client
+        .database(function_name!())
+        .create_collection(function_name!(), None)
+        .expect("create collection should succeed");
 
     session
         .start_transaction(None)

src/test/spec/mod.rs

@@ -16,6 +16,7 @@ mod sessions;
 mod transactions;
 mod unified_runner;
 mod v2_runner;
+mod versioned_api;
 
 use std::{
     convert::TryFrom,

src/test/spec/transactions.rs

@@ -2,15 +2,13 @@ use serde::{Deserialize, Serialize};
 use tokio::sync::{RwLockReadGuard, RwLockWriteGuard};
 
 use crate::{
-    bson::{serde_helpers::serialize_u64_as_i32, Document},
+    bson::{doc, serde_helpers::serialize_u64_as_i32, Document},
     client::session::TransactionState,
     test::{run_spec_test, TestClient, LOCK},
 };
 
 use super::run_v2_test;
 
-use crate::bson::doc;
-
 #[cfg_attr(feature = "tokio-runtime", tokio::test(flavor = "multi_thread"))]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn run() {

src/test/spec/unified_runner/mod.rs

@@ -255,10 +255,3 @@ async fn test_examples() {
     let _guard: RwLockWriteGuard<_> = LOCK.run_exclusively().await;
     run_spec_test(&["unified-runner-examples"], run_unified_format_test).await;
 }
-
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn test_versioned_api() {
-    let _guard: RwLockWriteGuard<_> = LOCK.run_exclusively().await;
-    run_spec_test(&["versioned-api"], run_unified_format_test).await;
-}

src/test/spec/versioned_api.rs

@@ -0,0 +1,69 @@
+use tokio::sync::{RwLockReadGuard, RwLockWriteGuard};
+
+use crate::{
+    bson::doc,
+    options::{ServerApi, ServerApiVersion},
+    test::{run_spec_test, EventClient, TestClient, CLIENT_OPTIONS, LOCK},
+};
+
+use super::run_unified_format_test;
+
+#[cfg_attr(feature = "tokio-runtime", tokio::test)]
+#[cfg_attr(feature = "async-std-runtime", async_std::test)]
+async fn run() {
+    let _guard: RwLockWriteGuard<_> = LOCK.run_exclusively().await;
+    // TODO RUST-725 Unskip these tests on 5.0
+    if TestClient::new().await.server_version_gte(5, 0) {
+        return;
+    }
+    run_spec_test(&["versioned-api"], run_unified_format_test).await;
+}
+
+// TODO RUST-817 Remove this test in favor of transaction-handling.json versioned API spec test when
+// transactions are implemented in the unified runner
+#[cfg_attr(feature = "tokio-runtime", tokio::test)]
+#[cfg_attr(feature = "async-std-runtime", async_std::test)]
+#[function_name::named]
+async fn transaction_handling() {
+    let _guard: RwLockReadGuard<_> = LOCK.run_concurrently().await;
+
+    let version = ServerApi::builder()
+        .version(ServerApiVersion::Version1)
+        .build();
+
+    let mut options = CLIENT_OPTIONS.clone();
+    options.server_api = Some(version);
+    let client = EventClient::with_options(options).await;
+    if !client.is_replica_set() || client.server_version_lt(5, 0) {
+        return;
+    }
+
+    let mut session = client.start_session(None).await.unwrap();
+    session.start_transaction(None).await.unwrap();
+
+    let coll = client
+        .database(function_name!())
+        .collection(function_name!());
+
+    coll.insert_one_with_session(doc! { "x": 1 }, None, &mut session)
+        .await
+        .unwrap();
+    session.commit_transaction().await.unwrap();
+    session.commit_transaction().await.unwrap();
+
+    session.start_transaction(None).await.unwrap();
+
+    coll.insert_one_with_session(doc! { "y": 2 }, None, &mut session)
+        .await
+        .unwrap();
+    session.abort_transaction().await.unwrap();
+    session
+        .abort_transaction()
+        .await
+        .expect_err("aborting twice should fail");
+
+    let events = client.get_all_command_started_events();
+    for event in events {
+        assert!(event.command.contains_key("apiVersion"));
+    }
+}