RUST-1722 Remove test lock (#945)

Author: isabelatkinson

src/client/session/test.rs

@@ -4,7 +4,6 @@ use std::{future::Future, sync::Arc, time::Duration};
 
 use bson::Document;
 use futures::stream::StreamExt;
-use tokio::sync::RwLockReadGuard;
 
 use crate::{
     bson::{doc, Bson},
@@ -22,7 +21,6 @@ use crate::{
         SdamEvent,
         TestClient,
         CLIENT_OPTIONS,
-        LOCK,
     },
     Client,
     Collection,
@@ -212,8 +210,6 @@ macro_rules! for_each_op {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn pool_is_lifo() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = TestClient::new().await;
     // Wait for the implicit sessions created in TestClient::new to be returned to the pool.
     runtime::delay_for(Duration::from_millis(500)).await;
@@ -248,8 +244,6 @@ async fn pool_is_lifo() {
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 #[function_name::named]
 async fn cluster_time_in_commands() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let test_client = TestClient::new().await;
     if test_client.is_standalone() {
         log_uncaptured("skipping cluster_time_in_commands test due to standalone topology");
@@ -402,8 +396,6 @@ async fn cluster_time_in_commands() {
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 #[function_name::named]
 async fn session_usage() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = TestClient::new().await;
     if client.is_standalone() {
         return;
@@ -432,8 +424,6 @@ async fn session_usage() {
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 #[function_name::named]
 async fn implicit_session_returned_after_immediate_exhaust() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
     if client.is_standalone() {
         return;
@@ -475,8 +465,6 @@ async fn implicit_session_returned_after_immediate_exhaust() {
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 #[function_name::named]
 async fn implicit_session_returned_after_exhaust_by_get_more() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
     if client.is_standalone() {
         return;
@@ -527,8 +515,6 @@ async fn implicit_session_returned_after_exhaust_by_get_more() {
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 #[function_name::named]
 async fn find_and_getmore_share_session() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
     if client.is_standalone() {
         log_uncaptured(

src/client/session/test/causal_consistency.rs

@@ -1,14 +1,13 @@
 use bson::{doc, Document};
 use futures::{future::BoxFuture, FutureExt};
-use tokio::sync::RwLockReadGuard;
 
 use crate::{
     client::options::SessionOptions,
     coll::options::CollectionOptions,
     error::Result,
     event::command::CommandEvent,
     options::ReadConcern,
-    test::{log_uncaptured, EventClient, LOCK},
+    test::{log_uncaptured, EventClient},
     ClientSession,
     Collection,
 };
@@ -146,8 +145,6 @@ fn all_session_ops() -> impl Iterator<Item = Operation> {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn new_session_operation_time_null() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
 
     if client.is_standalone() {
@@ -165,8 +162,6 @@ async fn new_session_operation_time_null() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn first_read_no_after_cluser_time() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
 
     if client.is_standalone() {
@@ -204,8 +199,6 @@ async fn first_read_no_after_cluser_time() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn first_op_update_op_time() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
 
     if client.is_standalone() {
@@ -254,8 +247,6 @@ async fn first_op_update_op_time() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn read_includes_after_cluster_time() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
 
     if client.is_standalone() {
@@ -299,8 +290,6 @@ async fn read_includes_after_cluster_time() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn find_after_write_includes_after_cluster_time() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
 
     if client.is_standalone() {
@@ -341,8 +330,6 @@ async fn find_after_write_includes_after_cluster_time() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn not_causally_consistent_omits_after_cluster_time() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
 
     if client.is_standalone() {
@@ -379,8 +366,6 @@ async fn not_causally_consistent_omits_after_cluster_time() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn omit_after_cluster_time_standalone() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
 
     if !client.is_standalone() {
@@ -414,8 +399,6 @@ async fn omit_after_cluster_time_standalone() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn omit_default_read_concern_level() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
 
     if client.is_standalone() {
@@ -455,8 +438,6 @@ async fn omit_default_read_concern_level() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn test_causal_consistency_read_concern_merge() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
     if client.is_standalone() {
         log_uncaptured(
@@ -505,8 +486,6 @@ async fn test_causal_consistency_read_concern_merge() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn omit_cluster_time_standalone() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
     if !client.is_standalone() {
         log_uncaptured("skipping omit_cluster_time_standalone due to unsupported topology");
@@ -527,8 +506,6 @@ async fn omit_cluster_time_standalone() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn cluster_time_sent_in_commands() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client = EventClient::new().await;
     if client.is_standalone() {
         log_uncaptured("skipping cluster_time_sent_in_commands due to unsupported topology");

src/cmap/test.rs

@@ -4,7 +4,7 @@ mod integration;
 
 use std::{collections::HashMap, ops::Deref, sync::Arc, time::Duration};
 
-use tokio::sync::{Mutex, RwLock, RwLockWriteGuard};
+use tokio::sync::{Mutex, RwLock};
 
 use self::{
     event::EventHandler,
@@ -33,7 +33,6 @@ use crate::{
         MatchErrExt,
         Matchable,
         CLIENT_OPTIONS,
-        LOCK,
     },
 };
 use bson::doc;
@@ -434,8 +433,6 @@ async fn cmap_spec_tests() {
             return;
         }
 
-        let _guard: RwLockWriteGuard<()> = LOCK.run_exclusively().await;
-
         let mut options = CLIENT_OPTIONS.get().await.clone();
         if options.load_balanced.unwrap_or(false) {
             log_uncaptured(format!(

src/cmap/test/integration.rs

@@ -1,5 +1,4 @@
 use serde::Deserialize;
-use tokio::sync::{RwLockReadGuard, RwLockWriteGuard};
 
 use super::{event::EventHandler, EVENT_TIMEOUT};
 use crate::{
@@ -23,7 +22,6 @@ use crate::{
         FailPointMode,
         TestClient,
         CLIENT_OPTIONS,
-        LOCK,
     },
 };
 use semver::VersionReq;
@@ -42,8 +40,6 @@ struct DatabaseEntry {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn acquire_connection_and_send_command() {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
-
     let client_options = CLIENT_OPTIONS.get().await.clone();
     let mut pool_options = ConnectionPoolOptions::from_client_options(&client_options);
     pool_options.ready = Some(true);
@@ -88,8 +84,6 @@ async fn acquire_connection_and_send_command() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test)]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 async fn concurrent_connections() {
-    let _guard = LOCK.run_exclusively().await;
-
     let mut options = CLIENT_OPTIONS.get().await.clone();
     if options.load_balanced.unwrap_or(false) {
         log_uncaptured("skipping concurrent_connections test due to load-balanced topology");
@@ -178,9 +172,8 @@ async fn concurrent_connections() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test(flavor = "multi_thread"))]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 #[function_name::named]
-async fn connection_error_during_establishment() {
-    let _guard: RwLockWriteGuard<_> = LOCK.run_exclusively().await;
 
+async fn connection_error_during_establishment() {
     let mut client_options = CLIENT_OPTIONS.get().await.clone();
     if client_options.load_balanced.unwrap_or(false) {
         log_uncaptured(
@@ -242,9 +235,8 @@ async fn connection_error_during_establishment() {
 #[cfg_attr(feature = "tokio-runtime", tokio::test(flavor = "multi_thread"))]
 #[cfg_attr(feature = "async-std-runtime", async_std::test)]
 #[function_name::named]
-async fn connection_error_during_operation() {
-    let _guard: RwLockWriteGuard<_> = LOCK.run_exclusively().await;
 
+async fn connection_error_during_operation() {
     let mut options = CLIENT_OPTIONS.get().await.clone();
     let handler = Arc::new(EventHandler::new());
     options.cmap_event_handler = Some(handler.clone() as Arc<dyn CmapEventHandler>);

src/compression/test.rs

@@ -9,11 +9,9 @@ use bson::{doc, Bson};
 use crate::{
     client::options::ClientOptions,
     compression::{Compressor, CompressorId, Decoder},
-    test::{TestClient, CLIENT_OPTIONS, LOCK},
+    test::{TestClient, CLIENT_OPTIONS},
 };
 
-use tokio::sync::RwLockReadGuard;
-
 #[cfg(feature = "zlib-compression")]
 #[test]
 fn test_zlib_compressor() {
@@ -110,7 +108,6 @@ async fn ping_server_with_all_compressors() {
 }
 
 async fn send_ping_with_compression(client_options: ClientOptions) {
-    let _guard: RwLockReadGuard<()> = LOCK.run_concurrently().await;
     let client = TestClient::with_options(Some(client_options)).await;
     let ret = client
         .database("admin")