Migrate VC tests to tokio::test

validator_client/src/http_api/test_utils.rs

@@ -25,9 +25,8 @@ use std::marker::PhantomData;
 use std::net::{IpAddr, Ipv4Addr};
 use std::sync::Arc;
 use std::time::Duration;
-use task_executor::TaskExecutor;
+use task_executor::test_utils::TestRuntime;
 use tempfile::{tempdir, TempDir};
-use tokio::runtime::Runtime;
 use tokio::sync::oneshot;
 
 pub const PASSWORD_BYTES: &[u8] = &[42, 50, 37];
@@ -57,23 +56,13 @@ pub struct ApiTester {
     pub initialized_validators: Arc<RwLock<InitializedValidators>>,
     pub validator_store: Arc<ValidatorStore<TestingSlotClock, E>>,
     pub url: SensitiveUrl,
+    pub test_runtime: TestRuntime,
     pub _server_shutdown: oneshot::Sender<()>,
     pub _validator_dir: TempDir,
-    pub _runtime_shutdown: exit_future::Signal,
-}
-
-// Builds a runtime to be used in the testing configuration.
-pub fn build_runtime() -> Arc<Runtime> {
-    Arc::new(
-        tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()
-            .expect("Should be able to build a testing runtime"),
-    )
 }
 
 impl ApiTester {
-    pub async fn new(runtime: std::sync::Weak<Runtime>) -> Self {
+    pub async fn new() -> Self {
         let log = test_logger();
 
         let validator_dir = tempdir().unwrap();
@@ -105,9 +94,7 @@ impl ApiTester {
         let slot_clock =
             TestingSlotClock::new(Slot::new(0), Duration::from_secs(0), Duration::from_secs(1));
 
-        let (runtime_shutdown, exit) = exit_future::signal();
+        let test_runtime = TestRuntime::default();
-        let (shutdown_tx, _) = futures::channel::mpsc::channel(1);
-        let executor = TaskExecutor::new(runtime.clone(), exit, log.clone(), shutdown_tx);
 
         let validator_store = Arc::new(ValidatorStore::<_, E>::new(
             initialized_validators,
@@ -117,7 +104,7 @@ impl ApiTester {
             Some(Arc::new(DoppelgangerService::new(log.clone()))),
             slot_clock,
             &config,
-            executor.clone(),
+            test_runtime.task_executor.clone(),
             log.clone(),
         ));
 
@@ -128,7 +115,7 @@ impl ApiTester {
         let initialized_validators = validator_store.initialized_validators();
 
         let context = Arc::new(Context {
-            task_executor: executor,
+            task_executor: test_runtime.task_executor.clone(),
             api_secret,
             validator_dir: Some(validator_dir.path().into()),
             validator_store: Some(validator_store.clone()),
@@ -166,9 +153,9 @@ impl ApiTester {
             initialized_validators,
             validator_store,
             url,
+            test_runtime,
             _server_shutdown: shutdown_tx,
             _validator_dir: validator_dir,
-            _runtime_shutdown: runtime_shutdown,
         }
     }
 

validator_client/src/http_api/tests.rs

@@ -1,39 +1,31 @@
 #![cfg(test)]
-#![cfg(not(debug_assertions))]
+// #![cfg(not(debug_assertions))]
 
 mod keystores;
 
 use crate::http_api::test_utils::{
-    build_runtime, ApiTester, HdValidatorScenario, KeystoreValidatorScenario,
+    ApiTester, HdValidatorScenario, KeystoreValidatorScenario, Web3SignerValidatorScenario,
-    Web3SignerValidatorScenario, TEST_DEFAULT_FEE_RECIPIENT,
+    TEST_DEFAULT_FEE_RECIPIENT,
 };
 use account_utils::{random_password, random_password_string, ZeroizeString};
 use eth2::lighthouse_vc::types::*;
 use eth2_keystore::KeystoreBuilder;
 use std::future::Future;
-use std::sync::Arc;
 
 type E = MainnetEthSpec;
 
-#[test]
+#[tokio::test]
-fn invalid_pubkey() {
+async fn invalid_pubkey() {
-    let runtime = build_runtime();
+    ApiTester::new()
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
         .await
         .invalidate_api_token()
         .test_get_lighthouse_version_invalid()
         .await;
-    });
 }
 
-#[test]
+#[tokio::test]
-fn routes_with_invalid_auth() {
+async fn routes_with_invalid_auth() {
-    let runtime = build_runtime();
+    ApiTester::new()
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
         .await
         .test_with_invalid_auth(|client| async move { client.get_lighthouse_version().await })
         .await
@@ -43,9 +35,7 @@ fn routes_with_invalid_auth() {
             client.get_lighthouse_spec::<types::Config>().await
         })
         .await
-            .test_with_invalid_auth(
+        .test_with_invalid_auth(|client| async move { client.get_lighthouse_validators().await })
-                |client| async move { client.get_lighthouse_validators().await },
-            )
         .await
         .test_with_invalid_auth(|client| async move {
             client
@@ -130,16 +120,12 @@ fn routes_with_invalid_auth() {
                 })
                 .await
         })
-            .await
+        .await;
-    });
 }
 
-#[test]
+#[tokio::test]
-fn simple_getters() {
+async fn simple_getters() {
-    let runtime = build_runtime();
+    ApiTester::new()
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
         .await
         .test_get_lighthouse_version()
         .await
@@ -147,15 +133,11 @@ fn simple_getters() {
         .await
         .test_get_lighthouse_spec()
         .await;
-    });
 }
 
-#[test]
+#[tokio::test]
-fn hd_validator_creation() {
+async fn hd_validator_creation() {
-    let runtime = build_runtime();
+    ApiTester::new()
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
         .await
         .assert_enabled_validators_count(0)
         .assert_validators_count(0)
@@ -186,15 +168,11 @@ fn hd_validator_creation() {
         .await
         .assert_enabled_validators_count(2)
         .assert_validators_count(3);
-    });
 }
 
-#[test]
+#[tokio::test]
-fn validator_enabling() {
+async fn validator_enabling() {
-    let runtime = build_runtime();
+    ApiTester::new()
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
         .await
         .create_hd_validators(HdValidatorScenario {
             count: 2,
@@ -213,15 +191,11 @@ fn validator_enabling() {
         .await
         .assert_enabled_validators_count(2)
         .assert_validators_count(2);
-    });
 }
 
-#[test]
+#[tokio::test]
-fn validator_gas_limit() {
+async fn validator_gas_limit() {
-    let runtime = build_runtime();
+    ApiTester::new()
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
         .await
         .create_hd_validators(HdValidatorScenario {
             count: 2,
@@ -247,16 +221,12 @@ fn validator_gas_limit() {
         .await
         .assert_enabled_validators_count(2)
         .assert_gas_limit(0, 1000)
-            .await
+        .await;
-    });
 }
 
-#[test]
+#[tokio::test]
-fn validator_builder_proposals() {
+async fn validator_builder_proposals() {
-    let runtime = build_runtime();
+    ApiTester::new()
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
         .await
         .create_hd_validators(HdValidatorScenario {
             count: 2,
@@ -280,16 +250,12 @@ fn validator_builder_proposals() {
         .await
         .assert_enabled_validators_count(2)
         .assert_builder_proposals(0, false)
-            .await
+        .await;
-    });
 }
 
-#[test]
+#[tokio::test]
-fn keystore_validator_creation() {
+async fn keystore_validator_creation() {
-    let runtime = build_runtime();
+    ApiTester::new()
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
         .await
         .assert_enabled_validators_count(0)
         .assert_validators_count(0)
@@ -314,15 +280,11 @@ fn keystore_validator_creation() {
         .await
         .assert_enabled_validators_count(1)
         .assert_validators_count(2);
-    });
 }
 
-#[test]
+#[tokio::test]
-fn web3signer_validator_creation() {
+async fn web3signer_validator_creation() {
-    let runtime = build_runtime();
+    ApiTester::new()
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
         .await
         .assert_enabled_validators_count(0)
         .assert_validators_count(0)
@@ -333,5 +295,4 @@ fn web3signer_validator_creation() {
         .await
         .assert_enabled_validators_count(1)
         .assert_validators_count(1);
-    });
 }

validator_client/src/http_api/tests/keystores.rs

@@ -12,6 +12,7 @@ use itertools::Itertools;
 use rand::{rngs::SmallRng, Rng, SeedableRng};
 use slashing_protection::interchange::{Interchange, InterchangeMetadata};
 use std::{collections::HashMap, path::Path};
+use tokio::runtime::Handle;
 use types::Address;
 
 fn new_keystore(password: ZeroizeString) -> Keystore {
@@ -64,31 +65,23 @@ fn remotekey_validator_with_pubkey(pubkey: PublicKey) -> SingleImportRemotekeysR
     }
 }
 
-fn run_test<F, V>(f: F)
+async fn run_test<F, V>(f: F)
 where
     F: FnOnce(ApiTester) -> V,
     V: Future<Output = ()>,
 {
-    let runtime = build_runtime();
+    let tester = ApiTester::new().await;
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        let tester = ApiTester::new(weak_runtime).await;
     f(tester).await
-    });
 }
 
-fn run_dual_vc_test<F, V>(f: F)
+async fn run_dual_vc_test<F, V>(f: F)
 where
     F: FnOnce(ApiTester, ApiTester) -> V,
     V: Future<Output = ()>,
 {
-    let runtime = build_runtime();
+    let tester1 = ApiTester::new().await;
-    let weak_runtime = Arc::downgrade(&runtime);
+    let tester2 = ApiTester::new().await;
-    runtime.block_on(async {
-        let tester1 = ApiTester::new(weak_runtime.clone()).await;
-        let tester2 = ApiTester::new(weak_runtime).await;
     f(tester1, tester2).await
-    });
 }
 
 fn keystore_pubkey(keystore: &Keystore) -> PublicKeyBytes {
@@ -199,8 +192,8 @@ fn check_remotekey_delete_response(
     }
 }
 
-#[test]
+#[tokio::test]
-fn get_auth_no_token() {
+async fn get_auth_no_token() {
     run_test(|mut tester| async move {
         let _ = &tester;
         tester.client.send_authorization_header(false);
@@ -213,19 +206,21 @@ fn get_auth_no_token() {
         // The token should match the one that the client was originally initialised with.
         assert!(tester.client.api_token() == Some(&token));
     })
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn get_empty_keystores() {
+async fn get_empty_keystores() {
     run_test(|tester| async move {
         let _ = &tester;
         let res = tester.client.get_keystores().await.unwrap();
         assert_eq!(res, ListKeystoresResponse { data: vec![] });
     })
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn import_new_keystores() {
+async fn import_new_keystores() {
     run_test(|tester| async move {
         let _ = &tester;
         let password = random_password_string();
@@ -250,10 +245,11 @@ fn import_new_keystores() {
         let get_res = tester.client.get_keystores().await.unwrap();
         check_keystore_get_response(&get_res, &keystores);
     })
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn import_only_duplicate_keystores() {
+async fn import_only_duplicate_keystores() {
     run_test(|tester| async move {
         let _ = &tester;
         let password = random_password_string();
@@ -279,10 +275,11 @@ fn import_only_duplicate_keystores() {
         let get_res = tester.client.get_keystores().await.unwrap();
         check_keystore_get_response(&get_res, &keystores);
     })
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn import_some_duplicate_keystores() {
+async fn import_some_duplicate_keystores() {
     run_test(|tester| async move {
         let _ = &tester;
         let password = random_password_string();
@@ -330,10 +327,11 @@ fn import_some_duplicate_keystores() {
         let import_res = tester.client.post_keystores(&req2).await.unwrap();
         check_keystore_import_response(&import_res, expected);
     })
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn import_wrong_number_of_passwords() {
+async fn import_wrong_number_of_passwords() {
     run_test(|tester| async move {
         let _ = &tester;
         let password = random_password_string();
@@ -352,10 +350,11 @@ fn import_wrong_number_of_passwords() {
             .unwrap_err();
         assert_eq!(err.status().unwrap(), 400);
     })
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn get_web3_signer_keystores() {
+async fn get_web3_signer_keystores() {
     run_test(|tester| async move {
         let _ = &tester;
         let num_local = 3;
@@ -412,10 +411,11 @@ fn get_web3_signer_keystores() {
             assert!(get_res.data.contains(&response), "{:?}", response);
         }
     })
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn import_and_delete_conflicting_web3_signer_keystores() {
+async fn import_and_delete_conflicting_web3_signer_keystores() {
     run_test(|tester| async move {
         let _ = &tester;
         let num_keystores = 3;
@@ -477,10 +477,11 @@ fn import_and_delete_conflicting_web3_signer_keystores() {
         let delete_res = tester.client.delete_keystores(&delete_req).await.unwrap();
         check_keystore_delete_response(&delete_res, all_delete_error(keystores.len()));
     })
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn import_keystores_wrong_password() {
+async fn import_keystores_wrong_password() {
     run_test(|tester| async move {
         let _ = &tester;
         let num_keystores = 4;
@@ -551,11 +552,12 @@ fn import_keystores_wrong_password() {
             &import_res,
             (0..num_keystores).map(|_| ImportKeystoreStatus::Duplicate),
         );
-    });
+    })
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn import_invalid_slashing_protection() {
+async fn import_invalid_slashing_protection() {
     run_test(|tester| async move {
         let _ = &tester;
         let password = random_password_string();
@@ -589,10 +591,11 @@ fn import_invalid_slashing_protection() {
         let get_res = tester.client.get_keystores().await.unwrap();
         check_keystore_get_response(&get_res, &[]);
     })
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn check_get_set_fee_recipient() {
+async fn check_get_set_fee_recipient() {
     run_test(|tester: ApiTester| async move {
         let _ = &tester;
         let password = random_password_string();
@@ -768,6 +771,7 @@ fn check_get_set_fee_recipient() {
             );
         }
     })
+    .await;
 }
 
 #[test]
@@ -949,8 +953,8 @@ fn all_indices(count: usize) -> Vec<usize> {
     (0..count).collect()
 }
 
-#[test]
+#[tokio::test]
-fn migrate_all_with_slashing_protection() {
+async fn migrate_all_with_slashing_protection() {
     let n = 3;
     generic_migration_test(
         n,
@@ -967,11 +971,12 @@ fn migrate_all_with_slashing_protection() {
             (1, make_attestation(2, 3), false),
             (2, make_attestation(1, 2), false),
         ],
-    );
+    )
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn migrate_some_with_slashing_protection() {
+async fn migrate_some_with_slashing_protection() {
     let n = 3;
     generic_migration_test(
         n,
@@ -989,11 +994,12 @@ fn migrate_some_with_slashing_protection() {
             (0, make_attestation(2, 3), true),
             (1, make_attestation(3, 4), true),
         ],
-    );
+    )
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn migrate_some_missing_slashing_protection() {
+async fn migrate_some_missing_slashing_protection() {
     let n = 3;
     generic_migration_test(
         n,
@@ -1010,11 +1016,12 @@ fn migrate_some_missing_slashing_protection() {
             (1, make_attestation(2, 3), true),
             (0, make_attestation(2, 3), true),
         ],
-    );
+    )
+    .await;
 }
 
-#[test]
+#[tokio::test]
-fn migrate_some_extra_slashing_protection() {
+async fn migrate_some_extra_slashing_protection() {
     let n = 3;
     generic_migration_test(
         n,
@@ -1033,7 +1040,8 @@ fn migrate_some_extra_slashing_protection() {
             (1, make_attestation(3, 4), true),
             (2, make_attestation(2, 3), false),
         ],
-    );
+    )
+    .await;
 }
 
 /// Run a test that creates some validators on one VC, and then migrates them to a second VC.
@@ -1051,7 +1059,7 @@ fn migrate_some_extra_slashing_protection() {
 /// - `import_indices`: validators to transfer. It needn't be a subset of `delete_indices`.
 /// - `second_vc_attestations`: attestations to sign on the second VC after the transfer. The bool
 ///   indicates whether the signing should be successful.
-fn generic_migration_test(
+async fn generic_migration_test(
     num_validators: usize,
     first_vc_attestations: Vec<(usize, Attestation<E>)>,
     delete_indices: Vec<usize>,
@@ -1169,11 +1177,12 @@ fn generic_migration_test(
                 Err(e) => assert!(!should_succeed, "{:?}", e),
             }
         }
-    });
+    })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn delete_keystores_twice() {
+async fn delete_keystores_twice() {
     run_test(|tester| async move {
         let _ = &tester;
         let password = random_password_string();
@@ -1201,10 +1210,11 @@ fn delete_keystores_twice() {
         let delete_res = tester.client.delete_keystores(&delete_req).await.unwrap();
         check_keystore_delete_response(&delete_res, all_not_active(keystores.len()));
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn delete_nonexistent_keystores() {
+async fn delete_nonexistent_keystores() {
     run_test(|tester| async move {
         let _ = &tester;
         let password = random_password_string();
@@ -1219,6 +1229,7 @@ fn delete_nonexistent_keystores() {
         let delete_res = tester.client.delete_keystores(&delete_req).await.unwrap();
         check_keystore_delete_response(&delete_res, all_not_found(keystores.len()));
     })
+    .await
 }
 
 fn make_attestation(source_epoch: u64, target_epoch: u64) -> Attestation<E> {
@@ -1242,9 +1253,9 @@ fn make_attestation(source_epoch: u64, target_epoch: u64) -> Attestation<E> {
     }
 }
 
-#[test]
+#[tokio::test]
-fn delete_concurrent_with_signing() {
+async fn delete_concurrent_with_signing() {
-    let runtime = build_runtime();
+    let handle = Handle::try_current().unwrap();
     let num_keys = 8;
     let num_signing_threads = 8;
     let num_attestations = 100;
@@ -1257,9 +1268,7 @@ fn delete_concurrent_with_signing() {
         "num_keys should be divisible by num threads for simplicity"
     );
 
-    let weak_runtime = Arc::downgrade(&runtime);
+    let tester = ApiTester::new().await;
-    runtime.block_on(async {
-        let tester = ApiTester::new(weak_runtime).await;
 
     // Generate a lot of keys and import them.
     let password = random_password_string();
@@ -1289,7 +1298,7 @@ fn delete_concurrent_with_signing() {
             [thread_index * keys_per_thread..(thread_index + 1) * keys_per_thread]
             .to_vec();
 
-            let handle = runtime.spawn(async move {
+        let handle = handle.spawn(async move {
             for j in 0..num_attestations {
                 let mut att = make_attestation(j, j + 1);
                 for (_validator_id, public_key) in thread_pubkeys.iter().enumerate() {
@@ -1309,7 +1318,7 @@ fn delete_concurrent_with_signing() {
         let client = tester.client.clone();
         let all_pubkeys = all_pubkeys.clone();
 
-            let handle = runtime.spawn(async move {
+        let handle = handle.spawn(async move {
             let mut rng = SmallRng::from_entropy();
 
             let mut slashing_protection = vec![];
@@ -1360,12 +1369,11 @@ fn delete_concurrent_with_signing() {
         }
     }
 
-        futures::future::join_all(join_handles).await
+    futures::future::join_all(join_handles).await;
-    });
 }
 
-#[test]
+#[tokio::test]
-fn delete_then_reimport() {
+async fn delete_then_reimport() {
     run_test(|tester| async move {
         let _ = &tester;
         let password = random_password_string();
@@ -1396,19 +1404,21 @@ fn delete_then_reimport() {
         let import_res = tester.client.post_keystores(&import_req).await.unwrap();
         check_keystore_import_response(&import_res, all_imported(keystores.len()));
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn get_empty_remotekeys() {
+async fn get_empty_remotekeys() {
     run_test(|tester| async move {
         let _ = &tester;
         let res = tester.client.get_remotekeys().await.unwrap();
         assert_eq!(res, ListRemotekeysResponse { data: vec![] });
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn import_new_remotekeys() {
+async fn import_new_remotekeys() {
     run_test(|tester| async move {
         let _ = &tester;
 
@@ -1443,10 +1453,11 @@ fn import_new_remotekeys() {
         let get_res = tester.client.get_remotekeys().await.unwrap();
         check_remotekey_get_response(&get_res, expected_responses);
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn import_same_remotekey_different_url() {
+async fn import_same_remotekey_different_url() {
     run_test(|tester| async move {
         let _ = &tester;
 
@@ -1485,10 +1496,11 @@ fn import_same_remotekey_different_url() {
             }],
         );
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn delete_remotekey_then_reimport_different_url() {
+async fn delete_remotekey_then_reimport_different_url() {
     run_test(|tester| async move {
         let _ = &tester;
 
@@ -1534,10 +1546,11 @@ fn delete_remotekey_then_reimport_different_url() {
             vec![ImportRemotekeyStatus::Imported].into_iter(),
         );
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn import_only_duplicate_remotekeys() {
+async fn import_only_duplicate_remotekeys() {
     run_test(|tester| async move {
         let _ = &tester;
         let remotekeys = (0..3)
@@ -1582,10 +1595,11 @@ fn import_only_duplicate_remotekeys() {
         let get_res = tester.client.get_remotekeys().await.unwrap();
         check_remotekey_get_response(&get_res, expected_responses);
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn import_some_duplicate_remotekeys() {
+async fn import_some_duplicate_remotekeys() {
     run_test(|tester| async move {
         let _ = &tester;
         let num_remotekeys = 5;
@@ -1649,10 +1663,11 @@ fn import_some_duplicate_remotekeys() {
         let get_res = tester.client.get_remotekeys().await.unwrap();
         check_remotekey_get_response(&get_res, expected_responses);
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn import_remote_and_local_keys() {
+async fn import_remote_and_local_keys() {
     run_test(|tester| async move {
         let _ = &tester;
         let num_local = 3;
@@ -1714,10 +1729,11 @@ fn import_remote_and_local_keys() {
             assert!(get_res.data.contains(&response), "{:?}", response);
         }
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn import_same_local_and_remote_keys() {
+async fn import_same_local_and_remote_keys() {
     run_test(|tester| async move {
         let _ = &tester;
         let num_local = 3;
@@ -1782,9 +1798,10 @@ fn import_same_local_and_remote_keys() {
             assert!(get_res.data.contains(&response), "{:?}", response);
         }
     })
+    .await
 }
-#[test]
+#[tokio::test]
-fn import_same_remote_and_local_keys() {
+async fn import_same_remote_and_local_keys() {
     run_test(|tester| async move {
         let _ = &tester;
         let num_local = 3;
@@ -1847,10 +1864,11 @@ fn import_same_remote_and_local_keys() {
         let get_res = tester.client.get_remotekeys().await.unwrap();
         check_remotekey_get_response(&get_res, expected_responses);
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn delete_remotekeys_twice() {
+async fn delete_remotekeys_twice() {
     run_test(|tester| async move {
         let _ = &tester;
 
@@ -1893,10 +1911,11 @@ fn delete_remotekeys_twice() {
         let get_res = tester.client.get_remotekeys().await.unwrap();
         check_remotekey_get_response(&get_res, Vec::new());
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn delete_nonexistent_remotekey() {
+async fn delete_nonexistent_remotekey() {
     run_test(|tester| async move {
         let _ = &tester;
 
@@ -1919,10 +1938,11 @@ fn delete_nonexistent_remotekey() {
         let get_res = tester.client.get_remotekeys().await.unwrap();
         check_remotekey_get_response(&get_res, Vec::new());
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn delete_then_reimport_remotekeys() {
+async fn delete_then_reimport_remotekeys() {
     run_test(|tester| async move {
         let _ = &tester;
 
@@ -1984,10 +2004,11 @@ fn delete_then_reimport_remotekeys() {
         let get_res = tester.client.get_remotekeys().await.unwrap();
         check_remotekey_get_response(&get_res, expected_responses);
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn import_remotekey_web3signer() {
+async fn import_remotekey_web3signer() {
     run_test(|tester| async move {
         let _ = &tester;
 
@@ -2043,10 +2064,11 @@ fn import_remotekey_web3signer() {
         let get_res = tester.client.get_remotekeys().await.unwrap();
         check_remotekey_get_response(&get_res, expected_responses);
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn import_remotekey_web3signer_disabled() {
+async fn import_remotekey_web3signer_disabled() {
     run_test(|tester| async move {
         let _ = &tester;
 
@@ -2096,10 +2118,11 @@ fn import_remotekey_web3signer_disabled() {
         let get_res = tester.client.get_remotekeys().await.unwrap();
         check_remotekey_get_response(&get_res, expected_responses);
     })
+    .await
 }
 
-#[test]
+#[tokio::test]
-fn import_remotekey_web3signer_enabled() {
+async fn import_remotekey_web3signer_enabled() {
     run_test(|tester| async move {
         let _ = &tester;
 
@@ -2156,4 +2179,5 @@ fn import_remotekey_web3signer_enabled() {
         let get_res = tester.client.get_remotekeys().await.unwrap();
         check_remotekey_get_response(&get_res, expected_responses);
     })
+    .await
 }