github.com/platonnetwork/platon-go@v0.7.6/cases/tests/govern/test_vote.py (about) 1 import pytest 2 import allure 3 from common.log import log 4 import time 5 from tests.lib.utils import assert_code, wait_block_number, upload_platon 6 from tests.lib.client import get_client_by_nodeid 7 from tests.govern.conftest import version_proposal_vote, get_refund_to_account_block, proposal_vote, verifier_node_version 8 from dacite import from_dict 9 from tests.lib.genesis import Genesis 10 from tests.govern.test_voting_statistics import submitvpandvote, submittpandvote, submitcppandvote 11 12 13 def replace_platon_vote(pip, bin=None, program_version=None, version_sign=None): 14 ''' 15 Replace the bin package of the node, restart the node 16 :param pip: 17 :param bin: 18 :return: 19 ''' 20 if bin: 21 upload_platon(pip.node, bin) 22 pip.node.restart() 23 if program_version is None: 24 program_version = pip.node.program_version 25 if version_sign is None: 26 version_sign = pip.node.program_version_sign 27 proposalinfo = pip.get_effect_proposal_info_of_vote() 28 log.info('Get version proposal information {}'.format(proposalinfo)) 29 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 30 pip.node.staking_address, program_version=program_version, version_sign=version_sign, 31 transaction_cfg=pip.cfg.transaction_cfg) 32 log.info('Node {} vote result : {}'.format(pip.node.node_id, result)) 33 return result 34 35 36 @pytest.fixture() 37 def voting_version_proposal_verifier_pip(client_verifier): 38 pip = client_verifier.pip 39 if pip.chain_version != pip.cfg.version0: 40 log.info('The chain has been upgraded,restart!') 41 client_verifier.economic.env.deploy_all() 42 if pip.is_exist_effective_proposal: 43 if pip.is_exist_effective_proposal_for_vote(): 44 proposalinfo = pip.get_effect_proposal_info_of_vote() 45 log.info('get version proposalinfo : {}'.format(proposalinfo)) 46 if proposalinfo.get('EndVotingBlock') - pip.node.block_number > pip.economic.consensus_size * 2: 47 return pip 48 client_verifier.economic.env.deploy_all() 49 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 10, pip.node.staking_address, 50 transaction_cfg=pip.cfg.transaction_cfg) 51 log.info('node {} submit version proposal {}'.format(pip.node.node_id, result)) 52 assert_code(result, 0) 53 return pip 54 55 56 @pytest.fixture() 57 def voting_text_proposal_verifier_pip(client_verifier): 58 pip = client_verifier.pip 59 if pip.is_exist_effective_proposal_for_vote(pip.cfg.text_proposal): 60 proposalinfo = pip.get_effect_proposal_info_of_vote() 61 if proposalinfo.get('EndVotingBlock') - pip.node.eth.blockNumber > 2 * pip.economic.consensus_size: 62 return pip 63 else: 64 client_verifier.economic.env.deploy_all() 65 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 66 transaction_cfg=pip.cfg.transaction_cfg) 67 log.info('Submit text proposal result {}'.format(result)) 68 assert_code(result, 0) 69 return pip 70 71 72 class TestVoteVP: 73 @pytest.mark.P1 74 @allure.title('Version proposal voting function verification--voting stage') 75 def test_V_STA_2_to_5(self, no_vp_proposal, clients_verifier): 76 pip = no_vp_proposal 77 value = len(clients_verifier) - 2 78 submitvpandvote(clients_verifier[:value], votingrounds=3) 79 proposalinfo = pip.get_effect_proposal_info_of_vote() 80 log.info('Get version proposal information : {}'.format(proposalinfo)) 81 result = version_proposal_vote(clients_verifier[-2].pip) 82 log.info('Node {} vote proposal result : {}'.format(clients_verifier[-1].node.node_id, result)) 83 assert_code(result, 0) 84 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 85 pip = clients_verifier[-1].pip 86 upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN) 87 pip.node.restart() 88 log.info('Replace the platon bin and restart the node {}'.format(pip.node.node_id)) 89 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 90 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 91 log.info('Node {} vote proposal result : {}'.format(clients_verifier[-1].node.node_id, result)) 92 assert_code(result, 302026) 93 log.info('{}'.format(pip.pip.getTallyResult(proposalinfo.get('ProposalID')))) 94 assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 4) 95 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 96 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 97 log.info('Node {} vote proposal result : {}'.format(clients_verifier[-1].node.node_id, result)) 98 assert_code(result, 302026) 99 wait_block_number(pip.node, proposalinfo.get('ActiveBlock')) 100 assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 5) 101 102 103 @pytest.mark.compatibility 104 @pytest.mark.P0 105 @allure.title('Version proposal voting function verification') 106 def test_VO_VO_001_V0_RE_001_V0_WA_001_V_STA_1_VO_OP_001_VO_OP_002(no_vp_proposal): 107 pip = no_vp_proposal 108 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version8, 2, 109 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 110 log.info('Submit version proposal result : {}'.format(result)) 111 assert_code(result, 0) 112 proposalinfo = pip.get_effect_proposal_info_of_vote() 113 log.info('Get version proposalinfo {}'.format(proposalinfo)) 114 115 upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN) 116 log.info('Replace the node platon package to {}'.format(pip.cfg.version5)) 117 pip.node.restart() 118 log.info('Restart the node {}'.format(pip.node.node_id)) 119 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 120 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 121 address, transaction_cfg=pip.cfg.transaction_cfg) 122 log.info('Not staking address vote result : {}'.format(result)) 123 assert_code(result, 302021) 124 125 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_nays, 126 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 127 log.info('vote option {} result {}'.format(pip.cfg.vote_option_nays, result)) 128 assert_code(result, 302002) 129 130 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_Abstentions, 131 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 132 log.info('vote option {} result {}'.format(pip.cfg.vote_option_Abstentions, result)) 133 assert_code(result, 302002) 134 135 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), 0, 136 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 137 log.info('vote option {} result {}'.format(0, result)) 138 assert_code(result, 302002) 139 140 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), 'a', 141 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 142 log.info('vote option {} result {}'.format(pip.cfg.vote_option_nays, result)) 143 assert_code(result, 302002) 144 145 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 146 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 147 address, transaction_cfg=pip.cfg.transaction_cfg) 148 assert_code(result, 302021) 149 150 node_version = verifier_node_version(pip) 151 result = version_proposal_vote(pip) 152 assert_code(result, 0) 153 verifier_node_version(pip, node_version) 154 155 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 156 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 157 log.info('vote duplicated result: {}'.format(result)) 158 assert_code(result, 302027) 159 160 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 161 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 162 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 163 log.info('endblock vote result: {}'.format(result)) 164 assert_code(result, 302026) 165 166 167 @pytest.mark.P0 168 @allure.title('Text proposal voting function verification') 169 def test_VO_VO_003_V_STA_9_V_STA_10_V_STA_11_V0_WA_003_V0_RE_003(voting_text_proposal_verifier_pip, clients_verifier): 170 pip = voting_text_proposal_verifier_pip 171 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 172 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 173 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, address, 174 transaction_cfg=pip.cfg.transaction_cfg) 175 log.info('Not staking address vote result {}'.format(result)) 176 assert_code(result, 302021) 177 178 result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) 179 log.info('vote result {}'.format(result)) 180 assert_code(result, 0) 181 182 result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) 183 log.info('Repeat vote result {}'.format(result)) 184 assert_code(result, 302027) 185 for client in clients_verifier: 186 if client.node.node_id != pip.node.node_id: 187 pip_test = client.pip 188 break 189 190 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock') - 10) 191 result = proposal_vote(pip_test, proposaltype=pip.cfg.text_proposal) 192 log.info('Node {} vote result {}'.format(pip_test.node.node_id, result)) 193 assert_code(result, 0) 194 195 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 196 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_nays, 197 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 198 log.info('Endvoting block vote result {}'.format(result)) 199 assert_code(result, 302026) 200 201 202 class TestVoteNodeException: 203 @pytest.mark.P0 204 @allure.title('Voting function verification---Abnormal node') 205 def test_VO_TE_001_002_PP_VO_009_010_PP_VO_011_012_PP_VO_014_VO_TER_008_VO_TER_006(self, new_genesis_env, 206 clients_consensus, 207 client_noconsensus): 208 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 209 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 640 210 genesis.economicModel.staking.unStakeFreezeDuration = 2 211 new_genesis_env.set_genesis(genesis.to_dict()) 212 new_genesis_env.deploy_all() 213 pip = clients_consensus[0].pip 214 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 215 transaction_cfg=pip.cfg.transaction_cfg) 216 log.info('Submit text proposal information : {}'.format(result)) 217 assert_code(result, 0) 218 proposalinfo_text = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 219 log.info('Get text proposal information : {}'.format(proposalinfo_text)) 220 221 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 222 '123', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 223 log.info('Submit param proposal information : {}'.format(result)) 224 assert_code(result, 0) 225 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 226 log.info('Get param proposal information : {}'.format(proposalinfo_param)) 227 228 result = pip.submitCancel(pip.node.node_id, str(time.time()), 10, proposalinfo_param.get('ProposalID'), 229 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 230 log.info('Submit cancel proposal information : {}'.format(result)) 231 assert_code(result, 0) 232 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 233 log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel)) 234 235 result = clients_consensus[0].staking.withdrew_staking(clients_consensus[0].node.staking_address) 236 log.info('Node {} withdrew staking result {}'.format(clients_consensus[0].node.node_id, result)) 237 assert_code(result, 0) 238 address = clients_consensus[0].node.staking_address 239 240 result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) 241 log.info('node vote text proposal result {}'.format(result)) 242 assert_code(result, 302020) 243 244 result = proposal_vote(pip) 245 log.info('node vote param proposal result {}'.format(result)) 246 assert_code(result, 302020) 247 248 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 249 log.info('node vote cancel proposal result {}'.format(result)) 250 assert_code(result, 302020) 251 252 address_test, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 253 result = client_noconsensus.pip.vote(client_noconsensus.node.node_id, proposalinfo_text.get('ProposalID'), 254 pip.cfg.vote_option_yeas, address_test, 255 transaction_cfg=pip.cfg.transaction_cfg) 256 log.info('node {} vote text proposal result {}'.format(client_noconsensus.node.node_id, result)) 257 assert_code(result, 302022) 258 259 result = client_noconsensus.pip.vote(client_noconsensus.node.node_id, proposalinfo_param.get('ProposalID'), 260 pip.cfg.vote_option_yeas, address_test, 261 transaction_cfg=pip.cfg.transaction_cfg) 262 log.info('node {} vote param proposal result {}'.format(client_noconsensus.node.node_id, result)) 263 assert_code(result, 302022) 264 265 result = client_noconsensus.pip.vote(client_noconsensus.node.node_id, proposalinfo_cancel.get('ProposalID'), 266 pip.cfg.vote_option_yeas, address_test, 267 transaction_cfg=pip.cfg.transaction_cfg) 268 log.info('node {} vote cancel proposal result {}'.format(client_noconsensus.node.node_id, result)) 269 assert_code(result, 302022) 270 271 pip.economic.wait_settlement_blocknum(pip.node, pip.economic.unstaking_freeze_ratio) 272 result = pip.vote(pip.node.node_id, proposalinfo_text.get('ProposalID'), pip.cfg.vote_option_nays, 273 address, transaction_cfg=pip.cfg.transaction_cfg) 274 log.info('Exited node vote text proposal result {}'.format(result)) 275 assert_code(result, 302022) 276 277 result = pip.vote(pip.node.node_id, proposalinfo_param.get('ProposalID'), pip.cfg.vote_option_nays, 278 address, transaction_cfg=pip.cfg.transaction_cfg) 279 log.info('Exited node vote param proposal result {}'.format(result)) 280 assert_code(result, 302022) 281 282 result = pip.vote(pip.node.node_id, proposalinfo_cancel.get('ProposalID'), pip.cfg.vote_option_nays, 283 address, transaction_cfg=pip.cfg.transaction_cfg) 284 log.info('Exited node vote cancel proposal result {}'.format(result)) 285 assert_code(result, 302022) 286 287 @pytest.mark.P0 288 @allure.title('Voting function verification---Abnormal node') 289 def test_VO_VE_001_002_VO_CA_001_002_VO_TER_002_VO_TER_004(self, new_genesis_env, clients_consensus, 290 client_noconsensus): 291 pip = clients_consensus[0].pip 292 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 293 genesis.economicModel.gov.versionProposalVoteDurationSeconds = 3200 294 genesis.economicModel.staking.unStakeFreezeDuration = 2 295 new_genesis_env.set_genesis(genesis.to_dict()) 296 new_genesis_env.deploy_all() 297 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 20, 298 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 299 log.info('Submit version proposal information : {}'.format(result)) 300 assert_code(result, 0) 301 proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal) 302 log.info('Get param proposal information : {}'.format(proposalinfo_version)) 303 304 result = pip.submitCancel(pip.node.node_id, str(time.time()), 10, proposalinfo_version.get('ProposalID'), 305 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 306 log.info('Submit cancel proposal information : {}'.format(result)) 307 assert_code(result, 0) 308 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 309 log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel)) 310 311 result = clients_consensus[0].staking.withdrew_staking(clients_consensus[0].node.staking_address) 312 log.info('Node {} withdrew staking result {}'.format(clients_consensus[0].node.node_id, result)) 313 assert_code(result, 0) 314 address = clients_consensus[0].node.staking_address 315 316 result = version_proposal_vote(pip) 317 log.info('node vote version proposal result {}'.format(result)) 318 assert_code(result, 302020) 319 320 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 321 log.info('node vote cancel proposal result {}'.format(result)) 322 assert_code(result, 302020) 323 324 address_test, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 100000) 325 result = client_noconsensus.pip.vote(client_noconsensus.node.node_id, proposalinfo_version.get('ProposalID'), 326 pip.cfg.vote_option_yeas, address_test, 327 transaction_cfg=pip.cfg.transaction_cfg) 328 log.info('node {} vote param proposal result {}'.format(client_noconsensus.node.node_id, result)) 329 assert_code(result, 302022) 330 331 result = client_noconsensus.pip.vote(client_noconsensus.node.node_id, proposalinfo_cancel.get('ProposalID'), 332 pip.cfg.vote_option_yeas, address_test, 333 transaction_cfg=pip.cfg.transaction_cfg) 334 log.info('node {} vote cancel proposal result {}'.format(client_noconsensus.node.node_id, result)) 335 assert_code(result, 302022) 336 337 pip.economic.wait_settlement_blocknum(pip.node, pip.economic.unstaking_freeze_ratio) 338 result = pip.vote(pip.node.node_id, proposalinfo_version.get('ProposalID'), pip.cfg.vote_option_yeas, 339 address, transaction_cfg=pip.cfg.transaction_cfg) 340 log.info('Exited node vote version proposal result {}'.format(result)) 341 assert_code(result, 302022) 342 343 result = pip.vote(pip.node.node_id, proposalinfo_cancel.get('ProposalID'), pip.cfg.vote_option_nays, 344 address, transaction_cfg=pip.cfg.transaction_cfg) 345 log.info('Exited node vote cancel proposal result {}'.format(result)) 346 assert_code(result, 302022) 347 348 @pytest.mark.P1 349 @allure.title('Voting function verification---Abnormal node') 350 def test_VO_TER_002_004(self, no_vp_proposal, client_candidate, clients_verifier): 351 pip = client_candidate.pip 352 ver_pip = clients_verifier[0].pip 353 result = ver_pip.submitParam(ver_pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 354 '111', ver_pip.node.staking_address, 355 transaction_cfg=ver_pip.cfg.transaction_cfg) 356 log.info('Submit version proposal result : {}'.format(result)) 357 assert_code(result, 0) 358 proposalinfo = ver_pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 359 log.info('Get param proposal information : {}'.format(proposalinfo)) 360 result = ver_pip.submitCancel(ver_pip.node.node_id, str(time.time()), 2, proposalinfo.get('ProposalID'), 361 ver_pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 362 log.info('Submit cancel proposal result : {}'.format(result)) 363 assert_code(result, 0) 364 result = proposal_vote(pip) 365 log.info('Candidate node {} vote param proposal result : {}'.format(pip.node.node_id, result)) 366 assert_code(result, 302022) 367 368 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 369 log.info('Candidate node {} vote cancel proposal result : {}'.format(pip.node.node_id, result)) 370 assert_code(result, 302022) 371 372 @pytest.mark.P1 373 @allure.title('Voting function verification') 374 def test_VO_TER_001_003_005(self, candidate_has_proposal, client_verifier): 375 pip = candidate_has_proposal 376 pip_test = client_verifier.pip 377 proposalinfo_version = pip_test.get_effect_proposal_info_of_vote() 378 log.info('Get proposal information :{}'.format(proposalinfo_version)) 379 result = pip_test.submitCancel(pip_test.node.node_id, str(time.time()), 1, proposalinfo_version.get('ProposalID'), 380 pip_test.node.staking_address, transaction_cfg=pip_test.cfg.transaction_cfg) 381 log.info('Submit cancel proposal result : {}'.format(result)) 382 assert_code(result, 0) 383 result = pip_test.submitText(pip_test.node.node_id, str(time.time()), pip_test.node.staking_address, 384 transaction_cfg=pip_test.cfg.transaction_cfg) 385 log.info('Submit text proposal result : {}'.format(result)) 386 assert_code(result, 0) 387 result = version_proposal_vote(pip) 388 log.info('Candidate node {} vote version proposal result : {}'.format(pip.node.node_id, result)) 389 assert_code(result, 302022) 390 391 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 392 log.info('Candidate node {} vote cancel proposal result : {}'.format(pip.node.node_id, result)) 393 assert_code(result, 302022) 394 395 result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) 396 log.info('Candidate node {} vote text proposal result : {}'.format(pip.node.node_id, result)) 397 assert_code(result, 302022) 398 399 400 class TestVoteCancelVersion: 401 @pytest.mark.compatibility 402 @pytest.mark.P0 403 @allure.title('Cancel proposal voting function verification') 404 def test_VO_VO_002_V0_WA_002_V0_RE_002_V_STA_8(self, submit_cancel): 405 pip = submit_cancel 406 address, _ = pip.economic.account.generate_account(pip.node.web3, 10 ** 18 * 10000) 407 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 408 log.info('Cancel proposal info : {}'.format(proposalinfo)) 409 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_Abstentions, 410 address, transaction_cfg=pip.cfg.transaction_cfg) 411 log.info('Not staking address , node {}, vote cancel proposal result {}'.format(pip.node.node_id, result)) 412 assert_code(result, 302021) 413 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 414 assert_code(result, 0) 415 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 416 assert_code(result, 302027) 417 418 @pytest.mark.P1 419 @allure.title('Cancel proposal voting function verification--candidate') 420 def test_V_STA_6_7(self, submit_cancel, clients_verifier): 421 pip = submit_cancel 422 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 423 log.info('Cancel proposal info : {}'.format(proposalinfo)) 424 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock') - 10) 425 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 426 assert_code(result, 0) 427 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 428 for client in clients_verifier: 429 if client.node.node_id != pip.node.node_id: 430 pip_test = client.pip 431 break 432 result = pip_test.vote(pip_test.node.node_id, proposalinfo.get('ProposalID'), pip_test.cfg.vote_option_Abstentions, 433 pip_test.node.staking_address, transaction_cfg=pip_test.cfg.transaction_cfg) 434 log.info('Node {} vote result {}'.format(pip_test.node.node_id, result)) 435 assert_code(result, 302026) 436 437 438 class TestVoteCancelParam: 439 @pytest.mark.compatibility 440 @pytest.mark.P0 441 @allure.title('Cancel proposal voting function verification') 442 def test_PP_VO_001_PP_VO_005_PP_VO_015_PP_VO_017(self, submit_cancel_param): 443 pip = submit_cancel_param 444 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 445 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 446 log.info('Cancel proposal info : {}'.format(proposalinfo)) 447 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_Abstentions, 448 address, transaction_cfg=pip.cfg.transaction_cfg) 449 log.info('Not staking address , node {}, vote cancel proposal result {}'.format(pip.node.node_id, result)) 450 assert_code(result, 302021) 451 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 452 assert_code(result, 0) 453 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 454 assert_code(result, 302027) 455 456 457 class TestVoteParam: 458 @pytest.mark.compatibility 459 @pytest.mark.P0 460 @allure.title('Param proposal voting function verification') 461 def test_PP_VO_002_PP_VO_008_PP_VO_018_PP_VO_016(self, submit_param): 462 pip = submit_param 463 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 464 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 465 log.info('param proposal info : {}'.format(proposalinfo)) 466 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_Abstentions, 467 address, transaction_cfg=pip.cfg.transaction_cfg) 468 log.info('Not staking address , node {}, vote param proposal result {}'.format(pip.node.node_id, result)) 469 assert_code(result, 302021) 470 result = proposal_vote(pip) 471 assert_code(result, 0) 472 result = proposal_vote(pip) 473 assert_code(result, 302027) 474 475 @pytest.mark.P2 476 @allure.title('voting function verification') 477 def test_PP_VO_009_PP_VO_010_V0_TE_001_V0_TE_002(self, submit_param, all_clients): 478 pip = submit_param 479 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 480 transaction_cfg=pip.cfg.transaction_cfg) 481 log.info('Submit text proposal result : {}'.format(result)) 482 assert_code(result, 0) 483 address = pip.node.staking_address 484 client = get_client_by_nodeid(pip.node.node_id, all_clients) 485 result = client.staking.withdrew_staking(pip.node.staking_address) 486 endblock = get_refund_to_account_block(pip) 487 log.info('Node {} withdrew staking result {}'.format(pip.node.node_id, result)) 488 assert_code(result, 0) 489 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 490 log.info('Cancel proposal info : {}'.format(proposalinfo)) 491 proposalinfo_text = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 492 log.info('Text proposal info : {}'.format(proposalinfo_text)) 493 result = proposal_vote(pip) 494 assert_code(result, 302020) 495 result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) 496 assert_code(result, 302020) 497 wait_block_number(pip.node, endblock) 498 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_nays, address, 499 transaction_cfg=pip.cfg.transaction_cfg) 500 assert_code(result, 302022) 501 result = pip.vote(pip.node.node_id, proposalinfo_text.get('ProposalID'), pip.cfg.vote_option_yeas, 502 address, transaction_cfg=pip.cfg.transaction_cfg) 503 assert_code(result, 302022) 504 505 506 @pytest.mark.compatibility 507 @pytest.mark.P0 508 @allure.title('Param proposal voting function verification') 509 def test_PP_VO_003_PP_VO_004_VS_EP_002_VS_EP_003(new_genesis_env, clients_consensus): 510 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 511 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 0 512 new_genesis_env.set_genesis(genesis.to_dict()) 513 new_genesis_env.deploy_all() 514 pip = clients_consensus[0].pip 515 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '123', 516 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 517 log.info('Submit param proposal result : {}'.format(result)) 518 assert_code(result, 0) 519 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 520 log.info('param proposal info {}'.format(proposalinfo)) 521 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock') - 10) 522 result = proposal_vote(pip) 523 assert_code(result, 0) 524 result = pip.pip.getTallyResult(proposalinfo.get('ProposalID')) 525 log.info('Interface getTallyResult result is {}'.format(result)) 526 assert_code(result, 302030) 527 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 528 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 529 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 530 log.info('Node {} vote param proposal result : {}'.format(pip.node.node_id, result)) 531 result = pip.pip.getTallyResult(proposalinfo.get('ProposalID')) 532 log.info('Interface getTallyResult result is {}'.format(result)) 533 assert_code(result, 0) 534 535 536 @pytest.mark.P0 537 @allure.title('Cancel proposal voting function verification') 538 def test_PP_VO_001_PP_VO_006_PP_VO_007_VS_EP_001(submit_cancel_param): 539 pip = submit_cancel_param 540 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 541 log.info('cancel proposal info {}'.format(proposalinfo)) 542 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock') - 8) 543 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 544 assert_code(result, 0) 545 result = pip.pip.getTallyResult(proposalinfo.get('ProposalID')) 546 log.info('Interface getTallyResult result is {}'.format(result)) 547 assert_code(result, 302030) 548 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 549 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 550 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 551 log.info('Node {} vote cancel proposal result : {}'.format(pip.node.node_id, result)) 552 result = pip.pip.getTallyResult(proposalinfo.get('ProposalID')) 553 log.info('Interface getTallyResult result is {}'.format(result)) 554 assert_code(result, 0) 555 556 557 class TestVoteVPVerify: 558 def vote_wrong_version(self, pip, proposaltype): 559 proposalinfo = pip.get_effect_proposal_info_of_vote(proposaltype) 560 log.info('Get proposal information : {}'.format(proposalinfo)) 561 program_version = pip.cfg.version1 562 if pip.node.program_version == pip.cfg.version1: 563 program_version = pip.cfg.version2 564 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 565 pip.node.staking_address, program_version=program_version, 566 transaction_cfg=pip.cfg.transaction_cfg) 567 log.info('Wrong program version vote result : {}'.format(result)) 568 return result 569 570 def vote_wrong_versionsign(self, pip, proposaltype): 571 proposalinfo = pip.get_effect_proposal_info_of_vote(proposaltype) 572 log.info('Get proposal information : {}'.format(proposalinfo)) 573 version_sign = pip.node.program_version_sign 574 version_sign = version_sign.replace(version_sign[2:4], '11') 575 result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, 576 pip.node.staking_address, version_sign=version_sign, 577 transaction_cfg=pip.cfg.transaction_cfg) 578 log.info('Wrong version sign vote result : {}'.format(result)) 579 return result 580 581 @pytest.mark.P1 582 @allure.title('Version proposal voting function verification--platon version') 583 def test_VO_VER_001_003_VO_SI_001_V_UP_1(self, submit_version): 584 pip = submit_version 585 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN1) 586 assert_code(result, 302025) 587 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN2) 588 assert_code(result, 302025) 589 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN0) 590 assert_code(result, 302025) 591 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN3) 592 assert_code(result, 302025) 593 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN4) 594 assert_code(result, 302025) 595 version_sign = pip.node.program_version_sign 596 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN, version_sign=version_sign) 597 assert_code(result, 302024) 598 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN6) 599 assert_code(result, 302025) 600 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN7) 601 assert_code(result, 302025) 602 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN8) 603 assert_code(result, 302025) 604 605 @pytest.mark.P1 606 @allure.title('Version proposal voting function verification--platon version') 607 def test_VO_VER_002_004_VO_SI_002(self, no_vp_proposal): 608 pip = no_vp_proposal 609 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version9, 4, 610 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 611 log.info('Node {} submit version proposal result : {}'.format(pip.node.node_id, result)) 612 assert_code(result, 0) 613 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN0) 614 assert_code(result, 302025) 615 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN1) 616 assert_code(result, 302025) 617 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN2) 618 assert_code(result, 302025) 619 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN3) 620 assert_code(result, 302025) 621 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN4) 622 assert_code(result, 302025) 623 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN) 624 assert_code(result, 302025) 625 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN6) 626 assert_code(result, 302025) 627 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN7) 628 assert_code(result, 302025) 629 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN8) 630 assert_code(result, 302025) 631 version_sign = pip.node.program_version_sign 632 result = replace_platon_vote(pip, bin=pip.cfg.PLATON_NEW_BIN9, version_sign=version_sign) 633 assert_code(result, 302024) 634 635 @pytest.mark.P2 636 @allure.title('Text proposal voting function verification') 637 def test_VO_SI_011_012(self, clients_verifier): 638 pip = clients_verifier[0].pip 639 pip_two = clients_verifier[1].pip 640 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 641 transaction_cfg=pip.cfg.transaction_cfg) 642 log.info('Submit text proposal result : {}'.format(result)) 643 assert_code(result, 0) 644 result = self.vote_wrong_version(pip, pip.cfg.text_proposal) 645 assert_code(result, 0) 646 result = self.vote_wrong_versionsign(pip_two, pip.cfg.text_proposal) 647 assert_code(result, 0) 648 649 @pytest.mark.P2 650 @allure.title('Cancel proposal voting function verification') 651 def test_VO_SI_013_VO_SI_014_VO_SI_015_VO_SI_016(self, submit_cancel_param, clients_verifier): 652 pip = submit_cancel_param 653 for client in clients_verifier: 654 if pip.node.node_id != client.node.node_id: 655 pip_two = client.pip 656 break 657 result = self.vote_wrong_version(pip, pip.cfg.param_proposal) 658 assert_code(result, 0) 659 result = self.vote_wrong_versionsign(pip_two, pip.cfg.param_proposal) 660 assert_code(result, 0) 661 662 result = self.vote_wrong_version(pip, pip.cfg.cancel_proposal) 663 assert_code(result, 0) 664 result = self.vote_wrong_versionsign(pip_two, pip.cfg.cancel_proposal) 665 assert_code(result, 0) 666 667 @pytest.mark.P2 668 @allure.title('Voting function verification--effective proposal id') 669 def test_V0_POI_001(self, client_verifier): 670 pip = client_verifier.pip 671 result = pip.vote(pip.node.node_id, '0x29b553fb979855751890aecf3e105948a11a21f121cad11f9e455c1f01b12345', 672 pip.cfg.vote_option_yeas, pip.node.staking_address, 673 transaction_cfg=pip.cfg.transaction_cfg) 674 log.info('Ineffective proposalid, vote result : {}'.format(result)) 675 assert_code(result, 302006) 676 677 678 class TestCadidateVote: 679 @pytest.mark.P1 680 @allure.title('Voting function verification--candidate') 681 def test_VO_TER_003_VO_TER_007_VO_TER_005_PP_VO_013(self, no_vp_proposal, client_candidate, client_verifier): 682 ca_pip = client_candidate.pip 683 ve_pip = client_verifier.pip 684 submittpandvote([client_verifier], 2) 685 submitvpandvote([client_verifier], votingrounds=1) 686 proposalinfo_version = ve_pip.get_effect_proposal_info_of_vote() 687 log.info('Version proposal information {}'.format(proposalinfo_version)) 688 result = version_proposal_vote(ca_pip) 689 assert_code(result, 302022) 690 result = proposal_vote(ca_pip, proposaltype=ca_pip.cfg.text_proposal) 691 assert_code(result, 302022) 692 wait_block_number(ca_pip.node, proposalinfo_version.get('EndVotingBlock')) 693 submitcppandvote([client_verifier], [2]) 694 result = proposal_vote(ca_pip, proposaltype=ca_pip.cfg.param_proposal) 695 assert_code(result, 302022) 696 result = proposal_vote(ca_pip, proposaltype=ca_pip.cfg.cancel_proposal) 697 assert_code(result, 302022)