mock-cosmwasm-contract 0.1.2

Mock CosmWasm contract that can set predetermined responses to queries and keep track of execution for testing purposes.
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

#[cfg(not(feature = "library"))]
use cosmwasm_std::entry_point;
use cosmwasm_std::{to_json_binary, Binary, Deps, DepsMut, Env, MessageInfo, Response};

use crate::error::ContractError;
use crate::msg::{ExecuteMsg, InstantiateMsg, QueryMsg};
use crate::state::STUBS;

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn instantiate(
    _deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    _msg: InstantiateMsg,
) -> Result<Response, ContractError> {
    Ok(Response::default())
}

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn execute(
    deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, ContractError> {
    match msg {
        ExecuteMsg::SetStubQuery { query, response } => {
            STUBS.save(deps.storage, query.0, &to_json_binary(&response)?)?;
        }
        ExecuteMsg::RemoveStubQuery { query } => {
            STUBS.remove(deps.storage, query.0);
        }
    }

    Ok(Response::default())
}

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> Result<Binary, ContractError> {
    let response = STUBS.may_load(deps.storage, msg.0.clone())?;
    response.ok_or_else(|| ContractError::NoStubQuery { query: msg.0 })
}

#[cfg(test)]
mod tests {
    use cosmwasm_schema::cw_serde;
    use cosmwasm_std::{
        from_json,
        testing::{mock_dependencies, mock_env, mock_info},
        to_json_string,
    };

    use crate::msg::{query_msg, set_stub_query_msg};

    use super::*;

    #[cw_serde]
    enum TestQueryMsg {
        QueryVariant { arg: String },
    }

    #[cw_serde]
    struct QueryResponse {
        value: String,
    }

    #[test]
    fn test_stub_query() {
        let mut deps = mock_dependencies();

        let q = TestQueryMsg::QueryVariant {
            arg: "first".to_string(),
        };

        let query_response = QueryResponse {
            value: "first".to_string(),
        };

        execute(
            deps.as_mut(),
            mock_env(),
            mock_info("sender", &[]),
            set_stub_query_msg(&q, &query_response).unwrap(),
        )
        .unwrap();

        let actual_query_response =
            query(deps.as_ref(), mock_env(), query_msg(&q).unwrap()).unwrap();

        assert_eq!(
            to_json_string(&query_response).unwrap(),
            from_json::<String>(&actual_query_response.as_slice()).unwrap()
        );

        let q = query_msg(&TestQueryMsg::QueryVariant {
            arg: "first_no_stub".to_string(),
        })
        .unwrap();

        let err = query(deps.as_ref(), mock_env(), q).unwrap_err();

        assert_eq!(
            err,
            ContractError::NoStubQuery {
                query: to_json_string(&TestQueryMsg::QueryVariant {
                    arg: "first_no_stub".to_string()
                })
                .unwrap()
            }
        );
    }
}