gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-05-07 00:42:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use async tests

Browse Source
This commit is contained in:
Paul Hauner
2023-07-10 18:30:46 +10:00
parent ad65cf65f3
commit 8d3aa4419b
1 changed files with 326 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

706
validator_client/src/http_api/tests.rs
View File

@@ -31,7 +31,7 @@ use std::net::{IpAddr, Ipv4Addr};
use std::str::FromStr; use std::str::FromStr;
use std::sync::Arc; use std::sync::Arc;
use std::time::Duration; use std::time::Duration;
use task_executor::TaskExecutor; use task_executor::test_utils::TestRuntime;
use tempfile::{tempdir, TempDir}; use tempfile::{tempdir, TempDir};
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use tokio::sync::oneshot; use tokio::sync::oneshot;
@@ -48,9 +48,8 @@ struct ApiTester {
validator_store: Arc<ValidatorStore<TestingSlotClock, E>>, validator_store: Arc<ValidatorStore<TestingSlotClock, E>>,
url: SensitiveUrl, url: SensitiveUrl,
slot_clock: TestingSlotClock, slot_clock: TestingSlotClock,
_server_shutdown: oneshot::Sender<()>,
_validator_dir: TempDir, _validator_dir: TempDir,
_runtime_shutdown: exit_future::Signal, _test_runtime: TestRuntime,
} }
// Builds a runtime to be used in the testing configuration. // Builds a runtime to be used in the testing configuration.
@@ -64,7 +63,7 @@ fn build_runtime() -> Arc<Runtime> {
} }
impl ApiTester { impl ApiTester {
pub async fn new(runtime: std::sync::Weak<Runtime>) -> Self { pub async fn new() -> Self {
let log = test_logger(); let log = test_logger();
let validator_dir = tempdir().unwrap(); let validator_dir = tempdir().unwrap();
@@ -100,9 +99,7 @@ impl ApiTester {
Duration::from_secs(1), 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( let validator_store = Arc::new(ValidatorStore::<_, E>::new(
initialized_validators, initialized_validators,
@@ -112,7 +109,7 @@ impl ApiTester {
Some(Arc::new(DoppelgangerService::new(log.clone()))), Some(Arc::new(DoppelgangerService::new(log.clone()))),
slot_clock.clone(), slot_clock.clone(),
&config, &config,
executor.clone(), test_runtime.task_executor.clone(),
log.clone(), log.clone(),
)); ));
@@ -123,7 +120,7 @@ impl ApiTester {
let initialized_validators = validator_store.initialized_validators(); let initialized_validators = validator_store.initialized_validators();
let context = Arc::new(Context { let context = Arc::new(Context {
task_executor: executor, task_executor: test_runtime.task_executor.clone(),
api_secret, api_secret,
validator_dir: Some(validator_dir.path().into()), validator_dir: Some(validator_dir.path().into()),
secrets_dir: Some(secrets_dir.path().into()), secrets_dir: Some(secrets_dir.path().into()),
@@ -145,12 +142,8 @@ impl ApiTester {
_phantom: PhantomData, _phantom: PhantomData,
}); });
let ctx = context.clone(); let ctx = context.clone();
let (shutdown_tx, shutdown_rx) = oneshot::channel(); let (listening_socket, server) =
let server_shutdown = async { super::serve(ctx, test_runtime.task_executor.exit()).unwrap();
// It's not really interesting why this triggered, just that it happened.
let _ = shutdown_rx.await;
};
let (listening_socket, server) = super::serve(ctx, server_shutdown).unwrap();
tokio::spawn(async { server.await }); tokio::spawn(async { server.await });
@@ -169,9 +162,8 @@ impl ApiTester {
validator_store, validator_store,
url, url,
slot_clock, slot_clock,
_server_shutdown: shutdown_tx,
_validator_dir: validator_dir, _validator_dir: validator_dir,
_runtime_shutdown: runtime_shutdown, _test_runtime: test_runtime,
} }
} }
@@ -679,387 +671,341 @@ struct Web3SignerValidatorScenario {
enabled: bool, enabled: bool,
} }
#[test] #[tokio::test]
fn invalid_pubkey() { async fn invalid_pubkey() {
let runtime = build_runtime(); ApiTester::new()
let weak_runtime = Arc::downgrade(&runtime); .await
runtime.block_on(async { .invalidate_api_token()
ApiTester::new(weak_runtime) .test_get_lighthouse_version_invalid()
.await .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); .await
runtime.block_on(async { .test_with_invalid_auth(|client| async move { client.get_lighthouse_version().await })
ApiTester::new(weak_runtime) .await
.await .test_with_invalid_auth(|client| async move { client.get_lighthouse_health().await })
.test_with_invalid_auth(|client| async move { client.get_lighthouse_version().await }) .await
.await .test_with_invalid_auth(|client| async move {
.test_with_invalid_auth(|client| async move { client.get_lighthouse_health().await }) client.get_lighthouse_spec::<types::Config>().await
.await })
.test_with_invalid_auth(|client| async move { .await
client.get_lighthouse_spec::<types::Config>().await .test_with_invalid_auth(|client| async move { client.get_lighthouse_validators().await })
}) .await
.await .test_with_invalid_auth(|client| async move {
.test_with_invalid_auth( client
|client| async move { client.get_lighthouse_validators().await }, .get_lighthouse_validators_pubkey(&PublicKeyBytes::empty())
) .await
.await })
.test_with_invalid_auth(|client| async move { .await
client .test_with_invalid_auth(|client| async move {
.get_lighthouse_validators_pubkey(&PublicKeyBytes::empty()) client
.await .post_lighthouse_validators(vec![ValidatorRequest {
}) enable: <_>::default(),
.await description: <_>::default(),
.test_with_invalid_auth(|client| async move { graffiti: <_>::default(),
client suggested_fee_recipient: <_>::default(),
.post_lighthouse_validators(vec![ValidatorRequest { gas_limit: <_>::default(),
enable: <_>::default(), builder_proposals: <_>::default(),
description: <_>::default(), deposit_gwei: <_>::default(),
graffiti: <_>::default(), }])
suggested_fee_recipient: <_>::default(), .await
gas_limit: <_>::default(), })
builder_proposals: <_>::default(), .await
deposit_gwei: <_>::default(), .test_with_invalid_auth(|client| async move {
}]) client
.await .post_lighthouse_validators_mnemonic(&CreateValidatorsMnemonicRequest {
}) mnemonic: String::default().into(),
.await key_derivation_path_offset: <_>::default(),
.test_with_invalid_auth(|client| async move { validators: <_>::default(),
client })
.post_lighthouse_validators_mnemonic(&CreateValidatorsMnemonicRequest { .await
mnemonic: String::default().into(), })
key_derivation_path_offset: <_>::default(), .await
validators: <_>::default(), .test_with_invalid_auth(|client| async move {
}) let password = random_password();
.await let keypair = Keypair::random();
}) let keystore = KeystoreBuilder::new(&keypair, password.as_bytes(), String::new())
.await .unwrap()
.test_with_invalid_auth(|client| async move { .build()
let password = random_password(); .unwrap();
let keypair = Keypair::random(); client
let keystore = KeystoreBuilder::new(&keypair, password.as_bytes(), String::new()) .post_lighthouse_validators_keystore(&KeystoreValidatorsPostRequest {
.unwrap() password: String::default().into(),
.build() enable: <_>::default(),
.unwrap(); keystore,
client graffiti: <_>::default(),
.post_lighthouse_validators_keystore(&KeystoreValidatorsPostRequest { suggested_fee_recipient: <_>::default(),
password: String::default().into(), gas_limit: <_>::default(),
enable: <_>::default(), builder_proposals: <_>::default(),
keystore, })
graffiti: <_>::default(), .await
suggested_fee_recipient: <_>::default(), })
gas_limit: <_>::default(), .await
builder_proposals: <_>::default(), .test_with_invalid_auth(|client| async move {
}) client
.await .patch_lighthouse_validators(
}) &PublicKeyBytes::empty(),
.await Some(false),
.test_with_invalid_auth(|client| async move { None,
client None,
.patch_lighthouse_validators( None,
&PublicKeyBytes::empty(), )
Some(false), .await
None, })
None, .await
None, .test_with_invalid_auth(|client| async move { client.get_keystores().await })
) .await
.await .test_with_invalid_auth(|client| async move {
}) let password = random_password_string();
.await let keypair = Keypair::random();
.test_with_invalid_auth(|client| async move { client.get_keystores().await }) let keystore = KeystoreBuilder::new(&keypair, password.as_ref(), String::new())
.await .unwrap()
.test_with_invalid_auth(|client| async move { .build()
let password = random_password_string(); .map(KeystoreJsonStr)
let keypair = Keypair::random(); .unwrap();
let keystore = KeystoreBuilder::new(&keypair, password.as_ref(), String::new()) client
.unwrap() .post_keystores(&ImportKeystoresRequest {
.build() keystores: vec![keystore],
.map(KeystoreJsonStr) passwords: vec![password],
.unwrap(); slashing_protection: None,
client })
.post_keystores(&ImportKeystoresRequest { .await
keystores: vec![keystore], })
passwords: vec![password], .await
slashing_protection: None, .test_with_invalid_auth(|client| async move {
}) let keypair = Keypair::random();
.await client
}) .delete_keystores(&DeleteKeystoresRequest {
.await pubkeys: vec![keypair.pk.compress()],
.test_with_invalid_auth(|client| async move { })
let keypair = Keypair::random(); .await
client })
.delete_keystores(&DeleteKeystoresRequest { .await;
pubkeys: vec![keypair.pk.compress()],
})
.await
})
.await
});
} }
#[test] #[tokio::test]
fn simple_getters() { async fn simple_getters() {
let runtime = build_runtime(); ApiTester::new()
let weak_runtime = Arc::downgrade(&runtime); .await
runtime.block_on(async { .test_get_lighthouse_version()
ApiTester::new(weak_runtime) .await
.await .test_get_lighthouse_health()
.test_get_lighthouse_version() .await
.await .test_get_lighthouse_spec()
.test_get_lighthouse_health() .await;
.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); .await
runtime.block_on(async { .assert_enabled_validators_count(0)
ApiTester::new(weak_runtime) .assert_validators_count(0)
.await .create_hd_validators(HdValidatorScenario {
.assert_enabled_validators_count(0) count: 2,
.assert_validators_count(0) specify_mnemonic: true,
.create_hd_validators(HdValidatorScenario { key_derivation_path_offset: 0,
count: 2, disabled: vec![],
specify_mnemonic: true, })
key_derivation_path_offset: 0, .await
disabled: vec![], .assert_enabled_validators_count(2)
}) .assert_validators_count(2)
.await .create_hd_validators(HdValidatorScenario {
.assert_enabled_validators_count(2) count: 1,
.assert_validators_count(2) specify_mnemonic: false,
.create_hd_validators(HdValidatorScenario { key_derivation_path_offset: 0,
count: 1, disabled: vec![0],
specify_mnemonic: false, })
key_derivation_path_offset: 0, .await
disabled: vec![0], .assert_enabled_validators_count(2)
}) .assert_validators_count(3)
.await .create_hd_validators(HdValidatorScenario {
.assert_enabled_validators_count(2) count: 0,
.assert_validators_count(3) specify_mnemonic: true,
.create_hd_validators(HdValidatorScenario { key_derivation_path_offset: 4,
count: 0, disabled: vec![],
specify_mnemonic: true, })
key_derivation_path_offset: 4, .await
disabled: vec![], .assert_enabled_validators_count(2)
}) .assert_validators_count(3);
.await
.assert_enabled_validators_count(2)
.assert_validators_count(3);
});
} }
#[test] #[tokio::test]
fn validator_exit() { async fn validator_exit() {
let runtime = build_runtime(); ApiTester::new()
let weak_runtime = Arc::downgrade(&runtime); .await
runtime.block_on(async { .create_hd_validators(HdValidatorScenario {
ApiTester::new(weak_runtime) count: 2,
.await specify_mnemonic: false,
.create_hd_validators(HdValidatorScenario { key_derivation_path_offset: 0,
count: 2, disabled: vec![],
specify_mnemonic: false, })
key_derivation_path_offset: 0, .await
disabled: vec![], .assert_enabled_validators_count(2)
}) .assert_validators_count(2)
.await .test_sign_voluntary_exits(0, None)
.assert_enabled_validators_count(2) .await
.assert_validators_count(2) .test_sign_voluntary_exits(0, Some(Epoch::new(256)))
.test_sign_voluntary_exits(0, None) .await;
.await
.test_sign_voluntary_exits(0, Some(Epoch::new(256)))
.await;
});
} }
#[test] #[tokio::test]
fn validator_enabling() { async fn validator_enabling() {
let runtime = build_runtime(); ApiTester::new()
let weak_runtime = Arc::downgrade(&runtime); .await
runtime.block_on(async { .create_hd_validators(HdValidatorScenario {
ApiTester::new(weak_runtime) count: 2,
.await specify_mnemonic: false,
.create_hd_validators(HdValidatorScenario { key_derivation_path_offset: 0,
count: 2, disabled: vec![],
specify_mnemonic: false, })
key_derivation_path_offset: 0, .await
disabled: vec![], .assert_enabled_validators_count(2)
}) .assert_validators_count(2)
.await .set_validator_enabled(0, false)
.assert_enabled_validators_count(2) .await
.assert_validators_count(2) .assert_enabled_validators_count(1)
.set_validator_enabled(0, false) .assert_validators_count(2)
.await .set_validator_enabled(0, true)
.assert_enabled_validators_count(1) .await
.assert_validators_count(2) .assert_enabled_validators_count(2)
.set_validator_enabled(0, true) .assert_validators_count(2);
.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); .await
runtime.block_on(async { .create_hd_validators(HdValidatorScenario {
ApiTester::new(weak_runtime) count: 2,
.await specify_mnemonic: false,
.create_hd_validators(HdValidatorScenario { key_derivation_path_offset: 0,
count: 2, disabled: vec![],
specify_mnemonic: false, })
key_derivation_path_offset: 0, .await
disabled: vec![], .assert_enabled_validators_count(2)
}) .assert_validators_count(2)
.await .set_gas_limit(0, 500)
.assert_enabled_validators_count(2) .await
.assert_validators_count(2) .assert_gas_limit(0, 500)
.set_gas_limit(0, 500) .await
.await // Update gas limit while validator is disabled.
.assert_gas_limit(0, 500) .set_validator_enabled(0, false)
.await .await
// Update gas limit while validator is disabled. .assert_enabled_validators_count(1)
.set_validator_enabled(0, false) .assert_validators_count(2)
.await .set_gas_limit(0, 1000)
.assert_enabled_validators_count(1) .await
.assert_validators_count(2) .set_validator_enabled(0, true)
.set_gas_limit(0, 1000) .await
.await .assert_enabled_validators_count(2)
.set_validator_enabled(0, true) .assert_gas_limit(0, 1000)
.await .await;
.assert_enabled_validators_count(2)
.assert_gas_limit(0, 1000)
.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); .await
runtime.block_on(async { .create_hd_validators(HdValidatorScenario {
ApiTester::new(weak_runtime) count: 2,
.await specify_mnemonic: false,
.create_hd_validators(HdValidatorScenario { key_derivation_path_offset: 0,
count: 2, disabled: vec![],
specify_mnemonic: false, })
key_derivation_path_offset: 0, .await
disabled: vec![], .assert_enabled_validators_count(2)
}) .assert_validators_count(2)
.await .set_builder_proposals(0, true)
.assert_enabled_validators_count(2) .await
.assert_validators_count(2) // Test setting builder proposals while the validator is disabled
.set_builder_proposals(0, true) .set_validator_enabled(0, false)
.await .await
// Test setting builder proposals while the validator is disabled .assert_enabled_validators_count(1)
.set_validator_enabled(0, false) .assert_validators_count(2)
.await .set_builder_proposals(0, false)
.assert_enabled_validators_count(1) .await
.assert_validators_count(2) .set_validator_enabled(0, true)
.set_builder_proposals(0, false) .await
.await .assert_enabled_validators_count(2)
.set_validator_enabled(0, true) .assert_builder_proposals(0, false)
.await .await;
.assert_enabled_validators_count(2)
.assert_builder_proposals(0, false)
.await
});
} }
#[test] #[tokio::test]
fn validator_graffiti() { async fn validator_graffiti() {
let runtime = build_runtime(); ApiTester::new()
let weak_runtime = Arc::downgrade(&runtime); .await
runtime.block_on(async { .create_hd_validators(HdValidatorScenario {
ApiTester::new(weak_runtime) count: 2,
.await specify_mnemonic: false,
.create_hd_validators(HdValidatorScenario { key_derivation_path_offset: 0,
count: 2, disabled: vec![],
specify_mnemonic: false, })
key_derivation_path_offset: 0, .await
disabled: vec![], .assert_enabled_validators_count(2)
}) .assert_validators_count(2)
.await .set_graffiti(0, "Mr F was here")
.assert_enabled_validators_count(2) .await
.assert_validators_count(2) .assert_graffiti(0, "Mr F was here")
.set_graffiti(0, "Mr F was here") .await
.await // Test setting graffiti while the validator is disabled
.assert_graffiti(0, "Mr F was here") .set_validator_enabled(0, false)
.await .await
// Test setting graffiti while the validator is disabled .assert_enabled_validators_count(1)
.set_validator_enabled(0, false) .assert_validators_count(2)
.await .set_graffiti(0, "Mr F was here again")
.assert_enabled_validators_count(1) .await
.assert_validators_count(2) .set_validator_enabled(0, true)
.set_graffiti(0, "Mr F was here again") .await
.await .assert_enabled_validators_count(2)
.set_validator_enabled(0, true) .assert_graffiti(0, "Mr F was here again")
.await .await;
.assert_enabled_validators_count(2)
.assert_graffiti(0, "Mr F was here again")
.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); .await
runtime.block_on(async { .assert_enabled_validators_count(0)
ApiTester::new(weak_runtime) .assert_validators_count(0)
.await .create_keystore_validators(KeystoreValidatorScenario {
.assert_enabled_validators_count(0) correct_password: true,
.assert_validators_count(0) enabled: true,
.create_keystore_validators(KeystoreValidatorScenario { })
correct_password: true, .await
enabled: true, .assert_enabled_validators_count(1)
}) .assert_validators_count(1)
.await .create_keystore_validators(KeystoreValidatorScenario {
.assert_enabled_validators_count(1) correct_password: false,
.assert_validators_count(1) enabled: true,
.create_keystore_validators(KeystoreValidatorScenario { })
correct_password: false, .await
enabled: true, .assert_enabled_validators_count(1)
}) .assert_validators_count(1)
.await .create_keystore_validators(KeystoreValidatorScenario {
.assert_enabled_validators_count(1) correct_password: true,
.assert_validators_count(1) enabled: false,
.create_keystore_validators(KeystoreValidatorScenario { })
correct_password: true, .await
enabled: false, .assert_enabled_validators_count(1)
}) .assert_validators_count(2);
.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); .await
runtime.block_on(async { .assert_enabled_validators_count(0)
ApiTester::new(weak_runtime) .assert_validators_count(0)
.await .create_web3signer_validators(Web3SignerValidatorScenario {
.assert_enabled_validators_count(0) count: 1,
.assert_validators_count(0) enabled: true,
.create_web3signer_validators(Web3SignerValidatorScenario { })
count: 1, .await
enabled: true, .assert_enabled_validators_count(1)
}) .assert_validators_count(1);
.await
.assert_enabled_validators_count(1)
.assert_validators_count(1);
});
} }