diff --git a/validator_client/src/http_api/test_utils.rs b/validator_client/src/http_api/test_utils.rs
index 45282c8fd2..3e670c4914 100644
--- a/validator_client/src/http_api/test_utils.rs
+++ b/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 (shutdown_tx, _) = futures::channel::mpsc::channel(1);
-        let executor = TaskExecutor::new(runtime.clone(), exit, log.clone(), shutdown_tx);
+        let test_runtime = TestRuntime::default();
 
         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,
         }
     }
 
diff --git a/validator_client/src/http_api/tests.rs b/validator_client/src/http_api/tests.rs
index 2fa4662226..6de088c37c 100644
--- a/validator_client/src/http_api/tests.rs
+++ b/validator_client/src/http_api/tests.rs
@@ -1,337 +1,298 @@
 #![cfg(test)]
-#![cfg(not(debug_assertions))]
+// #![cfg(not(debug_assertions))]
 
 mod keystores;
 
 use crate::http_api::test_utils::{
-    build_runtime, ApiTester, HdValidatorScenario, KeystoreValidatorScenario,
-    Web3SignerValidatorScenario, TEST_DEFAULT_FEE_RECIPIENT,
+    ApiTester, HdValidatorScenario, KeystoreValidatorScenario, Web3SignerValidatorScenario,
+    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]
-fn invalid_pubkey() {
-    let runtime = build_runtime();
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
-            .await
-            .invalidate_api_token()
-            .test_get_lighthouse_version_invalid()
-            .await;
-    });
+#[tokio::test]
+async fn invalid_pubkey() {
+    ApiTester::new()
+        .await
+        .invalidate_api_token()
+        .test_get_lighthouse_version_invalid()
+        .await;
 }
 
