refactor(test): platform_{http,p2p}_port > addrs_platform_{https,p2p}

We also update the type annotations to reflect the three different types
of valid input (port, single address, array of addresses).

Author: kwvg

test/functional/rpc_netinfo.py

@@ -61,17 +61,17 @@ def is_mn_visible(self, _protx_hash = None) -> bool:
                 mn_visible = True
         return mn_visible
 
-    def register_mn(self, test: BitcoinTestFramework, submit: bool, addrs_core_p2p, addrs_platform_p2p = None, addrs_platform_http = None, code = None, msg = None) -> str:
+    def register_mn(self, test: BitcoinTestFramework, submit: bool, addrs_core_p2p, addrs_platform_p2p = None, addrs_platform_https = None, code = None, msg = None) -> str:
         assert self.mn.nodeIdx is not None
 
-        if self.mn.evo and (not addrs_platform_http or not addrs_platform_p2p):
-            raise AssertionError("EvoNode but platformP2PAddrs and platformHTTPSAddrs not specified")
+        if self.mn.evo and (not addrs_platform_https or not addrs_platform_p2p):
+            raise AssertionError("EvoNode but addrs_platform_p2p and addrs_platform_https not specified")
 
         # Evonode-specific fields are ignored if regular masternode
         self.platform_nodeid = hash160(b'%d' % randint(1, 65535)).hex()
         protx_output = self.mn.register(self.node, submit=submit, coreP2PAddrs=addrs_core_p2p, operator_reward=0,
-                                        platform_node_id=self.platform_nodeid, platform_p2p_port=addrs_platform_p2p,
-                                        platform_http_port=addrs_platform_http, expected_assert_code=code, expected_assert_msg=msg)
+                                        platform_node_id=self.platform_nodeid, addrs_platform_p2p=addrs_platform_p2p,
+                                        addrs_platform_https=addrs_platform_https, expected_assert_code=code, expected_assert_msg=msg)
 
         # If we expected error, make sure the transaction didn't succeed
         if code and msg:
@@ -93,15 +93,15 @@ def register_mn(self, test: BitcoinTestFramework, submit: bool, addrs_core_p2p,
         test.restart_node(self.mn.nodeIdx, extra_args=self.node.extra_args + [f'-masternodeblsprivkey={self.mn.keyOperator}'])
         return self.mn.proTxHash
 
-    def update_mn(self, test: BitcoinTestFramework, addrs_core_p2p, addrs_platform_p2p = None, addrs_platform_http = None) -> str:
+    def update_mn(self, test: BitcoinTestFramework, addrs_core_p2p, addrs_platform_p2p = None, addrs_platform_https = None) -> str:
         assert self.mn.nodeIdx is not None
 
-        if self.mn.evo and (not addrs_platform_http or not addrs_platform_p2p):
-            raise AssertionError("EvoNode but platformP2PAddrs and platformHTTPSAddrs not specified")
+        if self.mn.evo and (not addrs_platform_https or not addrs_platform_p2p):
+            raise AssertionError("EvoNode but addrs_platform_p2p and addrs_platform_https not specified")
 
         # Evonode-specific fields are ignored if regular masternode
         protx_output = self.mn.update_service(self.node, submit=True, coreP2PAddrs=addrs_core_p2p, platform_node_id=self.platform_nodeid,
-                                              platform_p2p_port=addrs_platform_p2p, platform_http_port=addrs_platform_http)
+                                              addrs_platform_p2p=addrs_platform_p2p, addrs_platform_https=addrs_platform_https)
         assert protx_output is not None
 
         self.mn.bury_tx(test, self.mn.nodeIdx, protx_output, 1)

test/functional/test_framework/test_framework.py

