github.com/platonnetwork/platon-go@v0.7.6/cases/tests/ppos_2/test_election.py (about) 1 # -*- coding: utf-8 -*- 2 from tests.lib.utils import * 3 import pytest 4 from tests.lib.config import EconomicConfig 5 from common.key import mock_duplicate_sign 6 7 8 @pytest.mark.P1 9 def test_CS_CL_001(clients_new_node): 10 """ 11 The longer the tenure, the easier it is to replace 12 :param client_new_node: 13 :return: 14 """ 15 client = clients_new_node[0] 16 address, _ = client.economic.account.generate_account(client.node.web3, 17 10 ** 18 * 10000000) 18 pledge_amount = client.economic.create_staking_limit * 2 19 result = client.staking.create_staking(0, address, address, amount=pledge_amount) 20 assert_code(result, 0) 21 # Next settlement period 22 client.economic.wait_settlement_blocknum(client.node) 23 # The next consensus cycle 24 client.economic.wait_consensus_blocknum(client.node) 25 validatorlist1 = get_pledge_list(client.ppos.getValidatorList) 26 log.info("validatorlist:{}".format(validatorlist1)) 27 node_1 = get_validator_term(client.node) 28 log.info("Maximum tenure node:{}".format(node_1)) 29 # The next consensus cycle 30 client.economic.wait_consensus_blocknum(client.node) 31 32 validatorlist2 = get_pledge_list(client.ppos.getValidatorList) 33 log.info("validatorlist:{}".format(validatorlist2)) 34 node_2 = get_validator_term(client.node) 35 log.info("Maximum tenure node:{}".format(node_2)) 36 assert node_1 not in validatorlist2 37 # The next consensus cycle 38 client.economic.wait_consensus_blocknum(client.node) 39 validatorlist3 = get_pledge_list(client.ppos.getValidatorList) 40 log.info("validatorlist:{}".format(validatorlist3)) 41 node_3 = get_validator_term(client.node) 42 log.info("Maximum tenure node:{}".format(node_3)) 43 assert node_2 not in validatorlist3 44 45 46 @pytest.mark.P1 47 def test_CS_CL_002(clients_new_node): 48 """ 49 The higher the consensus verifier list index is replaced 50 :param client_new_node: 51 :return: 52 """ 53 client = clients_new_node[0] 54 55 node = get_max_staking_tx_index(client.node) 56 log.info("The node with the largest trade index:{}".format(node)) 57 58 address, _ = client.economic.account.generate_account(client.node.web3, 59 10 ** 18 * 10000000) 60 pledge_amount = client.economic.create_staking_limit * 2 61 result = client.staking.create_staking(0, address, address, amount=pledge_amount) 62 assert_code(result, 0) 63 # Next settlement period 64 client.economic.wait_settlement_blocknum(client.node) 65 # The next consensus cycle 66 client.economic.wait_consensus_blocknum(client.node) 67 validatorlist = get_pledge_list(client.ppos.getValidatorList) 68 log.info("validatorlist:{}".format(validatorlist)) 69 assert node not in validatorlist 70 71 72 @pytest.mark.P1 73 def test_CS_CL_003(clients_new_node, clients_consensus): 74 """ 75 The higher the consensus verifier list block, the higher it is replaced 76 :param client_new_node: 77 :return: 78 """ 79 client_noconsensus1 = clients_new_node[0] 80 client_noconsensus2 = clients_new_node[1] 81 client_noconsensus3 = clients_new_node[2] 82 client_noconsensus4 = clients_new_node[3] 83 client_consensus1 = clients_consensus[0] 84 client_consensus2 = clients_consensus[1] 85 client_consensus3 = clients_consensus[2] 86 validatorlist = get_pledge_list(client_consensus1.ppos.getValidatorList) 87 log.info("validatorlist:{}".format(validatorlist)) 88 89 log.info("The next consensus cycle") 90 client_consensus1.economic.wait_consensus_blocknum(client_consensus1.node, number=1) 91 blocknumber = client_consensus1.node.eth.blockNumber 92 log.info("To report the double sign") 93 report_information1 = mock_duplicate_sign(1, client_consensus1.node.nodekey, 94 client_consensus1.node.blsprikey, 95 blocknumber) 96 log.info("Report information: {}".format(report_information1)) 97 98 report_information2 = mock_duplicate_sign(1, client_consensus2.node.nodekey, 99 client_consensus2.node.blsprikey, 100 blocknumber) 101 log.info("Report information: {}".format(report_information2)) 102 103 report_information3 = mock_duplicate_sign(1, client_consensus3.node.nodekey, 104 client_consensus3.node.blsprikey, 105 blocknumber) 106 log.info("Report information: {}".format(report_information3)) 107 108 address_1, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 109 10 ** 18 * 10000000) 110 address_2, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 111 10 ** 18 * 10000000) 112 address_3, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 113 10 ** 18 * 10000000) 114 result = client_consensus1.duplicatesign.reportDuplicateSign(1, report_information1, address_1) 115 log.info(result) 116 result = client_consensus2.duplicatesign.reportDuplicateSign(1, report_information2, address_2) 117 log.info(result) 118 result = client_consensus3.duplicatesign.reportDuplicateSign(1, report_information3, address_3) 119 log.info(result) 120 log.info("The next periods") 121 client_noconsensus3.economic.wait_settlement_blocknum(client_noconsensus3.node) 122 validatorlist = get_pledge_list(client_consensus1.ppos.getValidatorList) 123 log.info("After being reported validatorlist:{}".format(validatorlist)) 124 125 staking_address1, _ = client_noconsensus1.economic.account.generate_account(client_consensus1.node.web3, 126 10 ** 18 * 10000000) 127 staking_address2, _ = client_noconsensus1.economic.account.generate_account(client_consensus1.node.web3, 128 10 ** 18 * 10000000) 129 staking_address3, _ = client_noconsensus1.economic.account.generate_account(client_consensus1.node.web3, 130 10 ** 18 * 10000000) 131 staking_address4, _ = client_noconsensus1.economic.account.generate_account(client_consensus1.node.web3, 132 10 ** 18 * 10000000) 133 pledge_amount = client_consensus1.economic.create_staking_limit * 2 134 log.info("New pledge 4 verifiers") 135 result = client_noconsensus1.staking.create_staking(0, staking_address1, staking_address1, amount=pledge_amount) 136 assert_code(result, 0) 137 result = client_noconsensus2.staking.create_staking(0, staking_address2, staking_address2, amount=pledge_amount) 138 assert_code(result, 0) 139 result = client_noconsensus3.staking.create_staking(0, staking_address3, staking_address3, amount=pledge_amount) 140 assert_code(result, 0) 141 result = client_noconsensus4.staking.create_staking(0, staking_address4, staking_address4, amount=pledge_amount) 142 assert_code(result, 0) 143 log.info("Next settlement period") 144 client_noconsensus4.economic.wait_settlement_blocknum(client_noconsensus4.node) 145 log.info("The next consensus cycle") 146 client_noconsensus4.economic.wait_consensus_blocknum(client_noconsensus4.node) 147 verifierList = get_pledge_list(client_noconsensus4.ppos.getVerifierList) 148 log.info("verifierList:{}".format(verifierList)) 149 validatorlist1 = get_pledge_list(client_noconsensus4.ppos.getValidatorList) 150 log.info("validatorlist:{}".format(validatorlist1)) 151 assert client_noconsensus1.node.node_id in validatorlist1 152 153 client_noconsensus4.economic.wait_consensus_blocknum(client_noconsensus4.node) 154 verifierList = get_pledge_list(client_noconsensus4.ppos.getVerifierList) 155 log.info("verifierList:{}".format(verifierList)) 156 validatorlist2 = get_pledge_list(client_noconsensus4.ppos.getValidatorList) 157 log.info("validatorlist:{}".format(validatorlist2)) 158 assert client_noconsensus1.node.node_id in validatorlist2 159 160 client_noconsensus4.economic.wait_consensus_blocknum(client_noconsensus4.node) 161 verifierList = get_pledge_list(client_noconsensus4.ppos.getVerifierList) 162 log.info("verifierList:{}".format(verifierList)) 163 validatorlist3 = get_pledge_list(client_noconsensus4.ppos.getValidatorList) 164 log.info("validatorlist:{}".format(validatorlist3)) 165 assert client_noconsensus1.node.node_id in validatorlist3 166 167 168 @pytest.mark.P1 169 def test_CS_CL_004(clients_new_node, client_consensus): 170 """ 171 The lower the total Shares, the easier it is to be replaced 172 :param client_consensus_obj: 173 :param client_new_node: 174 :return: 175 """ 176 client = clients_new_node[0] 177 StakingAddress = EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS 178 value = client_consensus.node.web3.toWei(1000000, "ether") 179 result = client_consensus.staking.increase_staking(0, StakingAddress, amount=value) 180 assert_code(result, 0) 181 msg = client_consensus.ppos.getCandidateInfo(client_consensus.node.node_id) 182 log.info(msg) 183 address, _ = client.economic.account.generate_account(client.node.web3, 184 10 ** 18 * 10000000) 185 value = client.economic.create_staking_limit * 2 186 result = client.staking.create_staking(0, address, address, amount=value) 187 assert_code(result, 0) 188 log.info(client.node.node_id) 189 log.info("Next settlement period") 190 client_consensus.economic.wait_settlement_blocknum(client_consensus.node) 191 log.info("The next consensus cycle") 192 client_consensus.economic.wait_consensus_blocknum(client_consensus.node) 193 validatorlist1 = get_pledge_list(client_consensus.ppos.getValidatorList) 194 log.info("validatorlist:{}".format(validatorlist1)) 195 196 msg = client_consensus.ppos.getValidatorList() 197 log.info("Consensus validates the person's situation{}".format(msg)) 198 assert client_consensus.node.node_id in validatorlist1 199 200 client.economic.wait_consensus_blocknum(client.node) 201 validatorlist2 = get_pledge_list(client_consensus.ppos.getValidatorList) 202 log.info("validatorlist:{}".format(validatorlist2)) 203 msg = client_consensus.ppos.getValidatorList() 204 log.info("Consensus validates the person's situation{}".format(msg)) 205 assert client_consensus.node.node_id in validatorlist2 206 207 208 @pytest.mark.P1 209 def test_CS_CL_005_006_008(clients_new_node): 210 """ 211 :param client_consensus: 212 :param client_new_node: 213 :return: 214 """ 215 client_noconsensus1 = clients_new_node[0] 216 client_noconsensus2 = clients_new_node[1] 217 client_noconsensus1.economic.env.deploy_all() 218 address1, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 219 10 ** 18 * 10000000) 220 address2, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 221 10 ** 18 * 10000000) 222 value = client_noconsensus1.economic.create_staking_limit * 2 223 result = client_noconsensus1.staking.create_staking(0, address1, address1, amount=value) 224 assert_code(result, 0) 225 result = client_noconsensus2.staking.create_staking(0, address2, address2, 226 amount=value + 1300000000000000000000000) 227 assert_code(result, 0) 228 229 # Next settlement period 230 client_noconsensus2.economic.wait_settlement_blocknum(client_noconsensus2.node) 231 232 verifierlist = get_pledge_list(client_noconsensus2.ppos.getVerifierList) 233 log.info("verifierlist:{}".format(verifierlist)) 234 235 msg = client_noconsensus1.ppos.getCandidateInfo(client_noconsensus1.node.node_id) 236 log.info(msg) 237 msg = client_noconsensus2.ppos.getCandidateInfo(client_noconsensus2.node.node_id) 238 log.info(msg) 239 assert client_noconsensus2.node.node_id in verifierlist 240 assert client_noconsensus2.node.node_id == verifierlist[0] 241 242 address3, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 243 10 ** 18 * 10000000) 244 245 result = client_noconsensus1.delegate.delegate(0, address3, amount=700000000000000000000000) 246 log.info(result) 247 result = client_noconsensus1.staking.increase_staking(0, address1, amount=610000000000000000000000) 248 log.info(result) 249 250 # Next settlement period 251 client_noconsensus2.economic.wait_settlement_blocknum(client_noconsensus2.node) 252 msg = client_noconsensus1.ppos.getCandidateInfo(client_noconsensus1.node.node_id) 253 log.info(msg) 254 msg = client_noconsensus2.ppos.getCandidateInfo(client_noconsensus2.node.node_id) 255 log.info(msg) 256 verifierlist = get_pledge_list(client_noconsensus2.ppos.getVerifierList) 257 log.info("verifierlist:{}".format(verifierlist)) 258 assert verifierlist[0] == client_noconsensus1.node.node_id 259 assert verifierlist[1] == client_noconsensus2.node.node_id 260 261 262 @pytest.mark.P1 263 def test_CS_CL_007(clients_new_node): 264 """ 265 :param clients_noconsensus: 266 :return: 267 """ 268 client_noconsensus1 = clients_new_node[0] 269 client_noconsensus2 = clients_new_node[1] 270 address1, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 271 10 ** 18 * 10000000) 272 address2, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 273 10 ** 18 * 10000000) 274 value = client_noconsensus1.economic.create_staking_limit * 2 275 result = client_noconsensus1.staking.create_staking(0, address1, address1, amount=value) 276 assert_code(result, 0) 277 result = client_noconsensus2.staking.create_staking(0, address2, address2, amount=value) 278 assert_code(result, 0) 279 # Next settlement period 280 client_noconsensus1.economic.wait_settlement_blocknum(client_noconsensus2.node) 281 282 verifierlist = get_pledge_list(client_noconsensus2.ppos.getVerifierList) 283 log.info("verifierlist:{}".format(verifierlist)) 284 log.info("node:{}".format(client_noconsensus1.node.node_id)) 285 assert verifierlist[0] == client_noconsensus1.node.node_id 286 287 288 @pytest.mark.P1 289 def test_CS_CL_010_030(clients_new_node): 290 """ 291 :param global_test_env: 292 :param client_new_node: 293 :return: 294 """ 295 client = clients_new_node[0] 296 address, _ = client.economic.account.generate_account(client.node.web3, 297 10 ** 18 * 10000000) 298 value = client.economic.create_staking_limit * 2 299 result = client.staking.create_staking(0, address, address, amount=value) 300 assert_code(result, 0) 301 log.info("The next periods") 302 client.economic.wait_settlement_blocknum(client.node) 303 log.info("The next consensus cycle") 304 client.economic.wait_consensus_blocknum(client.node) 305 number = client.node.eth.blockNumber 306 log.info("To report the double sign") 307 report_information = mock_duplicate_sign(1, client.node.nodekey, client.node.blsprikey, 308 number) 309 310 log.info("Report information: {}".format(report_information)) 311 address, _ = client.economic.account.generate_account(client.node.web3, 312 10 ** 18 * 10000000) 313 result = client.duplicatesign.reportDuplicateSign(1, report_information, address) 314 log.info(result) 315 316 log.info("The next periods") 317 client.economic.wait_settlement_blocknum(client.node) 318 verifierlist = get_pledge_list(client.ppos.getVerifierList) 319 log.info("verifierlist:{}".format(verifierlist)) 320 assert client.node.node_id not in verifierlist 321 322 323 @pytest.mark.P1 324 def test_CS_CL_012_032(clients_new_node): 325 """ 326 :param client_new_node: 327 :return: 328 """ 329 client = clients_new_node[0] 330 address, _ = client.economic.account.generate_account(client.node.web3, 331 10 ** 18 * 10000000) 332 value = client.economic.create_staking_limit * 2 333 result = client.staking.create_staking(0, address, address, amount=value) 334 assert_code(result, 0) 335 log.info("The next periods") 336 client.economic.wait_settlement_blocknum(client.node) 337 verifierlist = get_pledge_list(client.ppos.getVerifierList) 338 log.info("verifierlist:{}".format(verifierlist)) 339 340 assert client.node.node_id in verifierlist 341 342 result = client.staking.withdrew_staking(address) 343 assert_code(result, 0) 344 345 log.info("The next periods") 346 client.economic.wait_settlement_blocknum(client.node, number=1) 347 verifierlist = get_pledge_list(client.ppos.getVerifierList) 348 log.info("verifierlist:{}".format(verifierlist)) 349 350 assert client.node.node_id not in verifierlist 351 352 log.info("The next consensus cycle") 353 client.economic.wait_consensus_blocknum(client.node) 354 355 validatorlist = get_pledge_list(client.ppos.getValidatorList) 356 log.info("validatorlist:{}".format(validatorlist)) 357 358 assert client.node.node_id not in validatorlist 359 360 361 @pytest.mark.P1 362 @pytest.mark.compatibility 363 def test_CS_CL_013_031(clients_new_node, client_consensus): 364 """ 365 :param client_new_node: 366 :param client_consensus_obj: 367 :return: 368 """ 369 client = clients_new_node[0] 370 address, _ = client.economic.account.generate_account(client.node.web3, 371 10 ** 18 * 10000000) 372 value = client.economic.create_staking_limit * 2 373 result = client.staking.create_staking(0, address, address, amount=value) 374 assert_code(result, 0) 375 # Next settlement period 376 client.economic.wait_settlement_blocknum(client.node) 377 verifierlist = get_pledge_list(client.ppos.getVerifierList) 378 log.info("verifierlist:{}".format(verifierlist)) 379 assert client.node.node_id in verifierlist 380 381 log.info("Close one node") 382 client.node.stop() 383 node = client_consensus.node 384 log.info("The next periods") 385 client.economic.wait_settlement_blocknum(node) 386 verifierlist = get_pledge_list(client_consensus.ppos.getVerifierList) 387 log.info("verifierlist:{}".format(verifierlist)) 388 assert client.node.node_id not in verifierlist 389 390 391 @pytest.mark.P2 392 @pytest.mark.parametrize('status', [0, 1, 2]) 393 def test_CS_CL_014_015_016_029(status, clients_new_node, clients_consensus): 394 """ 395 :param status: 396 :param global_test_env: 397 :param client_con_list_obj: 398 :param clients_noconsensus: 399 :return: 400 """ 401 client_noconsensus1 = clients_new_node[0] 402 client_noconsensus2 = clients_new_node[1] 403 client_noconsensus3 = clients_new_node[2] 404 client_noconsensus4 = clients_new_node[3] 405 client_consensus1 = clients_consensus[0] 406 client_consensus2 = clients_consensus[1] 407 client_consensus3 = clients_consensus[2] 408 client_consensus4 = clients_consensus[3] 409 410 log.info("The next consensus cycle") 411 client_consensus1.economic.wait_consensus_blocknum(client_consensus1.node, number=1) 412 blocknumber = client_consensus1.node.eth.blockNumber 413 414 log.info("To report the double sign") 415 report_information1 = mock_duplicate_sign(1, client_consensus1.node.nodekey, 416 client_consensus1.node.blsprikey, 417 blocknumber) 418 log.info("Report information: {}".format(report_information1)) 419 420 report_information2 = mock_duplicate_sign(1, client_consensus2.node.nodekey, 421 client_consensus2.node.blsprikey, 422 blocknumber) 423 log.info("Report information: {}".format(report_information2)) 424 425 report_information3 = mock_duplicate_sign(1, client_consensus3.node.nodekey, 426 client_consensus3.node.blsprikey, 427 blocknumber) 428 log.info("Report information: {}".format(report_information3)) 429 430 address_1, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 431 10 ** 18 * 10000000) 432 address_2, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 433 10 ** 18 * 10000000) 434 address_3, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 435 10 ** 18 * 10000000) 436 result = client_consensus1.duplicatesign.reportDuplicateSign(1, report_information1, address_1) 437 log.info(result) 438 result = client_consensus2.duplicatesign.reportDuplicateSign(1, report_information2, address_2) 439 log.info(result) 440 result = client_consensus3.duplicatesign.reportDuplicateSign(1, report_information3, address_3) 441 log.info(result) 442 log.info("The next periods") 443 client_noconsensus2.economic.wait_settlement_blocknum(client_noconsensus2.node) 444 validatorlist = get_pledge_list(client_consensus1.ppos.getValidatorList) 445 log.info("After being reported validatorlist:{}".format(validatorlist)) 446 447 if status == 0: 448 address1, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 449 10 ** 18 * 10000000) 450 value = client_noconsensus1.economic.create_staking_limit * 2 451 result = client_noconsensus1.staking.create_staking(0, address1, address1, amount=value) 452 assert_code(result, 0) 453 454 address2, _ = client_noconsensus2.economic.account.generate_account(client_noconsensus2.node.web3, 455 10 ** 18 * 10000000) 456 value = client_noconsensus2.economic.create_staking_limit * 2 457 result = client_noconsensus2.staking.create_staking(0, address2, address2, amount=value) 458 assert_code(result, 0) 459 460 log.info("The next periods") 461 client_noconsensus2.economic.wait_settlement_blocknum(client_noconsensus2.node) 462 463 log.info("The next consensus cycle") 464 client_noconsensus2.economic.wait_consensus_blocknum(client_noconsensus2.node) 465 466 validatorlist = get_pledge_list(client_noconsensus2.ppos.getValidatorList) 467 log.info("validatorlist:{}".format(validatorlist)) 468 log.info("node1:{}".format(client_noconsensus1.node.node_id)) 469 log.info("node2:{}".format(client_noconsensus2.node.node_id)) 470 log.info("node3:{}".format(client_consensus4.node.node_id)) 471 assert client_noconsensus1.node.node_id in validatorlist 472 assert client_noconsensus2.node.node_id in validatorlist 473 assert client_consensus4.node.node_id in validatorlist 474 475 if status == 1: 476 address1, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 477 10 ** 18 * 10000000) 478 value = client_noconsensus1.economic.create_staking_limit * 2 479 result = client_noconsensus1.staking.create_staking(0, address1, address1, amount=value) 480 assert_code(result, 0) 481 482 address2, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 483 10 ** 18 * 10000000) 484 value = client_noconsensus1.economic.create_staking_limit * 2 485 result = client_noconsensus2.staking.create_staking(0, address2, address2, amount=value) 486 assert_code(result, 0) 487 488 address3, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 489 10 ** 18 * 10000000) 490 value = client_noconsensus1.economic.create_staking_limit * 2 491 result = client_noconsensus3.staking.create_staking(0, address3, address3, amount=value) 492 assert_code(result, 0) 493 log.info("The next periods") 494 client_noconsensus2.economic.wait_settlement_blocknum(client_noconsensus2.node) 495 496 log.info("The next consensus cycle") 497 client_noconsensus2.economic.wait_consensus_blocknum(client_noconsensus2.node) 498 499 validatorlist = get_pledge_list(client_noconsensus2.ppos.getValidatorList) 500 log.info("validatorlist:{}".format(validatorlist)) 501 log.info("node1:{}".format(client_noconsensus1.node.node_id)) 502 log.info("node2:{}".format(client_noconsensus2.node.node_id)) 503 log.info("node3:{}".format(client_noconsensus3.node.node_id)) 504 log.info("node4:{}".format(client_consensus4.node.node_id)) 505 assert client_noconsensus1.node.node_id in validatorlist 506 assert client_noconsensus2.node.node_id in validatorlist 507 assert client_noconsensus3.node.node_id in validatorlist 508 assert client_consensus4.node.node_id in validatorlist 509 510 if status == 2: 511 address1, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 512 10 ** 18 * 10000000) 513 value = client_noconsensus1.economic.create_staking_limit * 2 514 result = client_noconsensus1.staking.create_staking(0, address1, address1, amount=value) 515 assert_code(result, 0) 516 517 address2, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 518 10 ** 18 * 10000000) 519 value = client_noconsensus1.economic.create_staking_limit * 2 520 result = client_noconsensus2.staking.create_staking(0, address2, address2, amount=value) 521 assert_code(result, 0) 522 523 address3, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 524 10 ** 18 * 10000000) 525 value = client_noconsensus1.economic.create_staking_limit * 2 526 result = client_noconsensus3.staking.create_staking(0, address3, address3, amount=value) 527 assert_code(result, 0) 528 529 address4, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 530 10 ** 18 * 10000000) 531 value = client_noconsensus1.economic.create_staking_limit * 2 532 result = client_noconsensus4.staking.create_staking(0, address4, address4, amount=value) 533 assert_code(result, 0) 534 535 log.info("The next periods") 536 client_noconsensus2.economic.wait_settlement_blocknum(client_noconsensus2.node) 537 538 log.info("The next consensus cycle") 539 client_noconsensus2.economic.wait_consensus_blocknum(client_noconsensus2.node) 540 541 validatorlist = get_pledge_list(client_noconsensus2.ppos.getValidatorList) 542 log.info("validatorlist:{}".format(validatorlist)) 543 log.info("node:{}".format(clients_consensus[3].node.node_id)) 544 assert client_consensus4.node.node_id in validatorlist 545 546 547 @pytest.mark.P2 548 @pytest.mark.parametrize('status', [0, 1]) 549 def test_CS_CL_017_018_019(status, clients_new_node, clients_consensus): 550 """ 551 :param status: 552 :param global_test_env: 553 :param client_con_list_obj: 554 :param clients_noconsensus: 555 :return: 556 """ 557 client_noconsensus1 = clients_new_node[0] 558 client_noconsensus2 = clients_new_node[1] 559 client_consensus1 = clients_consensus[0] 560 client_consensus2 = clients_consensus[1] 561 client_consensus3 = clients_consensus[2] 562 client_consensus4 = clients_consensus[3] 563 564 log.info("The next consensus cycle") 565 client_consensus1.economic.wait_consensus_blocknum(client_consensus1.node, number=1) 566 567 validatorlist = get_pledge_list(client_consensus1.ppos.getValidatorList) 568 log.info("initial validatorlist:{}".format(validatorlist)) 569 blocknumber = client_consensus1.node.eth.blockNumber 570 log.info("The thrill of being reported{}".format(blocknumber)) 571 572 log.info("To report the double sign") 573 report_information1 = mock_duplicate_sign(1, client_consensus1.node.nodekey, 574 client_consensus1.node.blsprikey, 575 blocknumber) 576 log.info("Report information: {}".format(report_information1)) 577 578 address, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 579 10 ** 18 * 10000000) 580 result = client_consensus1.duplicatesign.reportDuplicateSign(1, report_information1, address) 581 log.info(result) 582 log.info("The next periods") 583 client_noconsensus2.economic.wait_settlement_blocknum(client_noconsensus2.node) 584 validatorlist = get_pledge_list(client_consensus1.ppos.getValidatorList) 585 log.info("After being reported validatorlist:{}".format(validatorlist)) 586 587 if status == 0: 588 address1, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 589 10 ** 18 * 10000000) 590 value = client_noconsensus1.economic.create_staking_limit * 2 591 result = client_noconsensus1.staking.create_staking(0, address1, address1, amount=value) 592 assert_code(result, 0) 593 log.info("The next periods") 594 client_noconsensus2.economic.wait_settlement_blocknum(client_noconsensus2.node) 595 log.info("The next consensus cycle") 596 client_noconsensus2.economic.wait_consensus_blocknum(client_noconsensus2.node) 597 validatorlist = get_pledge_list(client_noconsensus2.ppos.getValidatorList) 598 log.info("validatorlist:{}".format(validatorlist)) 599 assert client_consensus2.node.node_id in validatorlist 600 assert client_consensus3.node.node_id in validatorlist 601 assert client_consensus4.node.node_id in validatorlist 602 assert client_noconsensus1.node.node_id in validatorlist 603 604 if status == 1: 605 address1, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 606 10 ** 18 * 10000000) 607 value = client_noconsensus1.economic.create_staking_limit * 2 608 result = client_noconsensus1.staking.create_staking(0, address1, address1, amount=value) 609 assert_code(result, 0) 610 611 address2, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 612 10 ** 18 * 10000000) 613 value = client_noconsensus1.economic.create_staking_limit * 2 614 result = client_noconsensus2.staking.create_staking(0, address2, address2, amount=value) 615 assert_code(result, 0) 616 617 log.info("The next periods") 618 client_noconsensus2.economic.wait_settlement_blocknum(client_noconsensus2.node) 619 log.info("The next consensus cycle") 620 client_noconsensus2.economic.wait_consensus_blocknum(client_noconsensus2.node) 621 622 validatorlist = get_pledge_list(client_noconsensus2.ppos.getValidatorList) 623 log.info("validatorlist:{}".format(validatorlist)) 624 assert client_consensus2.node.node_id in validatorlist 625 assert client_consensus3.node.node_id in validatorlist 626 assert client_consensus4.node.node_id in validatorlist 627 628 629 @pytest.mark.P2 630 def test_CS_CL_027_028(clients_new_node): 631 client_noconsensus1 = clients_new_node[0] 632 client_noconsensus2 = clients_new_node[1] 633 634 address1, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 635 10 ** 18 * 10000000) 636 address2, _ = client_noconsensus1.economic.account.generate_account(client_noconsensus1.node.web3, 637 10 ** 18 * 10000000) 638 639 result = client_noconsensus1.staking.create_staking(0, address1, address1, 640 amount=client_noconsensus1.economic.create_staking_limit * 2) 641 assert_code(result, 0) 642 643 result = client_noconsensus2.staking.create_staking(0, address2, address2, 644 amount=client_noconsensus2.economic.create_staking_limit) 645 assert_code(result, 0) 646 647 log.info("Next settlement period") 648 client_noconsensus2.economic.wait_settlement_blocknum(client_noconsensus2.node) 649 msg = client_noconsensus2.ppos.getVerifierList() 650 log.info(msg) 651 verifierlist = get_pledge_list(client_noconsensus2.ppos.getVerifierList) 652 log.info("verifierlist:{}".format(verifierlist)) 653 assert client_noconsensus1.node.node_id in verifierlist 654 assert client_noconsensus2.node.node_id not in verifierlist 655 656 657 @pytest.mark.P2 658 def test_CS_CL_033(clients_new_node): 659 client = clients_new_node[0] 660 address1, _ = client.economic.account.generate_account(client.node.web3, 661 10 ** 18 * 10000000) 662 663 value = client.economic.create_staking_limit * 2 664 result = client.staking.create_staking(0, address1, address1, amount=value) 665 assert_code(result, 0) 666 667 # Next settlement period 668 client.economic.wait_settlement_blocknum(client.node) 669 # Next consensus period 670 client.economic.wait_consensus_blocknum(client.node) 671 verifierlist = get_pledge_list(client.ppos.getVerifierList) 672 log.info("verifierlist:{}".format(verifierlist)) 673 assert client.node.node_id in verifierlist