[Tests] Tier2 tests: minor fixes

random-zebra · furszy · commit 48b4514b5640 · 2020-11-05T10:55:09.000-03:00
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
@@ -1110,6 +1110,7 @@ def get_mn_status(self, node, mnTxHash):
         mnData = node.listmasternodes(mnTxHash)
         if len(mnData) == 0:
             return ""
+        assert_equal(len(mnData), 1)
         return mnData[0]["status"]
 
 
@@ -1119,36 +1120,56 @@ def advance_mocktime(self, secs):
         time.sleep(1)
 
 
-    def wait_until_mnsync_finished(self, _timeout):
-        for i in range(self.num_nodes):
-            try:
-                wait_until(lambda: self.nodes[i].mnsync("status")["RequestedMasternodeAssets"] == 999,
-                           timeout=_timeout, mocktime=self.advance_mocktime)
-            except AssertionError:
-                raise AssertionError("Unable to complete mnsync on node %d" % i)
+    def wait_until_mnsync_finished(self):
+        SYNC_FINISHED = [999] * self.num_nodes
+        synced = [-1] * self.num_nodes
+        time.sleep(2)
+        timeout = time.time() + 300
+        while synced != SYNC_FINISHED and time.time() < timeout:
+            for i in range(self.num_nodes):
+                if synced[i] != SYNC_FINISHED[i]:
+                    synced[i] = self.nodes[i].mnsync("status")["RequestedMasternodeAssets"]
+            if synced != SYNC_FINISHED:
+                time.sleep(5)
+        if synced != SYNC_FINISHED:
+            raise AssertionError("Unable to complete mnsync: %s" % str(synced))
 
 
     def wait_until_mn_status(self, status, mnTxHash, _timeout, orEmpty=False, with_ping_mns=[]):
-        def _sendpings():
-            if len(with_ping_mns) == 0:
-                return
-            else:
-                self.send_pings(with_ping_mns)
+        nodes_status = [None] * self.num_nodes
 
-        for i in range(self.num_nodes):
-            try:
-                wait_until(lambda: (self.get_mn_status(self.nodes[i], mnTxHash) == status or
-                                    (orEmpty and self.get_mn_status(self.nodes[i], mnTxHash) == "")),
-                           timeout=_timeout, sendpings=_sendpings, mocktime=self.advance_mocktime)
-            except AssertionError:
-                strErr = "Unable to get status \"%s\" on node %d for mnode %s" % (status, i, mnTxHash)
-                raise AssertionError(strErr)
+        def node_synced(i):
+            return nodes_status[i] == status or (orEmpty and nodes_status[i] == "")
+
+        def all_synced():
+            for i in range(self.num_nodes):
+                if not node_synced(i):
+                    return False
+            return True
+
+        time.sleep(2)
+        timeout = time.time() + _timeout
+        while not all_synced() and time.time() < timeout:
+            for i in range(self.num_nodes):
+                if not node_synced(i):
+                    nodes_status[i] = self.get_mn_status(self.nodes[i], mnTxHash)
+            if not all_synced():
+                time.sleep(2)
+                self.send_pings(with_ping_mns)
+        if not all_synced():
+            strErr = "Unable to get get status \"%s\" on all nodes for mnode %s. Current: %s" % (
+                    status, mnTxHash, str(nodes_status))
+            raise AssertionError(strErr)
 
 
     def wait_until_mn_enabled(self, mnTxHash, _timeout, _with_ping_mns=[]):
         self.wait_until_mn_status("ENABLED", mnTxHash, _timeout, with_ping_mns=_with_ping_mns)
 
 
+    def wait_until_mn_preenabled(self, mnTxHash, _timeout, _with_ping_mns=[]):
+        self.wait_until_mn_status("PRE_ENABLED", mnTxHash, _timeout, with_ping_mns=_with_ping_mns)
+
+
     def wait_until_mn_vinspent(self, mnTxHash, _timeout, _with_ping_mns=[]):
         self.wait_until_mn_status("VIN_SPENT", mnTxHash, _timeout, orEmpty=True, with_ping_mns=_with_ping_mns)
 
