github.com/platonnetwork/platon-go@v0.7.6/cases/tests/govern/test_declare_version.py (about) 1 from common.log import log 2 from tests.lib.utils import upload_platon, assert_code, wait_block_number, get_pledge_list 3 import pytest 4 import allure 5 import time 6 from tests.govern.test_voting_statistics import submitvpandvote, createstaking, version_proposal_vote 7 from tests.lib import Genesis 8 from tests.lib.client import get_client_by_nodeid, get_clients_by_nodeid 9 from dacite import from_dict 10 from tests.govern.conftest import verifier_node_version 11 12 13 @pytest.fixture() 14 def large_version_proposal_pips(all_clients): 15 ''' 16 get verifier Client object list 17 :param global_test_env: 18 :return: 19 ''' 20 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 21 log.info('verifier list {}'.format(verifier_list)) 22 pip = get_client_by_nodeid(verifier_list[0], all_clients).pip 23 if pip.chain_version != pip.cfg.version0: 24 pip.economic.env.deploy_all() 25 if pip.is_exist_effective_proposal(): 26 proposalinfo = pip.get_effect_proposal_info_of_vote() 27 log.info('proprosalinfo : {}'.format(proposalinfo)) 28 if proposalinfo.get('EndVotingBlock') - pip.node.block_number > 2 * pip.economic.consensus_size \ 29 and proposalinfo.get('NewVersion') == pip.cfg.version8: 30 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 31 log.info('verifierlist{}'.format(verifier_list)) 32 clients = get_clients_by_nodeid(verifier_list, all_clients) 33 return [client.pip for client in clients] 34 else: 35 pip.economic.env.deploy_all() 36 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version8, 10, 37 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 38 log.info('version proposal result :{}'.format(result)) 39 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 40 log.info('verifierlist{}'.format(verifier_list)) 41 clients = get_clients_by_nodeid(verifier_list, all_clients) 42 return [client.pip for client in clients] 43 44 45 @pytest.fixture() 46 def proposal_candidate_pips(all_clients): 47 ''' 48 There is voting stage proposal, get candidate list pip object 49 :param global_test_env: 50 :return: 51 ''' 52 pip = all_clients[0].pip 53 if pip.chain_version != pip.cfg.version0 or (pip.is_exist_effective_proposal() 54 and not pip.is_exist_effective_proposal_for_vote()): 55 log.info('The chain has been upgraded or there is preactive proposal,restart!') 56 pip.economic.env.deploy_all() 57 nodeid_list = pip.get_candidate_list_not_verifier() 58 if nodeid_list: 59 if pip.get_effect_proposal_info_of_vote(): 60 proposalinfo = pip.get_effect_proposal_info_of_vote() 61 log.info('get version proposalinfo : {}'.format(proposalinfo)) 62 if proposalinfo.get('NewVersion') == pip.cfg.version8: 63 pip.economic.env.deploy_all() 64 else: 65 if proposalinfo.get('EndVotingBlock') - pip.node.block_number > pip.economic.consensus_size: 66 client_candidates = get_clients_by_nodeid(nodeid_list, all_clients) 67 return [client.pip for client in client_candidates] 68 69 candidate_list = get_pledge_list(all_clients[0].ppos.getCandidateList) 70 log.info('candidate_list{}'.format(candidate_list)) 71 for client in all_clients: 72 if client.node.node_id not in candidate_list: 73 address, _ = client.economic.account.generate_account(client.node.web3, 10**18 * 10000000) 74 result = client.staking.create_staking(0, address, address) 75 log.info('node {} staking result {}'.format(client.node.node_id, result)) 76 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 77 log.info('Verifier list {}'.format(verifier_list)) 78 verifier_pip = get_client_by_nodeid(verifier_list[0], all_clients).pip 79 result = verifier_pip.submitVersion(verifier_pip.node.node_id, str(time.time()), verifier_pip.cfg.version5, 80 10, verifier_pip.node.staking_address, 81 transaction_cfg=verifier_pip.cfg.transaction_cfg) 82 log.info('Submit version proposal result {}'.format(result)) 83 assert_code(result, 0) 84 nodeid_list = all_clients[0].pip.get_candidate_list_not_verifier() 85 if not nodeid_list: 86 raise Exception('get candidate not verifier failed') 87 client_candiates = get_clients_by_nodeid(nodeid_list, all_clients) 88 return [client_candiate.pip for client_candiate in client_candiates] 89 90 91 @pytest.fixture() 92 def large_version_proposal_candidate_pips(all_clients): 93 ''' 94 There is voting stage proposal, get candidate list pip object 95 :param global_test_env: 96 :return: 97 ''' 98 pip = all_clients[0].pip 99 if pip.chain_version != pip.cfg.version0 or (pip.is_exist_effective_proposal() 100 and not pip.is_exist_effective_proposal_for_vote()): 101 log.info('The chain has been upgraded or there is preactive proposal,restart!') 102 pip.economic.env.deploy_all() 103 nodeid_list = pip.get_candidate_list_not_verifier() 104 if nodeid_list: 105 if pip.get_effect_proposal_info_of_vote(): 106 proposalinfo = pip.get_effect_proposal_info_of_vote() 107 log.info('get version proposalinfo : {}'.format(proposalinfo)) 108 if proposalinfo.get('NewVersion') == pip.cfg.version5: 109 pip.economic.env.deploy_all() 110 else: 111 if proposalinfo.get('EndVotingBlock') - pip.node.block_number > pip.economic.consensus_size: 112 client_candiates = get_clients_by_nodeid(nodeid_list, all_clients) 113 return [client.pip for client in client_candiates] 114 115 candidate_list = get_pledge_list(all_clients[0].ppos.getCandidateList) 116 log.info('candidate_list{}'.format(candidate_list)) 117 for client in all_clients: 118 if client.node.node_id not in candidate_list: 119 address, _ = client.economic.account.generate_account(client.node.web3, 10**18 * 10000000) 120 result = client.staking.create_staking(0, address, address) 121 log.info('node {} staking result {}'.format(client.node.node_id, result)) 122 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 123 log.info('Verifier list {}'.format(verifier_list)) 124 verifier_pip = get_client_by_nodeid(verifier_list[0], all_clients).pip 125 result = verifier_pip.submitVersion(verifier_pip.node.node_id, str(time.time()), 126 verifier_pip.cfg.version8, 127 10, verifier_pip.node.staking_address, 128 transaction_cfg=verifier_pip.cfg.transaction_cfg) 129 log.info('Submit version proposal result {}'.format(result)) 130 assert_code(result, 0) 131 nodeid_list = all_clients[0].pip.get_candidate_list_not_verifier() 132 if not nodeid_list: 133 raise Exception('get candidate not verifier failed') 134 client_candidates = get_clients_by_nodeid(nodeid_list, all_clients) 135 return [client_candidate.pip for client_candidate in client_candidates] 136 137 138 @pytest.fixture() 139 def proposal_voted_pips(all_clients): 140 ''' 141 get verifier Client object list 142 :param global_test_env: 143 :return: 144 ''' 145 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 146 log.info('verifier list {}'.format(verifier_list)) 147 pip = get_client_by_nodeid(verifier_list[0], all_clients).pip 148 pip.economic.env.deploy_all() 149 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 10, 150 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 151 log.info('version proposal result :{}'.format(result)) 152 assert_code(result, 0) 153 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 154 log.info('verifierlist{}'.format(verifier_list)) 155 clients_verifier = get_clients_by_nodeid(verifier_list, all_clients) 156 result = version_proposal_vote(clients_verifier[0].pip) 157 assert_code(result, 0) 158 return [client.pip for client in clients_verifier] 159 160 161 @pytest.fixture() 162 def large_version_proposal_voted_pips(all_clients): 163 ''' 164 get verifier Client object list 165 :param global_test_env: 166 :return: 167 ''' 168 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 169 log.info('verifier list {}'.format(verifier_list)) 170 pip = get_client_by_nodeid(verifier_list[0], all_clients).pip 171 pip.economic.env.deploy_all() 172 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version8, 10, 173 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 174 log.info('version proposal result :{}'.format(result)) 175 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 176 log.info('verifierlist{}'.format(verifier_list)) 177 clients_verifier = get_clients_by_nodeid(verifier_list, all_clients) 178 result = version_proposal_vote(clients_verifier[0].pip) 179 assert_code(result, 0) 180 return [client.pip for client in clients_verifier] 181 182 183 def replace_version_declare(pip, platon_bin, versiontag): 184 upload_platon(pip.node, platon_bin) 185 log.info('Replace the platon of the node {} version{}'.format(pip.node.node_id, versiontag)) 186 pip.node.restart() 187 log.info('Restart the node{}'.format(pip.node.node_id)) 188 assert pip.node.program_version == versiontag 189 log.info('assert the version of the node is {}'.format(versiontag)) 190 log.info("staking: {}".format(pip.node.staking_address)) 191 log.info("account:{}".format(pip.economic.account.accounts)) 192 result = pip.declareVersion(pip.node.node_id, pip.node.staking_address, 193 transaction_cfg=pip.cfg.transaction_cfg) 194 log.info('declareversion {} result: {}'.format(pip.node.program_version, result)) 195 return result 196 197 198 def wrong_verisonsign_declare(pip, pip_test): 199 result = pip.declareVersion(pip.node.node_id, pip.node.staking_address, 200 version_sign=pip_test.node.program_version_sign, 201 transaction_cfg=pip.cfg.transaction_cfg) 202 log.info('wrong program version sign, declareVersion result : {}'.format(result)) 203 return result 204 205 206 def wrong_verison_declare(pip, version=None): 207 if not version: 208 proposalinfo = pip.get_effect_proposal_info_of_vote() 209 version = proposalinfo.get('NewVersion') 210 log.info('The new version of the proposal: {}'.format(version)) 211 result = pip.declareVersion(pip.node.node_id, pip.node.staking_address, 212 program_version=version, 213 transaction_cfg=pip.cfg.transaction_cfg) 214 log.info('wrong program version, declareVersion: {} result : {}'.format(version, result)) 215 return result 216 217 218 @pytest.mark.P0 219 @allure.title('Not staking address declare version') 220 def test_DE_DE_001(client_verifier): 221 pip = client_verifier.pip 222 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) 223 result = pip.declareVersion(pip.node.node_id, address, transaction_cfg=pip.cfg.transaction_cfg) 224 log.info('declareVersion result: {}'.format(result)) 225 assert_code(result, 302021) 226 227 228 class TestNoProposalVE: 229 @pytest.mark.P0 230 @pytest.mark.compatibility 231 @allure.title('No effective proposal, verifier declare version') 232 def test_DE_VE_001(self, noproposal_pips): 233 pip = noproposal_pips[0] 234 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 235 assert_code(result, 0) 236 verifier_node_version(pip, pip.cfg.version2) 237 238 result = wrong_verisonsign_declare(pip, noproposal_pips[1]) 239 assert_code(result, 302024) 240 241 result = wrong_verison_declare(pip, pip.chain_version) 242 assert_code(result, 302024) 243 244 @pytest.mark.P3 245 @allure.title('No effective proposal, verifier declare version') 246 def test_DE_VE_002(self, noproposal_pips, all_clients): 247 pip = noproposal_pips[0] 248 node_version = verifier_node_version(pip) 249 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 250 assert_code(result, 302028) 251 verifier_node_version(pip, node_version) 252 253 result = wrong_verisonsign_declare(pip, noproposal_pips[1]) 254 assert_code(result, 302024) 255 256 result = wrong_verison_declare(pip, pip.chain_version) 257 assert_code(result, 302024) 258 259 @pytest.mark.P0 260 @allure.title('No effective proposal, verifier declare version') 261 def test_DE_VE_004(self, noproposal_pips): 262 pip = noproposal_pips[0] 263 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 264 assert_code(result, 0) 265 verifier_node_version(pip, pip.cfg.version3) 266 267 result = wrong_verisonsign_declare(pip, noproposal_pips[1]) 268 assert_code(result, 302024) 269 270 result = wrong_verison_declare(pip, pip.chain_version) 271 assert_code(result, 302024) 272 273 @pytest.mark.P2 274 @allure.title('No effective proposal, verifier declare version') 275 def test_DE_VE_005(self, noproposal_pips): 276 pip = noproposal_pips[0] 277 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 278 assert_code(result, 302028) 279 280 result = wrong_verisonsign_declare(pip, noproposal_pips[1]) 281 assert_code(result, 302024) 282 283 result = wrong_verison_declare(pip, pip.chain_version) 284 assert_code(result, 302024) 285 286 @pytest.mark.P2 287 @allure.title('No effective proposal, verifier declare version') 288 def test_DE_VE_006(self, noproposal_pips): 289 pip = noproposal_pips[0] 290 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 291 assert_code(result, 302028) 292 293 result = wrong_verisonsign_declare(pip, noproposal_pips[1]) 294 assert_code(result, 302024) 295 296 result = wrong_verison_declare(pip, pip.chain_version) 297 assert_code(result, 302024) 298 299 @pytest.mark.P0 300 @allure.title('No effective proposal, verifier declare version') 301 def test_DE_VE_007(self, noproposal_pips): 302 pip = noproposal_pips[0] 303 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 304 assert_code(result, 0) 305 verifier_node_version(pip, pip.cfg.version0) 306 307 result = wrong_verisonsign_declare(pip, noproposal_pips[1]) 308 assert_code(result, 302024) 309 310 result = wrong_verison_declare(pip, pip.cfg.version3) 311 assert_code(result, 302024) 312 313 result = wrong_verison_declare(pip, pip.cfg.version2) 314 assert_code(result, 302024) 315 316 317 class TestVotingProposalVE: 318 @pytest.mark.P0 319 @allure.title('No effective proposal, verifier declare version') 320 def test_DE_VE_008(self, proposal_pips): 321 pip = proposal_pips[0] 322 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 323 assert_code(result, 0) 324 verifier_node_version(pip, pip.cfg.version2) 325 326 result = wrong_verisonsign_declare(pip, proposal_pips[1]) 327 assert_code(result, 302024) 328 329 result = wrong_verison_declare(pip, pip.chain_version) 330 assert_code(result, 302024) 331 332 result = wrong_verison_declare(pip) 333 assert_code(result, 302024) 334 335 @pytest.mark.P2 336 @allure.title('No effective proposal, verifier declare version') 337 def test_DE_VE_010(self, proposal_pips): 338 pip = proposal_pips[0] 339 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 340 assert_code(result, 302028) 341 342 result = wrong_verisonsign_declare(pip, proposal_pips[1]) 343 assert_code(result, 302024) 344 345 result = wrong_verison_declare(pip, pip.chain_version) 346 assert_code(result, 302024) 347 348 result = wrong_verison_declare(pip) 349 assert_code(result, 302024) 350 351 @pytest.mark.P1 352 @allure.title('No effective proposal, verifier declare version') 353 def test_DE_VE_014(self, large_version_proposal_pips): 354 pip = large_version_proposal_pips[0] 355 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 356 assert_code(result, 0) 357 verifier_node_version(pip, pip.cfg.version2) 358 359 result = wrong_verisonsign_declare(pip, large_version_proposal_pips[1]) 360 assert_code(result, 302024) 361 362 result = wrong_verison_declare(pip, pip.chain_version) 363 assert_code(result, 302024) 364 365 result = wrong_verison_declare(pip) 366 assert_code(result, 302024) 367 368 @pytest.mark.P2 369 @allure.title('No effective proposal, verifier declare version') 370 def test_DE_VE_025(self, large_version_proposal_pips): 371 pip = large_version_proposal_pips[0] 372 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 373 assert_code(result, 302028) 374 375 result = wrong_verisonsign_declare(pip, large_version_proposal_pips[1]) 376 assert_code(result, 302024) 377 378 result = wrong_verison_declare(pip, pip.chain_version) 379 assert_code(result, 302024) 380 381 result = wrong_verison_declare(pip) 382 assert_code(result, 302024) 383 384 @pytest.mark.P0 385 @allure.title('No effective proposal, verifier declare version') 386 def test_DE_VE_032(self, proposal_pips): 387 pip = proposal_pips[0] 388 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 389 assert_code(result, 0) 390 verifier_node_version(pip, pip.cfg.version0) 391 392 result = wrong_verisonsign_declare(pip, proposal_pips[1]) 393 assert_code(result, 302024) 394 395 result = wrong_verison_declare(pip) 396 assert_code(result, 302024) 397 398 @pytest.mark.P1 399 @allure.title('No effective proposal, verifier declare version') 400 def test_DE_VE_034(self, large_version_proposal_pips): 401 pip = large_version_proposal_pips[0] 402 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 403 assert_code(result, 0) 404 verifier_node_version(pip, pip.cfg.version0) 405 406 result = wrong_verisonsign_declare(pip, large_version_proposal_pips[1]) 407 assert_code(result, 302024) 408 409 result = wrong_verison_declare(pip) 410 assert_code(result, 302024) 411 412 @pytest.mark.P1 413 @allure.title('No effective proposal, verifier declare version') 414 def test_DE_VE_036(self, proposal_pips): 415 pip = proposal_pips[0] 416 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 417 assert_code(result, 0) 418 verifier_node_version(pip, pip.cfg.version3) 419 420 result = wrong_verisonsign_declare(pip, proposal_pips[1]) 421 assert_code(result, 302024) 422 423 result = wrong_verison_declare(pip) 424 assert_code(result, 302024) 425 426 result = wrong_verison_declare(pip, pip.chain_version) 427 assert_code(result, 302024) 428 429 @pytest.mark.P1 430 @allure.title('No effective proposal, verifier declare version') 431 def test_DE_VE_038(self, proposal_pips, all_clients): 432 pip = proposal_pips[0] 433 node_version = verifier_node_version(pip) 434 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 435 assert_code(result, 0) 436 verifier_node_version(pip, node_version) 437 438 result = wrong_verisonsign_declare(pip, proposal_pips[1]) 439 assert_code(result, 302024) 440 441 result = wrong_verison_declare(pip, pip.chain_version) 442 assert_code(result, 302024) 443 444 @pytest.mark.P2 445 @allure.title('No effective proposal, verifier declare version') 446 def test_DE_VE_040(self, proposal_pips): 447 pip = proposal_pips[0] 448 node_version = verifier_node_version(pip) 449 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN4, pip.cfg.version4) 450 assert_code(result, 0) 451 verifier_node_version(pip, node_version) 452 453 result = wrong_verisonsign_declare(pip, proposal_pips[1]) 454 assert_code(result, 302024) 455 456 result = wrong_verison_declare(pip) 457 assert_code(result, 302024) 458 459 result = wrong_verison_declare(pip, pip.chain_version) 460 assert_code(result, 302024) 461 462 @pytest.mark.P2 463 @allure.title('No effective proposal, verifier declare version') 464 def test_DE_VE_042(self, proposal_pips): 465 pip = proposal_pips[0] 466 node_version = verifier_node_version(pip) 467 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN6, pip.cfg.version6) 468 assert_code(result, 0) 469 verifier_node_version(pip, node_version) 470 471 result = wrong_verisonsign_declare(pip, proposal_pips[1]) 472 assert_code(result, 302024) 473 474 result = wrong_verison_declare(pip) 475 assert_code(result, 302024) 476 477 result = wrong_verison_declare(pip, pip.chain_version) 478 assert_code(result, 302024) 479 480 @pytest.mark.P2 481 @allure.title('No effective proposal, verifier declare version') 482 def test_DE_VE_044(self, proposal_pips): 483 pip = proposal_pips[0] 484 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 485 assert_code(result, 302028) 486 487 result = wrong_verisonsign_declare(pip, proposal_pips[1]) 488 assert_code(result, 302024) 489 490 result = wrong_verison_declare(pip) 491 assert_code(result, 302024) 492 493 result = wrong_verison_declare(pip, pip.chain_version) 494 assert_code(result, 302024) 495 496 @pytest.mark.P1 497 @allure.title('No effective proposal, verifier declare version') 498 def test_DE_VE_046(self, large_version_proposal_pips): 499 pip = large_version_proposal_pips[0] 500 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 501 assert_code(result, 0) 502 verifier_node_version(pip, pip.cfg.version3) 503 504 result = wrong_verisonsign_declare(pip, large_version_proposal_pips[1]) 505 assert_code(result, 302024) 506 507 result = wrong_verison_declare(pip) 508 assert_code(result, 302024) 509 510 result = wrong_verison_declare(pip, pip.chain_version) 511 assert_code(result, 302024) 512 513 @pytest.mark.P1 514 @allure.title('No effective proposal, verifier declare version') 515 def test_DE_VE_048(self, large_version_proposal_pips): 516 pip = large_version_proposal_pips[0] 517 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 518 assert_code(result, 302028) 519 520 result = wrong_verisonsign_declare(pip, large_version_proposal_pips[1]) 521 assert_code(result, 302024) 522 523 result = wrong_verison_declare(pip) 524 assert_code(result, 302024) 525 526 result = wrong_verison_declare(pip, pip.chain_version) 527 assert_code(result, 302024) 528 529 @pytest.mark.P1 530 @allure.title('No effective proposal, verifier declare version') 531 def test_DE_VE_050(self, large_version_proposal_pips): 532 pip = large_version_proposal_pips[0] 533 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN4, pip.cfg.version4) 534 assert_code(result, 302028) 535 536 result = wrong_verisonsign_declare(pip, large_version_proposal_pips[1]) 537 assert_code(result, 302024) 538 539 result = wrong_verison_declare(pip) 540 assert_code(result, 302024) 541 542 result = wrong_verison_declare(pip, pip.chain_version) 543 assert_code(result, 302024) 544 545 @pytest.mark.P1 546 @allure.title('No effective proposal, verifier declare version') 547 def test_DE_VE_052(self, large_version_proposal_pips): 548 pip = large_version_proposal_pips[0] 549 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN6, pip.cfg.version6) 550 assert_code(result, 302028) 551 552 result = wrong_verisonsign_declare(pip, large_version_proposal_pips[1]) 553 assert_code(result, 302024) 554 555 result = wrong_verison_declare(pip) 556 assert_code(result, 302024) 557 558 result = wrong_verison_declare(pip, pip.chain_version) 559 assert_code(result, 302024) 560 561 @pytest.mark.P2 562 @allure.title('No effective proposal, verifier declare version') 563 def test_DE_VE_054(self, large_version_proposal_pips): 564 pip = large_version_proposal_pips[0] 565 node_version = verifier_node_version(pip) 566 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 567 assert_code(result, 0) 568 verifier_node_version(pip, node_version) 569 570 result = wrong_verisonsign_declare(pip, large_version_proposal_pips[1]) 571 assert_code(result, 302024) 572 573 result = wrong_verison_declare(pip, pip.chain_version) 574 assert_code(result, 302024) 575 576 577 class TestVotingProposlaVotedVE: 578 @pytest.mark.P2 579 @allure.title('There is a proposal in voting stage, verifier declare version') 580 def test_DE_VE_009(self, proposal_voted_pips): 581 pip = proposal_voted_pips[0] 582 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 583 assert_code(result, 302028) 584 585 result = wrong_verisonsign_declare(pip, proposal_voted_pips[1]) 586 assert_code(result, 302024) 587 588 result = wrong_verison_declare(pip) 589 assert_code(result, 302024) 590 591 result = wrong_verison_declare(pip, pip.chain_version) 592 assert_code(result, 302024) 593 594 @pytest.mark.P2 595 @allure.title('There is a proposal in voting stage, verifier declare version') 596 def test_DE_VE_011(self, proposal_voted_pips): 597 pip = proposal_voted_pips[0] 598 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 599 assert_code(result, 302028) 600 601 result = wrong_verisonsign_declare(pip, proposal_voted_pips[1]) 602 assert_code(result, 302024) 603 604 result = wrong_verison_declare(pip) 605 assert_code(result, 302024) 606 607 result = wrong_verison_declare(pip, pip.chain_version) 608 assert_code(result, 302024) 609 610 @pytest.mark.P2 611 @allure.title('There is a proposal in voting stage, verifier declare version') 612 def test_DE_VE_021(self, large_version_proposal_voted_pips): 613 pip = large_version_proposal_voted_pips[0] 614 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 615 assert_code(result, 302028) 616 617 result = wrong_verisonsign_declare(pip, large_version_proposal_voted_pips[1]) 618 assert_code(result, 302024) 619 620 result = wrong_verison_declare(pip) 621 assert_code(result, 302024) 622 623 result = wrong_verison_declare(pip, pip.chain_version) 624 assert_code(result, 302024) 625 626 @pytest.mark.P2 627 @allure.title('There is a proposal in voting stage, verifier declare version') 628 def test_DE_VE_026(self, large_version_proposal_voted_pips): 629 pip = large_version_proposal_voted_pips[0] 630 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 631 assert_code(result, 302028) 632 633 result = wrong_verisonsign_declare(pip, large_version_proposal_voted_pips[1]) 634 assert_code(result, 302024) 635 636 result = wrong_verison_declare(pip) 637 assert_code(result, 302024) 638 639 result = wrong_verison_declare(pip, pip.chain_version) 640 assert_code(result, 302024) 641 642 @pytest.mark.P2 643 @allure.title('There is a proposal in voting stage, verifier declare version') 644 def test_DE_VE_033(self, proposal_voted_pips): 645 pip = proposal_voted_pips[0] 646 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 647 assert_code(result, 302028) 648 649 result = wrong_verisonsign_declare(pip, proposal_voted_pips[1]) 650 assert_code(result, 302024) 651 652 result = wrong_verison_declare(pip) 653 assert_code(result, 302024) 654 655 @pytest.mark.P2 656 @allure.title('There is a proposal in voting stage, verifier declare version') 657 def test_DE_VE_035(self, large_version_proposal_voted_pips): 658 pip = large_version_proposal_voted_pips[0] 659 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 660 assert_code(result, 302028) 661 662 result = wrong_verisonsign_declare(pip, large_version_proposal_voted_pips[1]) 663 assert_code(result, 302024) 664 665 result = wrong_verison_declare(pip) 666 assert_code(result, 302024) 667 668 @pytest.mark.P2 669 @allure.title('There is a proposal in voting stage, verifier declare version') 670 def test_DE_VE_037(self, proposal_voted_pips): 671 pip = proposal_voted_pips[0] 672 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 673 assert_code(result, 302028) 674 675 result = wrong_verisonsign_declare(pip, proposal_voted_pips[1]) 676 assert_code(result, 302024) 677 678 result = wrong_verison_declare(pip) 679 assert_code(result, 302024) 680 681 result = wrong_verison_declare(pip, pip.chain_version) 682 assert_code(result, 302024) 683 684 @pytest.mark.P1 685 @allure.title('There is a proposal in voting stage, verifier declare version') 686 def test_DE_VE_039(self, proposal_voted_pips): 687 pip = proposal_voted_pips[0] 688 node_version = verifier_node_version(pip) 689 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 690 assert_code(result, 0) 691 verifier_node_version(pip, node_version) 692 693 result = wrong_verisonsign_declare(pip, proposal_voted_pips[1]) 694 assert_code(result, 302024) 695 696 result = wrong_verison_declare(pip, pip.cfg.version4) 697 assert_code(result, 302024) 698 699 result = wrong_verison_declare(pip, pip.chain_version) 700 assert_code(result, 302024) 701 702 @pytest.mark.P2 703 @allure.title('There is a proposal in voting stage, verifier declare version') 704 def test_DE_VE_041(self, proposal_voted_pips): 705 pip = proposal_voted_pips[0] 706 node_version = verifier_node_version(pip) 707 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN4, pip.cfg.version4) 708 assert_code(result, 0) 709 verifier_node_version(pip, node_version) 710 711 result = wrong_verisonsign_declare(pip, proposal_voted_pips[1]) 712 assert_code(result, 302024) 713 714 result = wrong_verison_declare(pip, pip.cfg.version5) 715 assert_code(result, 302024) 716 717 result = wrong_verison_declare(pip, pip.chain_version) 718 assert_code(result, 302024) 719 720 @pytest.mark.P2 721 @allure.title('There is a proposal in voting stage, verifier declare version') 722 def test_DE_VE_043(self, proposal_voted_pips): 723 pip = proposal_voted_pips[0] 724 node_version = verifier_node_version(pip) 725 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN6, pip.cfg.version6) 726 assert_code(result, 0) 727 verifier_node_version(pip, node_version) 728 729 result = wrong_verisonsign_declare(pip, proposal_voted_pips[1]) 730 assert_code(result, 302024) 731 732 result = wrong_verison_declare(pip, pip.cfg.version5) 733 assert_code(result, 302024) 734 735 result = wrong_verison_declare(pip, pip.chain_version) 736 assert_code(result, 302024) 737 738 @pytest.mark.P2 739 @allure.title('There is a proposal in voting stage, verifier declare version') 740 def test_DE_VE_045(self, proposal_voted_pips): 741 pip = proposal_voted_pips[0] 742 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 743 assert_code(result, 302028) 744 745 result = wrong_verisonsign_declare(pip, proposal_voted_pips[1]) 746 assert_code(result, 302024) 747 748 result = wrong_verison_declare(pip, pip.cfg.version5) 749 assert_code(result, 302024) 750 751 result = wrong_verison_declare(pip, pip.chain_version) 752 assert_code(result, 302024) 753 754 @pytest.mark.P2 755 @allure.title('There is a proposal in voting stage, verifier declare version') 756 def test_DE_VE_047(self, large_version_proposal_voted_pips): 757 pip = large_version_proposal_voted_pips[0] 758 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 759 assert_code(result, 302028) 760 761 result = wrong_verisonsign_declare(pip, large_version_proposal_voted_pips[1]) 762 assert_code(result, 302024) 763 764 result = wrong_verison_declare(pip, pip.cfg.version5) 765 assert_code(result, 302024) 766 767 result = wrong_verison_declare(pip, pip.chain_version) 768 assert_code(result, 302024) 769 770 @pytest.mark.P1 771 @allure.title('There is a proposal in voting stage, verifier declare version') 772 def test_DE_VE_049(self, large_version_proposal_voted_pips): 773 pip = large_version_proposal_voted_pips[0] 774 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 775 assert_code(result, 302028) 776 777 result = wrong_verisonsign_declare(pip, large_version_proposal_voted_pips[1]) 778 assert_code(result, 302024) 779 780 result = wrong_verison_declare(pip, pip.cfg.version8) 781 assert_code(result, 302024) 782 783 result = wrong_verison_declare(pip, pip.chain_version) 784 assert_code(result, 302024) 785 786 @pytest.mark.P1 787 @allure.title('There is a proposal in voting stage, verifier declare version') 788 def test_DE_VE_051(self, large_version_proposal_voted_pips): 789 pip = large_version_proposal_voted_pips[0] 790 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN4, pip.cfg.version4) 791 assert_code(result, 302028) 792 793 result = wrong_verisonsign_declare(pip, large_version_proposal_voted_pips[1]) 794 assert_code(result, 302024) 795 796 result = wrong_verison_declare(pip, pip.cfg.version8) 797 assert_code(result, 302024) 798 799 result = wrong_verison_declare(pip, pip.chain_version) 800 assert_code(result, 302024) 801 802 @pytest.mark.P1 803 @allure.title('There is a proposal in voting stage, verifier declare version') 804 def test_DE_VE_053(self, large_version_proposal_voted_pips): 805 pip = large_version_proposal_voted_pips[0] 806 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN6, pip.cfg.version6) 807 assert_code(result, 302028) 808 809 result = wrong_verisonsign_declare(pip, large_version_proposal_voted_pips[1]) 810 assert_code(result, 302024) 811 812 result = wrong_verison_declare(pip, pip.cfg.version8) 813 assert_code(result, 302024) 814 815 result = wrong_verison_declare(pip, pip.chain_version) 816 assert_code(result, 302024) 817 818 @pytest.mark.P2 819 @allure.title('There is a proposal in voting stage, verifier declare version') 820 def test_DE_VE_055(self, large_version_proposal_voted_pips): 821 pip = large_version_proposal_voted_pips[0] 822 node_version = verifier_node_version(pip) 823 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 824 assert_code(result, 0) 825 verifier_node_version(pip, node_version) 826 827 result = wrong_verisonsign_declare(pip, large_version_proposal_voted_pips[1]) 828 assert_code(result, 302024) 829 830 result = wrong_verison_declare(pip, pip.chain_version) 831 assert_code(result, 302024) 832 833 834 class TestPreactiveProposalVE: 835 @pytest.mark.P2 836 @allure.title('There is a preactive proposal, verifier declare version') 837 def test_DE_VE_056(self, preactive_proposal_pips): 838 pip = preactive_proposal_pips[0] 839 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 840 assert_code(result, 302028) 841 842 result = wrong_verisonsign_declare(pip, preactive_proposal_pips[1]) 843 assert_code(result, 302024) 844 845 result = wrong_verison_declare(pip, pip.cfg.version5) 846 assert_code(result, 302024) 847 848 result = wrong_verison_declare(pip, pip.chain_version) 849 assert_code(result, 302024) 850 851 @pytest.mark.P2 852 @allure.title('There is a preactive proposal, verifier declare version') 853 def test_DE_VE_057(self, preactive_proposal_pips): 854 pip = preactive_proposal_pips[0] 855 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 856 assert_code(result, 302028) 857 858 result = wrong_verisonsign_declare(pip, preactive_proposal_pips[1]) 859 assert_code(result, 302024) 860 861 result = wrong_verison_declare(pip, pip.cfg.version5) 862 assert_code(result, 302024) 863 864 result = wrong_verison_declare(pip, pip.chain_version) 865 assert_code(result, 302024) 866 867 @pytest.mark.P2 868 @allure.title('There is a preactive proposal, verifier declare version') 869 def test_DE_VE_059(self, preactive_proposal_pips): 870 pip = preactive_proposal_pips[0] 871 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 872 assert_code(result, 302028) 873 874 result = wrong_verisonsign_declare(pip, preactive_proposal_pips[1]) 875 assert_code(result, 302024) 876 877 result = wrong_verison_declare(pip, pip.cfg.version5) 878 assert_code(result, 302024) 879 880 result = wrong_verison_declare(pip, pip.chain_version) 881 assert_code(result, 302024) 882 883 @pytest.mark.P2 884 @allure.title('There is a preactive proposal, verifier declare version') 885 def test_DE_VE_060(self, preactive_large_version_proposal_pips): 886 pip = preactive_large_version_proposal_pips[0] 887 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 888 assert_code(result, 302028) 889 890 result = wrong_verisonsign_declare(pip, preactive_large_version_proposal_pips[1]) 891 assert_code(result, 302024) 892 893 result = wrong_verison_declare(pip, pip.cfg.version8) 894 assert_code(result, 302024) 895 896 result = wrong_verison_declare(pip, pip.chain_version) 897 assert_code(result, 302024) 898 899 @pytest.mark.P1 900 @allure.title('There is a preactive proposal, verifier declare version') 901 def test_DE_VE_062(self, preactive_proposal_pips): 902 pip = preactive_proposal_pips[0] 903 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 904 assert_code(result, 302028) 905 906 result = wrong_verisonsign_declare(pip, preactive_proposal_pips[1]) 907 assert_code(result, 302024) 908 909 result = wrong_verison_declare(pip, pip.cfg.version5) 910 assert_code(result, 302024) 911 912 @pytest.mark.P2 913 @allure.title('There is a preactive proposal, verifier declare version') 914 def test_DE_VE_063(self, preactive_large_version_proposal_pips): 915 pip = preactive_large_version_proposal_pips[0] 916 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 917 assert_code(result, 302028) 918 919 result = wrong_verisonsign_declare(pip, preactive_large_version_proposal_pips[1]) 920 assert_code(result, 302024) 921 922 result = wrong_verison_declare(pip, pip.cfg.version8) 923 assert_code(result, 302024) 924 925 @pytest.mark.P2 926 @allure.title('There is a preactive proposal, verifier declare version') 927 def test_DE_VE_064(self, preactive_proposal_pips): 928 pip = preactive_proposal_pips[0] 929 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 930 assert_code(result, 302028) 931 932 result = wrong_verisonsign_declare(pip, preactive_proposal_pips[1]) 933 assert_code(result, 302024) 934 935 result = wrong_verison_declare(pip, pip.cfg.version5) 936 assert_code(result, 302024) 937 938 result = wrong_verison_declare(pip, pip.chain_version) 939 assert_code(result, 302024) 940 941 @pytest.mark.P2 942 @allure.title('There is a preactive proposal, verifier declare version') 943 def test_DE_VE_065(self, preactive_proposal_pips): 944 pip = preactive_proposal_pips[0] 945 node_version = verifier_node_version(pip) 946 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 947 assert_code(result, 0) 948 verifier_node_version(pip, node_version) 949 950 result = wrong_verisonsign_declare(pip, preactive_proposal_pips[1]) 951 assert_code(result, 302024) 952 953 result = wrong_verison_declare(pip, pip.cfg.version0) 954 assert_code(result, 302024) 955 956 @pytest.mark.P1 957 @allure.title('There is a preactive proposal, verifier declare version') 958 def test_DE_VE_066(self, preactive_proposal_pips): 959 pip = preactive_proposal_pips[0] 960 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN4, pip.cfg.version4) 961 assert_code(result, 0) 962 verifier_node_version(pip, pip.cfg.version4) 963 964 result = wrong_verisonsign_declare(pip, preactive_proposal_pips[1]) 965 assert_code(result, 302024) 966 967 result = wrong_verison_declare(pip, pip.cfg.version5) 968 assert_code(result, 302024) 969 970 result = wrong_verison_declare(pip, pip.chain_version) 971 assert_code(result, 302024) 972 973 @pytest.mark.P1 974 @allure.title('There is a preactive proposal, verifier declare version') 975 def test_DE_VE_067(self, preactive_proposal_pips): 976 pip = preactive_proposal_pips[0] 977 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN6, pip.cfg.version6) 978 assert_code(result, 0) 979 verifier_node_version(pip, pip.cfg.version6) 980 981 result = wrong_verisonsign_declare(pip, preactive_proposal_pips[1]) 982 assert_code(result, 302024) 983 984 result = wrong_verison_declare(pip, pip.cfg.version5) 985 assert_code(result, 302024) 986 987 result = wrong_verison_declare(pip, pip.chain_version) 988 assert_code(result, 302024) 989 990 @pytest.mark.P2 991 @allure.title('There is a preactive proposal, verifier declare version') 992 def test_DE_VE_068(self, preactive_proposal_pips): 993 pip = preactive_proposal_pips[0] 994 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 995 assert_code(result, 302028) 996 997 result = wrong_verisonsign_declare(pip, preactive_proposal_pips[1]) 998 assert_code(result, 302024) 999 1000 result = wrong_verison_declare(pip, pip.cfg.version5) 1001 assert_code(result, 302024) 1002 1003 result = wrong_verison_declare(pip, pip.chain_version) 1004 assert_code(result, 302024) 1005 1006 @pytest.mark.P2 1007 @allure.title('There is a preactive proposal, verifier declare version') 1008 def test_DE_VE_069(self, preactive_large_version_proposal_pips): 1009 pip = preactive_large_version_proposal_pips[0] 1010 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 1011 assert_code(result, 302028) 1012 1013 result = wrong_verisonsign_declare(pip, preactive_large_version_proposal_pips[1]) 1014 assert_code(result, 302024) 1015 1016 result = wrong_verison_declare(pip, pip.cfg.version8) 1017 assert_code(result, 302024) 1018 1019 result = wrong_verison_declare(pip, pip.chain_version) 1020 assert_code(result, 302024) 1021 1022 @pytest.mark.P2 1023 @allure.title('There is a preactive proposal, verifier declare version') 1024 def test_DE_VE_070(self, preactive_large_version_proposal_pips): 1025 pip = preactive_large_version_proposal_pips[0] 1026 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 1027 assert_code(result, 302028) 1028 1029 result = wrong_verisonsign_declare(pip, preactive_large_version_proposal_pips[1]) 1030 assert_code(result, 302024) 1031 1032 result = wrong_verison_declare(pip, pip.cfg.version8) 1033 assert_code(result, 302024) 1034 1035 result = wrong_verison_declare(pip, pip.chain_version) 1036 assert_code(result, 302024) 1037 1038 @pytest.mark.P2 1039 @allure.title('There is a preactive proposal, verifier declare version') 1040 def test_DE_VE_071(self, preactive_large_version_proposal_pips): 1041 pip = preactive_large_version_proposal_pips[0] 1042 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN4, pip.cfg.version4) 1043 assert_code(result, 302028) 1044 1045 result = wrong_verisonsign_declare(pip, preactive_large_version_proposal_pips[1]) 1046 assert_code(result, 302024) 1047 1048 result = wrong_verison_declare(pip, pip.cfg.version8) 1049 assert_code(result, 302024) 1050 1051 result = wrong_verison_declare(pip, pip.chain_version) 1052 assert_code(result, 302024) 1053 1054 @pytest.mark.P2 1055 @allure.title('There is a preactive proposal, verifier declare version') 1056 def test_DE_VE_072(self, preactive_large_version_proposal_pips): 1057 pip = preactive_large_version_proposal_pips[0] 1058 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN6, pip.cfg.version6) 1059 assert_code(result, 302028) 1060 1061 result = wrong_verisonsign_declare(pip, preactive_large_version_proposal_pips[1]) 1062 assert_code(result, 302024) 1063 1064 result = wrong_verison_declare(pip, pip.cfg.version8) 1065 assert_code(result, 302024) 1066 1067 result = wrong_verison_declare(pip, pip.chain_version) 1068 assert_code(result, 302024) 1069 1070 @pytest.mark.P2 1071 @allure.title('There is a preactive proposal, verifier declare version') 1072 def test_DE_VE_073(self, preactive_large_version_proposal_pips): 1073 pip = preactive_large_version_proposal_pips[0] 1074 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 1075 assert_code(result, 0) 1076 verifier_node_version(pip, pip.cfg.version8) 1077 1078 result = wrong_verisonsign_declare(pip, preactive_large_version_proposal_pips[1]) 1079 assert_code(result, 302024) 1080 1081 result = wrong_verison_declare(pip, pip.cfg.version0) 1082 assert_code(result, 302024) 1083 1084 1085 class TestNoProposalCA: 1086 @pytest.mark.P0 1087 @allure.title('No effective proposal, candiate declare version') 1088 def test_DE_CA_001(self, noproposal_candidate_pips, client_verifier): 1089 pip = noproposal_candidate_pips[0] 1090 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 1091 assert_code(result, 0) 1092 verifier_node_version(pip, pip.cfg.version2) 1093 1094 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1095 assert_code(result, 302024) 1096 1097 result = wrong_verison_declare(pip, pip.chain_version) 1098 assert_code(result, 302024) 1099 1100 @pytest.mark.P3 1101 @allure.title('No effective proposal, candiate declare version') 1102 def test_DE_CA_002(self, noproposal_candidate_pips, client_verifier): 1103 pip = noproposal_candidate_pips[0] 1104 1105 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 1106 assert_code(result, 302028) 1107 1108 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1109 assert_code(result, 302024) 1110 1111 result = wrong_verison_declare(pip, pip.chain_version) 1112 assert_code(result, 302024) 1113 1114 @pytest.mark.P0 1115 @allure.title('No effective proposal, candiate declare version') 1116 def test_DE_CA_004(self, noproposal_candidate_pips, client_verifier): 1117 pip = noproposal_candidate_pips[0] 1118 1119 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 1120 assert_code(result, 0) 1121 verifier_node_version(pip, pip.cfg.version3) 1122 1123 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1124 assert_code(result, 302024) 1125 1126 result = wrong_verison_declare(pip, pip.chain_version) 1127 assert_code(result, 302024) 1128 1129 @pytest.mark.P2 1130 @allure.title('No effective proposal, candiate declare version') 1131 def test_DE_CA_005(self, noproposal_candidate_pips, client_verifier): 1132 pip = noproposal_candidate_pips[0] 1133 1134 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 1135 assert_code(result, 302028) 1136 1137 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1138 assert_code(result, 302024) 1139 1140 result = wrong_verison_declare(pip, pip.chain_version) 1141 assert_code(result, 302024) 1142 1143 @pytest.mark.P2 1144 @allure.title('No effective proposal, candiate declare version') 1145 def test_DE_CA_006(self, noproposal_candidate_pips, client_verifier): 1146 pip = noproposal_candidate_pips[0] 1147 1148 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 1149 assert_code(result, 302028) 1150 1151 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1152 assert_code(result, 302024) 1153 1154 result = wrong_verison_declare(pip, pip.chain_version) 1155 assert_code(result, 302024) 1156 1157 @pytest.mark.P0 1158 @allure.title('No effective proposal, candiate declare version') 1159 def test_DE_CA_007(self, noproposal_candidate_pips, client_verifier): 1160 pip = noproposal_candidate_pips[0] 1161 1162 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 1163 assert_code(result, 0) 1164 verifier_node_version(pip, pip.cfg.version0) 1165 1166 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1167 assert_code(result, 302024) 1168 1169 result = wrong_verison_declare(pip, pip.cfg.version2) 1170 assert_code(result, 302024) 1171 1172 result = wrong_verison_declare(pip, pip.cfg.version3) 1173 assert_code(result, 302024) 1174 1175 @pytest.mark.P0 1176 @allure.title('No effective proposal, candiate declare version') 1177 def test_DE_CA_008(self, proposal_candidate_pips, client_verifier): 1178 pip = proposal_candidate_pips[0] 1179 1180 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 1181 assert_code(result, 0) 1182 verifier_node_version(pip, pip.cfg.version2) 1183 1184 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1185 assert_code(result, 302024) 1186 1187 result = wrong_verison_declare(pip) 1188 assert_code(result, 302024) 1189 1190 result = wrong_verison_declare(pip, pip.chain_version) 1191 assert_code(result, 302024) 1192 1193 @pytest.mark.P2 1194 @allure.title('No effective proposal, candiate declare version') 1195 def test_DE_CA_010(self, proposal_candidate_pips, client_verifier): 1196 pip = proposal_candidate_pips[0] 1197 1198 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 1199 assert_code(result, 302028) 1200 1201 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1202 assert_code(result, 302024) 1203 1204 result = wrong_verison_declare(pip) 1205 assert_code(result, 302024) 1206 1207 result = wrong_verison_declare(pip, pip.chain_version) 1208 assert_code(result, 302024) 1209 1210 @pytest.mark.P1 1211 @allure.title('No effective proposal, candiate declare version') 1212 def test_DE_CA_014(self, large_version_proposal_candidate_pips, client_verifier): 1213 pip = large_version_proposal_candidate_pips[0] 1214 1215 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 1216 assert_code(result, 0) 1217 verifier_node_version(pip, pip.cfg.version2) 1218 1219 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1220 assert_code(result, 302024) 1221 1222 result = wrong_verison_declare(pip) 1223 assert_code(result, 302024) 1224 1225 result = wrong_verison_declare(pip, pip.chain_version) 1226 assert_code(result, 302024) 1227 1228 @pytest.mark.P2 1229 @allure.title('No effective proposal, candiate declare version') 1230 def test_DE_CA_025(self, large_version_proposal_candidate_pips, client_verifier): 1231 pip = large_version_proposal_candidate_pips[0] 1232 1233 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 1234 assert_code(result, 302028) 1235 1236 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1237 assert_code(result, 302024) 1238 1239 result = wrong_verison_declare(pip) 1240 assert_code(result, 302024) 1241 1242 result = wrong_verison_declare(pip, pip.chain_version) 1243 assert_code(result, 302024) 1244 1245 @pytest.mark.P0 1246 @allure.title('No effective proposal, candiate declare version') 1247 def test_DE_CA_032(self, proposal_candidate_pips, client_verifier): 1248 pip = proposal_candidate_pips[0] 1249 1250 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 1251 assert_code(result, 0) 1252 verifier_node_version(pip, pip.cfg.version0) 1253 1254 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1255 assert_code(result, 302024) 1256 1257 result = wrong_verison_declare(pip) 1258 assert_code(result, 302024) 1259 1260 @pytest.mark.P2 1261 @allure.title('No effective proposal, candiate declare version') 1262 def test_DE_CA_034(self, large_version_proposal_candidate_pips, client_verifier): 1263 pip = large_version_proposal_candidate_pips[0] 1264 1265 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 1266 assert_code(result, 0) 1267 verifier_node_version(pip, pip.cfg.version0) 1268 1269 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1270 assert_code(result, 302024) 1271 1272 result = wrong_verison_declare(pip) 1273 assert_code(result, 302024) 1274 1275 @pytest.mark.P1 1276 @allure.title('No effective proposal, candiate declare version') 1277 def test_DE_CA_036(self, proposal_candidate_pips, client_verifier): 1278 pip = proposal_candidate_pips[0] 1279 1280 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 1281 assert_code(result, 0) 1282 verifier_node_version(pip, pip.cfg.version3) 1283 1284 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1285 assert_code(result, 302024) 1286 1287 result = wrong_verison_declare(pip) 1288 assert_code(result, 302024) 1289 1290 result = wrong_verison_declare(pip, pip.chain_version) 1291 assert_code(result, 302024) 1292 1293 @pytest.mark.P1 1294 @allure.title('No effective proposal, candiate declare version') 1295 def test_DE_CA_038(self, proposal_candidate_pips, client_verifier): 1296 pip = proposal_candidate_pips[0] 1297 1298 node_version = verifier_node_version(pip) 1299 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 1300 assert_code(result, 0) 1301 verifier_node_version(pip, node_version) 1302 1303 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1304 assert_code(result, 302024) 1305 1306 result = wrong_verison_declare(pip, pip.chain_version) 1307 assert_code(result, 302024) 1308 1309 @pytest.mark.P2 1310 @allure.title('No effective proposal, candiate declare version') 1311 def test_DE_CA_040(self, proposal_candidate_pips, client_verifier): 1312 pip = proposal_candidate_pips[0] 1313 1314 node_version = verifier_node_version(pip) 1315 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN4, pip.cfg.version4) 1316 assert_code(result, 0) 1317 verifier_node_version(pip, node_version) 1318 1319 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1320 assert_code(result, 302024) 1321 1322 result = wrong_verison_declare(pip) 1323 assert_code(result, 302024) 1324 1325 result = wrong_verison_declare(pip, pip.chain_version) 1326 assert_code(result, 302024) 1327 1328 @pytest.mark.P2 1329 @allure.title('No effective proposal, candiate declare version') 1330 def test_DE_CA_042(self, proposal_candidate_pips, client_verifier): 1331 pip = proposal_candidate_pips[0] 1332 1333 node_version = verifier_node_version(pip) 1334 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN6, pip.cfg.version6) 1335 assert_code(result, 0) 1336 verifier_node_version(pip, node_version) 1337 1338 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1339 assert_code(result, 302024) 1340 1341 result = wrong_verison_declare(pip) 1342 assert_code(result, 302024) 1343 1344 result = wrong_verison_declare(pip, pip.chain_version) 1345 assert_code(result, 302024) 1346 1347 @pytest.mark.P2 1348 @allure.title('No effective proposal, candiate declare version') 1349 def test_DE_CA_044(self, proposal_candidate_pips, client_verifier): 1350 pip = proposal_candidate_pips[0] 1351 1352 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 1353 assert_code(result, 302028) 1354 1355 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1356 assert_code(result, 302024) 1357 1358 result = wrong_verison_declare(pip) 1359 assert_code(result, 302024) 1360 1361 result = wrong_verison_declare(pip, pip.chain_version) 1362 assert_code(result, 302024) 1363 1364 @pytest.mark.P1 1365 @allure.title('No effective proposal, candiate declare version') 1366 def test_DE_CA_046(self, large_version_proposal_candidate_pips, client_verifier): 1367 pip = large_version_proposal_candidate_pips[0] 1368 1369 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 1370 assert_code(result, 0) 1371 verifier_node_version(pip, pip.cfg.version3) 1372 1373 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1374 assert_code(result, 302024) 1375 1376 result = wrong_verison_declare(pip) 1377 assert_code(result, 302024) 1378 1379 result = wrong_verison_declare(pip, pip.chain_version) 1380 assert_code(result, 302024) 1381 1382 @pytest.mark.P1 1383 @allure.title('No effective proposal, candiate declare version') 1384 def test_DE_CA_048(self, large_version_proposal_candidate_pips, client_verifier): 1385 pip = large_version_proposal_candidate_pips[0] 1386 1387 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 1388 assert_code(result, 302028) 1389 1390 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1391 assert_code(result, 302024) 1392 1393 result = wrong_verison_declare(pip) 1394 assert_code(result, 302024) 1395 1396 result = wrong_verison_declare(pip, pip.chain_version) 1397 assert_code(result, 302024) 1398 1399 @pytest.mark.P1 1400 @allure.title('No effective proposal, candiate declare version') 1401 def test_DE_CA_050(self, large_version_proposal_candidate_pips, client_verifier): 1402 pip = large_version_proposal_candidate_pips[0] 1403 1404 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN4, pip.cfg.version4) 1405 assert_code(result, 302028) 1406 1407 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1408 assert_code(result, 302024) 1409 1410 result = wrong_verison_declare(pip) 1411 assert_code(result, 302024) 1412 1413 result = wrong_verison_declare(pip, pip.chain_version) 1414 assert_code(result, 302024) 1415 1416 @pytest.mark.P1 1417 @allure.title('No effective proposal, candiate declare version') 1418 def test_DE_CA_052(self, large_version_proposal_candidate_pips, client_verifier): 1419 pip = large_version_proposal_candidate_pips[0] 1420 1421 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN6, pip.cfg.version6) 1422 assert_code(result, 302028) 1423 1424 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1425 assert_code(result, 302024) 1426 1427 result = wrong_verison_declare(pip) 1428 assert_code(result, 302024) 1429 1430 result = wrong_verison_declare(pip, pip.chain_version) 1431 assert_code(result, 302024) 1432 1433 @pytest.mark.P2 1434 @allure.title('No effective proposal, candiate declare version') 1435 def test_DE_CA_054(self, large_version_proposal_candidate_pips, client_verifier): 1436 pip = large_version_proposal_candidate_pips[0] 1437 1438 node_version = verifier_node_version(pip) 1439 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 1440 assert_code(result, 0) 1441 verifier_node_version(pip, node_version) 1442 1443 result = wrong_verisonsign_declare(pip, client_verifier.pip) 1444 assert_code(result, 302024) 1445 1446 result = wrong_verison_declare(pip, pip.chain_version) 1447 assert_code(result, 302024) 1448 1449 1450 class TestNewNodeDeclareVersion: 1451 @pytest.mark.P1 1452 @allure.title('New node declare version') 1453 def test_DE_NN_001_to_003(self, new_genesis_env, clients_consensus, clients_noconsensus): 1454 new_genesis_env.deploy_all() 1455 pip = clients_noconsensus[0].pip 1456 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000000) 1457 result = pip.declareVersion(pip.node.node_id, address, transaction_cfg=pip.cfg.transaction_cfg) 1458 log.info('New node declare version result : {}'.format(result)) 1459 assert_code(result, 302023) 1460 1461 submitvpandvote(clients_consensus) 1462 proposalinfo = pip.get_effect_proposal_info_of_vote() 1463 log.info('Get version proposal information : {}'.format(proposalinfo)) 1464 result = pip.declareVersion(pip.node.node_id, address, transaction_cfg=pip.cfg.transaction_cfg) 1465 log.info('New node declare version result : {}'.format(result)) 1466 assert_code(result, 302023) 1467 1468 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 1469 assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 4) 1470 wait_block_number(pip.node, proposalinfo.get('ActiveBlock')) 1471 assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 5) 1472 1473 result = pip.declareVersion(pip.node.node_id, address, transaction_cfg=pip.cfg.transaction_cfg) 1474 log.info('New node declare version result : {}'.format(result)) 1475 assert_code(result, 302023) 1476 1477 1478 class TestDV: 1479 @pytest.mark.P3 1480 @allure.title('Declare version') 1481 def test_DE_VE_003_DE_VE_012_DE_VE_027_DE_CA_003_DE_CA_012_DE_VE_061_DE_CA_027(self, new_genesis_env, 1482 clients_consensus): 1483 new_genesis_env.deploy_all() 1484 pip_ca = clients_consensus[-1].pip 1485 pip_ve = clients_consensus[0].pip 1486 submitvpandvote(clients_consensus[0:3], votingrounds=3, version=pip_ca.cfg.version9) 1487 proposalinfo = pip_ca.get_effect_proposal_info_of_vote() 1488 log.info("Get version proposal information : {}".format(proposalinfo)) 1489 wait_block_number(pip_ca.node, proposalinfo.get('EndVotingBlock')) 1490 assert_code(pip_ca.get_status_of_proposal(proposalinfo.get('ProposalID')), 4) 1491 wait_block_number(pip_ca.node, proposalinfo.get('ActiveBlock')) 1492 assert_code(pip_ca.get_status_of_proposal(proposalinfo.get('ProposalID')), 5) 1493 assert pip_ca.cfg.version9 == pip_ca.chain_version 1494 1495 verifier_list = get_pledge_list(clients_consensus[0].ppos.getVerifierList) 1496 log.info('verifier list : {}'.format(verifier_list)) 1497 assert pip_ca.node not in verifier_list 1498 1499 result = replace_version_declare(pip_ve, pip_ve.cfg.PLATON_NEW_BIN0, pip_ve.cfg.version0) 1500 assert_code(result, 302028) 1501 result = pip_ca.declareVersion(pip_ca.node.node_id, pip_ca.node.staking_address, 1502 transaction_cfg=pip_ca.cfg.transaction_cfg) 1503 log.info('Node {} declare version result {}'.format(pip_ca.node.node_id, result)) 1504 assert_code(result, 302028) 1505 result = clients_consensus[1].pip.submitVersion(clients_consensus[1].node.node_id, str(time.time()), 1506 pip_ca.cfg.version8, 2, 1507 clients_consensus[1].node.staking_address, 1508 transaction_cfg=pip_ca.cfg.transaction_cfg) 1509 log.info('Node {} submit version proposal result : {}'.format(clients_consensus[1].node.node_id, result)) 1510 assert_code(result, 0) 1511 result = replace_version_declare(pip_ve, pip_ve.cfg.PLATON_NEW_BIN0, versiontag=pip_ve.cfg.version0) 1512 assert_code(result, 302028) 1513 1514 result = replace_version_declare(pip_ca, pip_ve.cfg.PLATON_NEW_BIN0, versiontag=pip_ve.cfg.version0) 1515 assert_code(result, 302028) 1516 1517 for client in clients_consensus[:3]: 1518 version_proposal_vote(client.pip) 1519 proposalinfo = pip_ve.get_effect_proposal_info_of_vote() 1520 log.info('Get proposal information : {}'.format(proposalinfo)) 1521 wait_block_number(pip_ve.node, proposalinfo.get('EndVotingBlock')) 1522 assert_code(pip_ve.get_status_of_proposal(proposalinfo.get('ProposalID')), 4) 1523 wait_block_number(pip_ve.node, proposalinfo.get('ActiveBlock')) 1524 assert_code(pip_ve.get_status_of_proposal(proposalinfo.get('ProposalID')), 5) 1525 1526 result = replace_version_declare(pip_ve, pip_ve.cfg.PLATON_NEW_BIN0, versiontag=pip_ve.cfg.version0) 1527 assert_code(result, 302028) 1528 1529 1530 class TestVotedCADV: 1531 def get_candidate_no_verifier(self, client_list): 1532 verifier_list = get_pledge_list(client_list[0].ppos.getVerifierList) 1533 log.info('verifier list : {}'.format(verifier_list)) 1534 candidate_list = get_pledge_list(client_list[0].ppos.getCandidateList) 1535 log.info('candidate list : {}'.format(candidate_list)) 1536 for nodeid in candidate_list: 1537 if nodeid not in verifier_list: 1538 return get_client_by_nodeid(nodeid, client_list) 1539 raise Exception('There is not candidate no verifier node') 1540 1541 @pytest.mark.P2 1542 @allure.title('Voted candidate, Declare version') 1543 def test_DE_CA_009_011_033_037_039_041_043_045(self, new_genesis_env, clients_consensus, clients_noconsensus, 1544 all_clients): 1545 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 1546 genesis.economicModel.gov.versionProposalVoteDurationSeconds = 2000 1547 new_genesis_env.set_genesis(genesis.to_dict()) 1548 new_genesis_env.deploy_all() 1549 submitvpandvote(clients_consensus, votingrounds=40) 1550 createstaking(clients_noconsensus) 1551 clients_consensus[0].economic.wait_settlement_blocknum(clients_consensus[0].node) 1552 client = self.get_candidate_no_verifier(all_clients) 1553 pip = client.pip 1554 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 1555 assert_code(result, 302028) 1556 1557 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1558 assert_code(result, 302024) 1559 1560 result = wrong_verison_declare(pip, pip.chain_version) 1561 assert_code(result, 302024) 1562 1563 result = wrong_verison_declare(pip, pip.cfg.version5) 1564 assert_code(result, 302024) 1565 1566 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 1567 assert_code(result, 302028) 1568 1569 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1570 assert_code(result, 302024) 1571 1572 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 1573 assert_code(result, 302028) 1574 1575 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1576 assert_code(result, 302024) 1577 1578 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 1579 assert_code(result, 302028) 1580 1581 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1582 assert_code(result, 302024) 1583 1584 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 1585 assert_code(result, 0) 1586 1587 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1588 assert_code(result, 302024) 1589 1590 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN4, pip.cfg.version4) 1591 assert_code(result, 0) 1592 1593 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1594 assert_code(result, 302024) 1595 1596 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN6, pip.cfg.version6) 1597 assert_code(result, 0) 1598 1599 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1600 assert_code(result, 302024) 1601 1602 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 1603 assert_code(result, 302028) 1604 1605 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1606 assert_code(result, 302024) 1607 1608 @pytest.mark.P2 1609 @allure.title('Voted candidate, Declare version') 1610 def test_DE_CA_021_026_035_047_049_051_053_055(self, new_genesis_env, clients_consensus, clients_noconsensus, 1611 all_clients): 1612 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 1613 genesis.economicModel.gov.versionProposalVoteDurationSeconds = 2000 1614 new_genesis_env.set_genesis(genesis.to_dict()) 1615 new_genesis_env.deploy_all() 1616 submitvpandvote(clients_consensus, votingrounds=40, version=clients_noconsensus[0].pip.cfg.version8) 1617 createstaking(clients_noconsensus) 1618 clients_consensus[0].economic.wait_settlement_blocknum(clients_consensus[0].node) 1619 client = self.get_candidate_no_verifier(all_clients) 1620 pip = client.pip 1621 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN2, pip.cfg.version2) 1622 assert_code(result, 302028) 1623 1624 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1625 assert_code(result, 302024) 1626 1627 result = wrong_verison_declare(pip, pip.chain_version) 1628 assert_code(result, 302024) 1629 1630 result = wrong_verison_declare(pip, pip.cfg.version5) 1631 assert_code(result, 302024) 1632 1633 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN1, pip.cfg.version1) 1634 assert_code(result, 302028) 1635 1636 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1637 assert_code(result, 302024) 1638 1639 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 1640 assert_code(result, 302028) 1641 1642 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1643 assert_code(result, 302024) 1644 1645 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN3, pip.cfg.version3) 1646 assert_code(result, 302028) 1647 1648 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1649 assert_code(result, 302024) 1650 1651 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) 1652 assert_code(result, 302028) 1653 1654 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1655 assert_code(result, 302024) 1656 1657 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN4, pip.cfg.version4) 1658 assert_code(result, 302028) 1659 1660 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1661 assert_code(result, 302024) 1662 1663 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN6, pip.cfg.version6) 1664 assert_code(result, 302028) 1665 1666 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1667 assert_code(result, 302024) 1668 1669 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN8, pip.cfg.version8) 1670 assert_code(result, 0) 1671 1672 result = wrong_verisonsign_declare(pip, clients_noconsensus[0].pip) 1673 assert_code(result, 302024) 1674 1675 1676 @pytest.mark.P2 1677 @allure.title('Voted verifier, replace the platon bin and declare version') 1678 def test_DE_VE_074(no_vp_proposal, client_verifier): 1679 pip = client_verifier.pip 1680 submitvpandvote([client_verifier], votingrounds=1) 1681 proposalinfo = pip.get_effect_proposal_info_of_vote() 1682 log.info('Get proposal information : {}'.format(proposalinfo)) 1683 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 1684 assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 3) 1685 result = replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN0, pip.cfg.version0) 1686 assert_code(result, 0)