Struct abstract_testing::MockQuerierBuilder

pub struct MockQuerierBuilder { /* private fields */ }

MockQuerierBuilder is a helper to build a MockQuerier. Usage:

use cosmwasm_std::{from_json, to_json_binary};
use abstract_testing::MockQuerierBuilder;
use cosmwasm_std::testing::MockQuerier;
use abstract_sdk::mock_module::MockModuleExecuteMsg;

let querier = MockQuerierBuilder::default().with_smart_handler("contract_address", |msg| {
   // handle the message
    let res = match from_json::<MockModuleExecuteMsg>(msg).unwrap() {
        // handle the message
       _ => panic!("unexpected message"),
   };

  Ok(to_json_binary(&msg).unwrap())
}).build();

Implementations

impl MockQuerierBuilder

pub fn with_fallback_smart_handler<SH>(self, handler: SH) -> Self

where SH: 'static + Fn(&str, &Binary) -> Result<Binary, String>,

pub fn with_fallback_raw_handler<RH>(self, handler: RH) -> Self

where RH: 'static + Fn(&str, &Binary) -> Result<Binary, String>,

pub fn with_smart_handler<SH>(self, contract: &str, handler: SH) -> Self

where SH: 'static + Fn(&Binary) -> Result<Binary, String>,

Add a smart query contract handler to the mock querier. The handler will be called when the contract address is queried with the given message. Usage:

use cosmwasm_std::{from_json, to_json_binary};
use abstract_testing::MockQuerierBuilder;
use cosmwasm_std::testing::MockQuerier;
use abstract_sdk::mock_module::{MockModuleQueryMsg, MockModuleQueryResponse};

let querier = MockQuerierBuilder::default().with_smart_handler("contract_address", |msg| {
   // handle the message
    let res = match from_json::<MockModuleQueryMsg>(msg).unwrap() {
        // handle the message
        MockModuleQueryMsg =>
                        return to_json_binary(&MockModuleQueryResponse {}).map_err(|e| e.to_string())
   };
}).build();

pub fn with_raw_handler<RH>(self, contract: &str, handler: RH) -> Self

where RH: 'static + Fn(&str) -> Result<Binary, String>,

Add a raw query contract handler to the mock querier. The handler will be called when the contract address is queried with the given message. Usage:

use cosmwasm_std::{from_json, to_json_binary};
use abstract_testing::MockQuerierBuilder;
use cosmwasm_std::testing::MockQuerier;
use abstract_sdk::mock_module::{MockModuleQueryMsg, MockModuleQueryResponse};

let querier = MockQuerierBuilder::default().with_raw_handler("contract1", |key: &str| {
    // Example: Let's say, in the raw storage, the key "the key" maps to the value "the value"
    match key {
        "the key" => to_json_binary("the value").map_err(|e| e.to_string()),
        _ => to_json_binary("").map_err(|e| e.to_string())
    }
}).build();

pub fn with_contract_map_entry<'a, K, V>( self, contract: &str, cw_map: Map<'a, K, V>, entry: (K, V) ) -> Self

where K: PrimaryKey<'a>, V: Serialize + DeserializeOwned,

Add a map entry to the querier for the given contract.

use cw_storage_plus::Map;
use abstract_testing::MockQuerierBuilder;

const MAP: Map<String, String> = Map::new("map");

MockQuerierBuilder::default()
    .with_contract_map_entry(
    "contract_address",
    MAP,
    ("key".to_string(), "value".to_string())
);

pub fn with_contract_map_entries<'a, K, V>( self, contract: &str, cw_map: Map<'a, K, V>, entries: Vec<(K, V)> ) -> Self

where K: PrimaryKey<'a>, V: Serialize + DeserializeOwned,

pub fn with_contract_map_key<'a, K, V>( self, contract: &str, cw_map: Map<'a, K, V>, key: K ) -> Self

where K: PrimaryKey<'a>, V: Serialize + DeserializeOwned,

Add an empty map key to the querier for the given contract. This is useful when you want the item to exist, but not have a value.

pub fn with_empty_contract_item<T>( self, contract: &str, cw_item: Item<'_, T> ) -> Self

where T: Serialize + DeserializeOwned,

Add an empty item key to the querier for the given contract. This is useful when you want the item to exist, but not have a value.

pub fn with_contract_item<T>( self, contract: &str, cw_item: Item<'_, T>, value: &T ) -> Self

where T: Serialize + DeserializeOwned,

Include a contract item in the mock querier.

use cw_storage_plus::Item;
use abstract_testing::MockQuerierBuilder;

const ITEM: Item<String> = Item::new("item");

MockQuerierBuilder::default()
    .with_contract_item(
    "contract_address",
    ITEM,
    &"value".to_string(),
);

pub fn with_contract_version( self, contract: &str, version: impl ToString ) -> Self

Add a specific version of the contract to the mock querier.

use abstract_testing::MockQuerierBuilder;

MockQuerierBuilder::default()
   .with_contract_version("contract_address", "v1.0.0");

pub fn with_contract_admin( self, contract: impl ToString, admin: impl ToString ) -> Self

set the SDK-level contract admin for a contract.

pub fn build(self) -> MockQuerier

Build the MockQuerier.

Trait Implementations

impl Default for MockQuerierBuilder

fn default() -> Self

Create a default

impl MockQuerierOwnership for MockQuerierBuilder

fn with_owner(self, contract: &str, owner: Option<impl ToString>) -> Self

Add the cw_ownable::Ownership to the querier.