Struct rhaki_cw_multi_test::App
source · pub struct App<Bank = BankKeeper, Api = MockApi, Storage = MockStorage, Custom = FailingModule<Empty, Empty, Empty>, Wasm = WasmKeeper<Empty, Empty>, Staking = StakeKeeper, Distr = DistributionKeeper, Ibc = FailingModule<IbcMsg, IbcQuery, Empty>, Gov = FailingModule<GovMsg, Empty, Empty>> { /* private fields */ }
Expand description
Router is a persisted state. You can query this. Execution generally happens on the RouterCache, which then can be atomically committed or rolled back. We offer .execute() as a wrapper around cache, execute, commit/rollback process.
Implementations§
source§impl App<BankKeeper, MockApi, MemoryStorage, FailingModule<Empty, Empty, Empty>, WasmKeeper<Empty, Empty>, StakeKeeper, DistributionKeeper, FailingModule<IbcMsg, IbcQuery, Empty>, FailingModule<GovMsg, Empty, Empty>>
impl App<BankKeeper, MockApi, MemoryStorage, FailingModule<Empty, Empty, Empty>, WasmKeeper<Empty, Empty>, StakeKeeper, DistributionKeeper, FailingModule<IbcMsg, IbcQuery, Empty>, FailingModule<GovMsg, Empty, Empty>>
sourcepub fn new<F>(init_fn: F) -> Selfwhere
F: FnOnce(&mut Router<BankKeeper, FailingModule<Empty, Empty, Empty>, WasmKeeper<Empty, Empty>, StakeKeeper, DistributionKeeper, FailingModule<IbcMsg, IbcQuery, Empty>, FailingModule<GovMsg, Empty, Empty>>, &dyn Api, &mut dyn Storage),
pub fn new<F>(init_fn: F) -> Selfwhere F: FnOnce(&mut Router<BankKeeper, FailingModule<Empty, Empty, Empty>, WasmKeeper<Empty, Empty>, StakeKeeper, DistributionKeeper, FailingModule<IbcMsg, IbcQuery, Empty>, FailingModule<GovMsg, Empty, Empty>>, &dyn Api, &mut dyn Storage),
Creates new default App
implementation working with Empty custom messages.
source§impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT> App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>where
WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>,
BankT: Bank,
ApiT: Api,
StorageT: Storage,
CustomT: Module,
StakingT: Staking,
DistrT: Distribution,
IbcT: Ibc,
GovT: Gov,
impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT> App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>where WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>, BankT: Bank, ApiT: Api, StorageT: Storage, CustomT: Module, StakingT: Staking, DistrT: Distribution, IbcT: Ibc, GovT: Gov,
pub fn init_modules<F, T>(&mut self, init_fn: F) -> Twhere F: FnOnce(&mut Router<BankT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>, &dyn Api, &mut dyn Storage) -> T,
pub fn read_module<F, T>(&self, query_fn: F) -> Twhere F: FnOnce(&Router<BankT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>, &dyn Api, &dyn Storage) -> T,
source§impl<BankT, ApiT, StorageT, CustomT, StakingT, DistrT, IbcT, GovT> App<BankT, ApiT, StorageT, CustomT, WasmKeeper<CustomT::ExecT, CustomT::QueryT>, StakingT, DistrT, IbcT, GovT>where
BankT: Bank,
ApiT: Api,
StorageT: Storage,
CustomT: Module,
StakingT: Staking,
DistrT: Distribution,
IbcT: Ibc,
GovT: Gov,
CustomT::ExecT: Clone + Debug + PartialEq + JsonSchema + DeserializeOwned + 'static,
CustomT::QueryT: CustomQuery + DeserializeOwned + 'static,
impl<BankT, ApiT, StorageT, CustomT, StakingT, DistrT, IbcT, GovT> App<BankT, ApiT, StorageT, CustomT, WasmKeeper<CustomT::ExecT, CustomT::QueryT>, StakingT, DistrT, IbcT, GovT>where BankT: Bank, ApiT: Api, StorageT: Storage, CustomT: Module, StakingT: Staking, DistrT: Distribution, IbcT: Ibc, GovT: Gov, CustomT::ExecT: Clone + Debug + PartialEq + JsonSchema + DeserializeOwned + 'static, CustomT::QueryT: CustomQuery + DeserializeOwned + 'static,
sourcepub fn store_code(
&mut self,
code: Box<dyn Contract<CustomT::ExecT, CustomT::QueryT>>
) -> u64
pub fn store_code( &mut self, code: Box<dyn Contract<CustomT::ExecT, CustomT::QueryT>> ) -> u64
Registers contract code (like uploading wasm bytecode on a chain), so it can later be used to instantiate a contract.
sourcepub fn store_code_with_creator(
&mut self,
creator: Addr,
code: Box<dyn Contract<CustomT::ExecT, CustomT::QueryT>>
) -> u64
pub fn store_code_with_creator( &mut self, creator: Addr, code: Box<dyn Contract<CustomT::ExecT, CustomT::QueryT>> ) -> u64
Registers contract code (like store_code), takes the code creator address as an additional argument.
sourcepub fn duplicate_code(&mut self, code_id: u64) -> AnyResult<u64>
pub fn duplicate_code(&mut self, code_id: u64) -> AnyResult<u64>
Duplicates the contract code identified by code_id
and returns
the identifier of the newly created copy of the contract code.
Examples
use cosmwasm_std::Addr;
use cw_multi_test::App;
// contract implementation
mod echo {
// contract entry points not shown here
pub fn contract() -> Box<dyn Contract<Empty>> {
// should return the contract
}
}
let mut app = App::default();
// store a new contract, save the code id
let code_id = app.store_code_with_creator(Addr::unchecked("creator"), echo::contract());
// duplicate the existing contract, duplicated contract has different code id
assert_ne!(code_id, app.duplicate_code(code_id).unwrap());
// zero is an invalid identifier for contract code, returns an error
assert_eq!("code id: invalid", app.duplicate_code(0).unwrap_err().to_string());
// there is no contract code with identifier 100 stored yet, returns an error
assert_eq!("code id 100: no such code", app.duplicate_code(100).unwrap_err().to_string());
sourcepub fn contract_data(&self, address: &Addr) -> AnyResult<ContractData>
pub fn contract_data(&self, address: &Addr) -> AnyResult<ContractData>
This allows to get ContractData
for specific contract
sourcepub fn dump_wasm_raw(&self, address: &Addr) -> Vec<Record>
pub fn dump_wasm_raw(&self, address: &Addr) -> Vec<Record>
This gets a raw state dump of all key-values held by a given contract
source§impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT> App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>where
CustomT::ExecT: Debug + PartialEq + Clone + JsonSchema + DeserializeOwned + 'static,
CustomT::QueryT: CustomQuery + DeserializeOwned + 'static,
WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>,
BankT: Bank,
ApiT: Api,
StorageT: Storage,
CustomT: Module,
StakingT: Staking,
DistrT: Distribution,
IbcT: Ibc,
GovT: Gov,
impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT> App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>where CustomT::ExecT: Debug + PartialEq + Clone + JsonSchema + DeserializeOwned + 'static, CustomT::QueryT: CustomQuery + DeserializeOwned + 'static, WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>, BankT: Bank, ApiT: Api, StorageT: Storage, CustomT: Module, StakingT: Staking, DistrT: Distribution, IbcT: Ibc, GovT: Gov,
pub fn set_block(&mut self, block: BlockInfo)
pub fn update_block<F: Fn(&mut BlockInfo)>(&mut self, action: F)
sourcepub fn block_info(&self) -> BlockInfo
pub fn block_info(&self) -> BlockInfo
Returns a copy of the current block_info
sourcepub fn wrap(&self) -> QuerierWrapper<'_, CustomT::QueryT>
pub fn wrap(&self) -> QuerierWrapper<'_, CustomT::QueryT>
Simple helper so we get access to all the QuerierWrapper helpers, eg. wrap().query_wasm_smart, query_all_balances, …
sourcepub fn execute_multi(
&mut self,
sender: Addr,
msgs: Vec<CosmosMsg<CustomT::ExecT>>
) -> AnyResult<Vec<AppResponse>>
pub fn execute_multi( &mut self, sender: Addr, msgs: Vec<CosmosMsg<CustomT::ExecT>> ) -> AnyResult<Vec<AppResponse>>
Runs multiple CosmosMsg in one atomic operation. This will create a cache before the execution, so no state changes are persisted if any of them return an error. But all writes are persisted on success.
sourcepub fn wasm_sudo<T: Serialize, U: Into<Addr>>(
&mut self,
contract_addr: U,
msg: &T
) -> AnyResult<AppResponse>
pub fn wasm_sudo<T: Serialize, U: Into<Addr>>( &mut self, contract_addr: U, msg: &T ) -> AnyResult<AppResponse>
Call a smart contract in “sudo” mode. This will create a cache before the execution, so no state changes are persisted if this returns an error, but all are persisted on success.
sourcepub fn sudo(&mut self, msg: SudoMsg) -> AnyResult<AppResponse>
pub fn sudo(&mut self, msg: SudoMsg) -> AnyResult<AppResponse>
Runs arbitrary SudoMsg. This will create a cache before the execution, so no state changes are persisted if this returns an error, but all are persisted on success.
Trait Implementations§
source§impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT> Executor<<CustomT as Module>::ExecT> for App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>where
CustomT::ExecT: Clone + Debug + PartialEq + JsonSchema + DeserializeOwned + 'static,
CustomT::QueryT: CustomQuery + DeserializeOwned + 'static,
WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>,
BankT: Bank,
ApiT: Api,
StorageT: Storage,
CustomT: Module,
StakingT: Staking,
DistrT: Distribution,
IbcT: Ibc,
GovT: Gov,
impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT> Executor<<CustomT as Module>::ExecT> for App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>where CustomT::ExecT: Clone + Debug + PartialEq + JsonSchema + DeserializeOwned + 'static, CustomT::QueryT: CustomQuery + DeserializeOwned + 'static, WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>, BankT: Bank, ApiT: Api, StorageT: Storage, CustomT: Module, StakingT: Staking, DistrT: Distribution, IbcT: Ibc, GovT: Gov,
source§fn execute(
&mut self,
sender: Addr,
msg: CosmosMsg<CustomT::ExecT>
) -> AnyResult<AppResponse>
fn execute( &mut self, sender: Addr, msg: CosmosMsg<CustomT::ExecT> ) -> AnyResult<AppResponse>
source§fn instantiate_contract<T: Serialize, U: Into<String>>(
&mut self,
code_id: u64,
sender: Addr,
init_msg: &T,
send_funds: &[Coin],
label: U,
admin: Option<String>
) -> AnyResult<Addr>
fn instantiate_contract<T: Serialize, U: Into<String>>( &mut self, code_id: u64, sender: Addr, init_msg: &T, send_funds: &[Coin], label: U, admin: Option<String> ) -> AnyResult<Addr>
source§fn execute_contract<T: Serialize + Debug>(
&mut self,
sender: Addr,
contract_addr: Addr,
msg: &T,
send_funds: &[Coin]
) -> AnyResult<AppResponse>
fn execute_contract<T: Serialize + Debug>( &mut self, sender: Addr, contract_addr: Addr, msg: &T, send_funds: &[Coin] ) -> AnyResult<AppResponse>
source§fn migrate_contract<T: Serialize>(
&mut self,
sender: Addr,
contract_addr: Addr,
msg: &T,
new_code_id: u64
) -> AnyResult<AppResponse>
fn migrate_contract<T: Serialize>( &mut self, sender: Addr, contract_addr: Addr, msg: &T, new_code_id: u64 ) -> AnyResult<AppResponse>
fn send_tokens( &mut self, sender: Addr, recipient: Addr, amount: &[Coin] ) -> AnyResult<AppResponse>
source§impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT> Querier for App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>where
CustomT::ExecT: Clone + Debug + PartialEq + JsonSchema + DeserializeOwned + 'static,
CustomT::QueryT: CustomQuery + DeserializeOwned + 'static,
WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>,
BankT: Bank,
ApiT: Api,
StorageT: Storage,
CustomT: Module,
StakingT: Staking,
DistrT: Distribution,
IbcT: Ibc,
GovT: Gov,
impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT> Querier for App<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT>where CustomT::ExecT: Clone + Debug + PartialEq + JsonSchema + DeserializeOwned + 'static, CustomT::QueryT: CustomQuery + DeserializeOwned + 'static, WasmT: Wasm<CustomT::ExecT, CustomT::QueryT>, BankT: Bank, ApiT: Api, StorageT: Storage, CustomT: Module, StakingT: Staking, DistrT: Distribution, IbcT: Ibc, GovT: Gov,
source§fn raw_query(&self, bin_request: &[u8]) -> QuerierResult
fn raw_query(&self, bin_request: &[u8]) -> QuerierResult
Auto Trait Implementations§
impl<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov> RefUnwindSafe for App<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov>where Api: RefUnwindSafe, Bank: RefUnwindSafe, Custom: RefUnwindSafe, Distr: RefUnwindSafe, Gov: RefUnwindSafe, Ibc: RefUnwindSafe, Staking: RefUnwindSafe, Storage: RefUnwindSafe, Wasm: RefUnwindSafe,
impl<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov> Send for App<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov>where Api: Send, Bank: Send, Custom: Send, Distr: Send, Gov: Send, Ibc: Send, Staking: Send, Storage: Send, Wasm: Send,
impl<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov> Sync for App<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov>where Api: Sync, Bank: Sync, Custom: Sync, Distr: Sync, Gov: Sync, Ibc: Sync, Staking: Sync, Storage: Sync, Wasm: Sync,
impl<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov> Unpin for App<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov>where Api: Unpin, Bank: Unpin, Custom: Unpin, Distr: Unpin, Gov: Unpin, Ibc: Unpin, Staking: Unpin, Storage: Unpin, Wasm: Unpin,
impl<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov> UnwindSafe for App<Bank, Api, Storage, Custom, Wasm, Staking, Distr, Ibc, Gov>where Api: UnwindSafe, Bank: UnwindSafe, Custom: UnwindSafe, Distr: UnwindSafe, Gov: UnwindSafe, Ibc: UnwindSafe, Staking: UnwindSafe, Storage: UnwindSafe, Wasm: UnwindSafe,
Blanket Implementations§
§impl<U> As for U
impl<U> As for U
§fn as_<T>(self) -> Twhere
T: CastFrom<U>,
fn as_<T>(self) -> Twhere T: CastFrom<U>,
self
to type T
. The semantics of numeric casting with the as
operator are followed, so <T as As>::as_::<U>
can be used in the same way as T as U
for numeric conversions. Read more