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

     1  from decimal import Decimal
     2  import pytest
     3  from tests.lib.utils import assert_code
     4  
     5  
     6  def calculate(big_int, mul):
     7      return int(Decimal(str(big_int)) * Decimal(mul))
     8  
     9  
    10  @pytest.fixture()
    11  def create_staking_client(client_new_node):
    12      amount = calculate(client_new_node.economic.create_staking_limit, 5)
    13      staking_amount = calculate(client_new_node.economic.create_staking_limit, 2)
    14      staking_address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, amount)
    15      delegate_address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    16                                                                              client_new_node.economic.add_staking_limit * 2)
    17      client_new_node.staking.create_staking(0, staking_address, staking_address, amount=staking_amount)
    18      setattr(client_new_node, "staking_address", staking_address)
    19      setattr(client_new_node, "delegate_address", delegate_address)
    20      setattr(client_new_node, "amount", amount)
    21      setattr(client_new_node, "staking_amount", staking_amount)
    22      yield client_new_node
    23  
    24  
    25  @pytest.fixture()
    26  def staking_delegate_client(client_new_node):
    27      staking_amount = client_new_node.economic.create_staking_limit
    28      delegate_amount = client_new_node.economic.add_staking_limit
    29      staking_address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    30                                                                             staking_amount * 2)
    31      delegate_address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    32                                                                              staking_amount * 2)
    33      result = client_new_node.staking.create_staking(0, staking_address, staking_address)
    34      assert_code(result, 0)
    35      result = client_new_node.delegate.delegate(0, delegate_address, amount=delegate_amount * 2)
    36      assert_code(result, 0)
    37      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
    38      staking_blocknum = msg["Ret"]["StakingBlockNum"]
    39      setattr(client_new_node, "staking_address", staking_address)
    40      setattr(client_new_node, "delegate_address", delegate_address)
    41      setattr(client_new_node, "delegate_amount", delegate_amount)
    42      setattr(client_new_node, "staking_blocknum", staking_blocknum)
    43      yield client_new_node
    44  
    45  
    46  @pytest.fixture()
    47  def free_locked_delegate_client(client_new_node):
    48      staking_amount = client_new_node.economic.create_staking_limit
    49      delegate_amount = client_new_node.economic.add_staking_limit
    50      staking_address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    51                                                                             staking_amount * 2)
    52      delegate_address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    53                                                                              staking_amount * 2)
    54      result = client_new_node.staking.create_staking(0, staking_address, staking_address)
    55      assert_code(result, 0)
    56      result = client_new_node.delegate.delegate(0, delegate_address, amount=delegate_amount * 2)
    57      assert_code(result, 0)
    58  
    59      lockup_amount = client_new_node.node.web3.toWei(50, "ether")
    60      plan = [{'Epoch': 2, 'Amount': lockup_amount}]
    61      # Create a lock plan
    62      result = client_new_node.restricting.createRestrictingPlan(delegate_address, plan, delegate_address)
    63      assert_code(result, 0)
    64      result = client_new_node.delegate.delegate(1, delegate_address)
    65      assert_code(result, 0)
    66      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
    67      staking_blocknum = msg["Ret"]["StakingBlockNum"]
    68      setattr(client_new_node, "staking_address", staking_address)
    69      setattr(client_new_node, "delegate_address", delegate_address)
    70      setattr(client_new_node, "delegate_amount", delegate_amount)
    71      setattr(client_new_node, "staking_blocknum", staking_blocknum)
    72      yield client_new_node
    73  
    74  
    75  def check_receipt(node, hash, key, expected_result):
    76      result = node.eth.waitForTransactionReceipt(hash)
    77      if result["logs"] and key in result["logs"][0]:
    78          value = result["logs"][0][key]
    79          assert value == expected_result, "Value contrast error"
    80      else:
    81          assert result[key] == expected_result, "Value contrast error"
    82  
    83