-#[test]
-fn routes_with_invalid_auth() {
-    let runtime = build_runtime();
-    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
-            .test_with_invalid_auth(|client| async move { client.get_lighthouse_health().await })
-            .await
-            .test_with_invalid_auth(|client| async move {
-                client.get_lighthouse_spec::<types::Config>().await
-            })
-            .await
-            .test_with_invalid_auth(
-                |client| async move { client.get_lighthouse_validators().await },
-            )
-            .await
-            .test_with_invalid_auth(|client| async move {
-                client
-                    .get_lighthouse_validators_pubkey(&PublicKeyBytes::empty())
-                    .await
-            })
-            .await
-            .test_with_invalid_auth(|client| async move {
-                client
-                    .post_lighthouse_validators(vec![ValidatorRequest {
-                        enable: <_>::default(),
-                        description: <_>::default(),
-                        graffiti: <_>::default(),
-                        suggested_fee_recipient: <_>::default(),
-                        gas_limit: <_>::default(),
-                        builder_proposals: <_>::default(),
-                        deposit_gwei: <_>::default(),
-                    }])
-                    .await
-            })
-            .await
-            .test_with_invalid_auth(|client| async move {
-                client
-                    .post_lighthouse_validators_mnemonic(&CreateValidatorsMnemonicRequest {
-                        mnemonic: String::default().into(),
-                        key_derivation_path_offset: <_>::default(),
-                        validators: <_>::default(),
-                    })
-                    .await
-            })
-            .await
-            .test_with_invalid_auth(|client| async move {
-                let password = random_password();
-                let keypair = Keypair::random();
-                let keystore = KeystoreBuilder::new(&keypair, password.as_bytes(), String::new())
-                    .unwrap()
-                    .build()
-                    .unwrap();
-                client
-                    .post_lighthouse_validators_keystore(&KeystoreValidatorsPostRequest {
-                        password: String::default().into(),
-                        enable: <_>::default(),
-                        keystore,
-                        graffiti: <_>::default(),
-                        suggested_fee_recipient: <_>::default(),
-                        gas_limit: <_>::default(),
-                        builder_proposals: <_>::default(),
-                    })
-                    .await
-            })
-            .await
-            .test_with_invalid_auth(|client| async move {
-                client
-                    .patch_lighthouse_validators(&PublicKeyBytes::empty(), Some(false), None, None)
-                    .await
-            })
-            .await
-            .test_with_invalid_auth(|client| async move { client.get_keystores().await })
-            .await
-            .test_with_invalid_auth(|client| async move {
-                let password = random_password_string();
-                let keypair = Keypair::random();
-                let keystore = KeystoreBuilder::new(&keypair, password.as_ref(), String::new())
-                    .unwrap()
-                    .build()
-                    .map(KeystoreJsonStr)
-                    .unwrap();
-                client
-                    .post_keystores(&ImportKeystoresRequest {
-                        keystores: vec![keystore],
-                        passwords: vec![password],
-                        slashing_protection: None,
-                    })
-                    .await
-            })
-            .await
-            .test_with_invalid_auth(|client| async move {
-                let keypair = Keypair::random();
-                client
-                    .delete_keystores(&DeleteKeystoresRequest {
-                        pubkeys: vec![keypair.pk.compress()],
-                    })
-                    .await
-            })
-            .await
-    });
+#[tokio::test]
+async fn routes_with_invalid_auth() {
+    ApiTester::new()
+        .await
+        .test_with_invalid_auth(|client| async move { client.get_lighthouse_version().await })
+        .await
+        .test_with_invalid_auth(|client| async move { client.get_lighthouse_health().await })
+        .await
+        .test_with_invalid_auth(|client| async move {
+            client.get_lighthouse_spec::<types::Config>().await
+        })
+        .await
+        .test_with_invalid_auth(|client| async move { client.get_lighthouse_validators().await })
+        .await
+        .test_with_invalid_auth(|client| async move {
+            client
+                .get_lighthouse_validators_pubkey(&PublicKeyBytes::empty())
+                .await
+        })
+        .await
+        .test_with_invalid_auth(|client| async move {
+            client
+                .post_lighthouse_validators(vec![ValidatorRequest {
+                    enable: <_>::default(),
+                    description: <_>::default(),
+                    graffiti: <_>::default(),
+                    suggested_fee_recipient: <_>::default(),
+                    gas_limit: <_>::default(),
+                    builder_proposals: <_>::default(),
+                    deposit_gwei: <_>::default(),
+                }])
+                .await
+        })
+        .await
+        .test_with_invalid_auth(|client| async move {
+            client
+                .post_lighthouse_validators_mnemonic(&CreateValidatorsMnemonicRequest {
+                    mnemonic: String::default().into(),
+                    key_derivation_path_offset: <_>::default(),
+                    validators: <_>::default(),
+                })
+                .await
+        })
+        .await
+        .test_with_invalid_auth(|client| async move {
+            let password = random_password();
+            let keypair = Keypair::random();
+            let keystore = KeystoreBuilder::new(&keypair, password.as_bytes(), String::new())
+                .unwrap()
+                .build()
+                .unwrap();
+            client
+                .post_lighthouse_validators_keystore(&KeystoreValidatorsPostRequest {
+                    password: String::default().into(),
+                    enable: <_>::default(),
+                    keystore,
+                    graffiti: <_>::default(),
+                    suggested_fee_recipient: <_>::default(),
+                    gas_limit: <_>::default(),
+                    builder_proposals: <_>::default(),
+                })
+                .await
+        })
+        .await
+        .test_with_invalid_auth(|client| async move {
+            client
+                .patch_lighthouse_validators(&PublicKeyBytes::empty(), Some(false), None, None)
+                .await
+        })
+        .await
+        .test_with_invalid_auth(|client| async move { client.get_keystores().await })
+        .await
+        .test_with_invalid_auth(|client| async move {
+            let password = random_password_string();
+            let keypair = Keypair::random();
+            let keystore = KeystoreBuilder::new(&keypair, password.as_ref(), String::new())
+                .unwrap()
+                .build()
+                .map(KeystoreJsonStr)
+                .unwrap();
+            client
+                .post_keystores(&ImportKeystoresRequest {
+                    keystores: vec![keystore],
+                    passwords: vec![password],
+                    slashing_protection: None,
+                })
+                .await
+        })
+        .await
+        .test_with_invalid_auth(|client| async move {
+            let keypair = Keypair::random();
+            client
+                .delete_keystores(&DeleteKeystoresRequest {
+                    pubkeys: vec![keypair.pk.compress()],
+                })
+                .await
+        })
+        .await;
 }
 
