Struct tendermint_rpc::MockClient

pub struct MockClient<M: MockRequestMatcher> { /* private fields */ }

A mock client implementation for use in testing.

Examples

use tendermint_rpc::{Client, Method, MockClient, MockRequestMatcher, MockRequestMethodMatcher};

const ABCI_INFO_RESPONSE: &str = r#"{
  "jsonrpc": "2.0",
  "id": "",
  "result": {
    "response": {
      "data": "GaiaApp",
      "version": "0.17.0",
      "app_version": "1",
      "last_block_height": "488120",
      "last_block_app_hash": "2LnCw0fN+Zq/gs5SOuya/GRHUmtWftAqAkTUuoxl4g4="
    }
  }
}"#;

tokio_test::block_on(async {
    let matcher = MockRequestMethodMatcher::default()
        .map(Method::AbciInfo, Ok(ABCI_INFO_RESPONSE.to_string()));
    let (client, driver) = MockClient::new(matcher);
    let driver_hdl = tokio::spawn(async move { driver.run().await });

    let abci_info = client.abci_info().await.unwrap();
    println!("Got mock ABCI info: {:?}", abci_info);
    assert_eq!("GaiaApp".to_string(), abci_info.data);

    client.close();
    driver_hdl.await.unwrap();
});

Implementations

impl<M: MockRequestMatcher> MockClient<M>

pub fn new(matcher: M) -> (Self, MockClientDriver)

Create a new mock RPC client using the given request matcher.

pub fn publish(&self, ev: &Event)

Publishes the given event to all subscribers whose query exactly matches that of the event.

pub fn close(self)

Signal to the mock client’s driver to terminate.

Trait Implementations

impl<M: MockRequestMatcher> Client for MockClient<M>

fn perform<'life0, 'async_trait, R>(
    &'life0 self,
    request: R
) -> Pin<Box<dyn Future<Output = Result<R::Response, Error>> + Send + 'async_trait>> where
    R: Request,
    R: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Perform a request against the RPC endpoint

fn abci_info<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<AbciInfo, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/abci_info: get information about the ABCI application.

fn abci_query<'life0, 'async_trait, V>(
    &'life0 self,
    path: Option<Path>,
    data: V,
    height: Option<Height>,
    prove: bool
) -> Pin<Box<dyn Future<Output = Result<AbciQuery, Error>> + Send + 'async_trait>> where
    V: Into<Vec<u8>> + Send,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/abci_query: query the ABCI application

fn block<'life0, 'async_trait, H>(
    &'life0 self,
    height: H
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    H: Into<Height> + Send,
    H: 'async_trait,
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/block: get block at a given height.

fn latest_block<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/block: get the latest block.

fn block_results<'life0, 'async_trait, H>(
    &'life0 self,
    height: H
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    H: Into<Height> + Send,
    H: 'async_trait,
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/block_results: get ABCI results for a block at a particular height.

fn latest_block_results<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/block_results: get ABCI results for the latest block.

fn block_search<'life0, 'async_trait>(
    &'life0 self,
    query: Query,
    page: u32,
    per_page: u8,
    order: Order
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/block_search: search for blocks by BeginBlock and EndBlock events.

fn blockchain<'life0, 'async_trait, H>(
    &'life0 self,
    min: H,
    max: H
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    H: Into<Height> + Send,
    H: 'async_trait,
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/blockchain: get block headers for min <= height <= max.

fn broadcast_tx_async<'life0, 'async_trait>(
    &'life0 self,
    tx: Transaction
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/broadcast_tx_async: broadcast a transaction, returning immediately.

fn broadcast_tx_sync<'life0, 'async_trait>(
    &'life0 self,
    tx: Transaction
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/broadcast_tx_sync: broadcast a transaction, returning the response from CheckTx.

fn broadcast_tx_commit<'life0, 'async_trait>(
    &'life0 self,
    tx: Transaction
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/broadcast_tx_commit: broadcast a transaction, returning the response from DeliverTx.

fn commit<'life0, 'async_trait, H>(
    &'life0 self,
    height: H
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    H: Into<Height> + Send,
    H: 'async_trait,
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/commit: get block commit at a given height.

fn consensus_params<'life0, 'async_trait, H>(
    &'life0 self,
    height: H
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    H: Into<Height> + Send,
    H: 'async_trait,
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/consensus_params: get current consensus parameters at the specified height.

fn consensus_state<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/consensus_state: get current consensus state

fn validators<'life0, 'async_trait, H>(
    &'life0 self,
    height: H,
    paging: Paging
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    H: Into<Height> + Send,
    H: 'async_trait,
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/validators: get validators a given height.

fn latest_consensus_params<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/consensus_params: get the latest consensus parameters.

fn latest_commit<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/commit: get the latest block commit

fn health<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/health: get node health.

fn genesis<'life0, 'async_trait, AppState>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Genesis<AppState>, Error>> + Send + 'async_trait>> where
    AppState: Debug + Serialize + DeserializeOwned + Send,
    AppState: 'async_trait,
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/genesis: get genesis file.

fn net_info<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/net_info: obtain information about P2P and other network connections.

fn status<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/status: get Tendermint status including node info, pubkey, latest block hash, app hash, block height and time.

fn broadcast_evidence<'life0, 'async_trait>(
    &'life0 self,
    e: Evidence
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/broadcast_evidence: broadcast an evidence.

fn tx<'life0, 'async_trait>(
    &'life0 self,
    hash: Hash,
    prove: bool
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/tx: find transaction by hash.

fn tx_search<'life0, 'async_trait>(
    &'life0 self,
    query: Query,
    prove: bool,
    page: u32,
    per_page: u8,
    order: Order
) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

/tx_search: search for transactions with their results.

fn wait_until_healthy<'life0, 'async_trait, T>(
    &'life0 self,
    timeout: T
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    T: Into<Duration> + Send,
    T: 'async_trait,
    'life0: 'async_trait,
    Self: Sync + 'async_trait, 

Poll the /health endpoint until it returns a successful result or the given timeout has elapsed.

impl<M: Debug + MockRequestMatcher> Debug for MockClient<M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M: MockRequestMatcher> SubscriptionClient for MockClient<M>

fn subscribe<'life0, 'async_trait>(
    &'life0 self,
    query: Query
) -> Pin<Box<dyn Future<Output = Result<Subscription, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

/subscribe: subscribe to receive events produced by the given query.

fn unsubscribe<'life0, 'async_trait>(
    &'life0 self,
    query: Query
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

/unsubscribe: unsubscribe from events relating to the given query.

fn close(self) -> Result<(), Error>

Subscription clients will usually have long-running underlying transports that will need to be closed at some point.