@@ -1221,21 +1221,22 @@ def get_node(self, test: BitcoinTestFramework) -> TestNode:
         return test.nodes[self.nodeIdx]
 
     def register(self, node: TestNode, submit: bool, collateral_txid: Optional[str] = None, collateral_vout: Optional[int] = None,
-                 coreP2PAddrs: Union[str, List[str], None] = None, ownerAddr: Optional[str] = None, pubKeyOperator: Optional[str] = None, votingAddr: Optional[str] = None,
-                 operator_reward: Optional[int] = None, rewards_address: Optional[str] = None, fundsAddr: Optional[str] = None,
-                 platform_node_id: Optional[str] = None, platform_p2p_port: Optional[int] = None, platform_http_port: Optional[int] = None,
-                 expected_assert_code: Optional[int] = None, expected_assert_msg: Optional[str] = None) -> Optional[str]:
+                 coreP2PAddrs: Union[str, List[str], None] = None, ownerAddr: Optional[str] = None, pubKeyOperator: Optional[str] = None,
+                 votingAddr: Optional[str] = None, operator_reward: Optional[int] = None, rewards_address: Optional[str] = None,
+                 fundsAddr: Optional[str] = None, platform_node_id: Optional[str] = None, addrs_platform_p2p: Union[int, str, List[str], None] = None,
+                 addrs_platform_https: Union[int, str, List[str], None] = None, expected_assert_code: Optional[int] = None,
+                 expected_assert_msg: Optional[str] = None) -> Optional[str]:
         if (expected_assert_code and not expected_assert_msg) or (not expected_assert_code and expected_assert_msg):
             raise AssertionError("Intending to use assert_raises_rpc_error() but didn't specify code and message")
 
         # EvoNode-specific fields are ignored for regular masternodes
         if self.evo:
             if platform_node_id is None:
                 raise AssertionError("EvoNode but platform_node_id is missing, must be specified!")