-#[test]
-fn simple_getters() {
-    let runtime = build_runtime();
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
-            .await
-            .test_get_lighthouse_version()
-            .await
-            .test_get_lighthouse_health()
-            .await
-            .test_get_lighthouse_spec()
-            .await;
-    });
+#[tokio::test]
+async fn simple_getters() {
+    ApiTester::new()
+        .await
+        .test_get_lighthouse_version()
+        .await
+        .test_get_lighthouse_health()
+        .await
+        .test_get_lighthouse_spec()
+        .await;
 }
 
-#[test]
-fn hd_validator_creation() {
-    let runtime = build_runtime();
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
-            .await
-            .assert_enabled_validators_count(0)
-            .assert_validators_count(0)
-            .create_hd_validators(HdValidatorScenario {
-                count: 2,
-                specify_mnemonic: true,
-                key_derivation_path_offset: 0,
-                disabled: vec![],
-            })
-            .await
-            .assert_enabled_validators_count(2)
-            .assert_validators_count(2)
-            .create_hd_validators(HdValidatorScenario {
-                count: 1,
-                specify_mnemonic: false,
-                key_derivation_path_offset: 0,
-                disabled: vec![0],
-            })
-            .await
-            .assert_enabled_validators_count(2)
-            .assert_validators_count(3)
-            .create_hd_validators(HdValidatorScenario {
-                count: 0,
-                specify_mnemonic: true,
-                key_derivation_path_offset: 4,
-                disabled: vec![],
-            })
-            .await
-            .assert_enabled_validators_count(2)
-            .assert_validators_count(3);
-    });
+#[tokio::test]
+async fn hd_validator_creation() {
+    ApiTester::new()
+        .await
+        .assert_enabled_validators_count(0)
+        .assert_validators_count(0)
+        .create_hd_validators(HdValidatorScenario {
+            count: 2,
+            specify_mnemonic: true,
+            key_derivation_path_offset: 0,
+            disabled: vec![],
+        })
+        .await
+        .assert_enabled_validators_count(2)
+        .assert_validators_count(2)
+        .create_hd_validators(HdValidatorScenario {
+            count: 1,
+            specify_mnemonic: false,
+            key_derivation_path_offset: 0,
+            disabled: vec![0],
+        })
+        .await
+        .assert_enabled_validators_count(2)
+        .assert_validators_count(3)
+        .create_hd_validators(HdValidatorScenario {
+            count: 0,
+            specify_mnemonic: true,
+            key_derivation_path_offset: 4,
+            disabled: vec![],
+        })
+        .await
+        .assert_enabled_validators_count(2)
+        .assert_validators_count(3);
 }
 
-#[test]
-fn validator_enabling() {
-    let runtime = build_runtime();
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
-            .await
-            .create_hd_validators(HdValidatorScenario {
-                count: 2,
-                specify_mnemonic: false,
-                key_derivation_path_offset: 0,
-                disabled: vec![],
-            })
-            .await
-            .assert_enabled_validators_count(2)
-            .assert_validators_count(2)
-            .set_validator_enabled(0, false)
-            .await
-            .assert_enabled_validators_count(1)
-            .assert_validators_count(2)
-            .set_validator_enabled(0, true)
-            .await
-            .assert_enabled_validators_count(2)
-            .assert_validators_count(2);
-    });
+#[tokio::test]
+async fn validator_enabling() {
+    ApiTester::new()
+        .await
+        .create_hd_validators(HdValidatorScenario {
+            count: 2,
+            specify_mnemonic: false,
+            key_derivation_path_offset: 0,
+            disabled: vec![],
+        })
+        .await
+        .assert_enabled_validators_count(2)
+        .assert_validators_count(2)
+        .set_validator_enabled(0, false)
+        .await
+        .assert_enabled_validators_count(1)
+        .assert_validators_count(2)
+        .set_validator_enabled(0, true)
+        .await
+        .assert_enabled_validators_count(2)
+        .assert_validators_count(2);
 }
 
