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