github.com/platonnetwork/platon-go@v0.7.6/cases/tests/ppos_2/test_delegate.py (about)

     1  # -*- coding: utf-8 -*-
     2  
     3  from tests.lib.utils import *
     4  import pytest
     5  from tests.lib.config import EconomicConfig
     6  import allure
     7  
     8  
     9  @allure.title("Query delegate parameter validation")
    10  @pytest.mark.P1
    11  @pytest.mark.compatibility
    12  def test_DI_001_009(client_new_node):
    13      """
    14      001:Query delegate parameter validation
    15      009:The money entrusted is equal to the low threshold entrusted
    16      """
    17      address, pri_key = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    18                                                                           10 ** 18 * 10000000)
    19      client_new_node.staking.create_staking(0, address, address)
    20      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    21                                                                      10 ** 18 * 10000000)
    22      result = client_new_node.delegate.delegate(0, address1)
    23      assert_code(result, 0)
    24      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
    25      staking_blocknum = msg["Ret"]["StakingBlockNum"]
    26      msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address1, client_new_node.node.node_id)
    27      log.info(msg)
    28      assert client_new_node.node.web3.toChecksumAddress(msg["Ret"]["Addr"]) == address1
    29      assert msg["Ret"]["NodeId"] == client_new_node.node.node_id
    30      assert msg["Ret"]["ReleasedHes"] == client_new_node.economic.delegate_limit
    31  
    32  
    33  @allure.title("Delegate to different people")
    34  @pytest.mark.P1
    35  def test_DI_002_003_004(clients_new_node):
    36      """
    37      002:Delegate to candidate
    38      003:Delegate to verifier
    39      004:Delegate to consensus verifier
    40      """
    41      client1 = clients_new_node[0]
    42      client2 = clients_new_node[1]
    43  
    44      staking_amount = client1.economic.create_staking_limit
    45      address, pri_key = client1.economic.account.generate_account(client1.node.web3, 10 ** 18 * 10000000)
    46      client1.staking.create_staking(0, address, address, amount=staking_amount)
    47  
    48      address, pri_key = client2.economic.account.generate_account(client2.node.web3, 10 ** 18 * 10000000)
    49      client2.staking.create_staking(0, address, address, amount=staking_amount * 2)
    50  
    51      client2.economic.wait_settlement_blocknum(client2.node)
    52  
    53      nodeid_list = get_pledge_list(client2.ppos.getVerifierList)
    54      log.info("The billing cycle validates the list of people{}".format(nodeid_list))
    55      assert client1.node.node_id not in nodeid_list
    56  
    57      address1, _ = client1.economic.account.generate_account(client1.node.web3, 10 ** 18 * 10000000)
    58      log.info("The candidate delegate")
    59      result = client1.delegate.delegate(0, address1)
    60      assert_code(result, 0)
    61  
    62      assert client2.node.node_id in nodeid_list
    63      address2, _ = client2.economic.account.generate_account(client2.node.web3,
    64                                                              10 ** 18 * 10000000)
    65      log.info("The verifier delegates")
    66      result = client2.delegate.delegate(0, address2)
    67      assert_code(result, 0)
    68  
    69      client2.economic.wait_consensus_blocknum(client2.node)
    70      nodeid_list = get_pledge_list(client2.ppos.getValidatorList)
    71      log.info("Consensus validator list:{}".format(nodeid_list))
    72      assert client2.node.node_id in nodeid_list
    73      address3, _ = client2.economic.account.generate_account(client2.node.web3,
    74                                                              10 ** 18 * 10000000)
    75      log.info("Consensus verifier delegates")
    76      result = client2.delegate.delegate(0, address3)
    77      assert_code(result, 0)
    78  
    79  
    80  @allure.title("The amount entrusted by the client is less than the threshold")
    81  @pytest.mark.P3
    82  def test_DI_005(client_consensus):
    83      """
    84      :param client_consensus_obj:
    85      :return:
    86      """
    87      address, _ = client_consensus.economic.account.generate_account(client_consensus.node.web3,
    88                                                                      10 ** 18 * 10000000)
    89  
    90      result = client_consensus.delegate.delegate(0, address)
    91      log.info(result)
    92      assert_code(result, 301107)
    93  
    94  
    95  @allure.title("The amount entrusted by the client is less than the threshold")
    96  @pytest.mark.P1
    97  def test_DI_006(client_new_node):
    98      """
    99      :param client_new_node_obj:
   100      :return:
   101      """
   102      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   103                                                                     10 ** 18 * 10000000)
   104  
   105      client_new_node.staking.create_staking(0, address, address)
   106      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   107                                                                      10 ** 18 * 10000000)
   108      delegate_limit = client_new_node.economic.delegate_limit
   109      result = client_new_node.delegate.delegate(0, address1, amount=delegate_limit - 1)
   110      log.info(result)
   111      assert_code(result, 301105)
   112  
   113  
   114  @allure.title("gas Insufficient entrustment")
   115  @pytest.mark.P1
   116  def test_DI_007(client_new_node):
   117      """
   118      :param client_new_node_obj:
   119      :return:
   120      """
   121      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   122                                                                     10 ** 18 * 10000000)
   123  
   124      client_new_node.staking.create_staking(0, address, address)
   125      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   126                                                                      10 ** 18 * 10000000)
   127  
   128      fig = {"gas": 1}
   129      status = 0
   130      try:
   131          result = client_new_node.delegate.delegate(0, address1, transaction_cfg=fig)
   132          log.info(result)
   133      except BaseException:
   134          status = 1
   135      assert status == 1
   136  
   137  
   138  @allure.title("not sufficient funds")
   139  @pytest.mark.P1
   140  def test_DI_008(client_new_node):
   141      """
   142      :param client_new_node_obj:
   143      :return:
   144      """
   145      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   146                                                                     10 ** 18 * 10000000)
   147  
   148      client_new_node.staking.create_staking(0, address, address)
   149      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   150                                                                      10)
   151      status = 0
   152      try:
   153          result = client_new_node.delegate.delegate(0, address1)
   154          log.info(result)
   155      except BaseException:
   156          status = 1
   157      assert status == 1
   158  
   159  
   160  @allure.title("Delegate to a candidate who doesn't exist")
   161  @pytest.mark.P3
   162  def test_DI_010_020(client_new_node):
   163      """
   164      Delegate to a candidate who doesn't exist
   165      :param client_new_node_obj:
   166      :return:
   167      """
   168      illegal_nodeID = "7ee3276fd6b9c7864eb896310b5393324b6db785a2528c00cc28ca8c" \
   169                       "3f86fc229a86f138b1f1c8e3a942204c03faeb40e3b22ab11b8983c35dc025de42865990"
   170      address1, pri_key = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   171                                                                            10 ** 18 * 10000000)
   172      result = client_new_node.delegate.delegate(0, address1, node_id=illegal_nodeID)
   173      log.info(result)
   174      assert_code(result, 301102)
   175  
   176  
   177  @allure.title("Delegate to different people{status}")
   178  @pytest.mark.P1
   179  @pytest.mark.parametrize('status', [0, 1, 2, 3])
   180  def test_DI_011_012_013_014(client_new_node, status):
   181      """
   182      0:A valid candidate whose commission is still in doubt
   183      1:The delegate is also a valid candidate at a lockup period
   184      2:A candidate whose mandate is voluntarily withdrawn but who is still in the freeze period
   185      3:A candidate whose mandate has been voluntarily withdrawn and whose freeze period has expired
   186      :param client_new_node_obj:
   187      :param status:
   188      :return:
   189      """
   190  
   191      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   192                                                                     10 ** 18 * 10000000)
   193  
   194      client_new_node.staking.create_staking(0, address, address)
   195      if status == 0:
   196          # A valid candidate whose commission is still in doubt
   197          address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   198                                                                          10 ** 18 * 10000000)
   199          result = client_new_node.delegate.delegate(0, address1)
   200          assert_code(result, 0)
   201  
   202      if status == 1:
   203          # The delegate is also a valid candidate at a lockup period
   204          address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   205                                                                          10 ** 18 * 10000000)
   206          client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   207          result = client_new_node.delegate.delegate(0, address1)
   208          assert_code(result, 0)
   209  
   210      if status == 2:
   211          address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   212                                                                          10 ** 18 * 10000000)
   213          client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   214          result = client_new_node.staking.withdrew_staking(address)
   215          assert_code(result, 0)
   216          result = client_new_node.delegate.delegate(0, address1)
   217          assert_code(result, 301103)
   218  
   219      if status == 3:
   220          address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   221                                                                          10 ** 18 * 10000000)
   222          client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   223          result = client_new_node.staking.withdrew_staking(address)
   224          assert_code(result, 0)
   225          client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=2)
   226          result = client_new_node.delegate.delegate(0, address1)
   227          log.info(result)
   228          assert_code(result, 301102)
   229  
   230  
   231  @allure.title("Delegate to candidates whose penalties have lapsed (freeze period and after freeze period)")
   232  @pytest.mark.P1
   233  def test_DI_015_016(client_new_node, client_consensus):
   234      """
   235      :param client_new_node_obj:
   236      :param client_consensus_obj:
   237      :return:
   238      """
   239      client = client_new_node
   240      node = client.node
   241      other_node = client_consensus.node
   242      economic = client.economic
   243      address, _ = economic.account.generate_account(client_new_node.node.web3,
   244                                                           10 ** 18 * 10000000)
   245      address_delegate, _ = economic.account.generate_account(client_new_node.node.web3,
   246                                                           10 ** 18 * 10000000)
   247      value = economic.create_staking_limit * 2
   248      result = client.staking.create_staking(0, address, address, amount=value)
   249      assert_code(result, 0)
   250      economic.wait_consensus_blocknum(other_node, number=4)
   251      validator_list = get_pledge_list(other_node.ppos.getValidatorList)
   252      assert node.node_id in validator_list
   253      candidate_info = other_node.ppos.getCandidateInfo(node.node_id)
   254      log.info(candidate_info)
   255      log.info("Close one node")
   256      node.stop()
   257      for i in range(4):
   258          economic.wait_consensus_blocknum(other_node, number=i)
   259          candidate_info = other_node.ppos.getCandidateInfo(node.node_id)
   260          log.info(candidate_info)
   261          if candidate_info["Ret"]["Released"] < value:
   262              break
   263          log.info("Node exceptions are not penalized")
   264      log.info("Restart the node")
   265      client_new_node.node.start()
   266      result = client.delegate.delegate(0, address_delegate)
   267      log.info(result)
   268      assert_code(result, 301103)
   269      log.info("Next settlement period")
   270      client_new_node.economic.wait_settlement_blocknum(node,number=2)
   271      result = client.delegate.delegate(0, address_delegate)
   272      assert_code(result, 301102)
   273  
   274  
   275  @allure.title("Use the pledge account as the entrustment")
   276  @pytest.mark.P1
   277  def test_DI_017(client_new_node):
   278      """
   279      Use the pledge account as the entrustment
   280      :param client_new_node_obj:
   281      :return:
   282      """
   283      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   284                                                                     10 ** 18 * 10000000)
   285  
   286      result = client_new_node.staking.create_staking(0, address, address)
   287      assert_code(result, 0)
   288      result = client_new_node.delegate.delegate(0, address)
   289      log.info(result)
   290      assert_code(result, 301106)
   291  
   292  
   293  @allure.title(
   294      "The verification section receives the delegate, exits, becomes the verification node, and receives the delegate")
   295  @pytest.mark.P1
   296  def test_DI_019(client_new_node):
   297      """
   298      :param client_new_node_obj:
   299      :return:
   300      """
   301      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   302                                                                     10 ** 18 * 10000000)
   303      result = client_new_node.staking.create_staking(0, address, address)
   304      assert_code(result, 0)
   305  
   306      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   307                                                                      10 ** 18 * 10000000)
   308      result = client_new_node.delegate.delegate(0, address1)
   309      log.info(result)
   310      # Exit the pledge
   311      result = client_new_node.staking.withdrew_staking(address)
   312      assert_code(result, 0)
   313      # Repeat pledge
   314      result = client_new_node.staking.create_staking(0, address, address)
   315      assert_code(result, 0)
   316      result = client_new_node.delegate.delegate(0, address1)
   317      log.info(result)
   318      # Recheck wallet associations
   319      msg = client_new_node.ppos.getRelatedListByDelAddr(address1)
   320      log.info(msg)
   321      print(len(msg["Ret"]))
   322      assert len(msg["Ret"]) == 2
   323      for i in msg["Ret"]:
   324          assert client_new_node.node.web3.toChecksumAddress(i["Addr"]) == address1
   325          assert i["NodeId"] == client_new_node.node.node_id
   326  
   327  
   328  @allure.title("The entrusted verifier is penalized to verify the entrusted principal")
   329  @pytest.mark.P3
   330  def test_DI_021(client_new_node, client_consensus):
   331      """
   332      :param client_new_node_obj:
   333      :return:
   334      """
   335      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   336                                                                     10 ** 18 * 10000000)
   337      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   338                                                                      10 ** 18 * 10000000)
   339      value = client_new_node.economic.create_staking_limit * 2
   340      result = client_new_node.staking.create_staking(0, address, address, amount=value)
   341      assert_code(result, 0)
   342      result = client_new_node.delegate.delegate(0, address1)
   343      log.info(result)
   344      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   345      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   346      log.info("Close one node")
   347      client_new_node.node.stop()
   348      node = client_consensus.node
   349      log.info("The next two periods")
   350      client_new_node.economic.wait_settlement_blocknum(node, number=2)
   351      log.info("Restart the node")
   352      client_new_node.node.start()
   353      msg = client_consensus.ppos.getDelegateInfo(staking_blocknum, address1, client_new_node.node.node_id)
   354      log.info(msg)
   355      assert msg["Ret"]["Released"] == client_new_node.economic.delegate_limit
   356  
   357  
   358  @allure.title("Free amount in different periods when additional entrustment is made")
   359  @pytest.mark.P2
   360  @pytest.mark.parametrize('status', [0, 1, 2])
   361  def test_DI_022_023_024(client_new_node, status):
   362      """
   363      022:There is only the free amount of hesitation period when additional entrusting
   364      023:Only the free amount of the lockup period exists when the delegate is added
   365      024:The amount of both hesitation period and lockup period exists when additional entrustment is made
   366      :param client_new_node_obj:
   367      :param status:
   368      :return:
   369      """
   370      client_new_node.economic.env.deploy_all()
   371      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   372                                                                     10 ** 18 * 10000000)
   373  
   374      client_new_node.staking.create_staking(0, address, address)
   375      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   376                                                                      10 ** 18 * 10000000)
   377      result = client_new_node.delegate.delegate(0, address1)
   378      log.info(result)
   379      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   380      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   381  
   382      if status == 0:
   383          result = client_new_node.delegate.delegate(0, address1)
   384          log.info(result)
   385          msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address1, client_new_node.node.node_id)
   386          log.info(msg)
   387          assert msg["Ret"]["ReleasedHes"] == client_new_node.economic.delegate_limit * 2
   388  
   389      if status == 1:
   390          client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   391          result = client_new_node.delegate.delegate(0, address1)
   392          log.info(result)
   393          msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address1, client_new_node.node.node_id)
   394          log.info(msg)
   395          assert msg["Ret"]["ReleasedHes"] == client_new_node.economic.delegate_limit
   396          assert msg["Ret"]["Released"] == client_new_node.economic.delegate_limit
   397  
   398      if status == 2:
   399          client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   400          result = client_new_node.delegate.delegate(0, address1)
   401          log.info(result)
   402          result = client_new_node.delegate.delegate(0, address1)
   403          log.info(result)
   404          msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address1, client_new_node.node.node_id)
   405          log.info(msg)
   406          assert msg["Ret"]["ReleasedHes"] == client_new_node.economic.delegate_limit * 2
   407          assert msg["Ret"]["Released"] == client_new_node.economic.delegate_limit
   408  
   409  
   410  @allure.title("uncommitted")
   411  @pytest.mark.P2
   412  def test_DI_025(client_new_node):
   413      """
   414      :param client_new_node_obj:
   415      :return:
   416      """
   417      address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   418                                                                              10 ** 18 * 10000000)
   419  
   420      result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate)
   421      log.info(result)
   422      assert_code(result, 301203)
   423  
   424  
   425  @allure.title("The entrusted candidate is valid")
   426  @pytest.mark.P2
   427  def test_DI_026(client_new_node):
   428      """
   429      :param client_new_node_obj:
   430      :return:
   431      """
   432      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   433                                                                     10 ** 18 * 10000000)
   434      address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   435                                                                              10 ** 18 * 10000000)
   436      result = client_new_node.staking.create_staking(0, address, address)
   437      assert_code(result, 0)
   438  
   439      result = client_new_node.delegate.delegate(0, address_delegate)
   440      assert_code(result, 0)
   441  
   442      result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate)
   443      log.info(result)
   444      assert result["Code"] == 0
   445      assert client_new_node.node.web3.toChecksumAddress(result["Ret"][0]["Addr"]) == address_delegate
   446      assert result["Ret"][0]["NodeId"] == client_new_node.node.node_id
   447  
   448  
   449  @allure.title("The entrusted candidate does not exist")
   450  @pytest.mark.P2
   451  def test_DI_027(client_new_node):
   452      """
   453      The entrusted candidate does not exist
   454      :param client_new_node_obj:
   455      :return:
   456      """
   457      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   458                                                                     10 ** 18 * 10000000)
   459      address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   460                                                                              10 ** 18 * 10000000)
   461      illegal_nodeID = "7ee3276fd6b9c7864eb896310b5393324b6db785a2528c00cc28ca8c" \
   462                       "3f86fc229a86f138b1f1c8e3a942204c03faeb40e3b22ab11b8983c35dc025de42865990"
   463  
   464      result = client_new_node.delegate.delegate(0, address_delegate, node_id=illegal_nodeID)
   465      log.info(result)
   466      result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate)
   467      log.info(result)
   468      assert_code(result, 301203)
   469  
   470  
   471  @allure.title("The entrusted candidate is invalid")
   472  @pytest.mark.P2
   473  def test_DI_028(client_new_node):
   474      """
   475      The entrusted candidate is invalid
   476      """
   477      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   478                                                                     10 ** 18 * 10000000)
   479      address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   480                                                                              10 ** 18 * 10000000)
   481      result = client_new_node.staking.create_staking(0, address, address)
   482      assert_code(result, 0)
   483  
   484      result = client_new_node.delegate.delegate(0, address_delegate)
   485      assert_code(result, 0)
   486  
   487      # Exit the pledge
   488      result = client_new_node.staking.withdrew_staking(address)
   489      assert_code(result, 0)
   490      result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate)
   491      assert result["Code"] == 0
   492      assert client_new_node.node.web3.toChecksumAddress(result["Ret"][0]["Addr"]) == address_delegate
   493      assert result["Ret"][0]["NodeId"] == client_new_node.node.node_id
   494  
   495  
   496  @allure.title("Delegate information in the hesitation period, lock period")
   497  @pytest.mark.P2
   498  def test_DI_029_030(client_new_node):
   499      """
   500      029:Hesitation period inquiry entrustment details
   501      030:Lock periodic query information
   502      """
   503      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   504                                                                     10 ** 18 * 10000000)
   505      address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   506                                                                              10 ** 18 * 10000000)
   507  
   508      client_new_node.staking.create_staking(0, address, address)
   509      result = client_new_node.delegate.delegate(0, address_delegate)
   510      assert_code(result, 0)
   511  
   512      # Hesitation period inquiry entrustment details
   513      result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate)
   514      log.info(result)
   515      log.info("The next cycle")
   516      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   517      result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate)
   518      assert result["Code"] == 0
   519      assert client_new_node.node.web3.toChecksumAddress(result["Ret"][0]["Addr"]) == address_delegate
   520      assert result["Ret"][0]["NodeId"] == client_new_node.node.node_id
   521  
   522  
   523  @allure.title("The delegate message no longer exists")
   524  @pytest.mark.P2
   525  def test_DI_031(client_new_node):
   526      """
   527      The delegate message no longer exists
   528      """
   529      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   530                                                                     10 ** 18 * 10000000)
   531      address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   532                                                                              10 ** 18 * 10000000)
   533  
   534      client_new_node.staking.create_staking(0, address, address)
   535      result = client_new_node.delegate.delegate(0, address_delegate)
   536      assert_code(result, 0)
   537  
   538      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   539      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   540  
   541      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate)
   542      assert_code(result, 0)
   543      result = client_new_node.ppos.getDelegateInfo(staking_blocknum, address_delegate,
   544                                                    client_new_node.node.node_id)
   545      log.info(result)
   546      assert_code(result, 301205)
   547  
   548  
   549  @allure.title("The commission information is still in the hesitation period & The delegate information is still locked")
   550  @pytest.mark.P2
   551  def test_DI_032_033(client_new_node):
   552      """
   553      032:The commission information is still in the hesitation period
   554      033The delegate information is still locked
   555      """
   556      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   557                                                                     10 ** 18 * 10000000)
   558      address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   559                                                                              10 ** 18 * 10000000)
   560  
   561      client_new_node.staking.create_staking(0, address, address)
   562      result = client_new_node.delegate.delegate(0, address_delegate)
   563      assert_code(result, 0)
   564  
   565      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   566      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   567  
   568      # Hesitation period inquiry entrustment details
   569      result = client_new_node.ppos.getDelegateInfo(staking_blocknum, address_delegate,
   570                                                    client_new_node.node.node_id)
   571      log.info(result)
   572      assert client_new_node.node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate
   573      assert result["Ret"]["NodeId"] == client_new_node.node.node_id
   574      log.info("The next cycle")
   575      client_new_node.economic.wait_consensus_blocknum(client_new_node.node)
   576      result = client_new_node.ppos.getDelegateInfo(staking_blocknum, address_delegate,
   577                                                    client_new_node.node.node_id)
   578      log.info(result)
   579      assert client_new_node.node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate
   580      assert result["Ret"]["NodeId"] == client_new_node.node.node_id
   581  
   582  
   583  @allure.title("The entrusted candidate has withdrawn of his own accord")
   584  @pytest.mark.P2
   585  def test_DI_034(client_new_node):
   586      """
   587      The entrusted candidate has withdrawn of his own accord
   588      """
   589      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   590                                                                     10 ** 18 * 10000000)
   591      address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   592                                                                              10 ** 18 * 10000000)
   593  
   594      client_new_node.staking.create_staking(0, address, address)
   595      result = client_new_node.delegate.delegate(0, address_delegate)
   596      assert_code(result, 0)
   597  
   598      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   599      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   600  
   601      # Exit the pledge
   602      result = client_new_node.staking.withdrew_staking(address)
   603      assert_code(result, 0)
   604  
   605      result = client_new_node.ppos.getDelegateInfo(staking_blocknum, address_delegate,
   606                                                    client_new_node.node.node_id)
   607      log.info(result)
   608      assert client_new_node.node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate
   609      assert result["Ret"]["NodeId"] == client_new_node.node.node_id
   610  
   611  
   612  @allure.title("Entrusted candidate (penalized in lockup period, penalized out completely)")
   613  @pytest.mark.P2
   614  def test_DI_035_036(clients_new_node, client_consensus):
   615      """
   616      The entrusted candidate is still penalized in the lockup period
   617      The entrusted candidate was penalized to withdraw completely
   618  
   619      """
   620      client = clients_new_node[0]
   621      node = client.node
   622      other_node = client_consensus.node
   623      economic = client.economic
   624      address, _ = economic.account.generate_account(node.web3,10 ** 18 * 10000000)
   625  
   626      address_delegate, _ = economic.account.generate_account(node.web3,10 ** 18 * 10000000)
   627  
   628      value = economic.create_staking_limit * 2
   629      result = client.staking.create_staking(0, address, address)
   630      assert_code(result, 0)
   631      result = client.delegate.delegate(0, address_delegate)
   632      assert_code(result, 0)
   633      ##The validation node becomes the out-block validation node
   634      economic.wait_consensus_blocknum(other_node, number=4)
   635      validator_list = get_pledge_list(other_node.ppos.getValidatorList)
   636      assert node.node_id in validator_list
   637      candidate_info = other_node.ppos.getCandidateInfo(node.node_id)
   638      log.info(candidate_info)
   639      staking_blocknum = candidate_info["Ret"]["StakingBlockNum"]
   640  
   641      log.info("Close one node")
   642      node.stop()
   643      for i in range(4):
   644          economic.wait_consensus_blocknum(other_node, number=i)
   645          candidate_info = other_node.ppos.getCandidateInfo(node.node_id)
   646          log.info(candidate_info)
   647          if candidate_info["Ret"]["Released"] < value:
   648              break
   649  
   650      result = other_node.ppos.getDelegateInfo(staking_blocknum, address_delegate,
   651                                         node.node_id)
   652      log.info(result)
   653      assert other_node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate
   654      assert result["Ret"]["NodeId"] == node.node_id
   655      log.info("Restart the node")
   656      node.start()
   657      log.info("Next settlement period")
   658      economic.wait_settlement_blocknum(other_node,number=2)
   659  
   660      result = other_node.ppos.getDelegateInfo(staking_blocknum, address_delegate,
   661                                         node.node_id)
   662      log.info(result)
   663      assert other_node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate
   664      assert result["Ret"]["NodeId"] == node.node_id
   665  
   666  
   667  @allure.title("Query for delegate information in undo")
   668  @pytest.mark.P2
   669  def test_DI_038(client_new_node):
   670      """
   671      Query for delegate information in undo
   672      :param client_new_node_obj:
   673      :return:
   674      """
   675      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   676                                                                     10 ** 18 * 10000000)
   677      address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   678                                                                              10 ** 18 * 10000000)
   679  
   680      client_new_node.staking.create_staking(0, address, address)
   681      result = client_new_node.delegate.delegate(0, address_delegate)
   682      assert_code(result, 0)
   683  
   684      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   685      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   686  
   687      log.info("The next cycle")
   688      client_new_node.economic.wait_consensus_blocknum(client_new_node.node)
   689  
   690      # Exit the pledge
   691      result = client_new_node.staking.withdrew_staking(address)
   692      assert_code(result, 0)
   693  
   694      result = client_new_node.ppos.getDelegateInfo(staking_blocknum, address_delegate,
   695                                                    client_new_node.node.node_id)
   696      log.info(result)
   697      assert client_new_node.node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate
   698      assert result["Ret"]["NodeId"] == client_new_node.node.node_id