-#[test]
-fn validator_gas_limit() {
-    let runtime = build_runtime();
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
-            .await
-            .create_hd_validators(HdValidatorScenario {
-                count: 2,
-                specify_mnemonic: false,
-                key_derivation_path_offset: 0,
-                disabled: vec![],
-            })
-            .await
-            .assert_enabled_validators_count(2)
-            .assert_validators_count(2)
-            .set_gas_limit(0, 500)
-            .await
-            .assert_gas_limit(0, 500)
-            .await
-            // Update gas limit while validator is disabled.
-            .set_validator_enabled(0, false)
-            .await
-            .assert_enabled_validators_count(1)
-            .assert_validators_count(2)
-            .set_gas_limit(0, 1000)
-            .await
-            .set_validator_enabled(0, true)
-            .await
-            .assert_enabled_validators_count(2)
-            .assert_gas_limit(0, 1000)
-            .await
-    });
+#[tokio::test]
+async fn validator_gas_limit() {
+    ApiTester::new()
+        .await
+        .create_hd_validators(HdValidatorScenario {
+            count: 2,
+            specify_mnemonic: false,
+            key_derivation_path_offset: 0,
+            disabled: vec![],
+        })
+        .await
+        .assert_enabled_validators_count(2)
+        .assert_validators_count(2)
+        .set_gas_limit(0, 500)
+        .await
+        .assert_gas_limit(0, 500)
+        .await
+        // Update gas limit while validator is disabled.
+        .set_validator_enabled(0, false)
+        .await
+        .assert_enabled_validators_count(1)
+        .assert_validators_count(2)
+        .set_gas_limit(0, 1000)
+        .await
+        .set_validator_enabled(0, true)
+        .await
+        .assert_enabled_validators_count(2)
+        .assert_gas_limit(0, 1000)
+        .await;
 }
 
-#[test]
-fn validator_builder_proposals() {
-    let runtime = build_runtime();
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
-            .await
-            .create_hd_validators(HdValidatorScenario {
-                count: 2,
-                specify_mnemonic: false,
-                key_derivation_path_offset: 0,
-                disabled: vec![],
-            })
-            .await
-            .assert_enabled_validators_count(2)
-            .assert_validators_count(2)
-            .set_builder_proposals(0, true)
-            .await
-            // Test setting builder proposals while the validator is disabled
-            .set_validator_enabled(0, false)
-            .await
-            .assert_enabled_validators_count(1)
-            .assert_validators_count(2)
-            .set_builder_proposals(0, false)
-            .await
-            .set_validator_enabled(0, true)
-            .await
-            .assert_enabled_validators_count(2)
-            .assert_builder_proposals(0, false)
-            .await
-    });
+#[tokio::test]
+async fn validator_builder_proposals() {
+    ApiTester::new()
+        .await
+        .create_hd_validators(HdValidatorScenario {
+            count: 2,
+            specify_mnemonic: false,
+            key_derivation_path_offset: 0,
+            disabled: vec![],
+        })
+        .await
+        .assert_enabled_validators_count(2)
+        .assert_validators_count(2)
+        .set_builder_proposals(0, true)
+        .await
+        // Test setting builder proposals while the validator is disabled
+        .set_validator_enabled(0, false)
+        .await
+        .assert_enabled_validators_count(1)
+        .assert_validators_count(2)
+        .set_builder_proposals(0, false)
+        .await
+        .set_validator_enabled(0, true)
+        .await
+        .assert_enabled_validators_count(2)
+        .assert_builder_proposals(0, false)
+        .await;
 }
 
