242 lines
8.6 KiB
Rust
242 lines
8.6 KiB
Rust
//! Snapshot tests for Zebra Scan gRPC responses.
|
|
//!
|
|
//! Currently we snapshot the `get_info` and `get_results` responses for both mainnet and testnet with a
|
|
//! mocked scanner database. Calls that return `Empty` responses are not snapshoted in this suite.
|
|
//!
|
|
//! To update these snapshots, run:
|
|
//! ```sh
|
|
//! cargo insta test --review --delete-unreferenced-snapshots
|
|
//! ```
|
|
use std::{collections::BTreeMap, thread::sleep, time::Duration};
|
|
|
|
use zebra_chain::{block::Height, parameters::Network, transaction};
|
|
use zebra_test::mock_service::MockService;
|
|
|
|
use zebra_node_services::scan_service::{
|
|
request::Request as ScanRequest,
|
|
response::{Response as ScanResponse, ScanResult},
|
|
};
|
|
|
|
use crate::{
|
|
scanner::{
|
|
self, scanner_client::ScannerClient, Empty, GetResultsRequest, GetResultsResponse,
|
|
InfoReply, KeyWithHeight,
|
|
},
|
|
server::init,
|
|
};
|
|
|
|
/// The extended Sapling viewing key of [ZECpages](https://zecpages.com/boardinfo)
|
|
pub const ZECPAGES_SAPLING_VIEWING_KEY: &str = "zxviews1q0duytgcqqqqpqre26wkl45gvwwwd706xw608hucmvfalr759ejwf7qshjf5r9aa7323zulvz6plhttp5mltqcgs9t039cx2d09mgq05ts63n8u35hyv6h9nc9ctqqtue2u7cer2mqegunuulq2luhq3ywjcz35yyljewa4mgkgjzyfwh6fr6jd0dzd44ghk0nxdv2hnv4j5nxfwv24rwdmgllhe0p8568sgqt9ckt02v2kxf5ahtql6s0ltjpkckw8gtymxtxuu9gcr0swvz";
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
async fn test_grpc_response_data() {
|
|
let _init_guard = zebra_test::init();
|
|
|
|
tokio::join!(
|
|
test_mocked_rpc_response_data_for_network(
|
|
Network::Mainnet,
|
|
zebra_test::net::random_known_port()
|
|
),
|
|
test_mocked_rpc_response_data_for_network(
|
|
Network::Testnet,
|
|
zebra_test::net::random_known_port()
|
|
),
|
|
);
|
|
}
|
|
|
|
async fn test_mocked_rpc_response_data_for_network(network: Network, random_port: u16) {
|
|
// get a mocked scan service
|
|
let mock_scan_service = MockService::build().for_unit_tests();
|
|
|
|
// start the gRPC server
|
|
let listen_addr: std::net::SocketAddr = format!("127.0.0.1:{random_port}")
|
|
.parse()
|
|
.expect("hard-coded IP and u16 port should parse successfully");
|
|
|
|
{
|
|
let mock_scan_service = mock_scan_service.clone();
|
|
tokio::spawn(async move {
|
|
init(listen_addr, mock_scan_service)
|
|
.await
|
|
.expect("Possible port conflict");
|
|
});
|
|
}
|
|
|
|
// wait for the server to start
|
|
sleep(Duration::from_secs(1));
|
|
|
|
// connect to the gRPC server
|
|
let client = ScannerClient::connect(format!("http://127.0.0.1:{random_port}"))
|
|
.await
|
|
.expect("server should receive connection");
|
|
|
|
// insta settings
|
|
let mut settings = insta::Settings::clone_current();
|
|
settings.set_snapshot_suffix(network.lowercase_name());
|
|
|
|
// snapshot the get_info grpc call
|
|
let get_info_response_fut = {
|
|
let mut client = client.clone();
|
|
let get_info_request = tonic::Request::new(Empty {});
|
|
tokio::spawn(async move { client.get_info(get_info_request).await })
|
|
};
|
|
|
|
{
|
|
let mut mock_scan_service = mock_scan_service.clone();
|
|
tokio::spawn(async move {
|
|
mock_scan_service
|
|
.expect_request_that(|req| matches!(req, ScanRequest::Info))
|
|
.await
|
|
.respond(ScanResponse::Info {
|
|
min_sapling_birthday_height: network.sapling_activation_height(),
|
|
})
|
|
});
|
|
}
|
|
|
|
// snapshot the get_info grpc call
|
|
|
|
let get_info_response = get_info_response_fut
|
|
.await
|
|
.expect("tokio task should join successfully")
|
|
.expect("get_info request should succeed");
|
|
|
|
snapshot_rpc_getinfo(get_info_response.into_inner(), &settings);
|
|
|
|
// snapshot the get_results grpc call
|
|
|
|
let get_results_response_fut = {
|
|
let mut client = client.clone();
|
|
let get_results_request = tonic::Request::new(GetResultsRequest {
|
|
keys: vec![ZECPAGES_SAPLING_VIEWING_KEY.to_string()],
|
|
});
|
|
tokio::spawn(async move { client.get_results(get_results_request).await })
|
|
};
|
|
|
|
{
|
|
let mut mock_scan_service = mock_scan_service.clone();
|
|
tokio::spawn(async move {
|
|
let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
|
|
let mut fake_results = BTreeMap::new();
|
|
for fake_result_height in [Height::MIN, Height(1), Height::MAX] {
|
|
fake_results.insert(
|
|
fake_result_height,
|
|
[transaction::Hash::from([0; 32])].repeat(3),
|
|
);
|
|
}
|
|
|
|
let mut fake_results_response = BTreeMap::new();
|
|
fake_results_response.insert(zec_pages_sapling_efvk, fake_results);
|
|
|
|
mock_scan_service
|
|
.expect_request_that(|req| matches!(req, ScanRequest::Results(_)))
|
|
.await
|
|
.respond(ScanResponse::Results(fake_results_response))
|
|
});
|
|
}
|
|
|
|
let get_results_response = get_results_response_fut
|
|
.await
|
|
.expect("tokio task should join successfully")
|
|
.expect("get_results request should succeed");
|
|
|
|
snapshot_rpc_getresults(get_results_response.into_inner(), &settings);
|
|
|
|
// snapshot the scan grpc method
|
|
|
|
let scan_response_fut = {
|
|
let mut client = client.clone();
|
|
let get_results_request = tonic::Request::new(scanner::ScanRequest {
|
|
keys: vec![KeyWithHeight {
|
|
key: ZECPAGES_SAPLING_VIEWING_KEY.to_string(),
|
|
height: None,
|
|
}],
|
|
});
|
|
tokio::spawn(async move { client.scan(get_results_request).await })
|
|
};
|
|
|
|
let (fake_results_sender, fake_results_receiver) = tokio::sync::mpsc::channel(1);
|
|
|
|
{
|
|
let mut mock_scan_service = mock_scan_service.clone();
|
|
tokio::spawn(async move {
|
|
let zec_pages_sapling_efvk = ZECPAGES_SAPLING_VIEWING_KEY.to_string();
|
|
let mut fake_results = BTreeMap::new();
|
|
for fake_result_height in [Height::MIN, Height(1), Height::MAX] {
|
|
fake_results.insert(
|
|
fake_result_height,
|
|
[transaction::Hash::from([0; 32])].repeat(3),
|
|
);
|
|
}
|
|
|
|
let mut fake_results_response = BTreeMap::new();
|
|
fake_results_response.insert(zec_pages_sapling_efvk.clone(), fake_results);
|
|
|
|
mock_scan_service
|
|
.expect_request_that(|req| matches!(req, ScanRequest::RegisterKeys(_)))
|
|
.await
|
|
.respond(ScanResponse::RegisteredKeys(vec![]));
|
|
|
|
mock_scan_service
|
|
.expect_request_that(|req| matches!(req, ScanRequest::Results(_)))
|
|
.await
|
|
.respond(ScanResponse::Results(fake_results_response));
|
|
|
|
mock_scan_service
|
|
.expect_request_that(|req| matches!(req, ScanRequest::SubscribeResults(_)))
|
|
.await
|
|
.respond(ScanResponse::SubscribeResults(fake_results_receiver));
|
|
});
|
|
}
|
|
|
|
let scan_response = scan_response_fut
|
|
.await
|
|
.expect("tokio task should join successfully")
|
|
.expect("get_results request should succeed");
|
|
|
|
let mut scan_response_stream = scan_response.into_inner();
|
|
|
|
let scan_response_message = scan_response_stream
|
|
.message()
|
|
.await
|
|
.expect("scan response message should be ok")
|
|
.expect("scan response message should be some");
|
|
|
|
snapshot_rpc_scan("cached", scan_response_message, &settings);
|
|
|
|
fake_results_sender
|
|
.send(ScanResult {
|
|
key: ZECPAGES_SAPLING_VIEWING_KEY.to_string(),
|
|
height: Height::MIN,
|
|
tx_id: transaction::Hash::from([0; 32]),
|
|
})
|
|
.await
|
|
.expect("should send fake result successfully");
|
|
|
|
let scan_response_message = scan_response_stream
|
|
.message()
|
|
.await
|
|
.expect("scan response message should be ok")
|
|
.expect("scan response message should be some");
|
|
|
|
snapshot_rpc_scan("subscribed", scan_response_message, &settings);
|
|
}
|
|
|
|
/// Snapshot `getinfo` response, using `cargo insta` and JSON serialization.
|
|
fn snapshot_rpc_getinfo(info: InfoReply, settings: &insta::Settings) {
|
|
settings.bind(|| insta::assert_json_snapshot!("get_info", info));
|
|
}
|
|
|
|
/// Snapshot `getresults` response, using `cargo insta` and JSON serialization.
|
|
fn snapshot_rpc_getresults(results: GetResultsResponse, settings: &insta::Settings) {
|
|
settings.bind(|| insta::assert_json_snapshot!("get_results", results));
|
|
}
|
|
|
|
/// Snapshot `scan` response, using `cargo insta` and JSON serialization.
|
|
fn snapshot_rpc_scan(
|
|
variant: &'static str,
|
|
scan_response: scanner::ScanResponse,
|
|
settings: &insta::Settings,
|
|
) {
|
|
settings.bind(|| insta::assert_json_snapshot!(format!("scan_{variant}"), scan_response));
|
|
}
|