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

     1  import pytest
     2  from common.log import log
     3  import time
     4  import math
     5  from tests.lib.client import get_client_by_nodeid, get_clients_by_nodeid, Client
     6  from tests.conftest import get_clients
     7  from tests.lib.utils import get_pledge_list, upload_platon, wait_block_number, assert_code, get_governable_parameter_value
     8  from typing import List
     9  from tests.lib import Pip
    10  
    11  
    12  def get_refund_to_account_block(pip, blocknumber=None):
    13      '''
    14      Get refund to account block
    15      :param pip:
    16      :return:
    17      '''
    18      if blocknumber is None:
    19          blocknumber = pip.node.block_number
    20      return math.ceil(blocknumber / pip.economic.settlement_size + pip.economic.unstaking_freeze_ratio
    21                       ) * pip.economic.settlement_size
    22  
    23  
    24  def version_proposal_vote(pip, vote_option=None):
    25      proposalinfo = pip.get_effect_proposal_info_of_vote()
    26      log.info('Version proposalinfo: {}'.format(proposalinfo))
    27      if not proposalinfo:
    28          raise Exception('there is no voting version proposal')
    29      if proposalinfo.get('NewVersion') == pip.cfg.version5:
    30          upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN)
    31          log.info('Replace the node {} version to {}'.format(pip.node.node_id, pip.cfg.version5))
    32      elif proposalinfo.get('NewVersion') == pip.cfg.version8:
    33          upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN8)
    34          log.info('Replace the node {} version to {}'.format(pip.node.node_id, pip.cfg.version8))
    35      elif proposalinfo.get('NewVersion') == pip.cfg.version9:
    36          upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN9)
    37          log.info('Replace the node {} version to {}'.format(pip.node.node_id, pip.cfg.version9))
    38      else:
    39          raise Exception('The new version of the proposal is{}'.format(proposalinfo.get('NewVersion')))
    40      pip.node.restart()
    41      log.info('Restart the node {}'.format(pip.node.node_id))
    42      if not vote_option:
    43          vote_option = pip.cfg.vote_option_yeas
    44      result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), vote_option,
    45                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
    46      log.info('The node {} vote result {}'.format(pip.node.node_id, result))
    47      return result
    48  
    49  
    50  def proposal_vote(pip, vote_option=None, proposaltype=3):
    51      if vote_option is None:
    52          vote_option = pip.cfg.vote_option_yeas
    53      proposalinfo = pip.get_effect_proposal_info_of_vote(proposaltype)
    54      log.info('proposalinfo: {}'.format(proposalinfo))
    55      result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), vote_option,
    56                        pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
    57      log.info('Node {} vote param proposal result {}'.format(pip.node.node_id, result))
    58      return result
    59  
    60  
    61  def verifier_node_version(obj, version=None):
    62      if not isinstance(obj, Client):
    63          obj = get_client_by_nodeid(obj.node.node_id, get_clients(obj.economic.env))
    64      node_version = obj.staking.get_version()
    65      log.info('Node {} version is {}'.format(obj.node.node_id, node_version))
    66      if version is None:
    67          return node_version
    68      else:
    69          assert_code(node_version, version)
    70  
    71  
    72  @pytest.fixture()
    73  def no_vp_proposal(global_test_env, client_verifier):
    74      pip = client_verifier.pip
    75      if pip.is_exist_effective_proposal() or pip.chain_version != pip.cfg.version0 \
    76              or pip.is_exist_effective_proposal_for_vote(pip.cfg.param_proposal):
    77          log.info('There is effective proposal,restart the chain')
    78          global_test_env.deploy_all()
    79      return pip
    80  
    81  
    82  @pytest.fixture()
    83  def submit_version(no_vp_proposal):
    84      pip = no_vp_proposal
    85      result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 10,
    86                                 pip.node.staking_address,
    87                                 transaction_cfg=pip.cfg.transaction_cfg)
    88      log.info('submit version result : {}'.format(result))
    89      assert_code(result, 0)
    90      return pip
    91  
    92  
    93  @pytest.fixture()
    94  def submit_param(no_vp_proposal, all_clients):
    95      pip = no_vp_proposal
    96      client = get_client_by_nodeid(pip.node.node_id, all_clients)
    97      newvalue = '1'
    98      if int(get_governable_parameter_value(client, 'slashBlocksReward')) == 1:
    99          newvalue = '2'
   100      result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', newvalue,
   101                               pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   102      log.info('submit param proposal result : {}'.format(result))
   103      assert_code(result, 0)
   104      return pip
   105  
   106  
   107  @pytest.fixture()
   108  def submit_cancel(submit_version):
   109      pip = submit_version
   110      propolsalinfo = pip.get_effect_proposal_info_of_vote()
   111      log.info('get voting version proposal info :{}'.format(propolsalinfo))
   112      result = pip.submitCancel(pip.node.node_id, str(time.time()), 2, propolsalinfo.get('ProposalID'),
   113                                pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   114      log.info('submit cancel proposal result : {}'.format(result))
   115      assert_code(result, 0)
   116      return pip
   117  
   118  
   119  @pytest.fixture()
   120  def submit_cancel_param(submit_param):
   121      pip = submit_param
   122      propolsalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
   123      log.info('Get voting param proposal info :{}'.format(propolsalinfo))
   124      result = pip.submitCancel(pip.node.node_id, str(time.time()), 2, propolsalinfo.get('ProposalID'),
   125                                pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   126      log.info('submit cancel proposal result : {}'.format(result))
   127      assert_code(result, 0)
   128      return pip
   129  
   130  
   131  @pytest.fixture()
   132  def submit_text(client_verifier):
   133      pip = client_verifier.pip
   134      result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address,
   135                              transaction_cfg=pip.cfg.transaction_cfg)
   136      log.info('submit text result:'.format(result))
   137      assert_code(result, 0)
   138      return pip
   139  
   140  
   141  @pytest.fixture()
   142  def new_node_has_proposal(client_new_node, client_verifier, client_noconsensus):
   143      pip = client_verifier.pip
   144      if pip.chain_version != pip.cfg.version0 or pip.is_exist_effective_proposal(pip.cfg.param_proposal):
   145          client_new_node.economic.env.deploy_all()
   146      if pip.is_exist_effective_proposal():
   147          proposalinfo = pip.get_effect_proposal_info_of_vote()
   148          log.info('Get version proposal information {}'.format(proposalinfo))
   149          if proposalinfo.get('EndVotingBlock') - pip.node.block_number < 2 * pip.economic.consensus_size:
   150              client_new_node.economic.env.deploy_all()
   151              result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 5,
   152                                         pip.node.staking_address,
   153                                         transaction_cfg=pip.cfg.transaction_cfg)
   154              assert_code(result, 0)
   155              return client_noconsensus.pip
   156          else:
   157              return client_new_node.pip
   158      result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 5,
   159                                 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   160      assert_code(result, 0)
   161      return client_new_node.pip
   162  
   163  
   164  @pytest.fixture()
   165  def candidate_has_proposal(clients_noconsensus, all_clients):
   166      clients_noconsensus[0].economic.env.deploy_all()
   167      for client in clients_noconsensus:
   168          address, _ = client.economic.account.generate_account(client.node.web3, 10 ** 18 * 10000000)
   169          log.info('Node {} staking'.format(client.node.node_id))
   170          result = client.staking.create_staking(0, address, address)
   171          log.info('Node {} staking result: {}'.format(client.node.node_id, result))
   172          assert_code(result, 0)
   173      client.economic.wait_settlement_blocknum(client.node)
   174      node_id_list = client.pip.get_candidate_list_not_verifier()
   175      if not node_id_list:
   176          raise Exception('Get candidate list')
   177      verifiers = get_pledge_list(client.ppos.getVerifierList)
   178      log.info('Verifier list : {}'.format(verifiers))
   179      pip = get_client_by_nodeid(verifiers[0], all_clients).pip
   180      result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 5,
   181                                 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   182      log.info('Submit version proposal result : {}'.format(result))
   183      assert_code(result, 0)
   184      return get_client_by_nodeid(node_id_list[0], all_clients).pip
   185  
   186  
   187  @pytest.fixture()
   188  def noproposal_pips(all_clients) -> List[Pip]:
   189      '''
   190      Get candidate Client object list
   191      :param global_test_env:
   192      :return:
   193      '''
   194      if all_clients[0].pip.is_exist_effective_proposal() or all_clients[0].pip.chain_version != \
   195              all_clients[0].pip.cfg.version0:
   196          log.info('There is effective proposal, Restart the chain')
   197          all_clients[0].economic.env.deploy_all()
   198      verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList)
   199      log.info('verifierlist{}'.format(verifier_list))
   200      clients = get_clients_by_nodeid(verifier_list, all_clients)
   201      return [client.pip for client in clients]
   202  
   203  
   204  @pytest.fixture()
   205  def noproposal_candidate_pips(all_clients) -> List[Pip]:
   206      '''
   207      Get verifier Client object list
   208      :param global_test_env:
   209      :return:
   210      '''
   211      if all_clients[0].pip.is_exist_effective_proposal() or all_clients[0].pip.chain_version != \
   212              all_clients[0].pip.cfg.version0:
   213          log.info('There is effective proposal, Restart the chain')
   214          all_clients[0].economic.env.deploy_all()
   215      nodeid_list = all_clients[0].pip.get_candidate_list_not_verifier()
   216      log.info('candidate not verifier list {}'.format(nodeid_list))
   217      if not nodeid_list:
   218          candidate_list = get_pledge_list(all_clients[0].ppos.getCandidateList)
   219          log.info('candidate_list{}'.format(candidate_list))
   220          for client in all_clients:
   221              if client.node.node_id not in candidate_list:
   222                  address, _ = client.economic.account.generate_account(client.node.web3, 10**18 * 10000000)
   223                  result = client.staking.create_staking(0, address, address)
   224                  log.info('node {} staking result {}'.format(client.node.node_id, result))
   225          client.economic.wait_settlement_blocknum(client.node)
   226          nodeid_list = all_clients[0].pip.get_candidate_list_not_verifier()
   227          if not nodeid_list:
   228              raise Exception('get candidate not verifier failed')
   229      clients_candidate = get_clients_by_nodeid(nodeid_list, all_clients)
   230      return [client_candidate.pip for client_candidate in clients_candidate]
   231  
   232  
   233  @pytest.fixture()
   234  def proposal_pips(all_clients):
   235      '''
   236      get verifier Client object list
   237      :param global_test_env:
   238      :return:
   239      '''
   240      verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList)
   241      pip = get_client_by_nodeid(verifier_list[0], all_clients).pip
   242      if pip.chain_version != pip.cfg.version0:
   243          pip.economic.env.deploy_all()
   244      if pip.is_exist_effective_proposal():
   245          proposalinfo = pip.get_effect_proposal_info_of_vote()
   246          log.info('proprosalinfo : {}'.format(proposalinfo))
   247          if proposalinfo.get('EndVotingBlock') - pip.node.block_number > 2 * pip.economic.consensus_size \
   248                  and proposalinfo.get('NewVersion') == pip.cfg.version5:
   249              verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList)
   250              log.info('verifierlist{}'.format(verifier_list))
   251              clients_verifier = get_clients_by_nodeid(verifier_list, all_clients)
   252              return [client.pip for client in clients_verifier]
   253          else:
   254              pip.economic.env.deploy_all()
   255      result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 10,
   256                                 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
   257      log.info('version proposal result :{}'.format(result))
   258      verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList)
   259      log.info('verifierlist{}'.format(verifier_list))
   260      clients_verifier = get_clients_by_nodeid(verifier_list, all_clients)
   261      return [client.pip for client in clients_verifier]
   262  
   263  
   264  @pytest.fixture()
   265  def preactive_proposal_pips(all_clients):
   266      if all_clients[0].pip.is_exist_effective_proposal() or all_clients[0].pip.chain_version != \
   267              all_clients[0].pip.cfg.version0 or all_clients[0].pip.is_exist_effective_proposal_for_vote(
   268          all_clients[0].pip.cfg.param_proposal
   269      ):
   270          log.info('There is effective version proposal, restart the chain')
   271          all_clients[0].economic.env.deploy_all()
   272      verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList)
   273      log.info('verifierlist :{}'.format(verifier_list))
   274      client_verifiers = get_clients_by_nodeid(verifier_list, all_clients)
   275      pips = [client_verifier.pip for client_verifier in client_verifiers]
   276      result = pips[0].submitVersion(pips[0].node.node_id, str(time.time()),
   277                                     pips[0].cfg.version5, 2, pips[0].node.staking_address,
   278                                     transaction_cfg=pips[0].cfg.transaction_cfg)
   279      log.info('submit version proposal, result : {}'.format(result))
   280      proposalinfo = pips[0].get_effect_proposal_info_of_vote()
   281      log.info('Version proposalinfo: {}'.format(proposalinfo))
   282      for pip in pips:
   283          result = version_proposal_vote(pip)
   284          assert_code(result, 0)
   285      wait_block_number(pip.node, proposalinfo.get('EndVotingBlock'))
   286      assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 4
   287      return pips
   288  
   289  
   290  @pytest.fixture()
   291  def preactive_large_version_proposal_pips(all_clients):
   292      if all_clients[0].pip.is_exist_effective_proposal() or all_clients[0].pip.chain_version != \
   293              all_clients[0].pip.cfg.version0:
   294          log.info('There is effective version proposal, restart the chain')
   295          all_clients[0].economic.env.deploy_all()
   296      verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList)
   297      log.info('verifierlist :{}'.format(verifier_list))
   298      client_verifiers = get_clients_by_nodeid(verifier_list, all_clients)
   299      pips = [client.pip for client in client_verifiers]
   300      result = pips[0].submitVersion(pips[0].node.node_id, str(time.time()),
   301                                     pips[0].cfg.version8, 2, pips[0].node.staking_address,
   302                                     transaction_cfg=pips[0].cfg.transaction_cfg)
   303      log.info('submit version proposal, result : {}'.format(result))
   304      proposalinfo = pips[0].get_effect_proposal_info_of_vote()
   305      log.info('Version proposalinfo: {}'.format(proposalinfo))
   306      for pip in pips:
   307          result = version_proposal_vote(pip)
   308          assert_code(result, 0)
   309      wait_block_number(pip.node, proposalinfo.get('EndVotingBlock'))
   310      assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 4
   311      return pips