@@ -1205,7 +1226,7 @@ def setupMasternode(self,
         assert_equal(mnCollateralOutput["txhash"], collateralTxId)
         mnCollateralOutputIndex = mnCollateralOutput["outputidx"]
 
-        self.log.info("collateral accepted for "+ masternodeAlias +".. updating masternode.conf and stopping the node")
+        self.log.info("collateral accepted for "+ masternodeAlias +". Updating masternode.conf...")
 
         # verify collateral confirmed
         confData = masternodeAlias + " 127.0.0.1:" + str(p2p_port(mnRemotePos)) + " " + str(masternodePrivKey) + " " + str(mnCollateralOutput["txhash"]) + " " + str(mnCollateralOutputIndex)
@@ -1269,7 +1290,6 @@ def set_test_params(self):
                            [],
                            ["-listen", "-externalip=127.0.0.1"],
                            ["-sporkkey=932HEevBSujW2ud7RfB1YF91AFygbBRQj3de3LyaCRqNzKKgWXi"]]
-        self.setup_clean_chain = True
         self.enable_mocktime()
 
         self.ownerOnePos = 0
@@ -1293,6 +1313,7 @@ def set_test_params(self):
         self.mnOneTxHash = ""
         self.mnTwoTxHash = ""
 
+
     def send_3_pings(self):
         self.advance_mocktime(30)
         self.send_pings([self.remoteOne, self.remoteTwo])
@@ -1307,10 +1328,12 @@ def stake(self, num_blocks, with_ping_mns=[]):
     def controller_start_all_masternodes(self):
         self.controller_start_masternode(self.ownerOne, self.masternodeOneAlias)
         self.controller_start_masternode(self.ownerTwo, self.masternodeTwoAlias)
+        self.wait_until_mn_preenabled(self.mnOneTxHash, 40)
+        self.wait_until_mn_preenabled(self.mnTwoTxHash, 40)
         self.log.info("masternodes started, waiting until both get enabled..")
         self.send_3_pings()
-        self.wait_until_mn_enabled(self.mnOneTxHash, 60, [self.remoteOne, self.remoteTwo])
-        self.wait_until_mn_enabled(self.mnTwoTxHash, 60, [self.remoteOne, self.remoteTwo])
+        self.wait_until_mn_enabled(self.mnOneTxHash, 120, [self.remoteOne, self.remoteTwo])
+        self.wait_until_mn_enabled(self.mnTwoTxHash, 120, [self.remoteOne, self.remoteTwo])
         self.log.info("masternodes enabled and running properly!")
 
     def advance_mocktime_and_stake(self, secs_to_add):
@@ -1361,12 +1384,10 @@ def setup_2_masternodes_network(self):
         remoteTwoPort = p2p_port(self.remoteOnePos)
         self.remoteOne.initmasternode(self.mnOnePrivkey, "127.0.0.1:"+str(remoteOnePort))
         self.remoteTwo.initmasternode(self.mnTwoPrivkey, "127.0.0.1:"+str(remoteTwoPort))
-        self.advance_mocktime(3)
 
         # wait until mnsync complete on all nodes
         self.stake(1)
-        time.sleep(20)
-        self.wait_until_mnsync_finished(35)
+        self.wait_until_mnsync_finished()
         self.log.info("tier two synced! starting masternodes..")
 
         # Now everything is set, can start both masternodes
diff --git a/test/functional/tiertwo_masternode_activation.py b/test/functional/tiertwo_masternode_activation.py
@@ -30,19 +30,18 @@ class MasternodeActivationTest(PivxTier2TestFramework):
 
     def disconnect_remotes(self):
         for i in [self.remoteOnePos, self.remoteTwoPos]:
-            disconnect_nodes(self.nodes[i + 1], i)
-            disconnect_nodes(self.nodes[i], i - 1)
+            for j in range(self.num_nodes):
+                if i != j:
+                    disconnect_nodes(self.nodes[i], j)
 
     def reconnect_remotes(self):
-        # !TODO: for some reason we need two-way connections now...
         connect_nodes_clique(self.nodes)
         self.sync_all()
 
     def reconnect_and_restart_masternodes(self):
         self.log.info("Reconnecting nodes and sending start message again...")
         self.reconnect_remotes()
-        time.sleep(2)
-        self.wait_until_mnsync_finished(35)
+        self.wait_until_mnsync_finished()
         self.controller_start_all_masternodes()
 
     def spend_collateral(self):
