cw-multi-test 3.0.1

Testing tools for multi-contract interactions
Documentation 
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

mod test_submessage_payload;

mod test_contracts {
    pub mod payloader {
        use cosmwasm_schema::cw_serde;
        use cosmwasm_std::{
            from_json, to_json_binary, BankMsg, Binary, Coin, Deps, DepsMut, Empty, Env,
            MessageInfo, Reply, ReplyOn, Response, StdResult, SubMsg, Uint128,
        };

        #[cw_serde]
        pub enum ExecuteMessage {
            Send(String, u128, String),
            SendMulti(String, u128, String, u128, String),
            Burn(u128, String),
            BurnNoPayload(u128, String),
            Nop,
        }

        #[cw_serde]
        pub struct Payload {
            pub id: u64,
            pub action: String,
        }

        pub fn instantiate(
            _deps: DepsMut,
            _env: Env,
            _info: MessageInfo,
            _msg: Empty,
        ) -> StdResult<Response> {
            Ok(Response::default())
        }

        pub fn execute(
            _deps: DepsMut,
            _env: Env,
            _info: MessageInfo,
            msg: ExecuteMessage,
        ) -> StdResult<Response> {
            let mut response = Response::new().set_data(to_json_binary(&Payload {
                id: 0,
                action: "EXECUTE".to_string(),
            })?);
            match msg {
                ExecuteMessage::Send(addr, amount, denom) => {
                    let msg_send = BankMsg::Send {
                        to_address: addr.clone(),
                        amount: vec![Coin::new(Uint128::new(amount), denom.clone())],
                    };
                    response = response.add_submessage(SubMsg {
                        id: 1,
                        payload: to_json_binary(&Payload {
                            id: 0,
                            action: "SEND".to_string(),
                        })?,
                        msg: msg_send.into(),
                        gas_limit: None,
                        reply_on: ReplyOn::Always,
                    });
                }
                ExecuteMessage::SendMulti(addr1, amount1, addr2, amount2, denom) => {
                    let msg_send = BankMsg::Send {
                        to_address: addr1.clone(),
                        amount: vec![Coin::new(Uint128::new(amount1), denom.clone())],
                    };
                    response = response.add_submessage(SubMsg {
                        id: 2,
                        payload: to_json_binary(&Payload {
                            id: 0,
                            action: "SEND".to_string(),
                        })?,
                        msg: msg_send.into(),
                        gas_limit: None,
                        reply_on: ReplyOn::Always,
                    });
                    let msg_send = BankMsg::Send {
                        to_address: addr2.clone(),
                        amount: vec![Coin::new(Uint128::new(amount2), denom.clone())],
                    };
                    response = response.add_submessage(SubMsg {
                        id: 3,
                        payload: to_json_binary(&Payload {
                            id: 0,
                            action: "SEND".to_string(),
                        })?,
                        msg: msg_send.into(),
                        gas_limit: None,
                        reply_on: ReplyOn::Always,
                    });
                }
                ExecuteMessage::Burn(amount, denom) => {
                    let msg_send = BankMsg::Burn {
                        amount: vec![Coin::new(Uint128::new(amount), denom.clone())],
                    };
                    response = response.add_submessage(SubMsg {
                        id: 4,
                        payload: to_json_binary(&Payload {
                            id: 0,
                            action: "BURN".to_string(),
                        })?,
                        msg: msg_send.into(),
                        gas_limit: None,
                        reply_on: ReplyOn::Always,
                    });
                }
                ExecuteMessage::BurnNoPayload(amount, denom) => {
                    let msg_send = BankMsg::Burn {
                        amount: vec![Coin::new(Uint128::new(amount), denom.clone())],
                    };
                    response = response.add_submessage(SubMsg {
                        id: 5,
                        payload: Binary::default(),
                        msg: msg_send.into(),
                        gas_limit: None,
                        reply_on: ReplyOn::Always,
                    });
                }
                ExecuteMessage::Nop => {}
            }
            Ok(response)
        }

        pub fn query(_deps: Deps, _env: Env, _msg: Empty) -> StdResult<Binary> {
            Ok(Binary::default())
        }

        pub fn reply(_deps: DepsMut, _env: Env, msg: Reply) -> StdResult<Response> {
            #[allow(deprecated)]
            let Reply { id, payload, .. } = msg;
            let payload = if let Ok(mut payload) = from_json::<Payload>(payload.clone()) {
                payload.id = id;
                payload
            } else {
                Payload {
                    id,
                    action: "EMPTY".to_string(),
                }
            };
            Ok(Response::new().set_data(to_json_binary(&payload)?))
        }
    }
}