dash/test/functional/feature_governance_objects.py at develop · dashpay/dash · GitHub

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
#!/usr/bin/env python3
# Copyright (c) 2018-2024 The Dash Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Tests around dash governance objects."""

import time

from test_framework.governance import prepare_object
from test_framework.messages import uint256_to_string
from test_framework.test_framework import DashTestFramework
from test_framework.util import assert_equal, assert_greater_than, assert_raises_rpc_error


def validate_object(prepared, rpc_prepared):
    assert_equal(prepared["parentHash"], rpc_prepared["parentHash"])
    assert_equal(prepared["collateralHash"], rpc_prepared["collateralHash"])
    assert_equal(prepared["createdAt"], rpc_prepared["createdAt"])
    assert_equal(prepared["revision"], rpc_prepared["revision"])
    assert_equal(prepared["hex"], rpc_prepared["data"]["hex"])
    del rpc_prepared["data"]["hex"]
    assert_equal(prepared["data"], rpc_prepared["data"])

class DashGovernanceTest (DashTestFramework):
    def add_options(self, parser):
        self.add_wallet_options(parser)

    def set_test_params(self):
        self.set_dash_test_params(1, 0)

    def prepare_object(self, object_type, parent_hash, creation_time, revision, name, amount):
        payment_address = self.nodes[0].getnewaddress()
        return prepare_object(self.nodes[0], object_type, parent_hash, creation_time, revision, name, amount, payment_address)

    def run_test(self):

        time_start = time.time()
        object_type = 1  # GOVERNANCE PROPOSAL

        # At start there should be no prepared objects available
        assert_equal(len(self.nodes[0].gobject("list-prepared")), 0)
        # Create 5 proposals with different creation times and validate their ordered like expected
        p1 = self.prepare_object(object_type, uint256_to_string(0), time_start, 0, "SortByTime1", 1)
        p2 = self.prepare_object(object_type, uint256_to_string(0), time_start + 10, 1000, "SortByTime2", 10)
        p3 = self.prepare_object(object_type, uint256_to_string(0), time_start - 10, 1000000000, "SortByTime3", 20)
        p4 = self.prepare_object(object_type, uint256_to_string(0), time_start + 1, -20, "SortByTime4", 400)
        p5 = self.prepare_object(object_type, uint256_to_string(0), time_start + 30, 1, "SortByTime5", 100000000)

        rpc_list_prepared = self.nodes[0].gobject("list-prepared")
        assert_equal(len(rpc_list_prepared), 5)

        expected_order = [p3, p1, p4, p2, p5]
        for i in range(len(expected_order)):
            validate_object(expected_order[i], rpc_list_prepared[i])

        # Create two more with the same time
        self.prepare_object(object_type, uint256_to_string(0), time_start + 60, 1, "SameTime1", 2)
        self.prepare_object(object_type, uint256_to_string(0), time_start + 60, 2, "SameTime2", 2)
        # Query them with count=2
        rpc_list_prepared = self.nodes[0].gobject("list-prepared", 2)
        # And make sure it does only return 2 of the 7 available
        assert_equal(len(rpc_list_prepared), 2)
        # Since they have the same time they should be sorted by hex data, in this case, the second should be greater
        assert_greater_than(rpc_list_prepared[1]["data"]["hex"], rpc_list_prepared[0]["data"]["hex"])
        # Restart node0 and make sure it still contains all valid proposals after restart
        rpc_full_list_pre_restart = self.nodes[0].gobject("list-prepared")
        self.restart_node(0)
        rpc_full_list_post_restart = self.nodes[0].gobject("list-prepared")
        assert_equal(rpc_full_list_pre_restart, rpc_full_list_post_restart)
        # Create more objects so that we have a total of 11
        self.prepare_object(object_type, uint256_to_string(0), time_start, 0, "More1", 1)
        self.prepare_object(object_type, uint256_to_string(0), time_start, 0, "More2", 1)
        self.prepare_object(object_type, uint256_to_string(0), time_start, 0, "More3", 1)
        self.prepare_object(object_type, uint256_to_string(0), time_start, 0, "More4", 1)
        # Make sure default count is 10 while there are 11 in total
        assert_equal(len(self.nodes[0].gobject("list-prepared")), 10)
        assert_equal(len(self.nodes[0].gobject("list-prepared", 12)), 11)
        # count greater than the number of prepared objects returns all of them (no overflow)
        assert_equal(len(self.nodes[0].gobject("list-prepared", 1000)), 11)
        # Very large count (near INT64_MAX) must still be clamped safely
        assert_equal(len(self.nodes[0].gobject("list-prepared", 9223372036854775807)), 11)
        # Make sure it returns 0 objects with count=0
        assert_equal(len(self.nodes[0].gobject("list-prepared", 0)), 0)
        # And test some invalid count values
        assert_raises_rpc_error(-8, "Negative count", self.nodes[0].gobject, "list-prepared", -1)
        assert_raises_rpc_error(-8, "Negative count", self.nodes[0].gobject, "list-prepared", -1000)


if __name__ == '__main__':
    DashGovernanceTest().main()