test: check pre-fork conditions for ProRegTx and ProUpServTx preparation

Author: kwvg

test/functional/rpc_netinfo.py

@@ -5,7 +5,8 @@
 """Test network information fields across RPCs."""
 
 from test_framework.util import (
-    assert_equal
+    assert_equal,
+    assert_raises_rpc_error
 )
 from test_framework.script import (
     hash160
@@ -95,19 +96,31 @@ 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) -> str:
+    def register_mn(self, test: BitcoinTestFramework, submit: bool, addrs_core_p2p, addrs_platform_p2p = None, addrs_platform_http = None, code = None, msg = None) -> str:
+        assert((code and msg) or (not code and not msg))
         protx_output: str = ""
         if self.is_evo:
             assert(addrs_platform_http and addrs_platform_p2p)
             self.platform_nodeid = hash160(b'%d' % randint(1, 65535)).hex()
-            protx_output = self.node.protx(
-                "register_evo", self.collateral_txid, self.collateral_vout, addrs_core_p2p, self.address_owner, self.operator_pk,
-                self.address_voting, 0, self.address_reward, self.platform_nodeid, addrs_platform_p2p, addrs_platform_http,
-                self.address_funds, submit)
+            if code and msg:
+                assert_raises_rpc_error(
+                    code, msg, self.node.protx, "register_evo", self.collateral_txid, self.collateral_vout, addrs_core_p2p, self.address_owner, self.operator_pk,
+                    self.address_voting, 0, self.address_reward, self.platform_nodeid, addrs_platform_p2p, addrs_platform_http, self.address_funds, submit)
+                return ""
+            else:
+                protx_output = self.node.protx(
+                    "register_evo", self.collateral_txid, self.collateral_vout, addrs_core_p2p, self.address_owner, self.operator_pk,
+                    self.address_voting, 0, self.address_reward, self.platform_nodeid, addrs_platform_p2p, addrs_platform_http, self.address_funds, submit)
         else:
-            protx_output = self.node.protx(
-                "register", self.collateral_txid, self.collateral_vout, addrs_core_p2p, self.address_owner, self.operator_pk,
-                self.address_voting, 0, self.address_reward, self.address_funds, submit)
+            if code and msg:
+                assert_raises_rpc_error(
+                    code, msg, self.node.protx, "register", self.collateral_txid, self.collateral_vout, addrs_core_p2p, self.address_owner, self.operator_pk,
+                    self.address_voting, 0, self.address_reward, self.address_funds, submit)
+                return ""
+            else:
+                protx_output = self.node.protx(
+                    "register", self.collateral_txid, self.collateral_vout, addrs_core_p2p, self.address_owner, self.operator_pk,
+                    self.address_voting, 0, self.address_reward, self.address_funds, submit)
         if not submit:
             return ""
         self.provider_txid = protx_output
@@ -194,6 +207,38 @@ def run_test(self):
 
         self.node_evo.generate_collateral(self)
 
+        self.test_validation()
+        self.test_deprecation()
+
+    def test_validation(self):
+        self.log.info("Test input validation for masternode address fields")
+        # Arrays of addresses are recognized by coreP2PAddrs
+        self.node_evo.register_mn(self, False, [f"127.0.0.1:{self.node_evo.port_p2p}", f"127.0.0.2:9998"], "22200", "22201",
+                                  -8, f"Error setting coreP2PAddrs[1] to '127.0.0.2:9998' (too many entries)")
+
+        # platformP2PPort and platformHTTPPort doesn't accept non-numeric inputs
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.port_p2p}", "127.0.0.1:22200", "22201",
+                                  -8, "platformP2PPort must be a 32bit integer (not '127.0.0.1:22200')")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.port_p2p}", ["127.0.0.1:22200"], "22201",
+                                  -8, "Invalid param for platformP2PPort, must be number")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.port_p2p}", "22200", "127.0.0.1:22201",
+                                  -8, "platformHTTPPort must be a 32bit integer (not '127.0.0.1:22201')")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.port_p2p}", "22200", ["127.0.0.1:22201"],
+                                  -8, "Invalid param for platformHTTPPort, must be number")
+
+        # platformP2PPort and platformHTTPPort must be within acceptable range (i.e. a valid port number)
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.port_p2p}", "0", "22201",
+                                  -8, "platformP2PPort must be a valid port [1-65535]")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.port_p2p}", "65536", "22201",
+                                  -8, "platformP2PPort must be a valid port [1-65535]")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.port_p2p}", "22200", "0",
+                                  -8, "platformHTTPPort must be a valid port [1-65535]")
+        self.node_evo.register_mn(self, False, f"127.0.0.1:{self.node_evo.port_p2p}", "22200", "65536",
+                                  -8, "platformHTTPPort must be a valid port [1-65535]")
+
+    def test_deprecation(self):
+        self.log.info("Test output masternode address fields for consistency")
+
         # netInfo is represented with JSON in CProRegTx, CProUpServTx, CDeterministicMNState and CSimplifiedMNListEntry,
         # so we need to test calls that rely on these underlying implementations. Start by collecting RPC responses.
         self.log.info("Collect JSON RPC responses from node")