333 lines
10 KiB
Rust
333 lines
10 KiB
Rust
//! Tests for ScanService.
|
|
|
|
use tokio::sync::mpsc::error::TryRecvError;
|
|
use tower::{Service, ServiceBuilder, ServiceExt};
|
|
|
|
use color_eyre::{eyre::eyre, Result};
|
|
|
|
use zebra_chain::{block::Height, parameters::Network};
|
|
use zebra_node_services::scan_service::{request::Request, response::Response};
|
|
use zebra_state::TransactionIndex;
|
|
|
|
use crate::{
|
|
service::{scan_task::ScanTaskCommand, ScanService},
|
|
storage::db::tests::{fake_sapling_results, new_test_storage},
|
|
tests::{mock_sapling_scanning_keys, ZECPAGES_SAPLING_VIEWING_KEY},
|
|
Config,
|
|
};
|
|
|
|
/// Tests that keys are deleted correctly
|
|
#[tokio::test]
|
|
pub async fn scan_service_deletes_keys_correctly() -> Result<()> {
|
|
let mut db = new_test_storage(Network::Mainnet);
|
|
|
|
let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
|
|
|
|
for fake_result_height in [Height::MIN, Height(1), Height::MAX] {
|
|
db.insert_sapling_results(
|
|
&zec_pages_sapling_efvk,
|
|
fake_result_height,
|
|
fake_sapling_results([
|
|
TransactionIndex::MIN,
|
|
TransactionIndex::from_index(40),
|
|
TransactionIndex::MAX,
|
|
]),
|
|
);
|
|
}
|
|
|
|
assert!(
|
|
!db.sapling_results(&zec_pages_sapling_efvk).is_empty(),
|
|
"there should be some results for this key in the db"
|
|
);
|
|
|
|
let (mut scan_service, mut cmd_receiver) = ScanService::new_with_mock_scanner(db);
|
|
|
|
let response_fut = scan_service
|
|
.ready()
|
|
.await
|
|
.map_err(|err| eyre!(err))?
|
|
.call(Request::DeleteKeys(vec![zec_pages_sapling_efvk.clone()]));
|
|
|
|
let expected_keys = vec![zec_pages_sapling_efvk.clone()];
|
|
let cmd_handler_fut = tokio::spawn(async move {
|
|
let Some(ScanTaskCommand::RemoveKeys { done_tx, keys }) = cmd_receiver.recv().await else {
|
|
panic!("should successfully receive RemoveKeys message");
|
|
};
|
|
|
|
assert_eq!(keys, expected_keys, "keys should match the request keys");
|
|
|
|
done_tx.send(()).expect("send should succeed");
|
|
});
|
|
|
|
// Poll futures
|
|
let (response, join_result) = tokio::join!(response_fut, cmd_handler_fut);
|
|
join_result?;
|
|
|
|
match response.map_err(|err| eyre!(err))? {
|
|
Response::DeletedKeys => {}
|
|
_ => panic!("scan service returned unexpected response variant"),
|
|
};
|
|
|
|
assert!(
|
|
scan_service
|
|
.db
|
|
.sapling_results(&zec_pages_sapling_efvk)
|
|
.is_empty(),
|
|
"all results for this key should have been deleted"
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Tests that keys are deleted correctly
|
|
#[tokio::test]
|
|
pub async fn scan_service_subscribes_to_results_correctly() -> Result<()> {
|
|
let db = new_test_storage(Network::Mainnet);
|
|
|
|
let (mut scan_service, mut cmd_receiver) = ScanService::new_with_mock_scanner(db);
|
|
|
|
let keys = [String::from("fake key")];
|
|
|
|
let response_fut = scan_service
|
|
.ready()
|
|
.await
|
|
.map_err(|err| eyre!(err))?
|
|
.call(Request::SubscribeResults(keys.iter().cloned().collect()));
|
|
|
|
let expected_keys = keys.iter().cloned().collect();
|
|
let cmd_handler_fut = tokio::spawn(async move {
|
|
let Some(ScanTaskCommand::SubscribeResults {
|
|
result_sender: _,
|
|
keys,
|
|
}) = cmd_receiver.recv().await
|
|
else {
|
|
panic!("should successfully receive SubscribeResults message");
|
|
};
|
|
|
|
assert_eq!(keys, expected_keys, "keys should match the request keys");
|
|
});
|
|
|
|
// Poll futures
|
|
let (response, join_result) = tokio::join!(response_fut, cmd_handler_fut);
|
|
join_result?;
|
|
|
|
let mut results_receiver = match response.map_err(|err| eyre!(err))? {
|
|
Response::SubscribeResults(results_receiver) => results_receiver,
|
|
_ => panic!("scan service returned unexpected response variant"),
|
|
};
|
|
|
|
assert_eq!(
|
|
results_receiver.try_recv(),
|
|
Err(TryRecvError::Disconnected),
|
|
"channel with no items and dropped sender should be closed"
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Tests that results are cleared are deleted correctly
|
|
#[tokio::test]
|
|
pub async fn scan_service_clears_results_correctly() -> Result<()> {
|
|
let mut db = new_test_storage(Network::Mainnet);
|
|
|
|
let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
|
|
|
|
for fake_result_height in [Height::MIN, Height(1), Height::MAX] {
|
|
db.insert_sapling_results(
|
|
&zec_pages_sapling_efvk,
|
|
fake_result_height,
|
|
fake_sapling_results([
|
|
TransactionIndex::MIN,
|
|
TransactionIndex::from_index(40),
|
|
TransactionIndex::MAX,
|
|
]),
|
|
);
|
|
}
|
|
|
|
assert!(
|
|
!db.sapling_results(&zec_pages_sapling_efvk).is_empty(),
|
|
"there should be some results for this key in the db"
|
|
);
|
|
|
|
let (mut scan_service, _cmd_receiver) = ScanService::new_with_mock_scanner(db.clone());
|
|
|
|
let response = scan_service
|
|
.ready()
|
|
.await
|
|
.map_err(|err| eyre!(err))?
|
|
.call(Request::ClearResults(vec![zec_pages_sapling_efvk.clone()]))
|
|
.await
|
|
.map_err(|err| eyre!(err))?;
|
|
|
|
match response {
|
|
Response::ClearedResults => {}
|
|
_ => panic!("scan service returned unexpected response variant"),
|
|
};
|
|
|
|
assert_eq!(
|
|
db.sapling_results(&zec_pages_sapling_efvk).len(),
|
|
1,
|
|
"all results for this key should have been deleted, one empty entry should remain"
|
|
);
|
|
|
|
for (_, result) in db.sapling_results(&zec_pages_sapling_efvk) {
|
|
assert!(
|
|
result.is_empty(),
|
|
"there should be no results for this entry in the db"
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Tests that results for key are returned correctly
|
|
#[tokio::test]
|
|
pub async fn scan_service_get_results_for_key_correctly() -> Result<()> {
|
|
let mut db = new_test_storage(Network::Mainnet);
|
|
|
|
let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
|
|
|
|
for fake_result_height in [Height::MIN, Height(1), Height::MAX] {
|
|
db.insert_sapling_results(
|
|
&zec_pages_sapling_efvk,
|
|
fake_result_height,
|
|
fake_sapling_results([
|
|
TransactionIndex::MIN,
|
|
TransactionIndex::from_index(40),
|
|
TransactionIndex::MAX,
|
|
]),
|
|
);
|
|
}
|
|
|
|
assert!(
|
|
db.sapling_results(&zec_pages_sapling_efvk).len() == 3,
|
|
"there should be 3 heights for this key in the db"
|
|
);
|
|
|
|
for (_height, transactions) in db.sapling_results(&zec_pages_sapling_efvk) {
|
|
assert!(
|
|
transactions.len() == 3,
|
|
"there should be 3 transactions for each height for this key in the db"
|
|
);
|
|
}
|
|
|
|
// We don't need to send any command to the scanner for this call.
|
|
let (mut scan_service, _cmd_receiver) = ScanService::new_with_mock_scanner(db);
|
|
|
|
let response_fut = scan_service
|
|
.ready()
|
|
.await
|
|
.map_err(|err| eyre!(err))?
|
|
.call(Request::Results(vec![zec_pages_sapling_efvk.clone()]));
|
|
|
|
match response_fut.await.map_err(|err| eyre!(err))? {
|
|
Response::Results(results) => {
|
|
assert!(
|
|
results.contains_key(&zec_pages_sapling_efvk),
|
|
"results should contain the requested key"
|
|
);
|
|
assert!(results.len() == 1, "values are only for 1 key");
|
|
|
|
assert!(
|
|
results
|
|
.get_key_value(&zec_pages_sapling_efvk)
|
|
.unwrap()
|
|
.1
|
|
.len()
|
|
== 3,
|
|
"we should have 3 heights for the given key "
|
|
);
|
|
|
|
for transactions in results
|
|
.get_key_value(&zec_pages_sapling_efvk)
|
|
.unwrap()
|
|
.1
|
|
.values()
|
|
{
|
|
assert!(
|
|
transactions.len() == 3,
|
|
"there should be 3 transactions for each height for this key"
|
|
);
|
|
}
|
|
}
|
|
_ => panic!("scan service returned unexpected response variant"),
|
|
};
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Tests that the scan service registers keys correctly.
|
|
#[tokio::test]
|
|
pub async fn scan_service_registers_keys_correctly() -> Result<()> {
|
|
for network in Network::iter() {
|
|
scan_service_registers_keys_correctly_for(network).await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn scan_service_registers_keys_correctly_for(network: Network) -> Result<()> {
|
|
// Mock the state.
|
|
let (state, _, _, chain_tip_change) = zebra_state::populated_state(vec![], network).await;
|
|
|
|
// Instantiate the scan service.
|
|
let mut scan_service = ServiceBuilder::new()
|
|
.buffer(2)
|
|
.service(ScanService::new(&Config::ephemeral(), network, state, chain_tip_change).await);
|
|
|
|
// Mock three Sapling keys.
|
|
let mocked_keys = mock_sapling_scanning_keys(3, network);
|
|
|
|
// Add birth heights to the mocked keys.
|
|
let keys_to_register: Vec<_> = mocked_keys
|
|
.clone()
|
|
.into_iter()
|
|
.zip((0u32..).map(Some))
|
|
.collect();
|
|
|
|
// Register the first key.
|
|
match scan_service
|
|
.ready()
|
|
.await
|
|
.map_err(|err| eyre!(err))?
|
|
.call(Request::RegisterKeys(keys_to_register[..1].to_vec()))
|
|
.await
|
|
.map_err(|err| eyre!(err))?
|
|
{
|
|
Response::RegisteredKeys(registered_keys) => {
|
|
// The key should be registered.
|
|
assert_eq!(
|
|
registered_keys,
|
|
mocked_keys[..1],
|
|
"response should match newly registered key"
|
|
);
|
|
}
|
|
|
|
_ => panic!("scan service should have responded with the `RegisteredKeys` response"),
|
|
}
|
|
|
|
// Try registering all three keys.
|
|
match scan_service
|
|
.ready()
|
|
.await
|
|
.map_err(|err| eyre!(err))?
|
|
.call(Request::RegisterKeys(keys_to_register))
|
|
.await
|
|
.map_err(|err| eyre!(err))?
|
|
{
|
|
Response::RegisteredKeys(registered_keys) => {
|
|
// Only the last two keys should be registered in this service call since the first one
|
|
// was registered in the previous call.
|
|
assert_eq!(
|
|
registered_keys,
|
|
mocked_keys[1..3],
|
|
"response should match newly registered keys"
|
|
);
|
|
}
|
|
|
|
_ => panic!("scan service should have responded with the `RegisteredKeys` response"),
|
|
}
|
|
|
|
Ok(())
|
|
}
|