tg-voting-contract 0.8.0

Generic utils for building voting contracts for tgrade
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

use cosmwasm_std::StdError;
use tg3::Status;
use tg_utils::Expiration;

use crate::multitest::contracts::voting::Proposal;
use crate::multitest::suite::{get_proposal_id, SuiteBuilder};
use crate::state::{ProposalResponse, RulesBuilder, Votes};
use crate::ContractError;

#[test]
fn proposal_creation() {
    let rules = RulesBuilder::new().build();

    let mut suite = SuiteBuilder::new()
        .with_member("alice", 1)
        .with_member("bob", 3)
        .with_rules(rules.clone())
        .build();

    let res = suite
        .propose("alice", "best proposal", "it's just the best")
        .unwrap();

    let id = get_proposal_id(&res).unwrap();
    let proposal = suite.query_proposal(id).unwrap();
    let expected_expiration = Expiration::at_timestamp(
        suite
            .app
            .block_info()
            .time
            .plus_seconds(rules.voting_period_secs()),
    );
    assert_eq!(
        proposal,
        ProposalResponse {
            id: 1,
            title: "best proposal".to_string(),
            description: "it's just the best".to_string(),
            created_by: "alice".to_owned(),
            proposal: Proposal::Text {},
            status: Status::Open,
            expires: expected_expiration,
            rules,
            total_points: 4,
            votes: Votes::yes(1),
        }
    )
}

#[test]
fn member_with_no_voting_power_cannot_propose() {
    let mut suite = SuiteBuilder::new()
        .with_member("alice", 0)
        .with_member("bob", 3)
        .build();

    let err = suite
        .propose("alice", "do the thing", "do the thing")
        .unwrap_err();

    assert_eq!(
        ContractError::Std(StdError::GenericErr {
            msg: "Unauthorized: member doesn't have voting power".to_string()
        }),
        err.downcast().unwrap()
    );
}

#[test]
fn proposal_from_non_voter_is_rejected() {
    let mut suite = SuiteBuilder::new().with_member("alice", 1).build();

    let err = suite
        .propose("bob", "do the thing", "do the thing")
        .unwrap_err();

    assert_eq!(
        ContractError::Std(StdError::GenericErr {
            msg: "Unauthorized: not member of a group".to_string()
        }),
        err.downcast().unwrap()
    );
}

#[test]
fn proposal_from_voter_is_accepted() {
    let mut suite = SuiteBuilder::new()
        .with_member("alice", 1)
        .with_member("bob", 3)
        .build();

    let res = suite
        .propose("alice", "do the thing", "do the thing")
        .unwrap();

    assert_eq!(
        res.custom_attrs(1),
        [
            ("action", "propose"),
            ("sender", "alice"),
            ("proposal_id", "1"),
            ("status", "Open"),
        ],
    );
}

#[test]
fn proposal_from_voter_can_directly_pass() {
    let mut suite = SuiteBuilder::new()
        .with_member("alice", 1)
        .with_member("bob", 3)
        .build();

    let res = suite
        .propose("bob", "do the thing", "do the thing")
        .unwrap();

    assert_eq!(
        res.custom_attrs(1),
        [
            ("action", "propose"),
            ("sender", "bob"),
            ("proposal_id", "1"),
            ("status", "Passed"),
        ],
    );
}