-            if platform_p2p_port is None:
-                raise AssertionError("EvoNode but platform_p2p_port is missing, must be specified!")
-            if platform_http_port is None:
-                raise AssertionError("EvoNode but platform_http_port is missing, must be specified!")
+            if addrs_platform_p2p is None:
+                raise AssertionError("EvoNode but addrs_platform_p2p is missing, must be specified!")
+            if addrs_platform_https is None:
+                raise AssertionError("EvoNode but addrs_platform_https is missing, must be specified!")
 
         # Common arguments shared between regular masternodes and EvoNodes
         args = [
@@ -1261,7 +1262,7 @@ def register(self, node: TestNode, submit: bool, collateral_txid: Optional[str]
         # Construct final command and arguments
         if self.evo:
             command = "register_evo"
-            args = args + [platform_node_id, platform_p2p_port, platform_http_port, address_funds, submit] # type: ignore
+            args = args + [platform_node_id, addrs_platform_p2p, addrs_platform_https, address_funds, submit] # type: ignore
         else:
             command = "register_legacy" if self.legacy else "register"
             args = args + [address_funds, submit] # type: ignore
@@ -1279,19 +1280,20 @@ def register(self, node: TestNode, submit: bool, collateral_txid: Optional[str]
     def register_fund(self, node: TestNode, submit: bool, collateral_address: Optional[str] = None, coreP2PAddrs: Union[str, List[str], None] = None,
                       ownerAddr: Optional[str] = None, pubKeyOperator: Optional[str] = None, votingAddr: Optional[str] = None,
                       operator_reward: Optional[int] = None, rewards_address: Optional[str] = None, fundsAddr: Optional[str] = None,
-                      platform_node_id: Optional[str] = None, platform_p2p_port: Optional[int] = None, platform_http_port: Optional[int] = None,
-                      expected_assert_code: Optional[int] = None, expected_assert_msg: Optional[str] = None) -> Optional[str]:
+                      platform_node_id: Optional[str] = None, addrs_platform_p2p: Union[int, str, List[str], None] = None,
+                      addrs_platform_https: Union[int, str, List[str], None] = None, expected_assert_code: Optional[int] = None,
+                      expected_assert_msg: Optional[str] = None) -> Optional[str]:
         if (expected_assert_code and not expected_assert_msg) or (not expected_assert_code and expected_assert_msg):
             raise AssertionError("Intending to use assert_raises_rpc_error() but didn't specify code and message")
 
         # EvoNode-specific fields are ignored for regular masternodes
         if self.evo:
             if platform_node_id is None:
                 raise AssertionError("EvoNode but platform_node_id is missing, must be specified!")
-            if platform_p2p_port is None:
-                raise AssertionError("EvoNode but platform_p2p_port is missing, must be specified!")
-            if platform_http_port is None:
-                raise AssertionError("EvoNode but platform_http_port is missing, must be specified!")
+            if addrs_platform_p2p is None:
+                raise AssertionError("EvoNode but addrs_platform_p2p is missing, must be specified!")
+            if addrs_platform_https is None:
+                raise AssertionError("EvoNode but addrs_platform_https is missing, must be specified!")
 
         # Use assert_raises_rpc_error if we expect to error out
         use_assert: bool = bool(expected_assert_code and expected_assert_msg)
@@ -1316,7 +1318,7 @@ def register_fund(self, node: TestNode, submit: bool, collateral_address: Option
         # Construct final command and arguments
         if self.evo:
             command = "register_fund_evo"
-            args = args + [platform_node_id, platform_p2p_port, platform_http_port, address_funds, submit] # type: ignore
+            args = args + [platform_node_id, addrs_platform_p2p, addrs_platform_https, address_funds, submit] # type: ignore
         else:
             command = "register_fund_legacy" if self.legacy else "register_fund"
             args = args + [address_funds, submit] # type: ignore
@@ -1415,9 +1417,10 @@ def update_registrar(self, node: TestNode, submit: bool, pubKeyOperator: Optiona
 
         return ret
 
-    def update_service(self, node: TestNode, submit: bool, coreP2PAddrs: Union[str, List[str], None] = None, platform_node_id: Optional[str] = None, platform_p2p_port: Optional[int] = None,
-                       platform_http_port: Optional[int] = None, address_operator: Optional[str] = None, fundsAddr: Optional[str] = None,
-                       expected_assert_code: Optional[int] = None, expected_assert_msg: Optional[str] = None) -> Optional[str]:
+    def update_service(self, node: TestNode, submit: bool, coreP2PAddrs: Union[str, List[str], None] = None, platform_node_id: Optional[str] = None,
+                       addrs_platform_p2p: Union[int, str, List[str], None] = None, addrs_platform_https: Union[int, str, List[str], None] = None,
+                       address_operator: Optional[str] = None, fundsAddr: Optional[str] = None, expected_assert_code: Optional[int] = None,
+                       expected_assert_msg: Optional[str] = None) -> Optional[str]:
         if (expected_assert_code and not expected_assert_msg) or (not expected_assert_code and expected_assert_msg):
             raise AssertionError("Intending to use assert_raises_rpc_error() but didn't specify code and message")
 
@@ -1431,10 +1434,10 @@ def update_service(self, node: TestNode, submit: bool, coreP2PAddrs: Union[str,
         if self.evo:
             if platform_node_id is None:
                 raise AssertionError("EvoNode but platform_node_id is missing, must be specified!")
-            if platform_p2p_port is None:
-                raise AssertionError("EvoNode but platform_p2p_port is missing, must be specified!")
-            if platform_http_port is None:
-                raise AssertionError("EvoNode but platform_http_port is missing, must be specified!")
+            if addrs_platform_p2p is None:
+                raise AssertionError("EvoNode but addrs_platform_p2p is missing, must be specified!")
+            if addrs_platform_https is None:
+                raise AssertionError("EvoNode but addrs_platform_https is missing, must be specified!")
 
         # Use assert_raises_rpc_error if we expect to error out
         use_assert: bool = bool(expected_assert_code and expected_assert_msg)
@@ -1456,7 +1459,7 @@ def update_service(self, node: TestNode, submit: bool, coreP2PAddrs: Union[str,
         # Construct final command and arguments
         if self.evo:
             command = "update_service_evo"
-            args = args + [platform_node_id, platform_p2p_port, platform_http_port, address_operator, address_funds, submit] # type: ignore
+            args = args + [platform_node_id, addrs_platform_p2p, addrs_platform_https, address_operator, address_funds, submit] # type: ignore
         else:
             command = "update_service"
             args = args + [address_operator, address_funds, submit] # type: ignore
@@ -1641,8 +1644,8 @@ def dynamically_prepare_masternode(self, idx, node_p2p_port, evo=False, rnd=None
         mn.generate_addresses(self.nodes[0])
 
         platform_node_id = hash160(b'%d' % rnd).hex() if rnd is not None else hash160(b'%d' % node_p2p_port).hex()
-        platform_p2p_port = node_p2p_port + 101
-        platform_http_port = node_p2p_port + 102
+        addrs_platform_p2p = node_p2p_port + 101
+        addrs_platform_https = node_p2p_port + 102
 
         outputs = {mn.collateral_address: mn.get_collateral_value(), mn.fundsAddr: 1}
         collateral_txid = self.nodes[0].sendmany("", outputs)
@@ -1653,9 +1656,9 @@ def dynamically_prepare_masternode(self, idx, node_p2p_port, evo=False, rnd=None
         coreP2PAddrs = ['127.0.0.1:%d' % node_p2p_port]
         operatorReward = idx
 
-        # platform_node_id, platform_p2p_port and platform_http_port are ignored for regular masternodes
+        # platform_node_id, addrs_platform_p2p and addrs_platform_https are ignored for regular masternodes
         protx_result = mn.register(self.nodes[0], submit=True, collateral_txid=collateral_txid, collateral_vout=collateral_vout, coreP2PAddrs=coreP2PAddrs, operator_reward=operatorReward,
-                                   platform_node_id=platform_node_id, platform_p2p_port=platform_p2p_port, platform_http_port=platform_http_port)
+                                   platform_node_id=platform_node_id, addrs_platform_p2p=addrs_platform_p2p, addrs_platform_https=addrs_platform_https)
         assert protx_result is not None
 
         self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
@@ -1675,20 +1678,20 @@ def dynamically_evo_update_service(self, evo_info: MasternodeInfo, rnd=None, sho
         # For the sake of the test, generate random nodeid, p2p and http platform values
         r = rnd if rnd is not None else random.randint(21000, 65000)
         platform_node_id = hash160(b'%d' % r).hex()
-        platform_p2p_port = r + 1
-        platform_http_port = r + 2
+        addrs_platform_p2p = r + 1
+        addrs_platform_https = r + 2
 
         fund_txid = self.nodes[0].sendtoaddress(funds_address, 1)
         self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
         evo_info.bury_tx(self, genIdx=0, txid=fund_txid, depth=1)
 
         protx_success = False
         try:
-            protx_result = evo_info.update_service(self.nodes[0], True, f'127.0.0.1:{evo_info.nodePort}', platform_node_id, platform_p2p_port, platform_http_port, operator_reward_address, funds_address)
+            protx_result = evo_info.update_service(self.nodes[0], True, f'127.0.0.1:{evo_info.nodePort}', platform_node_id, addrs_platform_p2p, addrs_platform_https, operator_reward_address, funds_address)
             assert protx_result is not None
             self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
             evo_info.bury_tx(self, genIdx=0, txid=protx_result, depth=1)
-            self.log.info("Updated EvoNode %s: platformNodeID=%s, platformP2PPort=%s, platformHTTPPort=%s" % (evo_info.proTxHash, platform_node_id, platform_p2p_port, platform_http_port))
+            self.log.info("Updated EvoNode %s: platformNodeID=%s, platformP2PPort=%s, platformHTTPPort=%s" % (evo_info.proTxHash, platform_node_id, addrs_platform_p2p, addrs_platform_https))
             protx_success = True
         except:
             self.log.info("protx_evo rejected")