mirror of
https://github.com/dashpay/dash.git
synced 2024-12-25 12:02:48 +01:00
101 lines
5.1 KiB
Python
Executable File
101 lines
5.1 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Copyright (c) 2018-2020 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."""
|
|
|
|
from test_framework.test_framework import DashTestFramework
|
|
from test_framework.util import *
|
|
from test_framework.messages import *
|
|
|
|
|
|
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 set_test_params(self):
|
|
self.set_dash_test_params(2, 1)
|
|
|
|
def prepare_object(self, object_type, parent_hash, creation_time, revision, name, amount):
|
|
proposal_rev = revision
|
|
proposal_time = int(creation_time)
|
|
proposal_template = {
|
|
"type": object_type,
|
|
"name": name,
|
|
"start_epoch": proposal_time,
|
|
"end_epoch": proposal_time + 24 * 60 * 60,
|
|
"payment_amount": amount,
|
|
"payment_address": self.nodes[0].getnewaddress(),
|
|
"url": "https://dash.org"
|
|
}
|
|
proposal_hex = ''.join(format(x, '02x') for x in json.dumps(proposal_template).encode())
|
|
collateral_hash = self.nodes[0].gobject("prepare", parent_hash, proposal_rev, proposal_time, proposal_hex)
|
|
return {
|
|
"parentHash": parent_hash,
|
|
"collateralHash": collateral_hash,
|
|
"createdAt": proposal_time,
|
|
"revision": proposal_rev,
|
|
"hex": proposal_hex,
|
|
"data": proposal_template,
|
|
}
|
|
|
|
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)
|
|
# 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()
|