Function create_test_finalizer_mailbox

rpc/tests/utils.rs:52–161

Creates a mock finalizer mailbox that responds to queries with test data

(
    state: MockFinalizerState,
)

    }
}

/// Creates a mock finalizer mailbox that responds to queries with test data
pub fn create_test_finalizer_mailbox(
    state: MockFinalizerState,
) -> (ConsensusStateQuery<TestScheme>, JoinHandle<()>) {
    let (query, mut rx) = ConsensusStateQuery::new(100);

    let handle = tokio::spawn(async move {
        while let Some((request, response)) = rx.next().await {
            match request {
                ConsensusStateRequest::GetLatestHeight => {
                    let _ =
                        response.send(ConsensusStateResponse::LatestHeight(state.latest_height));
                }
                ConsensusStateRequest::GetLatestEpoch => {
                    let _ = response.send(ConsensusStateResponse::LatestEpoch(state.latest_epoch));
                }
                ConsensusStateRequest::GetCheckpoint(epoch) => {
                    let checkpoint = state
                        .checkpoints
                        .get(&epoch)
                        .cloned()
                        .flatten()
                        .and_then(|checkpoint| Some((checkpoint, Block::genesis([0; 32]))));
                    let _ = response.send(ConsensusStateResponse::Checkpoint(checkpoint));
                }
                ConsensusStateRequest::GetLatestCheckpoint => {
                    let (latest_checkpoint, epoch) =
                        state.latest_checkpoint.clone().unwrap_or((None, 0));
                    let latest_checkpoint =
                        latest_checkpoint.map(|checkpoint| (checkpoint, Block::genesis([0; 32])));
                    let _ = response.send(ConsensusStateResponse::LatestCheckpoint((
                        latest_checkpoint,
                        epoch,
                    )));
                }
                ConsensusStateRequest::GetValidatorBalance(public_key) => {
                    let balance = state.validator_balances.get(&public_key).cloned().flatten();
                    let _ = response.send(ConsensusStateResponse::ValidatorBalance(balance));
                }
                ConsensusStateRequest::GetValidatorAccount(public_key) => {
                    let account = state.validator_accounts.get(&public_key).cloned().flatten();
                    let _ = response.send(ConsensusStateResponse::ValidatorAccount(account));
                }
                ConsensusStateRequest::GetFinalizedHeader(epoch) => {
                    let header = state.finalized_headers.get(&epoch).cloned().flatten();
                    let _ = response.send(ConsensusStateResponse::FinalizedHeader(header));
                }
                ConsensusStateRequest::GetMinimumStake => {
                    let _ =
                        response.send(ConsensusStateResponse::MinimumStake(state.minimum_stake));
                }
                ConsensusStateRequest::GetMaximumStake => {
                    let _ =
                        response.send(ConsensusStateResponse::MaximumStake(state.maximum_stake));
                }
                ConsensusStateRequest::GetStateRoot => {
                    let _ = response.send(ConsensusStateResponse::StateRoot {