test-suite 3.15.0

Stargaze Test Suite for Launchpad
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
144
145
146
147
148
149

use cosmwasm_std::{Coin, Timestamp, Uint128};
use cw_multi_test::Executor;
use open_edition_factory::state::ParamsExtension;
use sg_std::{GENESIS_MINT_START_TIME, NATIVE_DENOM};

use open_edition_minter::msg::{EndTimeResponse, StartTimeResponse};
use open_edition_minter::msg::{ExecuteMsg, QueryMsg};

use crate::common_setup::setup_minter::common::constants::DEV_ADDRESS;
use crate::common_setup::setup_minter::open_edition_minter::minter_params::{
    default_nft_data, init_msg,
};
use crate::common_setup::templates::open_edition_minter_custom_template;

#[test]
fn check_start_end_time_updates() {
    let params_extension = ParamsExtension {
        max_token_limit: 10,
        max_per_address_limit: 10,
        airdrop_mint_fee_bps: 100,
        airdrop_mint_price: Coin {
            denom: NATIVE_DENOM.to_string(),
            amount: Uint128::new(100_000_000u128),
        },
        dev_fee_address: DEV_ADDRESS.to_string(),
    };
    let per_address_limit_minter = Some(2);
    let init_msg = init_msg(
        default_nft_data(),
        per_address_limit_minter,
        None,
        Some(Timestamp::from_nanos(GENESIS_MINT_START_TIME + 10_000)),
        None,
        None,
        None,
    );
    let vt = open_edition_minter_custom_template(params_extension, init_msg).unwrap();
    let (mut router, creator, _buyer) = (vt.router, vt.accts.creator, vt.accts.buyer);
    let minter_addr = vt.collection_response_vec[0].minter.clone().unwrap();

    // Query Start Time
    // We know it is GENESIS_MINT_START_TIME + 100
    let query_start_time_msg: QueryMsg = QueryMsg::StartTime {};
    let res: StartTimeResponse = router
        .wrap()
        .query_wasm_smart(minter_addr.clone(), &query_start_time_msg)
        .unwrap();
    assert_eq!(
        res.start_time,
        Timestamp::from_nanos(GENESIS_MINT_START_TIME + 100).to_string()
    );

    // Query End Time
    // We know it is GENESIS_MINT_START_TIME + 10_000
    let query_end_time_msg: QueryMsg = QueryMsg::EndTime {};
    let res: EndTimeResponse = router
        .wrap()
        .query_wasm_smart(minter_addr.clone(), &query_end_time_msg)
        .unwrap();
    assert_eq!(
        res.end_time,
        Some(Timestamp::from_nanos(GENESIS_MINT_START_TIME + 10_000).to_string())
    );

    // Cant change start time to before the current time
    let new_start_time_msg =
        ExecuteMsg::UpdateStartTime(Timestamp::from_nanos(1_500_000_000_000_000_000));
    let res = router.execute_contract(
        creator.clone(),
        minter_addr.clone(),
        &new_start_time_msg,
        &[],
    );
    assert_eq!(
        res.err().unwrap().source().unwrap().to_string(),
        "InvalidStartTime 1500000000.000000000 < 1571797419.879305533"
    );

    // Cant change start time to after the end time
    let new_start_time_msg =
        ExecuteMsg::UpdateStartTime(Timestamp::from_nanos(GENESIS_MINT_START_TIME + 10_001));
    let res = router.execute_contract(
        creator.clone(),
        minter_addr.clone(),
        &new_start_time_msg,
        &[],
    );
    assert_eq!(
        res.err().unwrap().source().unwrap().to_string(),
        "InvalidStartTime 1647032400.000010000 < 1647032400.000010001"
    );

    // Cant change end time to before the current time
    let new_end_time_msg =
        ExecuteMsg::UpdateEndTime(Timestamp::from_nanos(1_500_000_000_000_000_000));
    let res = router.execute_contract(creator.clone(), minter_addr.clone(), &new_end_time_msg, &[]);
    assert_eq!(
        res.err().unwrap().source().unwrap().to_string(),
        "InvalidEndTime 1500000000.000000000 < 1571797419.879305533"
    );

    // Cant change end time to before the start time
    let new_end_time_msg =
        ExecuteMsg::UpdateEndTime(Timestamp::from_nanos(GENESIS_MINT_START_TIME + 99));
    let res = router.execute_contract(creator.clone(), minter_addr.clone(), &new_end_time_msg, &[]);
    assert_eq!(
        res.err().unwrap().source().unwrap().to_string(),
        "InvalidEndTime 1647032400.000000099 < 1647032400.000000100"
    );

    // Make valid change to start time
    let new_start_time_msg =
        ExecuteMsg::UpdateStartTime(Timestamp::from_nanos(GENESIS_MINT_START_TIME + 1_000));
    let res = router.execute_contract(
        creator.clone(),
        minter_addr.clone(),
        &new_start_time_msg,
        &[],
    );
    assert!(res.is_ok());

    // Query to validate the new start time
    let query_start_time_msg: QueryMsg = QueryMsg::StartTime {};
    let res: StartTimeResponse = router
        .wrap()
        .query_wasm_smart(minter_addr.clone(), &query_start_time_msg)
        .unwrap();
    assert_eq!(
        res.start_time,
        Timestamp::from_nanos(GENESIS_MINT_START_TIME + 1_000).to_string()
    );

    // Make valid change to end time
    let new_end_time_msg =
        ExecuteMsg::UpdateEndTime(Timestamp::from_nanos(GENESIS_MINT_START_TIME + 20_000));
    let res = router.execute_contract(creator, minter_addr.clone(), &new_end_time_msg, &[]);
    assert!(res.is_ok());

    // Query to validate the new end time
    let query_end_time_msg: QueryMsg = QueryMsg::EndTime {};
    let res: EndTimeResponse = router
        .wrap()
        .query_wasm_smart(minter_addr, &query_end_time_msg)
        .unwrap();
    assert_eq!(
        res.end_time,
        Some(Timestamp::from_nanos(GENESIS_MINT_START_TIME + 20_000).to_string())
    );
}