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

     1  # -*- coding: utf-8 -*-
     2  from tests.lib.utils import *
     3  import pytest
     4  
     5  
     6  # Undo delegate use cases from 031 to 049
     7  
     8  
     9  @pytest.mark.P2
    10  def test_ROE_031(staking_delegate_client):
    11      """
    12      :param client_new_node:
    13      :return:
    14      """
    15      client = staking_delegate_client
    16      delegate_address = client.delegate_address
    17      node = client.node
    18      economic = client.economic
    19      # Return a pledge
    20      client.staking.withdrew_staking(client.staking_address)
    21      # The next cycle
    22      client.economic.wait_settlement_blocknum(node)
    23      result = client.delegate.delegate(0, delegate_address)
    24      log.info(result)
    25      # The next two cycle
    26      client.economic.wait_settlement_blocknum(node, number=2)
    27      balance1 = client.node.eth.getBalance(delegate_address)
    28      log.info("The wallet balance:{}".format(balance1))
    29  
    30      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address)
    31      assert_code(result, 0)
    32      balance2 = client.node.eth.getBalance(delegate_address)
    33      log.info("The wallet balance:{}".format(balance2))
    34      delegate_limit = economic.delegate_limit
    35      assert delegate_limit - (balance2 - balance1) < node.web3.toWei(1, "ether")
    36  
    37  
    38  @pytest.mark.P2
    39  def test_ROE_032_035(staking_delegate_client):
    40      client = staking_delegate_client
    41      delegate_address = client.delegate_address
    42      node = client.node
    43      economic = client.economic
    44      log.info("The next cycle")
    45      economic.wait_settlement_blocknum(node)
    46      result = client.delegate.delegate(0, delegate_address, amount=client.delegate_amount * 2)
    47      assert_code(result, 0)
    48      balance1 = node.eth.getBalance(delegate_address)
    49      log.info("Wallet balance{}".format(balance1))
    50      amount = client.delegate_amount * 2 + node.web3.toWei(1, "ether")
    51      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address,
    52                                                 amount=amount)
    53      assert_code(result, 0)
    54      balance2 = node.eth.getBalance(delegate_address)
    55      log.info("Wallet balance{}".format(balance2))
    56      assert amount - (balance2 - balance1) < node.web3.toWei(1, "ether")
    57  
    58  
    59  @pytest.mark.P2
    60  def test_ROE_033_034(staking_delegate_client):
    61      client = staking_delegate_client
    62      delegate_address = client.delegate_address
    63      node = client.node
    64      economic = client.economic
    65      log.info("The next cycle")
    66      economic.wait_settlement_blocknum(node)
    67      result = client.delegate.delegate(0, delegate_address)
    68      assert_code(result, 0)
    69      balance1 = node.eth.getBalance(delegate_address)
    70      log.info("Wallet balance{}".format(balance1))
    71      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address)
    72      assert_code(result, 0)
    73      balance2 = node.eth.getBalance(delegate_address)
    74      log.info("Wallet balance{}".format(balance2))
    75      assert client.delegate_amount - (balance2 - balance1) < node.web3.toWei(1, "ether")
    76  
    77  
    78  @pytest.mark.P2
    79  def test_ROE_038(staking_delegate_client):
    80      client = staking_delegate_client
    81      delegate_address = client.delegate_address
    82      node = client.node
    83      economic = client.economic
    84      log.info("The next cycle")
    85      economic.wait_settlement_blocknum(node)
    86      lockup_amount = client.node.web3.toWei(20, "ether")
    87      plan = [{'Epoch': 1, 'Amount': lockup_amount}]
    88      # Create a lock plan
    89      result = client.restricting.createRestrictingPlan(delegate_address, plan, delegate_address)
    90      assert_code(result, 0)
    91      result = client.delegate.delegate(1, delegate_address)
    92      assert_code(result, 0)
    93      result = client.delegate.delegate(0, delegate_address)
    94      assert_code(result, 0)
    95      balance1 = node.eth.getBalance(delegate_address)
    96      log.info("Wallet balance{}".format(balance1))
    97      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address)
    98      assert_code(result, 0)
    99      balance2 = node.eth.getBalance(delegate_address)
   100      log.info("Wallet balance{}".format(balance2))
   101      msg = client.ppos.getRestrictingInfo(delegate_address)
   102      log.info(msg)
   103      delegate_limit = client.delegate_amount
   104      assert delegate_limit - (balance2 - balance1) < node.web3.toWei(1, "ether")
   105      assert msg["Ret"]["Pledge"] == delegate_limit
   106  
   107  
   108  @pytest.mark.P2
   109  def test_ROE_039(staking_delegate_client):
   110      client = staking_delegate_client
   111      delegate_address = client.delegate_address
   112      node = client.node
   113      economic = client.economic
   114      log.info("The next cycle")
   115      economic.wait_settlement_blocknum(node)
   116      lockup_amount = client.node.web3.toWei(20, "ether")
   117      plan = [{'Epoch': 1, 'Amount': lockup_amount}]
   118      # Create a lock plan
   119      result = client.restricting.createRestrictingPlan(delegate_address, plan, delegate_address)
   120      assert_code(result, 0)
   121      result = client.delegate.delegate(1, delegate_address, amount=client.delegate_amount * 2)
   122      assert_code(result, 0)
   123      result = client.delegate.delegate(0, delegate_address)
   124      assert_code(result, 0)
   125      msg = client.ppos.getDelegateInfo(client.staking_blocknum, delegate_address, node.node_id)
   126      log.info(msg)
   127      balance1 = node.eth.getBalance(delegate_address)
   128      log.info("Wallet balance{}".format(balance1))
   129      amount = client.delegate_amount * 2
   130      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address,
   131                                                 amount=amount)
   132      assert_code(result, 0)
   133      balance2 = node.eth.getBalance(delegate_address)
   134      log.info("Wallet balance{}".format(balance2))
   135      msg = client.ppos.getRestrictingInfo(delegate_address)
   136      log.info(msg)
   137      assert client.delegate_amount - (balance2 - balance1) < node.web3.toWei(1, "ether")
   138      assert msg["Ret"]["Pledge"] == client.delegate_amount
   139  
   140  
   141  @pytest.mark.P2
   142  def test_ROE_040(free_locked_delegate_client):
   143      client = free_locked_delegate_client
   144      delegate_address = client.delegate_address
   145      node = client.node
   146      balance1 = node.eth.getBalance(delegate_address)
   147      log.info("Wallet balance{}".format(balance1))
   148      amount = client.delegate_amount * 2 + client.node.web3.toWei(1, "ether")
   149      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address,
   150                                                 amount=amount)
   151      assert_code(result, 0)
   152      balance2 = node.eth.getBalance(delegate_address)
   153      log.info("Wallet balance{}".format(balance2))
   154      assert client.delegate_amount * 2 - (balance2 - balance1) < node.web3.toWei(1, "ether")
   155      msg = client.ppos.getRestrictingInfo(delegate_address)
   156      log.info(msg)
   157      assert msg["Ret"]["Pledge"] == 0
   158  
   159  
   160  @pytest.mark.P2
   161  def test_ROE_041(free_locked_delegate_client):
   162      client = free_locked_delegate_client
   163      delegate_address = client.delegate_address
   164      node = client.node
   165      balance1 = node.eth.getBalance(delegate_address)
   166      log.info("Wallet balance{}".format(balance1))
   167      amount = client.delegate_amount * 3
   168      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address,
   169                                                 amount=amount)
   170      assert_code(result, 0)
   171      balance2 = node.eth.getBalance(delegate_address)
   172      log.info("Wallet balance{}".format(balance2))
   173      msg = client.ppos.getRestrictingInfo(delegate_address)
   174      log.info(msg)
   175      assert client.delegate_amount * 2 - (balance2 - balance1) < node.web3.toWei(1, "ether")
   176  
   177  
   178  @pytest.mark.P2
   179  def test_ROE_042(free_locked_delegate_client):
   180      client = free_locked_delegate_client
   181      delegate_address = client.delegate_address
   182      node = client.node
   183      economic = client.economic
   184      log.info("The next cycle")
   185      economic.wait_settlement_blocknum(node)
   186      result = client.delegate.delegate(0, delegate_address)
   187      assert_code(result, 0)
   188      balance1 = node.eth.getBalance(delegate_address)
   189      log.info("Wallet balance{}".format(balance1))
   190      amount = client.delegate_amount * 3 + node.web3.toWei(5, "ether")
   191      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address,
   192                                                 amount=amount)
   193      assert_code(result, 0)
   194      balance2 = node.eth.getBalance(delegate_address)
   195      log.info("Wallet balance{}".format(balance2))
   196      msg = client.ppos.getRestrictingInfo(delegate_address)
   197      log.info(msg)
   198      assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether")
   199      assert msg["Ret"]["Pledge"] == 0
   200  
   201  
   202  @pytest.mark.P2
   203  def test_ROE_043(free_locked_delegate_client):
   204      client = free_locked_delegate_client
   205      delegate_address = client.delegate_address
   206      node = client.node
   207      economic = client.economic
   208      log.info("The next cycle")
   209      economic.wait_settlement_blocknum(node)
   210      result = client.delegate.delegate(0, delegate_address)
   211      assert_code(result, 0)
   212      result = client.delegate.delegate(1, delegate_address)
   213      assert_code(result, 0)
   214      balance1 = node.eth.getBalance(delegate_address)
   215      log.info("Wallet balance{}".format(balance1))
   216      amount = client.delegate_amount * 4
   217      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address,
   218                                                 amount=amount)
   219      assert_code(result, 0)
   220      balance2 = node.eth.getBalance(delegate_address)
   221      log.info("Wallet balance{}".format(balance2))
   222      msg = client.ppos.getRestrictingInfo(delegate_address)
   223      log.info(msg)
   224      assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether")
   225      assert msg["Ret"]["Pledge"] == client.delegate_amount
   226  
   227  
   228  @pytest.mark.P2
   229  def test_ROE_044(free_locked_delegate_client):
   230      client = free_locked_delegate_client
   231      delegate_address = client.delegate_address
   232      node = client.node
   233      economic = client.economic
   234      log.info("The next cycle")
   235      economic.wait_settlement_blocknum(node)
   236      result = client.delegate.delegate(0, delegate_address)
   237      assert_code(result, 0)
   238      result = client.delegate.delegate(1, delegate_address)
   239      assert_code(result, 0)
   240      balance1 = node.eth.getBalance(delegate_address)
   241      log.info("Wallet balance{}".format(balance1))
   242      amount = client.delegate_amount * 4 + node.web3.toWei(5, "ether")
   243      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address,
   244                                                 amount=amount)
   245      assert_code(result, 0)
   246      balance2 = node.eth.getBalance(delegate_address)
   247      log.info("Wallet balance{}".format(balance2))
   248      msg = client.ppos.getRestrictingInfo(delegate_address)
   249      log.info(msg)
   250      log.info("Wallet balance{}".format(balance2))
   251      assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether")
   252      assert msg["Ret"]["Pledge"] == 0
   253  
   254  
   255  @pytest.mark.P2
   256  def test_ROE_045(staking_delegate_client):
   257      client = staking_delegate_client
   258      delegate_address = client.delegate_address
   259      node = client.node
   260      economic = client.economic
   261      log.info("The next cycle")
   262      economic.wait_settlement_blocknum(node)
   263      result = client.delegate.delegate(0, delegate_address)
   264      assert_code(result, 0)
   265      balance1 = node.eth.getBalance(delegate_address)
   266      log.info("Wallet balance{}".format(balance1))
   267      amount = client.delegate_amount * 3 - node.web3.toWei(1, "ether")
   268      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address,
   269                                                 amount=amount)
   270      assert_code(result, 0)
   271      balance2 = node.eth.getBalance(delegate_address)
   272      log.info("Wallet balance{}".format(balance2))
   273      assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether")
   274  
   275  
   276  @pytest.mark.P2
   277  def test_ROE_048(staking_delegate_client):
   278      client = staking_delegate_client
   279      delegate_address = client.delegate_address
   280      node = client.node
   281      economic = client.economic
   282      log.info("The next cycle")
   283      economic.wait_settlement_blocknum(node)
   284      result = client.delegate.delegate(0, delegate_address)
   285      assert_code(result, 0)
   286      balance1 = node.eth.getBalance(delegate_address)
   287      log.info("Wallet balance{}".format(balance1))
   288      amount = client.delegate_amount * 3 - node.web3.toWei(1, "ether")
   289      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address,
   290                                                 amount=amount)
   291      assert_code(result, 0)
   292      balance2 = node.eth.getBalance(delegate_address)
   293      log.info("Wallet balance{}".format(balance2))
   294      msg = client.ppos.getRestrictingInfo(delegate_address)
   295      log.info(msg)
   296      assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether")
   297  
   298  
   299  @pytest.mark.P2
   300  def test_ROE_049(staking_delegate_client):
   301      client = staking_delegate_client
   302      delegate_address = client.delegate_address
   303      node = client.node
   304      economic = client.economic
   305      log.info("The next cycle")
   306      economic.wait_settlement_blocknum(node)
   307      lockup_amount = client.node.web3.toWei(20, "ether")
   308      plan = [{'Epoch': 1, 'Amount': lockup_amount}]
   309      # Create a lock plan
   310      result = client.restricting.createRestrictingPlan(delegate_address, plan, delegate_address)
   311      assert_code(result, 0)
   312      result = client.delegate.delegate(1, delegate_address)
   313      assert_code(result, 0)
   314      result = client.delegate.delegate(0, delegate_address)
   315      assert_code(result, 0)
   316      balance1 = node.eth.getBalance(delegate_address)
   317      log.info("Wallet balance{}".format(balance1))
   318      amount = client.delegate_amount * 4
   319      result = client.delegate.withdrew_delegate(client.staking_blocknum, delegate_address,
   320                                                 amount=amount)
   321      assert_code(result, 0)
   322      balance2 = node.eth.getBalance(delegate_address)
   323      log.info("Wallet balance{}".format(balance2))
   324      msg = client.ppos.getRestrictingInfo(delegate_address)
   325      log.info(msg)
   326      assert client.delegate_amount * 3 - (balance2 - balance1) < node.web3.toWei(1, "ether")
   327      assert msg["Ret"]["Pledge"] == 0