RUST-1102 Run sync tests with #[test] attribute (#593)

Author: isabelatkinson

src/bson_util/mod.rs

@@ -217,9 +217,8 @@ pub(crate) fn read_document_bytes<R: Read>(mut reader: R) -> Result<Vec<u8>> {
 mod test {
     use crate::bson_util::num_decimal_digits;
 
-    #[cfg_attr(feature = "tokio-runtime", tokio::test)]
-    #[cfg_attr(feature = "async-std-runtime", async_std::test)]
-    async fn num_digits() {
+    #[test]
+    fn num_digits() {
         assert_eq!(num_decimal_digits(0), 1);
         assert_eq!(num_decimal_digits(1), 1);
         assert_eq!(num_decimal_digits(10), 2);

src/client/auth/scram.rs

@@ -721,9 +721,8 @@ mod tests {
 
     use super::ServerFirst;
 
-    #[cfg_attr(feature = "tokio-runtime", tokio::test)]
-    #[cfg_attr(feature = "async-std-runtime", async_std::test)]
-    async fn test_iteration_count() {
+    #[test]
+    fn test_iteration_count() {
         let nonce = "mocked";
 
         let invalid_iteration_count = ServerFirst {

src/client/auth/test.rs

@@ -11,9 +11,8 @@ lazy_static! {
     ];
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn negotiate_both_scram() {
+#[test]
+fn negotiate_both_scram() {
     let description_both = StreamDescription {
         sasl_supported_mechs: Some(MECHS.to_vec()),
         ..Default::default()
@@ -24,9 +23,8 @@ async fn negotiate_both_scram() {
     );
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn negotiate_sha1_only() {
+#[test]
+fn negotiate_sha1_only() {
     let description_sha1 = StreamDescription {
         sasl_supported_mechs: Some(MECHS[0..=0].to_vec()),
         ..Default::default()
@@ -37,9 +35,8 @@ async fn negotiate_sha1_only() {
     );
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn negotiate_sha256_only() {
+#[test]
+fn negotiate_sha256_only() {
     let description_sha256 = StreamDescription {
         sasl_supported_mechs: Some(MECHS[1..=1].to_vec()),
         ..Default::default()
@@ -50,19 +47,17 @@ async fn negotiate_sha256_only() {
     );
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn negotiate_none() {
+#[test]
+fn negotiate_none() {
     let description_none: StreamDescription = Default::default();
     assert_eq!(
         AuthMechanism::from_stream_description(&description_none),
         AuthMechanism::ScramSha1
     );
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn negotiate_mangled() {
+#[test]
+fn negotiate_mangled() {
     let description_mangled = StreamDescription {
         sasl_supported_mechs: Some(["NOT A MECHANISM".to_string(), "OTHER".to_string()].to_vec()),
         ..Default::default()
@@ -89,16 +84,14 @@ fn scram_sasl_first_options(mechanism: AuthMechanism) {
     }
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn sasl_first_options_specified() {
+#[test]
+fn sasl_first_options_specified() {
     scram_sasl_first_options(AuthMechanism::ScramSha1);
     scram_sasl_first_options(AuthMechanism::ScramSha256);
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn sasl_first_options_not_specified() {
+#[test]
+fn sasl_first_options_not_specified() {
     let sasl_first = SaslStart::new(String::new(), AuthMechanism::MongoDbX509, Vec::new(), None);
     let command = sasl_first.into_command();
     assert!(

src/client/options/mod.rs

@@ -2334,10 +2334,6 @@ mod tests {
         );
     }
 
-    #[cfg_attr(feature = "tokio-runtime", tokio::test)]
-    #[cfg_attr(feature = "async-std-runtime", async_std::test)]
-    async fn with_invalid_read_preference_mode() {}
-
     #[cfg_attr(feature = "tokio-runtime", tokio::test)]
     #[cfg_attr(feature = "async-std-runtime", async_std::test)]
     async fn with_mixed_options() {

src/operation/aggregate/test.rs

@@ -40,9 +40,8 @@ fn build_test(
     assert_eq!(cmd_doc, expected_body);
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn build() {
+#[test]
+fn build() {
     let ns = Namespace {
         db: "test_db".to_string(),
         coll: "test_coll".to_string(),
@@ -74,9 +73,8 @@ async fn build() {
     build_test(ns, pipeline, Some(options), expected_body);
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn build_batch_size() {
+#[test]
+fn build_batch_size() {
     let ns = Namespace {
         db: "test_db".to_string(),
         coll: "test_coll".to_string(),
@@ -128,9 +126,8 @@ async fn build_batch_size() {
     build_test(ns, merge_pipeline, Some(batch_size_options), expected_body);
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn build_target() {
+#[test]
+fn build_target() {
     let pipeline = Vec::new();
 
     let ns = Namespace {
@@ -155,9 +152,8 @@ async fn build_target() {
     build_test(ns.db, pipeline, None, expected_body);
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn build_max_await_time() {
+#[test]
+fn build_max_await_time() {
     let options = AggregateOptions::builder()
         .max_await_time(Duration::from_millis(5))
         .max_time(Duration::from_millis(10))
@@ -174,9 +170,8 @@ async fn build_max_await_time() {
     build_test("test_db".to_string(), Vec::new(), Some(options), body);
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn op_selection_criteria() {
+#[test]
+fn op_selection_criteria() {
     test::op_selection_criteria(|selection_criteria| {
         let options = AggregateOptions {
             selection_criteria,
@@ -186,9 +181,8 @@ async fn op_selection_criteria() {
     });
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn handle_max_await_time() {
+#[test]
+fn handle_max_await_time() {
     let response = doc! {
         "ok": 1,
         "cursor": {
@@ -211,9 +205,8 @@ async fn handle_max_await_time() {
     assert_eq!(spec.max_time(), Some(max_await));
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn handle_write_concern_error() {
+#[test]
+fn handle_write_concern_error() {
     let response = doc! {
         "ok": 1.0,
         "cursor": {
@@ -244,9 +237,8 @@ async fn handle_write_concern_error() {
     }
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn handle_invalid_response() {
+#[test]
+fn handle_invalid_response() {
     let aggregate = Aggregate::empty();
 
     let garbled = doc! { "asdfasf": "ASdfasdf" };

src/operation/count/test.rs

@@ -15,9 +15,8 @@ use crate::{
     options::ReadConcernLevel,
 };
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn build() {
+#[test]
+fn build() {
     let ns = Namespace {
         db: "test_db".to_string(),
         coll: "test_coll".to_string(),
@@ -35,9 +34,8 @@ async fn build() {
     assert_eq!(count_command.target_db, "test_db");
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn build_with_options() {
+#[test]
+fn build_with_options() {
     let read_concern: ReadConcern = ReadConcernLevel::Local.into();
     let max_time = Duration::from_millis(2_u64);
     let options: EstimatedDocumentCountOptions = EstimatedDocumentCountOptions::builder()
@@ -71,9 +69,8 @@ async fn build_with_options() {
     assert_eq!(cmd_doc, expected_body);
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn op_selection_criteria() {
+#[test]
+fn op_selection_criteria() {
     test::op_selection_criteria(|selection_criteria| {
         let options = EstimatedDocumentCountOptions {
             selection_criteria,
@@ -83,9 +80,8 @@ async fn op_selection_criteria() {
     });
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn handle_success() {
+#[test]
+fn handle_success() {
     let count_op = Count::empty();
 
     let n = 26;
@@ -95,9 +91,8 @@ async fn handle_success() {
     assert_eq!(actual_values, n);
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn handle_success_agg() {
+#[test]
+fn handle_success_agg() {
     let count_op = Count::empty();
 
     let n = 26;
@@ -116,9 +111,8 @@ async fn handle_success_agg() {
     assert_eq!(actual_values, n);
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn handle_response_no_n() {
+#[test]
+fn handle_response_no_n() {
     let count_op = Count::empty();
     handle_response_test(&count_op, doc! { "ok": 1.0 }).unwrap_err();
 }

src/operation/count_documents/test.rs

@@ -13,9 +13,8 @@ use crate::{
 
 use super::CountDocuments;
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn build() {
+#[test]
+fn build() {
     let ns = Namespace {
         db: "test_db".to_string(),
         coll: "test_coll".to_string(),
@@ -41,9 +40,8 @@ async fn build() {
     assert_eq!(count_command.target_db, "test_db");
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn build_with_options() {
+#[test]
+fn build_with_options() {
     let skip = 2;
     let limit = 5;
     let options = CountOptions::builder()
@@ -84,9 +82,8 @@ async fn build_with_options() {
     assert_eq!(cmd_doc, expected_body);
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn op_selection_criteria() {
+#[test]
+fn op_selection_criteria() {
     test::op_selection_criteria(|selection_criteria| {
         let options = CountOptions {
             selection_criteria,
@@ -96,9 +93,8 @@ async fn op_selection_criteria() {
     });
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn handle_success() {
+#[test]
+fn handle_success() {
     let ns = Namespace {
         db: "test_db".to_string(),
         coll: "test_coll".to_string(),

src/operation/create/test.rs

@@ -8,9 +8,8 @@ use crate::{
     Namespace,
 };
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn build() {
+#[test]
+fn build() {
     let mut op = Create::new(
         Namespace {
             db: "test_db".to_string(),
@@ -43,9 +42,8 @@ async fn build() {
     );
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn build_validator() {
+#[test]
+fn build_validator() {
     let query = doc! { "x": { "$gt": 1 } };
     let mut op = Create::new(
         Namespace {
@@ -72,16 +70,14 @@ async fn build_validator() {
     );
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn handle_success() {
+#[test]
+fn handle_success() {
     let op = Create::empty();
     handle_response_test(&op, doc! { "ok": 1.0 }).unwrap();
 }
 
-#[cfg_attr(feature = "tokio-runtime", tokio::test)]
-#[cfg_attr(feature = "async-std-runtime", async_std::test)]
-async fn handle_write_concern_error() {
+#[test]
+fn handle_write_concern_error() {
     let op = Create::empty();
 
     let response = doc! {