//! This example shows to how to use the `MockTransport` to mock the provider responses for testing

//! purposes.

//!

//! This aids in testing parts of your code that relies on provider without having to connect to a

//! network.

use alloy::{

primitives::{Address, U256},

providers::{Provider, ProviderBuilder},

rpc::json_rpc::ErrorPayload,

transports::mock::Asserter,

};

#[tokio::main]

async fn main() -> eyre::Result<()> {

// Asserter is used to push responses to the provided whether success or failure as you'll see

// in the next steps. Note that the `Asserter` wraps a FIFO queue and responses are returned

// in the order they are pushed.

let asserter = Asserter::new();

// Initialize the provider with the `MockTransport` that intercepts incoming requests and uses

// the `Asserter` to return the next response.

// `Asserter` is cheaply cloneable as the underlying queue is wrapped in an `Arc`.

let provider = ProviderBuilder::new().on_mocked_client(asserter.clone());

// Mock the response for a basic `get_block_number` request.

let expected_bn = 1000;

// The `.push_success` accepts any type that implements `serde::Serialize`

asserter.push_success(&expected_bn);

// Push an error response.

asserter.push_failure_msg("SOME ERROR");

// One can also push a custom `ErrorPayload` response that you're expecting the RPC server to

// return.

asserter.push_failure(ErrorPayload::invalid_request());

let actual_bn = provider.get_block_number().await?;

assert_eq!(actual_bn, expected_bn);

// Mock an error response.

let err = provider.get_block_number().await.unwrap_err();

assert!(err.as_error_resp().unwrap().to_string().contains("SOME ERROR"));

// Mock a custom error response.

let err = provider.get_block_number().await.unwrap_err();

assert_eq!(err.as_error_resp().unwrap().code, -32600);

assert_eq!(err.as_error_resp().unwrap().message, "Invalid Request");

// Mocking a certain response and expecting a different response will lead to a deserialization

// error.

let expected_balance = U256::MAX;

asserter.push_success(&expected_balance);

// Try to get block_number instead of balance.

// This will fail because the next response is going to be U256::MAX, but `get_block_number`

// tries to deserialize the response to `u64` which is not possible.

let err = provider.get_block_number().await.unwrap_err();

assert!(err.is_deser_error());

// Since we're using the `MockTransport`, we can assert raw JSON-RPC requests as well.

let expected_balance = U256::from(1000);

asserter.push_success(&expected_balance);

// Raw request

let addr = Address::with_last_byte(1);

let balance: U256 = provider.raw_request("eth_getBalance".into(), (addr,)).await?;

assert_eq!(balance, expected_balance);

Ok(())

}