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

     1  import os
     2  import pytest
     3  import json
     4  import allure
     5  from common.log import log
     6  from concurrent.futures import ThreadPoolExecutor, wait, ALL_COMPLETED
     7  from common.load_file import LoadFile
     8  from common.connect import run_ssh_cmd
     9  
    10  
    11  def one_put_config_task(node):
    12      try:
    13          node.put_config()
    14      except Exception as e:
    15          return False, "{} upload config file failed:{}".format(node.node_mark, e)
    16      return True, "{} upload config file success".format(node.node_mark)
    17  
    18  
    19  def one_put_static_task(node):
    20      try:
    21          node.put_static()
    22      except Exception as e:
    23          return False, "{} upload static file failed:{}".format(node.node_mark, e)
    24      return True, "{} upload static file success".format(node.node_mark)
    25  
    26  
    27  def one_put_genesis_task(node, genesis_file):
    28      try:
    29          node.put_genesis(genesis_file)
    30      except Exception as e:
    31          return False, "{} upload genesis file failed:{}".format(node.node_mark, e)
    32      return True, "{} upload genesis file success".format(node.node_mark)
    33  
    34  
    35  @pytest.fixture(scope="module", autouse=True)
    36  def reset_config(global_test_env):
    37      yield
    38      config_data = LoadFile(global_test_env.cfg.config_json_tmp).get_data()
    39      with open(global_test_env.cfg.config_json_tmp, 'w', encoding='utf-8') as f:
    40          f.write(json.dumps(config_data, indent=4))
    41      global_test_env.deploy_all()
    42  
    43  
    44  @allure.title("Node maximum link quantity test")
    45  @pytest.mark.P1
    46  def test_NE_P2P_001(global_test_env):
    47      log.info("Node maximum link quantity test")
    48      all_node = global_test_env.get_all_nodes()
    49  
    50      # stop node
    51      if global_test_env.running:
    52          global_test_env.stop_all()
    53  
    54      # modify config file
    55      config_data = LoadFile(global_test_env.cfg.config_json_tmp).get_data()
    56      config_data['node']['P2P']['MaxPeers'] = 2
    57      with open(global_test_env.cfg.config_json_tmp, 'w', encoding='utf-8') as f:
    58          f.write(json.dumps(config_data, indent=4))
    59  
    60      # upload config file
    61      global_test_env.executor(one_put_config_task, all_node)
    62  
    63      # start node
    64      global_test_env.cfg.init_chain = False
    65      global_test_env.start_all()
    66  
    67      # run ssh
    68      static_number = len(global_test_env.get_static_nodes())
    69      for node in all_node:
    70          cmd_list = run_ssh_cmd(node.ssh, "netstat -an | grep 16789 | grep ESTABLISHED |wc -l")
    71          assert int(cmd_list[0][0]) <= 2 + static_number
    72  
    73  
    74  @allure.title("Automatic discovery configuration test")
    75  @pytest.mark.P1
    76  def test_NE_P2P_002(global_test_env):
    77      log.info("Automatic discovery configuration test")
    78      all_node = global_test_env.get_all_nodes()
    79  
    80      # stop node
    81      if global_test_env.running:
    82          global_test_env.stop_all()
    83  
    84      # modify config file
    85      config_data = LoadFile(global_test_env.cfg.config_json_tmp).get_data()
    86      config_data['node']['P2P']['NoDiscovery'] = True
    87      with open(global_test_env.cfg.config_json_tmp, 'w', encoding='utf-8') as f:
    88          f.write(json.dumps(config_data, indent=4))
    89      all_node = global_test_env.get_all_nodes()
    90  
    91      # upload config file
    92      global_test_env.executor(one_put_config_task, all_node)
    93  
    94      # start node
    95      global_test_env.cfg.init_chain = False
    96      global_test_env.start_all()
    97  
    98      # run ssh
    99      for node in all_node:
   100          cmd_list = run_ssh_cmd(node.ssh, "netstat -unlp | grep 16789 |wc -l")
   101          assert 0 == int(cmd_list[0][0])
   102  
   103  
   104  @allure.title("Static node configuration test")
   105  @pytest.mark.P1
   106  def test_NE_P2P_003(global_test_env):
   107      log.info("Static node configuration test")
   108      all_node = global_test_env.get_all_nodes()
   109  
   110      # stop node
   111      if global_test_env.running:
   112          global_test_env.stop_all()
   113  
   114      # modify config file
   115      config_data = LoadFile(global_test_env.cfg.config_json_tmp).get_data()
   116      config_data['node']['P2P']['MaxPeers'] = 50
   117      config_data['node']['P2P']['NoDiscovery'] = True
   118      config_data['node']['P2P']["BootstrapNodes"] = []
   119      with open(global_test_env.cfg.config_json_tmp, 'w', encoding='utf-8') as f:
   120          f.write(json.dumps(config_data, indent=4))
   121      all_node = global_test_env.get_all_nodes()
   122  
   123      # upload config file
   124      global_test_env.executor(one_put_config_task, all_node)
   125  
   126      # start node
   127      global_test_env.cfg.init_chain = False
   128      global_test_env.start_all()
   129  
   130      # run ssh
   131      static_number = len(global_test_env.get_static_nodes())
   132      for node in all_node:
   133          # cmd_list = run_ssh_cmd(node.ssh, "netstat -an | grep 16789 | grep ESTABLISHED |wc -l")
   134          # log.info(node.web3.net.peerCount)
   135          # assert int(cmd_list[0][0]) <= static_number
   136          assert node.web3.net.peerCount <= static_number
   137  
   138  
   139  @allure.title("Exception can not be out of the block test")
   140  @pytest.mark.P1
   141  def test_NE_P2P_004(global_test_env):
   142      log.info("Exception can not be out of the block test")
   143      # stop node
   144      if global_test_env.running:
   145          global_test_env.stop_all()
   146  
   147      # modify config file
   148      config_data = LoadFile(global_test_env.cfg.config_json_tmp).get_data()
   149      config_data['node']['P2P']['MaxPeers'] = 50
   150      config_data['node']['P2P']['NoDiscovery'] = True
   151      config_data['node']['P2P']["BootstrapNodes"] = []
   152      with open(global_test_env.cfg.config_json_tmp, 'w', encoding='utf-8') as f:
   153          f.write(json.dumps(config_data, indent=4))
   154      all_node = global_test_env.get_all_nodes()
   155  
   156      # upload config file
   157      global_test_env.executor(one_put_config_task, all_node)
   158  
   159      # modify static file
   160      with open(global_test_env.cfg.static_node_tmp, 'w', encoding='utf-8') as f:
   161          f.write(json.dumps([], indent=4))
   162  
   163      # upload static file
   164      global_test_env.executor(one_put_static_task, all_node)
   165  
   166      # modify genesis file
   167      global_test_env.genesis_config['config']['cbft']["initialNodes"] = []
   168      with open(global_test_env.cfg.genesis_tmp, 'w', encoding='utf-8') as f:
   169          f.write(json.dumps(global_test_env.genesis_config, indent=4))
   170  
   171      # upload genesis file
   172      global_test_env.executor(one_put_genesis_task, all_node, global_test_env.cfg.genesis_tmp)
   173  
   174      # start node
   175      global_test_env.cfg.init_chain = False
   176      global_test_env.start_all()
   177  
   178      # check
   179      try:
   180          global_test_env.check_block()
   181      except Exception as e:
   182          log.error("check block has except:{}".format(e))
   183          assert 0 == 0