-#[test]
-fn keystore_validator_creation() {
-    let runtime = build_runtime();
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
-            .await
-            .assert_enabled_validators_count(0)
-            .assert_validators_count(0)
-            .create_keystore_validators(KeystoreValidatorScenario {
-                correct_password: true,
-                enabled: true,
-            })
-            .await
-            .assert_enabled_validators_count(1)
-            .assert_validators_count(1)
-            .create_keystore_validators(KeystoreValidatorScenario {
-                correct_password: false,
-                enabled: true,
-            })
-            .await
-            .assert_enabled_validators_count(1)
-            .assert_validators_count(1)
-            .create_keystore_validators(KeystoreValidatorScenario {
-                correct_password: true,
-                enabled: false,
-            })
-            .await
-            .assert_enabled_validators_count(1)
-            .assert_validators_count(2);
-    });
+#[tokio::test]
+async fn keystore_validator_creation() {
+    ApiTester::new()
+        .await
+        .assert_enabled_validators_count(0)
+        .assert_validators_count(0)
+        .create_keystore_validators(KeystoreValidatorScenario {
+            correct_password: true,
+            enabled: true,
+        })
+        .await
+        .assert_enabled_validators_count(1)
+        .assert_validators_count(1)
+        .create_keystore_validators(KeystoreValidatorScenario {
+            correct_password: false,
+            enabled: true,
+        })
+        .await
+        .assert_enabled_validators_count(1)
+        .assert_validators_count(1)
+        .create_keystore_validators(KeystoreValidatorScenario {
+            correct_password: true,
+            enabled: false,
+        })
+        .await
+        .assert_enabled_validators_count(1)
+        .assert_validators_count(2);
 }
 
-#[test]
-fn web3signer_validator_creation() {
-    let runtime = build_runtime();
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        ApiTester::new(weak_runtime)
-            .await
-            .assert_enabled_validators_count(0)
-            .assert_validators_count(0)
-            .create_web3signer_validators(Web3SignerValidatorScenario {
-                count: 1,
-                enabled: true,
-            })
-            .await
-            .assert_enabled_validators_count(1)
-            .assert_validators_count(1);
-    });
+#[tokio::test]
+async fn web3signer_validator_creation() {
+    ApiTester::new()
+        .await
+        .assert_enabled_validators_count(0)
+        .assert_validators_count(0)
+        .create_web3signer_validators(Web3SignerValidatorScenario {
+            count: 1,
+            enabled: true,
+        })
+        .await
+        .assert_enabled_validators_count(1)
+        .assert_validators_count(1);
 }
diff --git a/validator_client/src/http_api/tests/keystores.rs b/validator_client/src/http_api/tests/keystores.rs
index 769d8a1d49..6a40157557 100644
--- a/validator_client/src/http_api/tests/keystores.rs
+++ b/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 weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        let tester = ApiTester::new(weak_runtime).await;
-        f(tester).await
-    });
+    let tester = ApiTester::new().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 weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        let tester1 = ApiTester::new(weak_runtime.clone()).await;
-        let tester2 = ApiTester::new(weak_runtime).await;
-        f(tester1, tester2).await
-    });
+    let tester1 = ApiTester::new().await;
+    let tester2 = ApiTester::new().await;
+    f(tester1, tester2).await
 }
 
 fn keystore_pubkey(keystore: &Keystore) -> PublicKeyBytes {
@@ -199,8 +192,8 @@ fn check_remotekey_delete_response(
     }
 }
 
