github.com/platonnetwork/platon-go@v0.7.6/cases/tests/govern/test_submit_proposal.py (about) 1 from common.log import log 2 from dacite import from_dict 3 from tests.lib import Genesis 4 import pytest, allure 5 from tests.lib.utils import wait_block_number, assert_code, get_governable_parameter_value 6 from tests.lib.client import get_client_by_nodeid 7 import time 8 import math 9 from tests.govern.test_voting_statistics import submitcppandvote, submitcvpandvote 10 11 12 @pytest.mark.P0 13 @pytest.mark.compatibility 14 @allure.title('Submit version proposal function verification') 15 def test_VP_SU_001(submit_version): 16 pip = submit_version 17 proposalinfo = pip.get_effect_proposal_info_of_vote() 18 log.info('Get version proposal information : {}'.format(proposalinfo)) 19 endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 20 proposalinfo.get('EndVotingRounds') 21 ) * pip.economic.consensus_size - 20 22 log.info('Calculated endvoting block{},interface returned endvoting block{}'.format(endvotingblock_count, 23 proposalinfo.get('EndVotingBlock'))) 24 assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock') 25 assert int(endvotingblock_count) + 21 == proposalinfo.get('ActiveBlock') 26 27 28 @pytest.mark.P0 29 @pytest.mark.compatibility 30 @allure.title('Submit cancel proposal function verification') 31 def test_CP_SU_001_CP_UN_001(submit_cancel): 32 pip = submit_cancel 33 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 34 log.info('cancel proposalinfo : {}'.format(proposalinfo)) 35 endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 36 proposalinfo.get('EndVotingRounds') 37 ) * pip.economic.consensus_size - 20 38 log.info('Calculated endvoting block{},interface returned endvoting block{}'.format(endvotingblock_count, 39 proposalinfo.get('EndVotingBlock'))) 40 assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock') 41 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'), 42 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 43 log.info('Submit cancel proposal result : {}'.format(result)) 44 assert_code(result, 302014) 45 46 47 class TestsubmitCP: 48 @pytest.mark.P0 49 @allure.title('Submit param proposal function verification') 50 def test_CP_SU_002_CP_SU_003(self, submit_param): 51 pip = submit_param 52 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 53 log.info('param proposalinfo : {}'.format(proposalinfo)) 54 endvotingrounds_count = (proposalinfo.get('EndVotingBlock') - 55 math.ceil(pip.node.block_number/pip.economic.consensus_size) * 56 pip.economic.consensus_size) / pip.economic.consensus_size 57 log.info('caculated endvoting rounds is {}'.format(endvotingrounds_count)) 58 result = pip.submitCancel(pip.node.node_id, str(time.time()), endvotingrounds_count + 1, proposalinfo.get('ProposalID'), 59 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 60 log.info('Submit cancel proposal result : {}'.format(result)) 61 assert_code(result, 302010) 62 result = pip.submitCancel(pip.node.node_id, str(time.time()), endvotingrounds_count, proposalinfo.get('ProposalID'), 63 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 64 log.info('Submit cancel proposal result : {}'.format(result)) 65 assert_code(result, 0) 66 67 @pytest.mark.P0 68 @allure.title('Submit cancel param proposal function verification') 69 def test_CP_SU_002_CP_UN_002(self, submit_cancel_param): 70 pip = submit_cancel_param 71 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 72 log.info('cancel proposalinfo : {}'.format(proposalinfo)) 73 endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 74 proposalinfo.get('EndVotingRounds') 75 ) * pip.economic.consensus_size - 20 76 log.info('Calculated endvoting block{},interface returned endvoting block{}'.format(endvotingblock_count, 77 proposalinfo.get('EndVotingBlock'))) 78 assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock') 79 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'), 80 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 81 log.info('Submit cancel proposal result : {}'.format(result)) 82 assert_code(result, 302014) 83 84 85 @pytest.mark.P0 86 @pytest.mark.compatibility 87 @allure.title('Submit param proposal function verification') 88 def test_PP_SU_001_PP_UN_001_VP_UN_003(submit_param): 89 pip = submit_param 90 log.info('test chain version : {}'.format(pip.chain_version)) 91 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 92 log.info('param proposalinfo : {}'.format(proposalinfo)) 93 endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.settlement_size + 94 pip.economic.pp_vote_settlement_wheel 95 ) * pip.economic.settlement_size 96 log.info('Calculated endvoting block {},interface returned endvoting block {}'.format(endvotingblock_count, 97 proposalinfo.get('EndVotingBlock'))) 98 assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock') 99 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '22', 100 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 101 log.info('There is a voting param proposal,submit param proposal result : {}'.format(result)) 102 assert_code(result, 302032) 103 104 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, 105 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 106 log.info('There is a voting param proposal,submit version proposal result : {}'.format(result)) 107 assert_code(result, 302032) 108 109 @pytest.mark.P2 110 def test_PP_SU_021(new_genesis_env, client_consensus): 111 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 112 genesis.config.cbft.period = 1000 * 2 * genesis.config.cbft.amount 113 genesis.economicModel.common.maxEpochMinutes = 6 114 genesis.economicModel.gov.textProposalVoteDurationSeconds = 161 115 new_genesis_env.set_genesis(genesis.to_dict()) 116 new_genesis_env.deploy_all() 117 pip = client_consensus.pip 118 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '99', pip.node.staking_address, 119 transaction_cfg=pip.cfg.transaction_cfg) 120 assert_code(result, 0) 121 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 122 log.info('Param proposal information : {}'.format(proposalinfo)) 123 endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.settlement_size + 124 pip.economic.pp_vote_settlement_wheel 125 ) * pip.economic.settlement_size 126 log.info('Calculated endvoting block {},interface returned endvoting block {}'.format(endvotingblock_count, 127 proposalinfo.get( 128 'EndVotingBlock'))) 129 assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock') 130 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 131 transaction_cfg=pip.cfg.transaction_cfg) 132 log.info('Submit text proposal result : {}'.format(result)) 133 assert_code(result, 0) 134 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 135 log.info('Get text proposal information :{}'.format(proposalinfo)) 136 endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 4 137 ) * pip.economic.consensus_size - 20 138 log.info('calcuted endvoting block {},interface returns {}'.format(endvotingblock_count, 139 proposalinfo.get('EndVotingBlock'))) 140 assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock') 141 142 143 144 @pytest.mark.P0 145 @allure.title('Submit version proposal function verification') 146 def test_VP_VE_001_to_VP_VE_005(no_vp_proposal): 147 pip_tmp = no_vp_proposal 148 result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.cfg.version1, 1, 149 pip_tmp.node.staking_address, transaction_cfg=pip_tmp.cfg.transaction_cfg) 150 log.info('Submit version proposal result : {}'.format(result)) 151 assert_code(result, 302011) 152 153 result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.cfg.version2, 1, 154 pip_tmp.node.staking_address, transaction_cfg=pip_tmp.cfg.transaction_cfg) 155 log.info('Submit version proposal result : {}'.format(result)) 156 assert_code(result, 302011) 157 158 result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.cfg.version3, 1, 159 pip_tmp.node.staking_address, transaction_cfg=pip_tmp.cfg.transaction_cfg) 160 log.info('Submit version proposal result : {}'.format(result)) 161 assert_code(result, 302011) 162 163 result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.chain_version, 1, 164 pip_tmp.node.staking_address, transaction_cfg=pip_tmp.cfg.transaction_cfg) 165 log.info('Submit version proposal result : {}'.format(result)) 166 assert_code(result, 302011) 167 168 result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.cfg.version8, 1, 169 pip_tmp.node.staking_address, transaction_cfg=pip_tmp.cfg.transaction_cfg) 170 log.info('Submit version proposal result : {}'.format(result)) 171 assert_code(result, 0) 172 173 174 @pytest.mark.P2 175 @allure.title('Nostaking address, submit version proposal function verification') 176 def test_VP_WA_001(no_vp_proposal): 177 pip_tmp = no_vp_proposal 178 address, _ = pip_tmp.economic.account.generate_account(pip_tmp.node.web3, 10**18 * 10000000) 179 result = pip_tmp.submitVersion(pip_tmp.node.node_id, str(time.time()), pip_tmp.cfg.version5, 1, 180 address, transaction_cfg=pip_tmp.cfg.transaction_cfg) 181 log.info('Submit version proposal reuslt : {}'.format(result)) 182 assert_code(result, 302021) 183 184 185 @pytest.mark.P2 186 @allure.title('Nostaking address, submit text proposal function verification') 187 def test_TP_WA_001(client_verifier): 188 pip = client_verifier.pip 189 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000000) 190 result = pip.submitText(pip.node.node_id, str(time.time()), address, 191 transaction_cfg=pip.cfg.transaction_cfg) 192 log.info('Submit text proposal reuslt : {}'.format(result)) 193 assert_code(result, 302021) 194 195 196 @pytest.mark.P0 197 @allure.title('submit text proposal function verification') 198 def test_TP_UN_001(submit_text): 199 pip = submit_text 200 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 201 transaction_cfg=pip.cfg.transaction_cfg) 202 log.info('There is voting text proposal, submit text proposal result : {}'.format(result)) 203 assert_code(result, 0) 204 205 206 @pytest.mark.P0 207 @pytest.mark.compatibility 208 @allure.title('Submit version proposal function verification') 209 def test_VP_SU_001_VP_UN_001(submit_version): 210 pip = submit_version 211 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, 212 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 213 log.info('There is voting version proposal, submit version proposal result : {}'.format(result)) 214 assert_code(result, 302012) 215 216 217 @pytest.mark.P0 218 @allure.title('There is preactive proposal, submit proposal function verification') 219 def test_VP_UN_002_CP_ID_002(preactive_proposal_pips, new_genesis_env): 220 pip = preactive_proposal_pips[0] 221 proposalinfo = pip.get_effect_proposal_info_of_preactive() 222 log.info('Get preactive proposal info: {}'.format(proposalinfo)) 223 224 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, 225 pip.node.staking_address, 226 transaction_cfg=pip.cfg.transaction_cfg) 227 log.info('There is preactive version proposal, submit version proposal result : {}'.format(result)) 228 assert_code(result, 302013) 229 230 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'), 231 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 232 log.info('there is preactive version proposal, submit cancel proposal result: {}'.format(result)) 233 assert_code(result, 302017) 234 235 236 @pytest.mark.P0 237 @allure.title('There is preactive proposal, submit cancel parammeter proposal function verification') 238 def test_PP_UN_003(preactive_proposal_pips, new_genesis_env): 239 pip = preactive_proposal_pips[0] 240 proposalinfo = pip.get_effect_proposal_info_of_preactive() 241 log.info('Get preactive proposal info: {}'.format(proposalinfo)) 242 243 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 244 '84', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 245 log.info('there is preactive version proposal, submit cancel param proposal result: {}'.format(result)) 246 assert_code(result, 302013) 247 248 249 class TestEndVotingRounds: 250 def update_setting(self, new_genesis_env, pip, value=0): 251 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 252 genesis.economicModel.gov.versionProposalVoteDurationSeconds = 2 * pip.economic.consensus_size + value 253 genesis.economicModel.gov.textProposalVoteDurationSeconds = 2 * pip.economic.consensus_size + value 254 new_genesis_env.set_genesis(genesis.to_dict()) 255 new_genesis_env.deploy_all() 256 257 @pytest.mark.P1 258 @allure.title('Submit version and text proposal function verification--endvoting rounds') 259 def test_VP_CR_001_VP_CR_002_VP_CR_007_TP_TE_002(self, new_genesis_env, client_verifier): 260 ''' 261 Proposal vote duration set consensus size's accompanying number +1 262 :param pip_env: 263 :param pip: 264 :return: 265 ''' 266 pip = client_verifier.pip 267 self.update_setting(new_genesis_env, pip, value=1) 268 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 3, 269 pip.node.staking_address, 270 transaction_cfg=pip.cfg.transaction_cfg) 271 log.info('endvoting rounds is three, subtmit version proposal result : {}'.format(result)) 272 assert_code(result, 302010) 273 274 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 0, 275 pip.node.staking_address, 276 transaction_cfg=pip.cfg.transaction_cfg) 277 log.info('endvoting rounds is zero, subtmit version proposal result : {}'.format(result)) 278 assert_code(result, 302009) 279 280 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 2, 281 pip.node.staking_address, 282 transaction_cfg=pip.cfg.transaction_cfg) 283 log.info('endvoting rounds is two, subtmit version proposal result : {}'.format(result)) 284 assert_code(result, 0) 285 286 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 287 transaction_cfg=pip.cfg.transaction_cfg) 288 log.info('Submit text proposal result : {}'.format(result)) 289 assert_code(result, 0) 290 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 291 log.info('Get text proposal information :{}'.format(proposalinfo)) 292 endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 2 293 ) * pip.economic.consensus_size - 20 294 log.info('calcuted endvoting block {},interface returns {}'.format(endvotingblock_count, 295 proposalinfo.get('EndVotingBlock'))) 296 assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock') 297 298 @pytest.mark.P1 299 @allure.title('Submit version and text proposal function verification--endvoting rounds') 300 def test_VP_CR_003_VP_CR_004_VP_CR_007_TP_TE_003(self, new_genesis_env, client_verifier): 301 pip = client_verifier.pip 302 self.update_setting(new_genesis_env, pip, value=-1) 303 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 2, pip.node.staking_address, 304 transaction_cfg=pip.cfg.transaction_cfg) 305 log.info('endvoting rounds is two, subtmit version proposal result : {}'.format(result)) 306 assert_code(result, 302010) 307 308 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 0, pip.node.staking_address, 309 transaction_cfg=pip.cfg.transaction_cfg) 310 log.info('Endvoting rounds is zero, subtmit version proposal result : {}'.format(result)) 311 assert_code(result, 302009) 312 313 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, pip.node.staking_address, 314 transaction_cfg=pip.cfg.transaction_cfg) 315 log.info('Endvoting rounds is one, subtmit version proposal result : {}'.format(result)) 316 assert_code(result, 0) 317 318 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 319 transaction_cfg=pip.cfg.transaction_cfg) 320 log.info('Submit text proposal result : {}'.format(result)) 321 assert_code(result, 0) 322 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 323 log.info('Get text proposal information : {}'.format(proposalinfo)) 324 endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 1 325 ) * pip.economic.consensus_size - 20 326 log.info('Calcuted endvoting block {},interface return {}'.format(endvotingblock_count, 327 proposalinfo.get('EndVotingBlock'))) 328 assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock') 329 330 @pytest.mark.P1 331 @pytest.mark.compatibility 332 @allure.title('Submit version and text proposal function verification--endvoting rounds') 333 def test_VP_CR_005_VP_CR_006_TP_TE_001(self, new_genesis_env, client_verifier): 334 pip = client_verifier.pip 335 self.update_setting(new_genesis_env, pip) 336 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 3, 337 pip.node.staking_address, 338 transaction_cfg=pip.cfg.transaction_cfg) 339 log.info('Endvoting rounds is three, subtmit version proposal result : {}'.format(result)) 340 assert_code(result, 302010) 341 342 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 0, 343 pip.node.staking_address, 344 transaction_cfg=pip.cfg.transaction_cfg) 345 log.info('Endvoting rounds is zero, subtmit version proposal result : {}'.format(result)) 346 assert_code(result, 302009) 347 348 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 2, 349 pip.node.staking_address, 350 transaction_cfg=pip.cfg.transaction_cfg) 351 log.info('Endvoting rounds is two, subtmit version proposal result : {}'.format(result)) 352 assert_code(result, 0) 353 354 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 355 transaction_cfg=pip.cfg.transaction_cfg) 356 log.info('Submit text proposal result : {}'.format(result)) 357 assert_code(result, 0) 358 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 359 log.info('Get text proposal information {}'.format(proposalinfo)) 360 endvotingblock_count = math.ceil(proposalinfo.get('SubmitBlock') / pip.economic.consensus_size + 2 361 ) * pip.economic.consensus_size - 20 362 log.info('calcuted endvoting block {},interface return {}'.format(endvotingblock_count, 363 proposalinfo.get('EndVotingBlock'))) 364 assert int(endvotingblock_count) == proposalinfo.get('EndVotingBlock') 365 366 proosalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 367 log.info('text proposalinfo: {}'.format(proosalinfo)) 368 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proosalinfo.get('ProposalID'), 369 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 370 log.info('submit cancel result: {}'.format(result)) 371 assert_code(result, 302016) 372 373 374 class TestNoVerifierSubmitProposal: 375 @pytest.mark.P0 376 @allure.title('New node submit version and text proposal function verification') 377 def test_VP_PR_002_TP_PR_002(self, no_vp_proposal, client_new_node): 378 pip = client_new_node.pip 379 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000000) 380 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, address, 381 transaction_cfg=pip.cfg.transaction_cfg) 382 log.info('New node submit version proposal : {}'.format(result)) 383 assert_code(result, 302022) 384 385 result = pip.submitText(pip.node.node_id, str(time.time()), address, 386 transaction_cfg=pip.cfg.transaction_cfg) 387 log.info('New node submit text proposal : {}'.format(result)) 388 assert_code(result, 302022) 389 390 @pytest.mark.P0 391 @allure.title('Candidate node submit version and text proposal function verification') 392 def test_VP_PR_001_TP_PR_001(self, client_candidate): 393 pip = client_candidate.pip 394 result = pip.submitVersion(pip.node.node_id, str(time.time()), 395 pip.cfg.version5, 1, pip.node.staking_address, 396 transaction_cfg=pip.cfg.transaction_cfg) 397 log.info('Candidate node {} submit version proposal result : {}'.format(pip.node.node_id, result)) 398 assert_code(result, 302022) 399 400 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 401 transaction_cfg=pip.cfg.transaction_cfg) 402 log.info('candidate node {} submit text proposal result : {}'.format(pip.node.node_id, result)) 403 assert_code(result, 302022) 404 405 @pytest.mark.P2 406 @allure.title('Abnormal node submit proposal') 407 def test_VP_PR_003_VP_PR_004_TP_PR_003_TP_PR_004(self, client_verifier): 408 address = client_verifier.node.staking_address 409 result = client_verifier.staking.withdrew_staking(address) 410 log.info('Node {} withdrew staking result : {}'.format(client_verifier.node.node_id, result)) 411 assert_code(result, 0) 412 result = client_verifier.pip.submitVersion(client_verifier.node.node_id, str(time.time()), 413 client_verifier.pip.cfg.version5, 1, address, 414 transaction_cfg=client_verifier.pip.cfg.transaction_cfg) 415 log.info('Node exiting submit version proposal :{}'.format(result)) 416 assert_code(result, 302020) 417 418 result = client_verifier.pip.submitText(client_verifier.node.node_id, str(time.time()), address, 419 transaction_cfg=client_verifier.pip.cfg.transaction_cfg) 420 log.info('Node exiting submit text proposal : {}'.format(result)) 421 assert_code(result, 302020) 422 423 client_verifier.economic.wait_settlement_blocknum(client_verifier.node, 424 number=client_verifier.economic.unstaking_freeze_ratio) 425 result = client_verifier.pip.submitVersion(client_verifier.node.node_id, str(time.time()), 426 client_verifier.pip.cfg.version5, 1, address, 427 transaction_cfg=client_verifier.pip.cfg.transaction_cfg) 428 log.info('Node exited submit version proposal : {}'.format(result)) 429 assert_code(result, 302022) 430 431 client_verifier.economic.wait_settlement_blocknum(client_verifier.node, 432 number=client_verifier.economic.unstaking_freeze_ratio) 433 result = client_verifier.pip.submitText(client_verifier.node.node_id, str(time.time()), address, 434 transaction_cfg=client_verifier.pip.cfg.transaction_cfg) 435 log.info('Node exited submit text proposal : {}'.format(result)) 436 assert_code(result, 302022) 437 438 439 class TestSubmitCancel: 440 @pytest.mark.P0 441 @allure.title('Nostaking address submit cancel proposal') 442 def test_CP_WA_001(self, submit_version): 443 pip = submit_version 444 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 445 proposalinfo = pip.get_effect_proposal_info_of_vote() 446 log.info('Get version proposal information : {}'.format(proposalinfo)) 447 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'), 448 address, transaction_cfg=pip.cfg.transaction_cfg) 449 log.info('Submit cancel proposal result : {}'.format(result)) 450 assert_code(result, 302021) 451 452 @pytest.mark.P0 453 @allure.title('New node submit cancel proposal') 454 def test_CP_PR_001(self, new_node_has_proposal): 455 pip = new_node_has_proposal 456 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 457 proposalinfo = pip.get_effect_proposal_info_of_vote() 458 log.info('Get version proposal information : {}'.format(proposalinfo)) 459 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, 460 proposalinfo.get('ProposalID'), 461 address, transaction_cfg=pip.cfg.transaction_cfg) 462 log.info('Submit cancel proposal resullt : {}'.format(result)) 463 assert_code(result, 302022) 464 465 @pytest.mark.P0 466 @allure.title('Candidate node submit cancel proposal') 467 def test_CP_PR_002(self, candidate_has_proposal): 468 pip = candidate_has_proposal 469 proposalinfo = pip.get_effect_proposal_info_of_vote() 470 if not proposalinfo: 471 time.sleep(10) 472 proposalinfo = pip.get_effect_proposal_info_of_vote() 473 log.info('Get proposal information {}'.format(proposalinfo)) 474 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, 475 proposalinfo.get('ProposalID'), 476 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 477 log.info('Candidate submit cancel proposal result : {}'.format(result)) 478 assert_code(result, 302022) 479 480 @pytest.mark.P2 481 @allure.title('Abnormal node submit cancel proposal') 482 def test_CP_PR_003_CP_PR_004(self, new_genesis_env, client_consensus): 483 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 484 genesis.economicModel.gov.versionProposalVoteDurationSeconds = 10000 485 new_genesis_env.set_genesis(genesis.to_dict()) 486 new_genesis_env.deploy_all() 487 pip = client_consensus.pip 488 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 20, 489 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 490 log.info('Submit version proposal result : {}'.format(result)) 491 assert_code(result, 0) 492 proposalinfo = pip.get_effect_proposal_info_of_vote() 493 log.info('proposalinfo: {}'.format(proposalinfo)) 494 client = client_consensus 495 address = pip.node.staking_address 496 result = client.staking.withdrew_staking(address) 497 log.info('nodeid: {} withdrewstaking result: {}'.format(client.node.node_id, result)) 498 assert_code(result, 0) 499 result = client.pip.submitCancel(client.node.node_id, str(time.time()), 1, 500 proposalinfo.get('ProposalID'), address, 501 transaction_cfg=client.pip.cfg.transaction_cfg) 502 log.info('node exiting，cancel proposal result: {}'.format(result)) 503 assert_code(result, 302020) 504 505 client.economic.wait_settlement_blocknum(client.node, number=client.economic.unstaking_freeze_ratio) 506 result = client.pip.submitCancel(client.node.node_id, str(time.time()), 1, 507 proposalinfo.get('ProposalID'), address, 508 transaction_cfg=client.pip.cfg.transaction_cfg) 509 log.info('exited node，cancel proposal result: {}'.format(result)) 510 assert_code(result, 302022) 511 512 @pytest.mark.P0 513 @allure.title('Submit version proposal function verification--endvoting rounds') 514 def test_CP_CR_001_CP_CR_002(self, submit_version): 515 pip = submit_version 516 proposalinfo = pip.get_effect_proposal_info_of_vote() 517 log.info('proposalinfo: {}'.format(proposalinfo)) 518 endvoting_rounds = (proposalinfo.get('EndVotingBlock') + 20 - math.ceil( 519 pip.node.block_number / pip.economic.consensus_size) * pip.economic.consensus_size 520 ) / pip.economic.consensus_size 521 result = pip.submitCancel(pip.node.node_id, str(time.time()), endvoting_rounds, 522 proposalinfo.get('ProposalID'), pip.node.staking_address, 523 transaction_cfg=pip.cfg.transaction_cfg) 524 log.info('endvoting_rounds:{}， cancel proposal result:{}'.format(endvoting_rounds, result)) 525 assert_code(result, 302010) 526 527 result = pip.submitCancel(pip.node.node_id, str(time.time()), endvoting_rounds + 1, 528 proposalinfo.get('ProposalID'), pip.node.staking_address, 529 transaction_cfg=pip.cfg.transaction_cfg) 530 log.info('endvoting_rounds:{}， cancel proposal result:{}'.format(endvoting_rounds + 1, result)) 531 assert_code(result, 302010) 532 533 @pytest.mark.P0 534 @allure.title('Submit cancel proposal function verification--ineffective proposal id') 535 def test_CP_ID_001(self, no_vp_proposal): 536 pip = no_vp_proposal 537 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, 538 '0x49b83cfc4b99462f7131d14d80c73b6657237753cd1e878e8d62dc2e9f574123', 539 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 540 log.info('cancel proposal result: {}'.format(result)) 541 assert_code(result, 302015) 542 543 @pytest.mark.P0 544 @allure.title('Submit parammeter proposal function verification') 545 def test_CP_ID_004_CP_ID_003(self, new_genesis_env, client_consensus): 546 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 547 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 0 548 new_genesis_env.set_genesis(genesis.to_dict()) 549 new_genesis_env.deploy_all() 550 pip = client_consensus.pip 551 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '123', 552 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 553 log.info('Submit parameter proposal result : {}'.format(result)) 554 assert_code(result, 0) 555 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 556 transaction_cfg=pip.cfg.transaction_cfg) 557 log.info('Submit text proposal result : {}'.format(result)) 558 assert_code(result, 0) 559 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 560 log.info('Get parameter proposal information : {}'.format(proposalinfo_param)) 561 proposalinfo_text = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 562 log.info('Get text proposal information : {}'.format(proposalinfo_text)) 563 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo_text.get('ProposalID'), 564 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 565 log.info('Submit cancel proposal result : {}'.format(result)) 566 wait_block_number(pip.node, proposalinfo_param.get('EndVotingBlock')) 567 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo_param.get('ProposalID'), 568 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 569 log.info('Submit cancel proposal result : {}'.format(result)) 570 assert_code(result, 302017) 571 572 573 class TestPP: 574 @pytest.mark.P0 575 @allure.title('Submit parammeter proposal function verification') 576 def test_PP_SU_001_PP_SU_002(self, no_vp_proposal, all_clients): 577 pip = no_vp_proposal 578 client = get_client_by_nodeid(pip.node.node_id, all_clients) 579 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '', 580 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 581 log.info('Submit param proposal result : {}'.format(result)) 582 assert_code(result, 3) 583 584 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '1.1', 585 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 586 log.info('Submit param proposal result : {}'.format(result)) 587 assert_code(result, 3) 588 589 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '-1', 590 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 591 log.info('Submit param proposal result : {}'.format(result)) 592 assert_code(result, 3) 593 594 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '50000', 595 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 596 log.info('Submit param proposal result : {}'.format(result)) 597 assert_code(result, 3) 598 599 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 1, 600 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 601 log.info('Submit param proposal result : {}'.format(result)) 602 assert_code(result, 3) 603 604 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '1000000', 605 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 606 log.info('Submit param proposal result : {}'.format(result)) 607 assert_code(result, 3) 608 609 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 610 str(get_governable_parameter_value(client, 'slashBlocksReward')), 611 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 612 log.info('Submit param proposal result : {}'.format(result)) 613 assert_code(result, 302034) 614 615 if pip.economic.slash_blocks_reward != 0: 616 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '0', 617 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 618 log.info('Submit param proposal result : {}'.format(result)) 619 assert_code(result, 0) 620 621 @pytest.mark.P0 622 @allure.title('Submit parammeter proposal function verification') 623 def test_PP_SU_002(self, no_vp_proposal, all_clients): 624 pip = no_vp_proposal 625 if str(get_governable_parameter_value(all_clients[0], 'slashBlocksReward')) != 49999: 626 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '49999', 627 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 628 log.info('Submit param proposal result : {}'.format(result)) 629 assert_code(result, 0) 630 631 @pytest.mark.P0 632 @allure.title('Submit parammeter proposal function verification') 633 def test_PP_SU_003_PP_SU_004(self, no_vp_proposal, all_clients): 634 pip = no_vp_proposal 635 client = get_client_by_nodeid(pip.node.node_id, all_clients) 636 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', '', 637 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 638 log.info('Submit param proposal result : {}'.format(result)) 639 assert_code(result, 3) 640 641 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', '1.1', 642 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 643 log.info('Submit param proposal result : {}'.format(result)) 644 assert_code(result, 3) 645 646 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', '-1', 647 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 648 log.info('Submit param proposal result : {}'.format(result)) 649 assert_code(result, 3) 650 651 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', '0', 652 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 653 log.info('Submit param proposal result : {}'.format(result)) 654 assert_code(result, 3) 655 656 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', 1, 657 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 658 log.info('Submit param proposal result : {}'.format(result)) 659 assert_code(result, 3) 660 661 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', 662 str(get_governable_parameter_value(client, 'maxEvidenceAge')), 663 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 664 log.info('Submit param proposal result : {}'.format(result)) 665 assert_code(result, 302034) 666 667 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', 668 str(get_governable_parameter_value(client, 'unStakeFreezeDuration')), 669 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 670 log.info('Submit param proposal result : {}'.format(result)) 671 assert_code(result, 3) 672 673 if int(get_governable_parameter_value(client, 'maxEvidenceAge')) != 1: 674 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', '1', 675 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 676 log.info('Submit param proposal result : {}'.format(result)) 677 assert_code(result, 0) 678 679 @pytest.mark.P0 680 @allure.title('Submit parammeter proposal function verification') 681 def test_PP_SU_004(self, no_vp_proposal, all_clients): 682 pip = no_vp_proposal 683 if str(get_governable_parameter_value(all_clients[0], 'maxEvidenceAge')) != str( 684 pip.economic.unstaking_freeze_ratio - 1) and str(pip.economic.unstaking_freeze_ratio - 1) <= str( 685 get_governable_parameter_value(all_clients[0], 'unStakeFreezeDuration')): 686 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'maxEvidenceAge', 687 str(pip.economic.unstaking_freeze_ratio - 1), 688 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 689 log.info('Submit param proposal result : {}'.format(result)) 690 assert_code(result, 0) 691 692 @pytest.mark.P0 693 @allure.title('Submit parammeter proposal function verification') 694 def test_PP_SU_005_PP_SU_006(self, no_vp_proposal, all_clients): 695 pip = no_vp_proposal 696 client = get_client_by_nodeid(pip.node.node_id, all_clients) 697 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '', 698 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 699 log.info('Submit param proposal result : {}'.format(result)) 700 assert_code(result, 3) 701 702 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '1.1', 703 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 704 log.info('Submit param proposal result : {}'.format(result)) 705 assert_code(result, 3) 706 707 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '-1', 708 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 709 log.info('Submit param proposal result : {}'.format(result)) 710 assert_code(result, 3) 711 712 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '0', 713 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 714 log.info('Submit param proposal result : {}'.format(result)) 715 assert_code(result, 3) 716 717 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', 1, 718 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 719 log.info('Submit param proposal result : {}'.format(result)) 720 assert_code(result, 3) 721 722 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', 723 '10001', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 724 log.info('Submit param proposal result : {}'.format(result)) 725 assert_code(result, 3) 726 727 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', 728 str(get_governable_parameter_value(client, 'slashFractionDuplicateSign')), 729 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 730 log.info('Submit param proposal result : {}'.format(result)) 731 assert_code(result, 302034) 732 733 if int(get_governable_parameter_value(client, 'maxEvidenceAge')) != 1: 734 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '1', 735 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 736 log.info('Submit param proposal result : {}'.format(result)) 737 assert_code(result, 0) 738 739 @pytest.mark.P0 740 @allure.title('Submit parammeter proposal function verification') 741 def test_PP_SU_006(self, no_vp_proposal): 742 pip = no_vp_proposal 743 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashFractionDuplicateSign', '10000', 744 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 745 log.info('Submit param proposal result : {}'.format(result)) 746 assert_code(result, 0) 747 748 @pytest.mark.P0 749 @allure.title('Submit parammeter proposal function verification') 750 def test_PP_SU_007_PP_SU_008(self, no_vp_proposal, all_clients): 751 pip = no_vp_proposal 752 client = get_client_by_nodeid(pip.node.node_id, all_clients) 753 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', '', 754 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 755 log.info('Submit param proposal result : {}'.format(result)) 756 assert_code(result, 3) 757 758 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', '1.1', 759 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 760 log.info('Submit param proposal result : {}'.format(result)) 761 assert_code(result, 3) 762 763 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', '-1', 764 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 765 log.info('Submit param proposal result : {}'.format(result)) 766 assert_code(result, 3) 767 768 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', '0', 769 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 770 log.info('Submit param proposal result : {}'.format(result)) 771 assert_code(result, 3) 772 773 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', 1, 774 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 775 log.info('Submit param proposal result : {}'.format(result)) 776 assert_code(result, 3) 777 778 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', 779 '81', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 780 log.info('Submit param proposal result : {}'.format(result)) 781 assert_code(result, 3) 782 783 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', 784 str(get_governable_parameter_value(client, 'duplicateSignReportReward')), 785 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 786 log.info('Submit param proposal result : {}'.format(result)) 787 assert_code(result, 302034) 788 789 if int(get_governable_parameter_value(client, 'duplicateSignReportReward')) != 1: 790 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', '1', 791 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 792 log.info('Submit param proposal result : {}'.format(result)) 793 assert_code(result, 0) 794 795 @pytest.mark.P0 796 @allure.title('Submit parammeter proposal function verification') 797 def test_PP_SU_008(self, no_vp_proposal, all_clients): 798 pip = no_vp_proposal 799 if int(get_governable_parameter_value(all_clients[0], 'duplicateSignReportReward')) != 80: 800 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'duplicateSignReportReward', 801 '80', pip.node.staking_address, 802 transaction_cfg=pip.cfg.transaction_cfg) 803 log.info('Submit param proposal result : {}'.format(result)) 804 assert_code(result, 0) 805 806 @pytest.mark.P0 807 @allure.title('Submit parammeter proposal function verification') 808 def test_PP_SU_009_PP_SU_010(self, no_vp_proposal, all_clients): 809 pip = no_vp_proposal 810 client = get_client_by_nodeid(pip.node.node_id, all_clients) 811 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', '', 812 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 813 log.info('Submit param proposal result : {}'.format(result)) 814 assert_code(result, 3) 815 816 value = 10**18 * 1000000 + 0.1 817 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', str(value), 818 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 819 log.info('Submit param proposal result : {}'.format(result)) 820 assert_code(result, 3) 821 822 value = -10**18 * 1000000 823 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', str(value), 824 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 825 log.info('Submit param proposal result : {}'.format(result)) 826 assert_code(result, 3) 827 828 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', '0', 829 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 830 log.info('Submit param proposal result : {}'.format(result)) 831 assert_code(result, 3) 832 833 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', 10**18 * 1000000, 834 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 835 log.info('Submit param proposal result : {}'.format(result)) 836 assert_code(result, 3) 837 838 value = 10**18 * 1000000 - 1 839 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', 840 str(value), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 841 log.info('Submit param proposal result : {}'.format(result)) 842 assert_code(result, 3) 843 844 value = 10**18 * 10000000 + 1 845 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', 846 str(value), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 847 log.info('Submit param proposal result : {}'.format(result)) 848 assert_code(result, 3) 849 850 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', 851 str(get_governable_parameter_value(client, 'stakeThreshold')), 852 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 853 log.info('Submit param proposal result : {}'.format(result)) 854 assert_code(result, 302034) 855 856 if int(get_governable_parameter_value(client, 'stakeThreshold')) != 10**18 * 1000000: 857 value = 10**18 * 1000000 858 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', str(value), 859 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 860 log.info('Submit param proposal result : {}'.format(result)) 861 assert_code(result, 0) 862 863 @pytest.mark.P0 864 @allure.title('Submit parammeter proposal function verification') 865 def test_PP_SU_010(self, no_vp_proposal): 866 pip = no_vp_proposal 867 value = 10**18 * 10000000 868 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'stakeThreshold', 869 str(value), 870 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 871 log.info('Submit param proposal result : {}'.format(result)) 872 assert_code(result, 0) 873 874 @pytest.mark.P0 875 @allure.title('Submit parammeter proposal function verification') 876 def test_PP_SU_011_PP_SU_012(self, no_vp_proposal, all_clients): 877 pip = no_vp_proposal 878 client = get_client_by_nodeid(pip.node.node_id, all_clients) 879 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', '', 880 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 881 log.info('Submit param proposal result : {}'.format(result)) 882 assert_code(result, 3) 883 884 value = 10**18 * 10 + 0.5 885 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', str(value), 886 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 887 log.info('Submit param proposal result : {}'.format(result)) 888 assert_code(result, 3) 889 890 value = -10**18 * 10 891 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', str(value), 892 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 893 log.info('Submit param proposal result : {}'.format(result)) 894 assert_code(result, 3) 895 896 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', '0', 897 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 898 log.info('Submit param proposal result : {}'.format(result)) 899 assert_code(result, 3) 900 901 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', 1, 902 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 903 log.info('Submit param proposal result : {}'.format(result)) 904 assert_code(result, 3) 905 906 value = 10**18 * 10 - 1 907 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', 908 str(value), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 909 log.info('Submit param proposal result : {}'.format(result)) 910 assert_code(result, 3) 911 912 value = 10**18 * 10000 + 1 913 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', 914 str(value), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 915 log.info('Submit param proposal result : {}'.format(result)) 916 assert_code(result, 3) 917 918 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', 919 str(get_governable_parameter_value(client, 'operatingThreshold')), 920 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 921 log.info('Submit param proposal result : {}'.format(result)) 922 assert_code(result, 302034) 923 924 if int(get_governable_parameter_value(client, 'operatingThreshold')) != 10**18 * 10: 925 value = 10**18 * 10 926 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', str(value), 927 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 928 log.info('Submit param proposal result : {}'.format(result)) 929 assert_code(result, 0) 930 931 @pytest.mark.P0 932 @allure.title('Submit parammeter proposal function verification') 933 def test_PP_SU_012(self, no_vp_proposal): 934 pip = no_vp_proposal 935 value = 10**18 * 10000 936 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'operatingThreshold', 937 str(value), pip.node.staking_address, 938 transaction_cfg=pip.cfg.transaction_cfg) 939 log.info('Submit param proposal result : {}'.format(result)) 940 assert_code(result, 0) 941 942 @pytest.mark.P0 943 @allure.title('Submit parammeter proposal function verification') 944 def test_PP_SU_013_PP_SU_014(self, no_vp_proposal, all_clients): 945 pip = no_vp_proposal 946 client = get_client_by_nodeid(pip.node.node_id, all_clients) 947 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', '', 948 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 949 log.info('Submit param proposal result : {}'.format(result)) 950 assert_code(result, 3) 951 952 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', '10.5', 953 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 954 log.info('Submit param proposal result : {}'.format(result)) 955 assert_code(result, 3) 956 957 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', '-100', 958 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 959 log.info('Submit param proposal result : {}'.format(result)) 960 assert_code(result, 3) 961 962 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', '0', 963 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 964 log.info('Submit param proposal result : {}'.format(result)) 965 assert_code(result, 3) 966 967 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', 11, 968 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 969 log.info('Submit param proposal result : {}'.format(result)) 970 assert_code(result, 3) 971 972 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', 973 '113', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 974 log.info('Submit param proposal result : {}'.format(result)) 975 assert_code(result, 3) 976 977 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', 978 str(get_governable_parameter_value(client, 'unStakeFreezeDuration')), 979 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 980 log.info('Submit param proposal result : {}'.format(result)) 981 assert_code(result, 302034) 982 983 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', 984 str(get_governable_parameter_value(client, 'maxEvidenceAge')), 985 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 986 log.info('Submit param proposal result : {}'.format(result)) 987 assert_code(result, 3) 988 989 if int(get_governable_parameter_value(client, 'unStakeFreezeDuration')) != 112: 990 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', '112', 991 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 992 log.info('Submit param proposal result : {}'.format(result)) 993 assert_code(result, 0) 994 995 @pytest.mark.P0 996 @allure.title('Submit parammeter proposal function verification') 997 def test__PP_SU_014(self, no_vp_proposal, all_clients): 998 pip = no_vp_proposal 999 if int(get_governable_parameter_value(all_clients[0], 'unStakeFreezeDuration')) != str( 1000 int(get_governable_parameter_value(all_clients[0], 'maxEvidenceAge')) - 1): 1001 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'unStakeFreezeDuration', 1002 str(int(get_governable_parameter_value(all_clients[0], 'maxEvidenceAge')) + 5), 1003 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1004 log.info('Submit param proposal result : {}'.format(result)) 1005 assert_code(result, 0) 1006 1007 @pytest.mark.P0 1008 @allure.title('Submit parammeter proposal function verification') 1009 def test_PP_SU_015_PP_SU_016(self, no_vp_proposal, all_clients): 1010 pip = no_vp_proposal 1011 client = get_client_by_nodeid(pip.node.node_id, all_clients) 1012 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '', 1013 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1014 log.info('Submit param proposal result : {}'.format(result)) 1015 assert_code(result, 3) 1016 1017 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '30.5', 1018 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1019 log.info('Submit param proposal result : {}'.format(result)) 1020 assert_code(result, 3) 1021 1022 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '-100', 1023 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1024 log.info('Submit param proposal result : {}'.format(result)) 1025 assert_code(result, 3) 1026 1027 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '0', 1028 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1029 log.info('Submit param proposal result : {}'.format(result)) 1030 assert_code(result, 3) 1031 1032 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', 25, 1033 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1034 log.info('Submit param proposal result : {}'.format(result)) 1035 assert_code(result, 3) 1036 1037 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', 1038 '3', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1039 log.info('Submit param proposal result : {}'.format(result)) 1040 assert_code(result, 3) 1041 1042 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', 1043 '202', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1044 log.info('Submit param proposal result : {}'.format(result)) 1045 assert_code(result, 3) 1046 1047 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', 1048 str(get_governable_parameter_value(client, 'maxValidators')), 1049 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1050 log.info('Submit param proposal result : {}'.format(result)) 1051 assert_code(result, 302034) 1052 1053 if int(get_governable_parameter_value(client, 'maxValidators')) != 4: 1054 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '4', 1055 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1056 log.info('Submit param proposal result : {}'.format(result)) 1057 assert_code(result, 0) 1058 1059 @pytest.mark.P0 1060 @allure.title('Submit parammeter proposal function verification') 1061 def test_PP_SU_016(self, no_vp_proposal, all_clients): 1062 pip = no_vp_proposal 1063 if int(get_governable_parameter_value(all_clients[0], 'maxValidators')) != 201: 1064 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '201', 1065 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1066 log.info('Submit param proposal result : {}'.format(result)) 1067 assert_code(result, 0) 1068 1069 @pytest.mark.P0 1070 @allure.title('Submit parammeter proposal function verification') 1071 def test_PP_SU_016(self, no_vp_proposal, all_clients): 1072 pip = no_vp_proposal 1073 client = get_client_by_nodeid(pip.node.node_id, all_clients) 1074 if int(get_governable_parameter_value(client, 'maxValidators')) != 201: 1075 result = pip.submitParam(pip.node.node_id, str(time.time()), 'staking', 'maxValidators', '201', 1076 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1077 log.info('Submit param proposal result : {}'.format(result)) 1078 assert_code(result, 0) 1079 1080 @pytest.mark.P0 1081 @allure.title('Submit parammeter proposal function verification') 1082 def test_PP_SU_017_PP_SU_018(self, no_vp_proposal, all_clients): 1083 pip = no_vp_proposal 1084 client = get_client_by_nodeid(pip.node.node_id, all_clients) 1085 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '', 1086 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1087 log.info('Submit param proposal result : {}'.format(result)) 1088 assert_code(result, 3) 1089 1090 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '4712388.5', 1091 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1092 log.info('Submit param proposal result : {}'.format(result)) 1093 assert_code(result, 3) 1094 1095 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '-4712388', 1096 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1097 log.info('Submit param proposal result : {}'.format(result)) 1098 assert_code(result, 3) 1099 1100 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '0', 1101 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1102 log.info('Submit param proposal result : {}'.format(result)) 1103 assert_code(result, 3) 1104 1105 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', 4712388, 1106 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1107 log.info('Submit param proposal result : {}'.format(result)) 1108 assert_code(result, 3) 1109 1110 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', 1111 '4712387', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1112 log.info('Submit param proposal result : {}'.format(result)) 1113 assert_code(result, 3) 1114 1115 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', 1116 '210000001', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1117 log.info('Submit param proposal result : {}'.format(result)) 1118 assert_code(result, 3) 1119 1120 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', 1121 str(get_governable_parameter_value(client, 'maxBlockGasLimit')), 1122 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1123 log.info('Submit param proposal result : {}'.format(result)) 1124 assert_code(result, 302034) 1125 1126 if int(get_governable_parameter_value(client, 'maxBlockGasLimit')) != 4712388: 1127 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '4712388', 1128 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1129 log.info('Submit param proposal result : {}'.format(result)) 1130 assert_code(result, 0) 1131 1132 @pytest.mark.P0 1133 @allure.title('Submit parammeter proposal function verification') 1134 def test_PP_SU_018(self, no_vp_proposal): 1135 pip = no_vp_proposal 1136 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'maxBlockGasLimit', '210000000', 1137 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1138 log.info('Submit param proposal result : {}'.format(result)) 1139 assert_code(result, 0) 1140 1141 @pytest.mark.P0 1142 @allure.title('Submit parammeter proposal function verification') 1143 def test_PP_SU_019(self, no_vp_proposal): 1144 pip = no_vp_proposal 1145 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', '', '1', 1146 pip.node.staking_address, 1147 transaction_cfg=pip.cfg.transaction_cfg) 1148 log.info('Submit param proposal result : {}'.format(result)) 1149 assert_code(result, 302031) 1150 1151 result = pip.submitParam(pip.node.node_id, str(time.time()), 'block', 'unStakeFreezeDuration', '100', 1152 pip.node.staking_address, 1153 transaction_cfg=pip.cfg.transaction_cfg) 1154 log.info('Submit param proposal result : {}'.format(result)) 1155 assert_code(result, 302031) 1156 1157 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'SlashBlocksReward', '100', 1158 pip.node.staking_address, 1159 transaction_cfg=pip.cfg.transaction_cfg) 1160 log.info('Submit param proposal result : {}'.format(result)) 1161 assert_code(result, 302031) 1162 1163 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slash BlocksReward', '100', 1164 pip.node.staking_address, 1165 transaction_cfg=pip.cfg.transaction_cfg) 1166 log.info('Submit param proposal result : {}'.format(result)) 1167 assert_code(result, 302031) 1168 1169 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocks./,.Reward', '100', 1170 pip.node.staking_address, 1171 transaction_cfg=pip.cfg.transaction_cfg) 1172 log.info('Submit param proposal result : {}'.format(result)) 1173 assert_code(result, 302031) 1174 1175 @pytest.mark.P0 1176 @allure.title('Submit parammeter proposal function verification') 1177 def test_PP_SU_020(self, no_vp_proposal): 1178 pip = no_vp_proposal 1179 result = pip.submitParam(pip.node.node_id, str(time.time()), '', 'slashBlocksReward', '100', 1180 pip.node.staking_address, 1181 transaction_cfg=pip.cfg.transaction_cfg) 1182 log.info('Submit param proposal result : {}'.format(result)) 1183 assert_code(result, 302031) 1184 1185 result = pip.submitParam(pip.node.node_id, str(time.time()), 'Slashing', 'slashBlocksReward', '100', 1186 pip.node.staking_address, 1187 transaction_cfg=pip.cfg.transaction_cfg) 1188 log.info('Submit param proposal result : {}'.format(result)) 1189 assert_code(result, 302031) 1190 1191 result = pip.submitParam(pip.node.node_id, str(time.time()), 'sLashing', 'SlashBlocksReward', '100', 1192 pip.node.staking_address, 1193 transaction_cfg=pip.cfg.transaction_cfg) 1194 log.info('Submit param proposal result : {}'.format(result)) 1195 assert_code(result, 302031) 1196 1197 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing123', 'slash BlocksReward', '100', 1198 pip.node.staking_address, 1199 transaction_cfg=pip.cfg.transaction_cfg) 1200 log.info('Submit param proposal result : {}'.format(result)) 1201 assert_code(result, 302031) 1202 1203 result = pip.submitParam(pip.node.node_id, str(time.time()), 's lashing', 'slashBlocks./,.Reward', '100', 1204 pip.node.staking_address, 1205 transaction_cfg=pip.cfg.transaction_cfg) 1206 log.info('Submit param proposal result : {}'.format(result)) 1207 assert_code(result, 302031) 1208 1209 result = pip.submitParam(pip.node.node_id, str(time.time()), 's.,.lashing', 'slashBlocks./,.Reward', '100', 1210 pip.node.staking_address, 1211 transaction_cfg=pip.cfg.transaction_cfg) 1212 log.info('Submit param proposal result : {}'.format(result)) 1213 assert_code(result, 302031) 1214 1215 1216 class TestSubmitPPAbnormal: 1217 @pytest.mark.P0 1218 @allure.title('New node submit parammeter proposal function verification') 1219 def test_PP_PR_002(self, no_vp_proposal, client_new_node): 1220 pip = client_new_node.pip 1221 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 1222 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '88', 1223 address, transaction_cfg=pip.cfg.transaction_cfg) 1224 log.info('new node submit param proposal result : {}'.format(result)) 1225 assert_code(result, 302022) 1226 1227 @pytest.mark.P0 1228 @allure.title('Candidate submit parammeter proposal function verification') 1229 def test_PP_PR_001(self, no_vp_proposal, client_candidate): 1230 pip = client_candidate.pip 1231 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '87', 1232 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1233 log.info('candidate submit param proposal result :{}'.format(result)) 1234 assert_code(result, 302022) 1235 1236 @pytest.mark.P0 1237 @allure.title('There is a voting version proposal, submit parammeter proposal function verification') 1238 def test_PP_UN_002(self, submit_version): 1239 pip = submit_version 1240 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '99', 1241 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1242 log.info('There is voting version proposal, submit a param proposal : {}'.format(result)) 1243 assert_code(result, 302012) 1244 1245 @pytest.mark.P2 1246 @allure.title('Abnormal submit parammeter proposal function verification') 1247 def test_PP_PR_003_PP_PR_004(self, no_vp_proposal, all_clients): 1248 pip = no_vp_proposal 1249 client = get_client_by_nodeid(pip.node.node_id, all_clients) 1250 address = pip.node.staking_address 1251 result = client.staking.withdrew_staking(address) 1252 log.info('nodeid: {} withdrewstaking result: {}'.format(client.node.node_id, result)) 1253 assert_code(result, 0) 1254 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 1255 '86', address, transaction_cfg=pip.cfg.transaction_cfg) 1256 log.info('node exiting，param proposal result: {}'.format(result)) 1257 assert_code(result, 302020) 1258 1259 client.economic.wait_settlement_blocknum(client.node, 1260 number=client.economic.unstaking_freeze_ratio) 1261 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 1262 '86', address, transaction_cfg=pip.cfg.transaction_cfg) 1263 log.info('exited node，cancel proposal result: {}'.format(result)) 1264 assert_code(result, 302022) 1265 1266 @pytest.mark.P2 1267 @allure.title('Not staking address submit parammeter proposal function verification') 1268 def test_PP_WA_001(self, no_vp_proposal): 1269 pip = no_vp_proposal 1270 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 1271 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '87', 1272 address, transaction_cfg=pip.cfg.transaction_cfg) 1273 log.info('candidate submit param proposal result :{}'.format(result)) 1274 assert_code(result, 302021) 1275 1276 1277 class TestSubmitAgain: 1278 @pytest.mark.P2 1279 @allure.title('Submit parammeter proposal function verification') 1280 def test_PP_TI_001_002(self, new_genesis_env, clients_consensus): 1281 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 1282 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 0 1283 new_genesis_env.set_genesis(genesis.to_dict()) 1284 new_genesis_env.deploy_all() 1285 submitcppandvote(clients_consensus[:3], [1, 1, 1]) 1286 pip = clients_consensus[0].pip 1287 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 1288 log.info('Param proposal information : {}'.format(proposalinfo_param)) 1289 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 1290 log.info('Cancel proposal information : {}'.format(proposalinfo_cancel)) 1291 wait_block_number(pip.node, proposalinfo_cancel.get('EndVotingBlock')) 1292 assert_code(pip.get_status_of_proposal(proposalinfo_cancel.get('ProposalID')), 2) 1293 assert_code(pip.get_status_of_proposal(proposalinfo_param.get('ProposalID')), 6) 1294 1295 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '998', 1296 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1297 log.info('Submit param proposal result : {}'.format(result)) 1298 assert_code(result, 0) 1299 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 1300 log.info('Param proposal information : {}'.format(proposalinfo_param)) 1301 wait_block_number(pip.node, proposalinfo_param.get('EndVotingBlock')) 1302 1303 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '998', 1304 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1305 log.info('Submit param proposal result : {}'.format(result)) 1306 assert_code(result, 0) 1307 1308 @pytest.mark.P2 1309 @allure.title('Submit parammeter proposal function verification') 1310 def test_VP_TI_001_002(self, no_vp_proposal, clients_verifier): 1311 submitcvpandvote(clients_verifier[:3], 1, 1, 1) 1312 pip = clients_verifier[0].pip 1313 proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal) 1314 log.info('Version proposal information : {}'.format(proposalinfo_version)) 1315 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 1316 log.info('Cancel proposal information : {}'.format(proposalinfo_cancel)) 1317 wait_block_number(pip.node, proposalinfo_cancel.get('EndVotingBlock')) 1318 assert_code(pip.get_status_of_proposal(proposalinfo_cancel.get('ProposalID')), 2) 1319 assert_code(pip.get_status_of_proposal(proposalinfo_version.get('ProposalID')), 6) 1320 1321 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, 1322 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1323 log.info('Submit version proposal result : {}'.format(result)) 1324 assert_code(result, 0) 1325 proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal) 1326 log.info('Version proposal information : {}'.format(proposalinfo_version)) 1327 wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock')) 1328 1329 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, 1330 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1331 log.info('Submit version proposal result : {}'.format(result)) 1332 assert_code(result, 0) 1333 1334 1335 class TestPIPVerify: 1336 @pytest.mark.P0 1337 @allure.title('Submit proposal function verification---PIPID') 1338 def test_VP_PIP_001_003_TP_PI_001_003_CP_PI_001_003_CP_PI_001_003(self, no_vp_proposal): 1339 pip = no_vp_proposal 1340 pip_id_text = str(time.time()) 1341 result = pip.submitText(pip.node.node_id, pip_id_text, pip.node.staking_address, 1342 transaction_cfg=pip.cfg.transaction_cfg) 1343 log.info('Submit text proposal result : {}'.format(result)) 1344 assert_code(result, 0) 1345 1346 result = pip.submitVersion(pip.node.node_id, pip_id_text, pip.cfg.version5, 1, pip.node.staking_address, 1347 transaction_cfg=pip.cfg.transaction_cfg) 1348 log.info('Same PIPID, submit version proposal result : {}'.format(result)) 1349 assert_code(result, 302008) 1350 1351 result = pip.submitText(pip.node.node_id, pip_id_text, pip.node.staking_address, 1352 transaction_cfg=pip.cfg.transaction_cfg) 1353 log.info('Same PIPID, submit text proposal result : {}'.format(result)) 1354 assert_code(result, 302008) 1355 1356 result = pip.submitParam(pip.node.node_id, pip_id_text, 'slashing', 'slashBlocksReward', '889', 1357 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1358 log.info('Same PIPID, submit param proposal result : {}'.format(result)) 1359 assert_code(result, 302008) 1360 1361 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 3, 1362 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1363 log.info('Differ PIPID, submit version proposal result : {}'.format(result)) 1364 assert_code(result, 0) 1365 1366 proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal) 1367 log.info('Version proposal information : {}'.format(proposalinfo_version)) 1368 pip_id_version = proposalinfo_version.get('PIPID') 1369 1370 result = pip.submitCancel(pip.node.node_id, pip_id_text, 1, proposalinfo_version.get('ProposalID'), 1371 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1372 log.info('Same PIPID, submit cancel proposal result : {}'.format(result)) 1373 assert_code(result, 302008) 1374 1375 result = pip.submitCancel(pip.node.node_id, pip_id_version, 1, proposalinfo_version.get('ProposalID'), 1376 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1377 log.info('Same PIPID, submit cancel proposal result : {}'.format(result)) 1378 assert_code(result, 302008) 1379 1380 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo_version.get('ProposalID'), 1381 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1382 log.info('Differ PIPID, submit cancel proposal result : {}'.format(result)) 1383 assert_code(result, 0) 1384 1385 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 1386 log.info('Version proposal information : {}'.format(proposalinfo_cancel)) 1387 pip_id_cancel = proposalinfo_cancel.get('PIPID') 1388 1389 result = pip.submitText(pip.node.node_id, pip_id_version, pip.node.staking_address, 1390 transaction_cfg=pip.cfg.transaction_cfg) 1391 log.info('Same PIPID, submit text proposal result : {}'.format(result)) 1392 assert_code(result, 302008) 1393 1394 result = pip.submitText(pip.node.node_id, pip_id_cancel, pip.node.staking_address, 1395 transaction_cfg=pip.cfg.transaction_cfg) 1396 log.info('Same PIPID, submit text proposal result : {}'.format(result)) 1397 assert_code(result, 302008) 1398 1399 wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock')) 1400 result = pip.submitVersion(pip.node.node_id, pip_id_version, pip.cfg.version5, 1, 1401 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1402 log.info('Same PIPID, submit version proposal result : {}'.format(result)) 1403 assert_code(result, 0) 1404 1405 proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal) 1406 log.info('Version proposal information : {}'.format(proposalinfo_version)) 1407 wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock')) 1408 result = pip.submitParam(pip.node.node_id, pip_id_version, 'slashing', 'slashBlocksReward', '889', 1409 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1410 log.info('Differ PIPID, submit param proposal result : {}'.format(result)) 1411 assert_code(result, 0) 1412 1413 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 1414 log.info('Param proposal information : {}'.format(proposalinfo_param)) 1415 1416 result = pip.submitCancel(pip.node.node_id, pip_id_cancel, 1, proposalinfo_param.get('ProposalID'), 1417 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1418 log.info('Same PIPID, submit cancel proposal result : {}'.format(result)) 1419 assert_code(result, 0) 1420 1421 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 1422 log.info('Cancel proposal information : {}'.format(proposalinfo_cancel)) 1423 1424 wait_block_number(pip.node, proposalinfo_cancel.get('EndVotingBlock')) 1425 result = pip.submitText(pip.node.node_id, pip_id_cancel, pip.node.staking_address, 1426 transaction_cfg=pip.cfg.transaction_cfg) 1427 log.info('Same PIPID, submit text proposal result : {}'.format(result)) 1428 assert_code(result, 0) 1429 1430 @pytest.mark.P0 1431 @allure.title('Submit proposal function verification---PIPID') 1432 def test_VP_PIP_002_TP_PI_002_CP_PI_002_CP_PI_002(self, no_vp_proposal, clients_verifier): 1433 pip = clients_verifier[0].pip 1434 submitcvpandvote(clients_verifier, 1, 1, 1, 1) 1435 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 1436 pip_id = proposalinfo.get('PIPID') 1437 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 1438 assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 2) 1439 result = pip.submitText(pip.node.node_id, pip_id, pip.node.staking_address, 1440 transaction_cfg=pip.cfg.transaction_cfg) 1441 log.info('Same pipid, submit text proposal result : {}'.format(result)) 1442 assert_code(result, 302008) 1443 result = pip.submitVersion(pip.node.node_id, pip_id, pip.cfg.version5, 1, pip.node.staking_address, 1444 transaction_cfg=pip.cfg.transaction_cfg) 1445 log.info('Same pipid, submit text proposal result : {}'.format(result)) 1446 assert_code(result, 302008) 1447 1448 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 2, 1449 pip.node.staking_address, 1450 transaction_cfg=pip.cfg.transaction_cfg) 1451 log.info('Differ pipid, submit version proposal result : {}'.format(result)) 1452 assert_code(result, 0) 1453 proposalinfo_version = pip.get_effect_proposal_info_of_vote() 1454 log.info('Proposal information : {}'.format(proposalinfo_version)) 1455 result = pip.submitCancel(pip.node.node_id, pip_id, 1, proposalinfo_version.get('ProposalID'), 1456 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1457 log.info('Same pipid, submit cancel proposal result : {}'.format(result)) 1458 assert_code(result, 302008) 1459 1460 wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock')) 1461 result = pip.submitParam(pip.node.node_id, pip_id, 'slashing', 'slashBlocksReward', '19', 1462 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1463 log.info('Same pipid, submit param proposal result : {}'.format(result)) 1464 assert_code(result, 302008) 1465 1466 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '19', 1467 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1468 log.info('Differ pipid, submit param proposal result : {}'.format(result)) 1469 assert_code(result, 0) 1470 1471 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 1472 log.info('Get param proposal information : {}'.format(proposalinfo_param)) 1473 1474 result = pip.submitCancel(pip.node.node_id, pip_id, 1, proposalinfo_param.get('ProposalID'), 1475 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1476 log.info('Same pipid, submit cancel proposal result : {}'.format(result)) 1477 assert_code(result, 302008) 1478 1479 1480 @pytest.mark.P0 1481 @allure.title('Submit cancel proposal function verification---endvoting rounds') 1482 def test_CP_CR_003_CP_CR_004(submit_param): 1483 pip = submit_param 1484 proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 1485 log.info('proposalinfo: {}'.format(proposalinfo)) 1486 endvoting_rounds = (proposalinfo.get('EndVotingBlock') - math.ceil( 1487 pip.node.block_number / pip.economic.consensus_size) * pip.economic.consensus_size 1488 ) / pip.economic.consensus_size 1489 result = pip.submitCancel(pip.node.node_id, str(time.time()), endvoting_rounds + 1, 1490 proposalinfo.get('ProposalID'), pip.node.staking_address, 1491 transaction_cfg=pip.cfg.transaction_cfg) 1492 log.info('endvoting_rounds:{}， cancel proposal result:{}'.format(endvoting_rounds, result)) 1493 assert_code(result, 302010) 1494 1495 result = pip.submitCancel(pip.node.node_id, str(time.time()), endvoting_rounds, 1496 proposalinfo.get('ProposalID'), pip.node.staking_address, 1497 transaction_cfg=pip.cfg.transaction_cfg) 1498 log.info('endvoting_rounds:{}， cancel proposal result:{}'.format(endvoting_rounds + 1, result)) 1499 assert_code(result, 0) 1500 1501 1502 class TestGas: 1503 @pytest.mark.P2 1504 @allure.title('Submit version proposal function verification---gasprice') 1505 def test_VP_GP_001_VP_GP_002(self, no_vp_proposal): 1506 pip = no_vp_proposal 1507 transaction_cfg = {"gasPrice": 2100000000000000 - 1} 1508 try: 1509 pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, 1510 pip.node.staking_address, transaction_cfg=transaction_cfg) 1511 except ValueError as e: 1512 assert e.args[0].get('message') == "the tx data is invalid: Invalid parameter:Gas price under the min gas price." 1513 1514 transaction_cfg = {"gasPrice": 2100000000000000} 1515 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, 1516 pip.node.staking_address, transaction_cfg=transaction_cfg) 1517 log.info('Submit version proposal result : {}'.format(result)) 1518 assert_code(result, 0) 1519 1520 @pytest.mark.P2 1521 @allure.title('Submit param proposal function verification---gasprice') 1522 def test_PP_GP_001_PP_GP_002(self, no_vp_proposal): 1523 pip = no_vp_proposal 1524 transaction_cfg = {"gasPrice": 2000000000000000 - 1} 1525 try: 1526 pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '123', 1527 pip.node.staking_address, transaction_cfg=transaction_cfg) 1528 except ValueError as e: 1529 assert e.args[0].get('message') == "the tx data is invalid: Invalid parameter:Gas price under the min gas price." 1530 1531 transaction_cfg = {"gasPrice": 2000000000000000} 1532 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '123', 1533 pip.node.staking_address, transaction_cfg=transaction_cfg) 1534 log.info('Submit param proposal result : {}'.format(result)) 1535 assert_code(result, 0) 1536 1537 @pytest.mark.P2 1538 @allure.title('Submit text proposal function verification---gasprice') 1539 def test_TP_GP_001_TP_GP_002(self, client_verifier): 1540 pip = client_verifier.pip 1541 transaction_cfg = {"gasPrice": 1500000000000000 - 1} 1542 try: 1543 pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 1544 transaction_cfg=transaction_cfg) 1545 except ValueError as e: 1546 assert e.args[0].get('message') == "the tx data is invalid: Invalid parameter:Gas price under the min gas price." 1547 1548 transaction_cfg = {"gasPrice": 1500000000000000} 1549 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 1550 transaction_cfg=transaction_cfg) 1551 log.info('Submit text proposal result : {}'.format(result)) 1552 assert_code(result, 0) 1553 1554 @pytest.mark.P2 1555 @allure.title('Submit cancel proposal function verification---gas') 1556 def test_CP_GP_001_CP_GP_002(self, no_vp_proposal): 1557 pip = no_vp_proposal 1558 transaction_cfg = {"gasPrice": 3000000000000000 - 1, "gas": 100000} 1559 try: 1560 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 3, 1561 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 1562 assert_code(result, 0) 1563 proposalinfo = pip.get_effect_proposal_info_of_vote() 1564 log.info('Get proposal information {}'.format(proposalinfo)) 1565 pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'), 1566 pip.node.staking_address, transaction_cfg=transaction_cfg) 1567 except ValueError as e: 1568 assert e.args[0].get('message') == "the tx data is invalid: Invalid parameter:Gas price under the min gas price." 1569 transaction_cfg = {"gasPrice": 3000000000000000} 1570 result = pip.submitCancel(pip.node.node_id, str(time.time()), 1, proposalinfo.get('ProposalID'), 1571 pip.node.staking_address, transaction_cfg=transaction_cfg) 1572 log.info('Submit cancel proposal result : {}'.format(result)) 1573 assert_code(result, 0) 1574 1575 if __name__ == '__main__': 1576 pytest.main(['./tests/govern/', '-s', '-q', '--alluredir', './report/report'])