tx-test-tube 6.0.0

CosmWasm integration testing for TX
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use crate::{fn_execute, fn_query};
use tx_wasm_sdk::types::cosmos::bank::v1beta1::{
    MsgSend, MsgSendResponse, QueryAllBalancesRequest, QueryAllBalancesResponse,
    QueryBalanceRequest, QueryBalanceResponse, QueryTotalSupplyRequest, QueryTotalSupplyResponse,
};

use test_tube_tx::module::Module;
use test_tube_tx::runner::Runner;

pub struct Bank<'a, R: Runner<'a>> {
    runner: &'a R,
}

impl<'a, R: Runner<'a>> Module<'a, R> for Bank<'a, R> {
    fn new(runner: &'a R) -> Self {
        Self { runner }
    }
}

impl<'a, R> Bank<'a, R>
where
    R: Runner<'a>,
{
    fn_execute! {
        pub send: MsgSend["/cosmos.bank.v1beta1.MsgSend"] => MsgSendResponse
    }

    fn_query! {
        pub query_balance ["/cosmos.bank.v1beta1.Query/Balance"]: QueryBalanceRequest => QueryBalanceResponse
    }

    fn_query! {
        pub query_all_balances ["/cosmos.bank.v1beta1.Query/AllBalances"]: QueryAllBalancesRequest => QueryAllBalancesResponse
    }

    fn_query! {
        pub query_total_supply ["/cosmos.bank.v1beta1.Query/TotalSupply"]: QueryTotalSupplyRequest => QueryTotalSupplyResponse
    }
}

#[cfg(test)]
mod tests {
    use cosmwasm_std::Coin;
    use tx_wasm_sdk::types::cosmos::bank::v1beta1::{MsgSend, QueryBalanceRequest};
    use tx_wasm_sdk::types::cosmos::base::v1beta1::Coin as BaseCoin;

    use crate::runner::app::FEE_DENOM;
    use crate::{Account, Bank, Module, TXTestApp};

    #[test]
    fn bank_integration() {
        let app = TXTestApp::new();
        let signer = app
            .init_account(&[Coin::new(100_000_000_000_000_000_000u128, FEE_DENOM)])
            .unwrap();
        let receiver = app.init_account(&[Coin::new(1u128, FEE_DENOM)]).unwrap();
        let bank = Bank::new(&app);

        let response = bank
            .query_balance(&QueryBalanceRequest {
                address: receiver.address(),
                denom: FEE_DENOM.to_string(),
            })
            .unwrap();
        assert_eq!(
            response.balance.unwrap(),
            BaseCoin {
                amount: 1u128.to_string(),
                denom: FEE_DENOM.to_string(),
            }
        );

        bank.send(
            MsgSend {
                from_address: signer.address(),
                to_address: receiver.address(),
                amount: vec![BaseCoin {
                    amount: 9u128.to_string(),
                    denom: FEE_DENOM.to_string(),
                }],
            },
            &signer,
        )
        .unwrap();

        let response = bank
            .query_balance(&QueryBalanceRequest {
                address: receiver.address(),
                denom: FEE_DENOM.to_string(),
            })
            .unwrap();

        assert_eq!(
            response.balance.unwrap(),
            BaseCoin {
                amount: 10u128.to_string(),
                denom: FEE_DENOM.to_string(),
            }
        );
    }
}