github.com/platonnetwork/platon-go@v0.7.6/cases/tests/govern/test_interface.py (about) 1 from common.log import log 2 from tests.lib.utils import assert_code, wait_block_number, get_blockhash, get_the_dynamic_parameter_gas_fee 3 from dacite import from_dict 4 from tests.lib import Genesis 5 from common.key import mock_duplicate_sign 6 from tests.govern.test_voting_statistics import submitppandvote, submitcvpandvote, submitvpandvote, submittpandvote, submitcppandvote 7 8 import time 9 import math 10 import rlp 11 import pytest 12 import allure 13 from tests.govern.conftest import version_proposal_vote 14 15 cancelby = "0x0000000000000000000000000000000000000000000000000000000000000000" 16 17 18 class TestgetProposal: 19 @pytest.mark.P0 20 @allure.title('Interface getProposal function verification--cancel proposal') 21 def test_GP_IF_001(self, submit_cancel_param): 22 pip = submit_cancel_param 23 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 24 log.info('Cancel proposal information : {}'.format(proposalinfo)) 25 result = pip.pip.getProposal(proposalinfo.get('ProposalID')) 26 log.info('Interface getProposal result : {}'.format(result)) 27 assert result.get('Ret').get('Proposer') == pip.node.node_id 28 assert result.get('Ret').get('ProposalType') == pip.cfg.cancel_proposal 29 assert result.get('Ret').get('PIPID') == proposalinfo.get('PIPID') 30 assert result.get('Ret').get('SubmitBlock') == proposalinfo.get('SubmitBlock') 31 assert result.get('Ret').get('EndVotingBlock') == proposalinfo.get('EndVotingBlock') 32 33 @pytest.mark.P0 34 @allure.title('Interface getProposal function verification--parammeter proposal') 35 def test_GP_IF_002(self, submit_param): 36 pip = submit_param 37 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 38 log.info('Param proposal information : {}'.format(proposalinfo)) 39 result = pip.pip.getProposal(proposalinfo.get('ProposalID')) 40 log.info('Interface getProposal result : {}'.format(result)) 41 assert result.get('Ret').get('Proposer') == pip.node.node_id 42 assert result.get('Ret').get('ProposalType') == pip.cfg.param_proposal 43 assert result.get('Ret').get('PIPID') == proposalinfo.get('PIPID') 44 assert result.get('Ret').get('SubmitBlock') == proposalinfo.get('SubmitBlock') 45 assert result.get('Ret').get('EndVotingBlock') == proposalinfo.get('EndVotingBlock') 46 47 @pytest.mark.compatibility 48 @pytest.mark.P0 49 @allure.title('Interface getProposal function verification--version proposal') 50 def test_PR_IN_001_002(self, no_vp_proposal): 51 pip = no_vp_proposal 52 pip_id = str(time.time()) 53 result = pip.submitVersion(pip.node.node_id, pip_id, pip.cfg.version8, 3, pip.node.staking_address, 54 transaction_cfg=pip.cfg.transaction_cfg) 55 log.info('Submit version proposal result : {}'.format(result)) 56 assert_code(result, 0) 57 proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal) 58 log.info('Get version proposal information : {}'.format(proposalinfo_version)) 59 pip_id_cancel = str(time.time()) 60 result = pip.submitCancel(pip.node.node_id, pip_id_cancel, 1, proposalinfo_version.get('ProposalID'), 61 pip.node.staking_address, transaction_cfg=pip .cfg.transaction_cfg) 62 log.info('Submit cancel proposal result : {}'.format(result)) 63 assert_code(result, 0) 64 65 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 66 log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel)) 67 68 result_version = pip.pip.getProposal(proposalinfo_version.get('ProposalID')) 69 log.info('Interface getProposal-version result : {}'.format(result_version)) 70 71 result_cancel = pip.pip.getProposal(proposalinfo_cancel.get('ProposalID')) 72 log.info('Interface getProposal-cancel result : {}'.format(result_cancel)) 73 74 assert result_version.get('Ret').get('Proposer') == pip.node.node_id 75 assert result_version.get('Ret').get('ProposalType') == pip.cfg.version_proposal 76 assert result_version.get('Ret').get('PIPID') == pip_id 77 assert result_version.get('Ret').get('SubmitBlock') == proposalinfo_version.get('SubmitBlock') 78 caculated_endvotingblock = math.ceil(proposalinfo_version.get('SubmitBlock') / pip.economic.consensus_size 79 + 3) * pip.economic.consensus_size - 20 80 assert result_version.get('Ret').get('EndVotingBlock') == caculated_endvotingblock 81 82 assert result_cancel.get('Ret').get('Proposer') == pip.node.node_id 83 assert result_cancel.get('Ret').get('ProposalType') == pip.cfg.cancel_proposal 84 assert result_cancel.get('Ret').get('PIPID') == pip_id_cancel 85 assert result_cancel.get('Ret').get('SubmitBlock') == proposalinfo_cancel.get('SubmitBlock') 86 caculated_endvotingblock = math.ceil(proposalinfo_cancel.get('SubmitBlock') / pip.economic.consensus_size) * \ 87 pip.economic.consensus_size + 20 88 assert result_cancel.get('Ret').get('EndVotingBlock') == caculated_endvotingblock 89 90 @pytest.mark.P0 91 @allure.title('Interface getProposal function verification--text proposal') 92 def test_PR_IN_003(self, client_verifier): 93 pip = client_verifier.pip 94 pip_id = str(time.time()) 95 result = pip.submitText(pip.node.node_id, pip_id, pip.node.staking_address, 96 transaction_cfg=pip.cfg.transaction_cfg) 97 log.info('Submit text proposal result : {}'.format(result)) 98 assert_code(result, 0) 99 proposalinfo_text = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 100 log.info('Get text proposal information : {}'.format(proposalinfo_text)) 101 102 result_text = pip.pip.getProposal(proposalinfo_text.get('ProposalID')) 103 log.info('Interface getProposal-text result : {}'.format(result_text)) 104 105 assert result_text.get('Ret').get('Proposer') == pip.node.node_id 106 assert result_text.get('Ret').get('ProposalType') == pip.cfg.text_proposal 107 assert result_text.get('Ret').get('PIPID') == pip_id 108 assert result_text.get('Ret').get('SubmitBlock') == proposalinfo_text.get('SubmitBlock') 109 log.info(pip.economic.tp_vote_settlement_wheel) 110 caculated_endvotingblock = math.ceil(proposalinfo_text.get('SubmitBlock') / pip.economic.consensus_size 111 + pip.economic.tp_vote_settlement_wheel) * pip.economic.consensus_size - 20 112 assert result_text.get('Ret').get('EndVotingBlock') == caculated_endvotingblock 113 114 @pytest.mark.P1 115 @allure.title('Interface getProposal function verification--ineffective proposal id') 116 def test_PR_IN_004(self, client_noconsensus): 117 pip = client_noconsensus.pip 118 result = pip.pip.getProposal('0xa89162be0bd0d081c50a5160f412c4926b3ae9ea96cf792935564357ddd11111') 119 log.info('Interface getProposal-version result : {}'.format(result)) 120 assert_code(result, 302006) 121 122 123 class TestgetTallyResult: 124 @pytest.mark.P0 125 @allure.title('Interface getTallyResult function verification--cancel version proposal') 126 def test_TR_IN_002_TR_IN_003(self, no_vp_proposal, clients_verifier): 127 pip = no_vp_proposal 128 submitcvpandvote(clients_verifier, 1, 1, 1, 2) 129 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 130 log.info('Cancel proposal information {}'.format(proposalinfo_cancel)) 131 proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal) 132 log.info('Version proposal information {}'.format(proposalinfo_version)) 133 wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock')) 134 assert pip.get_canceledby_of_proposal(proposalinfo_cancel.get('ProposalID')) == cancelby 135 assert pip.get_status_of_proposal(proposalinfo_cancel.get('ProposalID')) == 2 136 assert pip.get_yeas_of_proposal(proposalinfo_cancel.get('ProposalID')) == 3 137 assert pip.get_nays_of_proposal(proposalinfo_cancel.get('ProposalID')) == 1 138 assert pip.get_abstentions_of_proposal(proposalinfo_cancel.get('ProposalID')) == 0 139 assert pip.get_accu_verifiers_of_proposal(proposalinfo_cancel.get('ProposalID')) == len(clients_verifier) 140 141 assert pip.get_canceledby_of_proposal(proposalinfo_version.get('ProposalID')) == proposalinfo_cancel.get('ProposalID') 142 assert pip.get_status_of_proposal(proposalinfo_version.get('ProposalID')) == 6 143 assert pip.get_yeas_of_proposal(proposalinfo_version.get('ProposalID')) == 0 144 assert pip.get_nays_of_proposal(proposalinfo_version.get('ProposalID')) == 0 145 assert pip.get_abstentions_of_proposal(proposalinfo_version.get('ProposalID')) == 0 146 assert pip.get_accu_verifiers_of_proposal(proposalinfo_version.get('ProposalID')) == len(clients_verifier) 147 148 @pytest.mark.P0 149 @pytest.mark.compatibility 150 @allure.title('Interface getTallyResult function verification--cancel version proposal') 151 def test_TR_IN_001(self, no_vp_proposal, clients_verifier): 152 pip = no_vp_proposal 153 submitcvpandvote(clients_verifier, 1, 2, 3, 3) 154 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 155 log.info('Cancel proposal information {}'.format(proposalinfo_cancel)) 156 proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal) 157 log.info('Version proposal information {}'.format(proposalinfo_version)) 158 wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock')) 159 assert pip.get_canceledby_of_proposal(proposalinfo_cancel.get('ProposalID')) == cancelby 160 assert pip.get_status_of_proposal(proposalinfo_cancel.get('ProposalID')) == 3 161 assert pip.get_yeas_of_proposal(proposalinfo_cancel.get('ProposalID')) == 1 162 assert pip.get_nays_of_proposal(proposalinfo_cancel.get('ProposalID')) == 1 163 assert pip.get_abstentions_of_proposal(proposalinfo_cancel.get('ProposalID')) == 2 164 assert pip.get_accu_verifiers_of_proposal(proposalinfo_cancel.get('ProposalID')) == len(clients_verifier) 165 166 assert pip.get_canceledby_of_proposal(proposalinfo_version.get('ProposalID')) == cancelby 167 assert pip.get_status_of_proposal(proposalinfo_version.get('ProposalID')) == 3 168 assert pip.get_yeas_of_proposal(proposalinfo_version.get('ProposalID')) == 0 169 assert pip.get_nays_of_proposal(proposalinfo_version.get('ProposalID')) == 0 170 assert pip.get_abstentions_of_proposal(proposalinfo_version.get('ProposalID')) == 0 171 assert pip.get_accu_verifiers_of_proposal(proposalinfo_version.get('ProposalID')) == len(clients_verifier) 172 173 @pytest.mark.P0 174 @allure.title('Interface getTallyResult function verification--parammeter proposal') 175 def test_TR_IN_010_005(self, new_genesis_env, clients_consensus): 176 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 177 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 0 178 new_genesis_env.set_genesis(genesis.to_dict()) 179 new_genesis_env.deploy_all() 180 pip = clients_consensus[0].pip 181 submitppandvote(clients_consensus[0:-1], 1, 2, 3) 182 proposalinfo = clients_consensus[0].pip.get_effect_proposal_info_of_vote(clients_consensus[0].pip.cfg.param_proposal) 183 log.info('Param proposal information {}'.format(proposalinfo)) 184 result = pip.pip.getTallyResult(proposalinfo.get('ProposalID')) 185 log.info('Interface getTallyResult info : {}'.format(result)) 186 assert_code(result, 302030) 187 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 188 189 assert pip.get_canceledby_of_proposal(proposalinfo.get('ProposalID')) == cancelby 190 assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 3 191 assert pip.get_yeas_of_proposal(proposalinfo.get('ProposalID')) == 1 192 assert pip.get_nays_of_proposal(proposalinfo.get('ProposalID')) == 1 193 assert pip.get_abstentions_of_proposal(proposalinfo.get('ProposalID')) == 1 194 assert pip.get_accu_verifiers_of_proposal(proposalinfo.get('ProposalID')) == len(clients_consensus) 195 196 @pytest.mark.P0 197 @allure.title('Interface getTallyResult function verification--cancel parammeter proposal') 198 def test_TR_IN_011_TR_IN_012(self, new_genesis_env, clients_consensus): 199 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 200 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 0 201 new_genesis_env.set_genesis(genesis.to_dict()) 202 new_genesis_env.deploy_all() 203 pip = clients_consensus[0].pip 204 submitcppandvote(clients_consensus, [1, 1, 1, 3]) 205 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 206 log.info('Param proposal information {}'.format(proposalinfo_param)) 207 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 208 log.info('Cancel proposal information {}'.format(proposalinfo_cancel)) 209 210 wait_block_number(pip.node, proposalinfo_cancel.get('EndVotingBlock')) 211 212 assert pip.get_canceledby_of_proposal(proposalinfo_cancel.get('ProposalID')) == cancelby 213 assert pip.get_canceledby_of_proposal(proposalinfo_param.get('ProposalID')) == proposalinfo_cancel.get('ProposalID') 214 215 assert pip.get_status_of_proposal(proposalinfo_cancel.get('ProposalID')) == 2 216 assert pip.get_yeas_of_proposal(proposalinfo_cancel.get('ProposalID')) == 3 217 assert pip.get_nays_of_proposal(proposalinfo_cancel.get('ProposalID')) == 0 218 assert pip.get_abstentions_of_proposal(proposalinfo_cancel.get('ProposalID')) == 1 219 assert pip.get_accu_verifiers_of_proposal(proposalinfo_cancel.get('ProposalID')) == len(clients_consensus) 220 221 assert pip.get_status_of_proposal(proposalinfo_param.get('ProposalID')) == 6 222 assert pip.get_yeas_of_proposal(proposalinfo_param.get('ProposalID')) == 0 223 assert pip.get_nays_of_proposal(proposalinfo_param.get('ProposalID')) == 0 224 assert pip.get_abstentions_of_proposal(proposalinfo_param.get('ProposalID')) == 0 225 assert pip.get_accu_verifiers_of_proposal(proposalinfo_param.get('ProposalID')) == len(clients_consensus) 226 227 @pytest.mark.P1 228 @allure.title('Interface getTallyResult function verification--ineffective proposal id') 229 def test_TR_IN_006(self, client_verifier): 230 pip = client_verifier.pip 231 result = pip.pip.getTallyResult('0x9992d1f843fe8f376884d871f87605dda02da0722fd6b350bbf683518f73f111') 232 log.info('Ineffective proposalID, interface getTallyResult return : {}'.format(result)) 233 assert_code(result, 302030) 234 235 236 class TestgetAccuVerifiersCount: 237 @pytest.mark.P0 238 @allure.title('Interface getTallyResult function verification--ineffective proposal id') 239 def test_AC_IN_018_to_025(self, new_genesis_env, clients_consensus): 240 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 241 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 0 242 new_genesis_env.set_genesis(genesis.to_dict()) 243 new_genesis_env.deploy_all() 244 pip = clients_consensus[0].pip 245 pip_test = clients_consensus[-1].pip 246 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '999', 247 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 248 log.info('Node submit param proposal result : {}'.format(result)) 249 assert_code(result, 0) 250 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 251 log.info('Get param proposal information : {}'.format(proposalinfo_param)) 252 result = pip.submitCancel(pip.node.node_id, str(time.time()), 3, proposalinfo_param.get('ProposalID'), 253 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 254 log.info('Node submit cancel proposal result : {}'.format(result)) 255 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 256 log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel)) 257 for index in range(3): 258 client = clients_consensus[index] 259 result = client.pip.vote(client.node.node_id, proposalinfo_param.get('ProposalID'), index + 1, 260 client.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 261 log.info('Node {} vote param proposal result : {}'.format(client.node.node_id, result)) 262 assert_code(result, 0) 263 result = client.pip.vote(client.node.node_id, proposalinfo_cancel.get('ProposalID'), index + 1, 264 client.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 265 log.info('Node {} vote cancel proposal result : {}'.format(client.node.node_id, result)) 266 assert_code(result, 0) 267 assert pip.get_accuverifiers_count(proposalinfo_param.get('ProposalID')) == [4, 1, 1, 1] 268 assert pip.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1] 269 log.info('Stop the node {}'.format(pip.node.node_id)) 270 pip.node.stop() 271 pip_test.economic.wait_consensus_blocknum(pip_test.node, 2) 272 assert pip_test.get_accuverifiers_count(proposalinfo_param.get('ProposalID')) == [4, 0, 1, 1] 273 assert pip_test.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 0, 1, 1] 274 275 report_information = mock_duplicate_sign(1, clients_consensus[1].node.nodekey, 276 clients_consensus[1].node.blsprikey, 41) 277 log.info("Report information: {}".format(report_information)) 278 address, _ = pip_test.economic.account.generate_account(pip_test.node.web3, 10 ** 18 * 1000) 279 result = clients_consensus[-1].duplicatesign.reportDuplicateSign(1, report_information, address) 280 log.info('Node duplicate block result : {}'.format(result)) 281 assert_code(result, 0) 282 time.sleep(2) 283 assert pip_test.get_accuverifiers_count(proposalinfo_param.get('ProposalID')) == [4, 0, 0, 1] 284 assert pip_test.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 0, 0, 1] 285 286 report_information = mock_duplicate_sign(2, clients_consensus[2].node.nodekey, 287 clients_consensus[2].node.blsprikey, 41) 288 log.info("Report information: {}".format(report_information)) 289 address, _ = pip_test.economic.account.generate_account(pip_test.node.web3, 10 ** 18 * 1000) 290 result = clients_consensus[-1].duplicatesign.reportDuplicateSign(2, report_information, address) 291 log.info('Node duplicate block result : {}'.format(result)) 292 assert_code(result, 0) 293 assert pip_test.get_accuverifiers_count(proposalinfo_param.get('ProposalID')) == [4, 0, 0, 0] 294 assert pip_test.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 0, 0, 0] 295 296 @pytest.mark.compatibility 297 @pytest.mark.P0 298 @allure.title('Interface getAccuVerifiersCount function verification') 299 def test_AC_IN_001_002_004_to_006_012_to_014(self, new_genesis_env, clients_consensus): 300 new_genesis_env.deploy_all() 301 pip = clients_consensus[-1].pip 302 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 5, pip.node.staking_address, 303 transaction_cfg=pip.cfg.transaction_cfg) 304 log.info('Submit version proposal result : {}'.format(result)) 305 assert_code(result, 0) 306 proposalinfo_version = pip.get_effect_proposal_info_of_vote() 307 log.info('Get version proposal information : {}'.format(proposalinfo_version)) 308 309 result = pip.submitCancel(pip.node.node_id, str(time.time()), 4, proposalinfo_version.get('ProposalID'), 310 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 311 log.info('Submit cancel proposal result : {}'.format(result)) 312 assert_code(result, 0) 313 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 314 log.info('Get cancel proposal information : {}'.format(proposalinfo_version)) 315 316 for index in range(3): 317 client = clients_consensus[index] 318 result = version_proposal_vote(client.pip) 319 assert_code(result, 0) 320 result = client.pip.vote(client.node.node_id, proposalinfo_cancel.get('ProposalID'), index + 1, 321 client.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 322 log.info('Node {} vote cancel proposal result : {}'.format(client.node.node_id, result)) 323 assert_code(result, 0) 324 325 assert pip.get_accuverifiers_count(proposalinfo_version.get('ProposalID')) == [4, 3, 0, 0] 326 assert pip.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1] 327 log.info('Stop the node {}'.format(clients_consensus[0].node.node_id)) 328 clients_consensus[0].node.stop() 329 pip.economic.wait_consensus_blocknum(pip.node, 2) 330 assert pip.get_accuverifiers_count(proposalinfo_version.get('ProposalID')) == [4, 2, 0, 0] 331 assert pip.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 0, 1, 1] 332 333 report_information = mock_duplicate_sign(1, clients_consensus[1].node.nodekey, 334 clients_consensus[1].node.blsprikey, 41) 335 log.info("Report information: {}".format(report_information)) 336 address, _ = pip.economic.account.generate_account(pip.node.web3, 10 ** 18 * 1000) 337 result = clients_consensus[-1].duplicatesign.reportDuplicateSign(1, report_information, address) 338 log.info('Node duplicate block result : {}'.format(result)) 339 assert_code(result, 0) 340 assert pip.get_accuverifiers_count(proposalinfo_version.get('ProposalID')) == [4, 1, 0, 0] 341 assert pip.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 0, 0, 1] 342 343 report_information = mock_duplicate_sign(2, clients_consensus[2].node.nodekey, 344 clients_consensus[2].node.blsprikey, 41) 345 log.info("Report information: {}".format(report_information)) 346 address, _ = pip.economic.account.generate_account(pip.node.web3, 10 ** 18 * 1000) 347 result = clients_consensus[-1].duplicatesign.reportDuplicateSign(2, report_information, address) 348 log.info('Node duplicate block result : {}'.format(result)) 349 assert_code(result, 0) 350 assert pip.get_accuverifiers_count(proposalinfo_version.get('ProposalID')) == [4, 0, 0, 0] 351 assert pip.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 0, 0, 0] 352 353 @pytest.mark.P0 354 @allure.title('Interface getAccuVerifiersCount function verification') 355 def test_AC_IN_003_008_010(self, new_genesis_env, clients_consensus): 356 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 357 genesis.economicModel.gov.textProposalVoteDurationSeconds = 120 358 new_genesis_env.set_genesis(genesis.to_dict()) 359 new_genesis_env.deploy_all() 360 pip = clients_consensus[-1].pip 361 submittpandvote(clients_consensus, 1, 2, 3, 1) 362 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 363 log.info('Get text proposal information : {}'.format(proposalinfo)) 364 assert pip.get_accuverifiers_count(proposalinfo.get('ProposalID')) == [4, 2, 1, 1] 365 log.info('Stop the node {}'.format(clients_consensus[0].node.node_id)) 366 clients_consensus[0].node.stop() 367 pip.economic.wait_consensus_blocknum(pip.node, 2) 368 assert pip.get_accuverifiers_count(proposalinfo.get('ProposalID')) == [4, 1, 1, 1] 369 370 report_information = mock_duplicate_sign(1, clients_consensus[1].node.nodekey, 371 clients_consensus[1].node.blsprikey, 41) 372 log.info("Report information: {}".format(report_information)) 373 address, _ = pip.economic.account.generate_account(pip.node.web3, 10 ** 18 * 1000) 374 result = clients_consensus[-1].duplicatesign.reportDuplicateSign(1, report_information, address) 375 log.info('Node duplicate block result : {}'.format(result)) 376 assert_code(result, 0) 377 assert pip.get_accuverifiers_count(proposalinfo.get('ProposalID')) == [4, 1, 0, 1] 378 379 report_information = mock_duplicate_sign(2, clients_consensus[2].node.nodekey, 380 clients_consensus[2].node.blsprikey, 41) 381 log.info("Report information: {}".format(report_information)) 382 address, _ = pip.economic.account.generate_account(pip.node.web3, 10 ** 18 * 1000) 383 result = clients_consensus[-1].duplicatesign.reportDuplicateSign(2, report_information, address) 384 log.info('Node duplicate block result : {}'.format(result)) 385 assert_code(result, 0) 386 assert pip.get_accuverifiers_count(proposalinfo.get('ProposalID')) == [4, 1, 0, 0] 387 388 @pytest.mark.P2 389 @allure.title('Interface getAccuVerifiersCount function verification') 390 def test_AC_IN_016_to_018(self, client_verifier): 391 pip = client_verifier.pip 392 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 393 transaction_cfg=pip.cfg.transaction_cfg) 394 log.info('Submit text proposal result : {}'.format(result)) 395 assert_code(result, 0) 396 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 397 log.info('Get text proposal information : {}'.format(proposalinfo)) 398 result = pip.pip.getAccuVerifiersCount('0x0c04f578466ead2208dbb15b927ecb27041881e8c16c17cd0db6b3df422e1111', 399 block_hash=get_blockhash(pip.node)) 400 log.info('Interface getAccuVerifiersCount result : {}'.format(result)) 401 assert_code(result, 302006) 402 log.info('{}'.format(get_blockhash(pip.node))) 403 404 result = pip.pip.getAccuVerifiersCount(proposalinfo.get('ProposalID'), block_hash='') 405 log.info('Interface getAccuVerifiersCount result : {}'.format(result)) 406 assert_code(result, 3) 407 408 result = pip.pip.getAccuVerifiersCount(proposalinfo.get('ProposalID'), 409 block_hash='0x5941605fe43ab32fbaf9c6e08dc0970eae50efb7da4248a9a8941f0e50711111') 410 log.info('Interface getAccuVerifiersCount result : {}'.format(result)) 411 assert_code(result, 0) 412 413 414 class TestListGovernParam: 415 def get_govern_param(self, client, module=None): 416 result = client.pip.pip.listGovernParam(module) 417 log.info('Interface listGovernParam result {}'.format(result)) 418 assert_code(result, 0) 419 resultinfo = result.get('Ret') 420 module = [] 421 name = [] 422 for param in resultinfo: 423 module.append(param.get('ParamItem').get('Module')) 424 name.append(param.get('ParamItem').get('Name')) 425 return name, module 426 427 @pytest.mark.P0 428 @allure.title('Interface listGovernParam function verification') 429 def test_IN_LG_001(self, client_noconsensus): 430 name, module = self.get_govern_param(client_noconsensus) 431 assert set(name) == {'maxValidators', 'unStakeFreezeDuration', 'operatingThreshold', 'slashBlocksReward', 432 'stakeThreshold', 'maxBlockGasLimit', 'duplicateSignReportReward', 'maxEvidenceAge', 'slashFractionDuplicateSign'} 433 assert set(module) == {'block', 'slashing', 'staking'} 434 435 @pytest.mark.P2 436 @allure.title('Interface listGovernParam function verification') 437 def test_IN_LG_002(self, client_noconsensus): 438 name, module = self.get_govern_param(client_noconsensus, 'staking') 439 assert set(name) == {'maxValidators', 'unStakeFreezeDuration', 'operatingThreshold', 'stakeThreshold'} 440 assert set(module) == {'staking'} 441 442 @pytest.mark.P2 443 @allure.title('Interface listGovernParam function verification') 444 def test_IN_LG_003(self, client_noconsensus): 445 name, module = self.get_govern_param(client_noconsensus, 'slashing') 446 assert set(name) == {'slashBlocksReward', 'duplicateSignReportReward', 'maxEvidenceAge', 'slashFractionDuplicateSign'} 447 assert set(module) == {'slashing'} 448 449 @pytest.mark.P2 450 @allure.title('Interface listGovernParam function verification') 451 def test_IN_LG_004(self, client_noconsensus): 452 name, module = self.get_govern_param(client_noconsensus, 'block') 453 assert set(name) == {'maxBlockGasLimit'} 454 assert set(module) == {'block'} 455 456 @pytest.mark.P2 457 @allure.title('Interface listGovernParam function verification') 458 def test_IN_LG_005(self, client_noconsensus): 459 result = client_noconsensus.pip.pip.listGovernParam('txpool') 460 log.info('Interface listGovernParam result {}'.format(result)) 461 assert_code(result, 2) 462 assert result.get('Ret') == "Object not found" 463 464 465 class TestGetGovernParam: 466 @pytest.mark.P0 467 @allure.title('Interface getGovernParamValue function verification') 468 def test_IN_GG_001(self, client_noconsensus): 469 client_noconsensus.economic.env.deploy_all() 470 genesis = from_dict(data_class=Genesis, data=client_noconsensus.economic.env.genesis_config) 471 pip = client_noconsensus.pip.pip 472 result = pip.getGovernParamValue('slashing', 'slashBlocksReward') 473 log.info('Interface getGovernParamValue result : {}'.format(result)) 474 assert genesis.economicModel.slashing.slashBlocksReward == int(result.get('Ret')) 475 476 result = pip.getGovernParamValue('slashing', 'maxEvidenceAge') 477 log.info('Interface getGovernParamValue result : {}'.format(result)) 478 assert genesis.economicModel.slashing.maxEvidenceAge == int(result.get('Ret')) 479 480 result = pip.getGovernParamValue('slashing', 'slashFractionDuplicateSign') 481 log.info('Interface getGovernParamValue result : {}'.format(result)) 482 assert genesis.economicModel.slashing.slashFractionDuplicateSign == int(result.get('Ret')) 483 484 result = pip.getGovernParamValue('slashing', 'duplicateSignReportReward') 485 log.info('Interface getGovernParamValue result : {}'.format(result)) 486 assert genesis.economicModel.slashing.duplicateSignReportReward == int(result.get('Ret')) 487 488 result = pip.getGovernParamValue('staking', 'stakeThreshold') 489 log.info('Interface getGovernParamValue result : {}'.format(result)) 490 assert genesis.economicModel.staking.stakeThreshold == int(result.get('Ret')) 491 492 result = pip.getGovernParamValue('staking', 'operatingThreshold') 493 log.info('Interface getGovernParamValue result : {}'.format(result)) 494 assert genesis.economicModel.staking.operatingThreshold == int(result.get('Ret')) 495 496 result = pip.getGovernParamValue('staking', 'unStakeFreezeDuration') 497 log.info('Interface getGovernParamValue result : {}'.format(result)) 498 assert genesis.economicModel.staking.unStakeFreezeDuration == int(result.get('Ret')) 499 500 result = pip.getGovernParamValue('staking', 'maxValidators') 501 log.info('Interface getGovernParamValue result : {}'.format(result)) 502 assert genesis.economicModel.staking.maxValidators == int(result.get('Ret')) 503 504 result = pip.getGovernParamValue('block', 'maxBlockGasLimit') 505 log.info('Interface getGovernParamValue result : {}'.format(result)) 506 assert_code(result, 0) 507 508 @pytest.mark.P2 509 @allure.title('Interface getGovernParamValue function verification') 510 def test_IN_GG_002(self, client_noconsensus): 511 pip = client_noconsensus.pip.pip 512 result = pip.getGovernParamValue('Staking', 'maxValidators') 513 assert_code(result, 302031) 514 pip = client_noconsensus.pip.pip 515 result = pip.getGovernParamValue('Slashing', 'slashBlocksReward') 516 assert_code(result, 302031) 517 pip = client_noconsensus.pip.pip 518 result = pip.getGovernParamValue('Block', 'maxBlockGasLimit') 519 assert_code(result, 302031) 520 521 @pytest.mark.P2 522 @allure.title('Interface getGovernParamValue function verification') 523 def test_IN_GG_003(self, client_noconsensus): 524 pip = client_noconsensus.pip.pip 525 result = pip.getGovernParamValue('staking', 'MaxValidators') 526 assert_code(result, 302031) 527 pip = client_noconsensus.pip.pip 528 result = pip.getGovernParamValue('slashing', 'SlashBlocksReward') 529 assert_code(result, 302031) 530 pip = client_noconsensus.pip.pip 531 result = pip.getGovernParamValue('block', 'MaxValidators') 532 assert_code(result, 302031) 533 534 535 class TestGetActiveVersion: 536 @pytest.mark.compatibility 537 @pytest.mark.P0 538 @allure.title('Interface getActiveVersion function verification') 539 def test_AV_IN_001(self, no_vp_proposal): 540 assert_code(no_vp_proposal.chain_version, no_vp_proposal.cfg.version0) 541 542 @pytest.mark.P0 543 @allure.title('Interface getActiveVersion function verification') 544 def test_AV_IN_002_003(self, clients_verifier): 545 pip = clients_verifier[0].pip 546 submitvpandvote(clients_verifier) 547 proposalinfo = pip.get_effect_proposal_info_of_vote() 548 log.info('Version proposal information : {}'.format(proposalinfo)) 549 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 550 assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 4) 551 assert_code(pip.chain_version, pip.cfg.version0) 552 wait_block_number(pip.node, proposalinfo.get('ActiveBlock')) 553 assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 5) 554 assert_code(pip.chain_version, pip.cfg.version5) 555 556 557 class TestListProposal: 558 @pytest.mark.P1 559 @allure.title('Interface listProposal function verification') 560 def test_LP_IN_001_002(self, no_vp_proposal): 561 pip = no_vp_proposal 562 pip_id = str(time.time()) 563 result = pip.submitParam(pip.node.node_id, pip_id, 'slashing', 'slashBlocksReward', '456', 564 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 565 log.info('Submit param proposal result : {}'.format(result)) 566 assert_code(result, 0) 567 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 568 log.info('Get param proposal information : {}'.format(proposalinfo)) 569 assert proposalinfo.get('Proposer') == pip.node.node_id 570 assert proposalinfo.get('ProposalType') == pip.cfg.param_proposal 571 log.info('{}'.format(pip.economic.pp_vote_settlement_wheel)) 572 calculated_endvotingblock = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.settlement_size 573 + pip.economic.pp_vote_settlement_wheel) * pip.economic.settlement_size 574 assert proposalinfo.get('EndVotingBlock') == calculated_endvotingblock 575 576 pip_id = str(time.time()) 577 result = pip.submitCancel(pip.node.node_id, pip_id, 1, proposalinfo.get('ProposalID'), 578 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 579 log.info('Submit cancel proposal result : {}'.format(result)) 580 assert_code(result, 0) 581 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 582 log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel)) 583 584 assert proposalinfo_cancel.get('Proposer') == pip.node.node_id 585 assert proposalinfo_cancel.get('ProposalType') == pip.cfg.cancel_proposal 586 log.info('{}'.format(pip.economic.pp_vote_settlement_wheel)) 587 calculated_endvotingblock = math.ceil(proposalinfo_cancel.get('SubmitBlock') / pip.economic.consensus_size 588 + 1) * pip.economic.consensus_size - 20 589 assert proposalinfo_cancel.get('EndVotingBlock') == calculated_endvotingblock 590 591 @pytest.mark.P1 592 @allure.title('Interface listProposal function verification') 593 def test_LP_IN_003(self, client_consensus): 594 client_consensus.economic.env.deploy_all() 595 result = client_consensus.pip.pip.listProposal() 596 log.info('There is no proposal, interface listProposal return : {}'.format(result)) 597 assert_code(result, 2) 598 assert result.get('Ret') == "Object not found" 599 600 601 class TestGasUse: 602 def get_balance(self, pip): 603 balance = pip.node.eth.getBalance(pip.node.staking_address) 604 log.info('address balance : {}'.format(balance)) 605 return balance 606 607 @pytest.mark.P2 608 @allure.title('Verify gas --submittext and vote') 609 def test_TP_GA_001(self, client_verifier): 610 pip = client_verifier.pip 611 pip_id = str(time.time()) 612 data = rlp.encode([rlp.encode(int(2000)), rlp.encode(bytes.fromhex(pip.node.node_id)), rlp.encode(pip_id)]) 613 balance_before = self.get_balance(pip) 614 result = pip.submitText(pip.node.node_id, pip_id, pip.node.staking_address, 615 transaction_cfg=pip.cfg.transaction_cfg) 616 log.info('Submit text proposal result : {}'.format(result)) 617 assert_code(result, 0) 618 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 619 log.info('Get text proposal information : {}'.format(proposalinfo)) 620 balance_after = self.get_balance(pip) 621 gas = get_the_dynamic_parameter_gas_fee(data) 622 log.info('Calculated gas : {}'.format(gas)) 623 assert_code(balance_before - balance_after, (gas + 350000) * pip.cfg.transaction_cfg.get('gasPrice')) 624 625 proposal_id = proposalinfo.get('ProposalID')[2:] 626 version_sign = pip.node.program_version_sign[2:] 627 data = rlp.encode([rlp.encode(int(2003)), rlp.encode(bytes.fromhex(pip.node.node_id)), 628 rlp.encode(bytes.fromhex(proposal_id)), 629 rlp.encode(pip.cfg.vote_option_yeas), rlp.encode(int(pip.node.program_version)), 630 rlp.encode(bytes.fromhex(version_sign))]) 631 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 632 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 633 log.info('Vote reuslt : {}'.format(result)) 634 assert_code(result, 0) 635 balance_after_vote = pip.node.eth.getBalance(pip.node.staking_address) 636 log.info('After vote text proposal, the address balance : {}'.format(balance_after_vote)) 637 gas = get_the_dynamic_parameter_gas_fee(data) 638 log.info('Calculated gas : {}'.format(gas)) 639 assert_code(balance_after - balance_after_vote, (gas + 32000) * pip.cfg.transaction_cfg.get('gasPrice')) 640 641 @pytest.mark.P2 642 @allure.title('Verify gas --submitversion') 643 def test_VP_GA_001(self, no_vp_proposal): 644 pip = no_vp_proposal 645 pip_id = str(time.time()) 646 balance_before = self.get_balance(pip) 647 result = pip.submitVersion(pip.node.node_id, pip_id, pip.cfg.version5, 1, pip.node.staking_address, 648 transaction_cfg=pip.cfg.transaction_cfg) 649 log.info('Submit version proposal result : {}'.format(result)) 650 assert_code(result, 0) 651 balance_after = self.get_balance(pip) 652 data = rlp.encode([rlp.encode(int(2001)), rlp.encode(bytes.fromhex(pip.node.node_id)), rlp.encode(pip_id), 653 rlp.encode(int(pip.cfg.version5)), rlp.encode(int(1))]) 654 gas = get_the_dynamic_parameter_gas_fee(data) 655 log.info('Calculated gas : {}'.format(gas)) 656 assert_code(balance_before - balance_after, (gas + 480000) * pip.cfg.transaction_cfg.get('gasPrice')) 657 658 @pytest.mark.P2 659 @allure.title('Verify gas --submitparam_and_cancel') 660 def test_PP_GA_001_CP_GA_001(self, no_vp_proposal): 661 pip = no_vp_proposal 662 pip_id = str(time.time()) 663 balance_before = self.get_balance(pip) 664 result = pip.submitParam(pip.node.node_id, pip_id, 'slashing', 'slashBlocksReward', '123', 665 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 666 log.info('Submit param proposal result : {}'.format(result)) 667 assert_code(result, 0) 668 proposalinfor_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 669 log.info('Get param proposal information : {}'.format(proposalinfor_param)) 670 balance_after = self.get_balance(pip) 671 data = rlp.encode([rlp.encode(int(2002)), rlp.encode(bytes.fromhex(pip.node.node_id)), 672 rlp.encode(pip_id), rlp.encode('slashing'), rlp.encode('slashBlocksReward'), 673 rlp.encode('123')]) 674 gas = get_the_dynamic_parameter_gas_fee(data) 675 log.info('Calculated gas : {}'.format(gas)) 676 assert_code(balance_before - balance_after, (gas + 530000) * pip.cfg.transaction_cfg.get('gasPrice')) 677 678 pip_id = str(time.time()) 679 result = pip.submitCancel(pip.node.node_id, pip_id, 1, proposalinfor_param.get('ProposalID'), 680 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 681 log.info('Submit cancel proposal result : {}'.format(result)) 682 assert_code(result, 0) 683 assert_code(balance_before - balance_after, (gas + 530000) * pip.cfg.transaction_cfg.get('gasPrice')) 684 balance_after_cancel = pip.node.eth.getBalance(pip.node.staking_address) 685 log.info('After submitting cancel proposal, the address balance : {}'.format(balance_after_cancel)) 686 tobe_canceled_proposal_id = proposalinfor_param.get('ProposalID')[2:] 687 data = rlp.encode([rlp.encode(int(2005)), rlp.encode(bytes.fromhex(pip.node.node_id)), rlp.encode(pip_id), 688 rlp.encode(int(1)), rlp.encode(bytes.fromhex(tobe_canceled_proposal_id))]) 689 gas = get_the_dynamic_parameter_gas_fee(data) 690 log.info('Calculated gas : {}'.format(gas)) 691 assert_code(balance_after - balance_after_cancel, (gas + 530000) * pip.cfg.transaction_cfg.get('gasPrice')) 692 693 @pytest.mark.P2 694 @allure.title('Verify gas --declare version') 695 def test_declareversion(self, client_verifier): 696 pip = client_verifier.pip 697 balance_before = self.get_balance(pip) 698 result = pip.declareVersion(pip.node.node_id, pip.node.staking_address, 699 transaction_cfg=pip.cfg.transaction_cfg) 700 log.info('Declare version result : {}'.format(result)) 701 assert_code(result, 0) 702 version_sign = pip.node.program_version_sign[2:] 703 data = rlp.encode([rlp.encode(int(2004)), rlp.encode(bytes.fromhex(pip.node.node_id)), 704 rlp.encode(int(pip.node.program_version)), rlp.encode(bytes.fromhex(version_sign))]) 705 gas = get_the_dynamic_parameter_gas_fee(data) 706 log.info('Calculated gas : {}'.format(gas)) 707 balance_after = self.get_balance(pip) 708 assert_code(balance_before - balance_after, (gas + 33000) * pip.cfg.transaction_cfg.get('gasPrice')) 709 710 711 if __name__ == '__main__': 712 pytest.main(['./tests/govern/', '-s', '-q', '--alluredir', './report/report'])