-#[test]
-fn get_auth_no_token() {
+#[tokio::test]
+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]
-fn get_empty_keystores() {
+#[tokio::test]
+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]
-fn import_new_keystores() {
+#[tokio::test]
+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]
-fn import_only_duplicate_keystores() {
+#[tokio::test]
+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]
-fn import_some_duplicate_keystores() {
+#[tokio::test]
+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]
-fn import_wrong_number_of_passwords() {
+#[tokio::test]
+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]
-fn get_web3_signer_keystores() {
+#[tokio::test]
+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]
-fn import_and_delete_conflicting_web3_signer_keystores() {
+#[tokio::test]
+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]
-fn import_keystores_wrong_password() {
+#[tokio::test]
+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]
-fn import_invalid_slashing_protection() {
+#[tokio::test]
+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]
-fn check_get_set_fee_recipient() {
+#[tokio::test]
+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]
-fn migrate_all_with_slashing_protection() {
+#[tokio::test]
+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]
-fn migrate_some_with_slashing_protection() {
+#[tokio::test]
+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]
-fn migrate_some_missing_slashing_protection() {
+#[tokio::test]
+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]
-fn migrate_some_extra_slashing_protection() {
+#[tokio::test]
+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]
-fn delete_keystores_twice() {
+#[tokio::test]
+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]
-fn delete_nonexistent_keystores() {
+#[tokio::test]
+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]
-fn delete_concurrent_with_signing() {
-    let runtime = build_runtime();
+#[tokio::test]
+async fn delete_concurrent_with_signing() {
+    let handle = Handle::try_current().unwrap();
     let num_keys = 8;
     let num_signing_threads = 8;
     let num_attestations = 100;
@@ -1257,115 +1268,112 @@ fn delete_concurrent_with_signing() {
         "num_keys should be divisible by num threads for simplicity"
     );
 
-    let weak_runtime = Arc::downgrade(&runtime);
-    runtime.block_on(async {
-        let tester = ApiTester::new(weak_runtime).await;
+    let tester = ApiTester::new().await;
 
-        // Generate a lot of keys and import them.
-        let password = random_password_string();
-        let keystores = (0..num_keys)
-            .map(|_| new_keystore(password.clone()))
-            .collect::<Vec<_>>();
-        let all_pubkeys = keystores.iter().map(keystore_pubkey).collect::<Vec<_>>();
+    // Generate a lot of keys and import them.
+    let password = random_password_string();
+    let keystores = (0..num_keys)
+        .map(|_| new_keystore(password.clone()))
+        .collect::<Vec<_>>();
+    let all_pubkeys = keystores.iter().map(keystore_pubkey).collect::<Vec<_>>();
 
-        let import_res = tester
-            .client
-            .post_keystores(&ImportKeystoresRequest {
-                keystores: keystores.clone(),
-                passwords: vec![password.clone(); keystores.len()],
-                slashing_protection: None,
-            })
-            .await
-            .unwrap();
-        check_keystore_import_response(&import_res, all_imported(keystores.len()));
+    let import_res = tester
+        .client
+        .post_keystores(&ImportKeystoresRequest {
+            keystores: keystores.clone(),
+            passwords: vec![password.clone(); keystores.len()],
+            slashing_protection: None,
+        })
+        .await
+        .unwrap();
+    check_keystore_import_response(&import_res, all_imported(keystores.len()));
 
-        // Start several threads signing attestations at sequential epochs.
-        let mut join_handles = vec![];
+    // Start several threads signing attestations at sequential epochs.
+    let mut join_handles = vec![];
 
-        for thread_index in 0..num_signing_threads {
-            let keys_per_thread = num_keys / num_signing_threads;
-            let validator_store = tester.validator_store.clone();
-            let thread_pubkeys = all_pubkeys
-                [thread_index * keys_per_thread..(thread_index + 1) * keys_per_thread]
-                .to_vec();
+    for thread_index in 0..num_signing_threads {
+        let keys_per_thread = num_keys / num_signing_threads;
+        let validator_store = tester.validator_store.clone();
+        let thread_pubkeys = all_pubkeys
+            [thread_index * keys_per_thread..(thread_index + 1) * keys_per_thread]
+            .to_vec();
 
-            let handle = runtime.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() {
-                        let _ = validator_store
-                            .sign_attestation(*public_key, 0, &mut att, Epoch::new(j + 1))
-                            .await;
-                    }
+        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() {
+                    let _ = validator_store
+                        .sign_attestation(*public_key, 0, &mut att, Epoch::new(j + 1))
+                        .await;
                 }
-            });
-            join_handles.push(handle);
-        }
-
-        // Concurrently, delete each validator one at a time. Store the slashing protection
-        // data so we can ensure it doesn't change after a key is exported.
-        let mut delete_handles = vec![];
-        for _ in 0..num_delete_threads {
-            let client = tester.client.clone();
-            let all_pubkeys = all_pubkeys.clone();
-
-            let handle = runtime.spawn(async move {
-                let mut rng = SmallRng::from_entropy();
-
-                let mut slashing_protection = vec![];
-                for _ in 0..num_delete_attempts {
-                    let to_delete = all_pubkeys
-                        .iter()
-                        .filter(|_| rng.gen_bool(delete_prob))
-                        .copied()
-                        .collect::<Vec<_>>();
-
-                    if !to_delete.is_empty() {
-                        let delete_res = client
-                            .delete_keystores(&DeleteKeystoresRequest { pubkeys: to_delete })
-                            .await
-                            .unwrap();
-
-                        for status in delete_res.data.iter() {
-                            assert_ne!(status.status, DeleteKeystoreStatus::Error);
-                        }
-
-                        slashing_protection.push(delete_res.slashing_protection);
-                    }
-                }
-                slashing_protection
-            });
-
-            delete_handles.push(handle);
-        }
-
-        // Collect slashing protection.
-        let mut slashing_protection_map = HashMap::new();
-        let collected_slashing_protection = futures::future::join_all(delete_handles).await;
-
-        for interchange in collected_slashing_protection
-            .into_iter()
-            .flat_map(Result::unwrap)
-        {
-            for validator_data in interchange.data {
-                slashing_protection_map
-                    .entry(validator_data.pubkey)
-                    .and_modify(|existing| {
-                        assert_eq!(
-                            *existing, validator_data,
-                            "slashing protection data changed after first export"
-                        )
-                    })
-                    .or_insert(validator_data);
             }
-        }
+        });
+        join_handles.push(handle);
+    }
 