diff --git a/test/functional/tiertwo_masternode_ping.py b/test/functional/tiertwo_masternode_ping.py
@@ -7,13 +7,9 @@
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
-    connect_nodes_clique,
-    disconnect_nodes,
     Decimal,
     p2p_port,
-    satoshi_round,
     sync_blocks,
-    wait_until,
 )
 
 import os
@@ -49,18 +45,26 @@ def run_test(self):
         masternodeAlias = "mnode"
         mnAddress = owner.getnewaddress(masternodeAlias)
         collateralTxId = miner.sendtoaddress(mnAddress, Decimal('10000'))
-        miner.generate(1)
+        miner.generate(2)
         sync_blocks(self.nodes)
+        time.sleep(1)
+        collateral_rawTx = owner.getrawtransaction(collateralTxId, 1)
         assert_equal(owner.getbalance(), Decimal('10000'))
-        assert_greater_than(owner.getrawtransaction(collateralTxId, 1)["confirmations"], 0)
+        assert_greater_than(collateral_rawTx["confirmations"], 0)
+
+        # Block time can be up to median time past +1. We might need to wait...
+        wait_time = collateral_rawTx["time"] - int(time.time())
+        if wait_time > 0:
+            self.log.info("Sleep %d seconds to catch up with the chain..." % wait_time)
+            time.sleep(wait_time)
 
         # Setup controller
         self.log.info("controller setup...")
         o = owner.getmasternodeoutputs()
         assert_equal(len(o), 1)
         assert_equal(o[0]["txhash"], collateralTxId)
         vout = o[0]["outputidx"]
-        self.log.info("collateral accepted for "+ masternodeAlias +".. updating masternode.conf and stopping the node")
+        self.log.info("collateral accepted for "+ masternodeAlias +". Updating masternode.conf...")
         confData = masternodeAlias + " 127.0.0.1:" + str(p2p_port(2)) + " " + \
                    str(mnPrivkey) +  " " + str(collateralTxId) + " " + str(vout)
         destPath = os.path.join(self.options.tmpdir, "node1", "regtest", "masternode.conf")
@@ -72,18 +76,14 @@ def run_test(self):
         self.log.info("initializing remote masternode...")
         remote.initmasternode(mnPrivkey, "127.0.0.1:" + str(p2p_port(2)))
 
-        # Wait until mnsync is complete (max 30 seconds)
-        self.log.info("waiting complete mnsync...")
-        synced = [False] * 3
-        timeout = time.time() + 30
-        while time.time() < timeout:
-            for i in range(3):
-                if not synced[i]:
-                    synced[i] = (self.nodes[i].mnsync("status")["RequestedMasternodeAssets"] == 999)
-            if synced != [True] * 3:
-                time.sleep(1)
-        if synced != [True] * 3:
-            raise AssertionError("Unable to complete mnsync: %s" % str(synced))
+        # Wait until mnsync is complete (max 120 seconds)
+        self.log.info("waiting to complete mnsync...")
+        start_time = time.time()
+        self.wait_until_mnsync_finished()
+        self.log.info("MnSync completed in %d seconds" % (time.time() - start_time))
+        miner.generate(1)
+        sync_blocks(self.nodes)
+        time.sleep(1)
 
         # Send Start message
         self.log.info("sending masternode broadcast...")
@@ -92,18 +92,12 @@ def run_test(self):
         sync_blocks(self.nodes)
         time.sleep(1)
 
-        # Wait until masternode is enabled anywhere (max 100 secs)
+        # Wait until masternode is enabled everywhere (max 180 secs)
         self.log.info("waiting till masternode gets enabled...")
-        enabled = [""] * 3
-        timeout = time.time() + 100
-        while time.time() < timeout:
-            for i in range(3):
-                if enabled[i] != "ENABLED":
-                    enabled[i] = self.get_mn_status(self.nodes[i], collateralTxId)
-            if enabled != ["ENABLED"] * 3:
-                time.sleep(1)
-        if enabled != ["ENABLED"] * 3:
-            raise AssertionError("Unable to get to \"ENABLED\" state: %s" % str(enabled))
+        start_time = time.time()
+        time.sleep(5)
+        self.wait_until_mn_enabled(collateralTxId, 180)
+        self.log.info("Masternode enabled in %d seconds" % (time.time() - start_time))
         self.log.info("Good. Masternode enabled")
         miner.generate(1)
         sync_blocks(self.nodes)