-        futures::future::join_all(join_handles).await
-    });
+    // Concurrently, delete each validator one at a time. Store the slashing protection
+    // data so we can ensure it doesn't change after a key is exported.
+    let mut delete_handles = vec![];
+    for _ in 0..num_delete_threads {
+        let client = tester.client.clone();
+        let all_pubkeys = all_pubkeys.clone();
+
+        let handle = handle.spawn(async move {
+            let mut rng = SmallRng::from_entropy();
+
+            let mut slashing_protection = vec![];
+            for _ in 0..num_delete_attempts {
+                let to_delete = all_pubkeys
+                    .iter()
+                    .filter(|_| rng.gen_bool(delete_prob))
+                    .copied()
+                    .collect::<Vec<_>>();
+
+                if !to_delete.is_empty() {
+                    let delete_res = client
+                        .delete_keystores(&DeleteKeystoresRequest { pubkeys: to_delete })
+                        .await
+                        .unwrap();
+
+                    for status in delete_res.data.iter() {
+                        assert_ne!(status.status, DeleteKeystoreStatus::Error);
+                    }
+
+                    slashing_protection.push(delete_res.slashing_protection);
+                }
+            }
+            slashing_protection
+        });
+
+        delete_handles.push(handle);
+    }
+
+    // Collect slashing protection.
+    let mut slashing_protection_map = HashMap::new();
+    let collected_slashing_protection = futures::future::join_all(delete_handles).await;
+
+    for interchange in collected_slashing_protection
+        .into_iter()
+        .flat_map(Result::unwrap)
+    {
+        for validator_data in interchange.data {
+            slashing_protection_map
+                .entry(validator_data.pubkey)
+                .and_modify(|existing| {
+                    assert_eq!(
+                        *existing, validator_data,
+                        "slashing protection data changed after first export"
+                    )
+                })
+                .or_insert(validator_data);
+        }
+    }
+
+    futures::future::join_all(join_handles).await;
 }
 
-#[test]
-fn delete_then_reimport() {
+#[tokio::test]
+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]
-fn get_empty_remotekeys() {
+#[tokio::test]
+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]
-fn import_new_remotekeys() {
+#[tokio::test]
+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]
-fn import_same_remotekey_different_url() {
+#[tokio::test]
+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]
-fn delete_remotekey_then_reimport_different_url() {
+#[tokio::test]
+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]
-fn import_only_duplicate_remotekeys() {
+#[tokio::test]
+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]
-fn import_some_duplicate_remotekeys() {
+#[tokio::test]
+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]
-fn import_remote_and_local_keys() {
+#[tokio::test]
+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]
-fn import_same_local_and_remote_keys() {
+#[tokio::test]
+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]
-fn import_same_remote_and_local_keys() {
+#[tokio::test]
+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]
-fn delete_remotekeys_twice() {
+#[tokio::test]
+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]
-fn delete_nonexistent_remotekey() {
+#[tokio::test]
+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]
-fn delete_then_reimport_remotekeys() {
+#[tokio::test]
+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]
-fn import_remotekey_web3signer() {
+#[tokio::test]
+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]
-fn import_remotekey_web3signer_disabled() {
+#[tokio::test]
+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]
-fn import_remotekey_web3signer_enabled() {
+#[tokio::test]
+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
 }