[tests] sync_with_ping should assert that ping hasn't timed out

sync_with_ping currently returns false if the timeout expires, and it is
the caller's responsibility to fail the test. However, none of the tests
currently assert on sync_with_ping()'s return code. This commit adds an
assert to sync_with_ping so the test will fail if the timeout expires.

This commit also removes all the duplicate implementations of
sync_with_ping() from the individual tests.

Author: jnewbery

test/functional/assumevalid.py

@@ -190,7 +190,8 @@ def run_test(self):
         # Send all blocks to node1. All blocks will be accepted.
         for i in range(2202):
             node1.send_message(msg_block(self.blocks[i]))
-        node1.sync_with_ping()  # make sure the most recent block is synced
+        # Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
+        node1.sync_with_ping(120)
         assert_equal(self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'], 2202)
 
         # Send blocks to node2. Block 102 will be rejected.

test/functional/maxuploadtarget.py

@@ -68,15 +68,6 @@ def on_pong(self, conn, message):
     def on_close(self, conn):
         self.peer_disconnected = True
 
-    # Sync up with the node after delivery of a block
-    def sync_with_ping(self, timeout=30):
-        def received_pong():
-            return (self.last_pong.nonce == self.ping_counter)
-        self.connection.send_message(msg_ping(nonce=self.ping_counter))
-        success = wait_until(received_pong, timeout=timeout)
-        self.ping_counter += 1
-        return success
-
 class MaxUploadTest(BitcoinTestFramework):
 
     def __init__(self):

test/functional/p2p-acceptblock.py

@@ -88,21 +88,6 @@ def send_message(self, message):
     def on_pong(self, conn, message):
         self.last_pong = message
 
-    # Sync up with the node after delivery of a block
-    def sync_with_ping(self, timeout=30):
-        self.connection.send_message(msg_ping(nonce=self.ping_counter))
-        received_pong = False
-        sleep_time = 0.05
-        while not received_pong and timeout > 0:
-            time.sleep(sleep_time)
-            timeout -= sleep_time
-            with mininode_lock:
-                if self.last_pong.nonce == self.ping_counter:
-                    received_pong = True
-        self.ping_counter += 1
-        return received_pong
-
-
 class AcceptBlockTest(BitcoinTestFramework):
     def add_options(self, parser):
         parser.add_option("--testbinary", dest="testbinary",

test/functional/p2p-mempool.py

@@ -62,15 +62,6 @@ def on_pong(self, conn, message):
     def on_close(self, conn):
         self.peer_disconnected = True
 
-    # Sync up with the node after delivery of a block
-    def sync_with_ping(self, timeout=30):
-        def received_pong():
-            return (self.last_pong.nonce == self.ping_counter)
-        self.connection.send_message(msg_ping(nonce=self.ping_counter))
-        success = wait_until(received_pong, timeout=timeout)
-        self.ping_counter += 1
-        return success
-
     def send_mempool(self):
         self.lastInv = []
         self.send_message(msg_mempool())

test/functional/p2p-segwit.py

@@ -80,13 +80,6 @@ def sync(self, test_function, timeout=60):
             timeout -= self.sleep_time
         raise AssertionError("Sync failed to complete")
 
-    def sync_with_ping(self, timeout=60):
-        self.send_message(msg_ping(nonce=self.ping_counter))
-        test_function = lambda: self.last_pong.nonce == self.ping_counter
-        self.sync(test_function, timeout)
-        self.ping_counter += 1
-        return
-
     def wait_for_block(self, blockhash, timeout=60):
         test_function = lambda: self.last_block != None and self.last_block.sha256 == blockhash
         self.sync(test_function, timeout)
@@ -148,7 +141,7 @@ def test_transaction_acceptance(self, tx, with_witness, accepted, reason=None):
         if with_witness:
             tx_message = msg_witness_tx(tx)
         self.send_message(tx_message)
-        self.sync_with_ping()
+        self.sync_with_ping(60)
         assert_equal(tx.hash in self.connection.rpc.getrawmempool(), accepted)
         if (reason != None and not accepted):
             # Check the rejection reason as well.
@@ -161,7 +154,7 @@ def test_witness_block(self, block, accepted, with_witness=True):
             self.send_message(msg_witness_block(block))
         else:
             self.send_message(msg_block(block))
-        self.sync_with_ping()
+        self.sync_with_ping(60)
         assert_equal(self.connection.rpc.getbestblockhash() == block.hash, accepted)
 
 
@@ -235,7 +228,7 @@ def test_non_witness_transaction(self):
         block = self.build_next_block(nVersion=1)
         block.solve()
         self.test_node.send_message(msg_block(block))
-        self.test_node.sync_with_ping() # make sure the block was processed
+        self.test_node.sync_with_ping(60) # make sure the block was processed
         txid = block.vtx[0].sha256
 
         self.nodes[0].generate(99) # let the block mature
@@ -251,7 +244,7 @@ def test_non_witness_transaction(self):
         assert_equal(msg_tx(tx).serialize(), msg_witness_tx(tx).serialize())
 
         self.test_node.send_message(msg_witness_tx(tx))
-        self.test_node.sync_with_ping() # make sure the tx was processed
+        self.test_node.sync_with_ping(60) # make sure the tx was processed
         assert(tx.hash in self.nodes[0].getrawmempool())
         # Save this transaction for later
         self.utxo.append(UTXO(tx.sha256, 0, 49*100000000))
@@ -291,7 +284,7 @@ def test_unnecessary_witness_before_segwit_activation(self):
         # But it should not be permanently marked bad...
         # Resend without witness information.
         self.test_node.send_message(msg_block(block))
-        self.test_node.sync_with_ping()
+        self.test_node.sync_with_ping(60)
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
         sync_blocks(self.nodes)
@@ -1257,7 +1250,7 @@ def test_segwit_versions(self):
         # Spending a higher version witness output is not allowed by policy,
         # even with fRequireStandard=false.
         self.test_node.test_transaction_acceptance(tx3, with_witness=True, accepted=False)
-        self.test_node.sync_with_ping()
+        self.test_node.sync_with_ping(60)
         with mininode_lock:
             assert(b"reserved for soft-fork upgrades" in self.test_node.last_reject.reason)
 
@@ -1387,7 +1380,7 @@ def test_signature_version_1(self):
         for i in range(NUM_TESTS):
             # Ping regularly to keep the connection alive
             if (not i % 100):
-                self.test_node.sync_with_ping()
+                self.test_node.sync_with_ping(60)
             # Choose random number of inputs to use.
             num_inputs = random.randint(1, 10)
             # Create a slight bias for producing more utxos

test/functional/p2p-versionbits-warning.py

@@ -46,21 +46,6 @@ def send_message(self, message):
     def on_pong(self, conn, message):
         self.last_pong = message
 
-    # Sync up with the node after delivery of a block
-    def sync_with_ping(self, timeout=30):
-        self.connection.send_message(msg_ping(nonce=self.ping_counter))
-        received_pong = False
-        sleep_time = 0.05
-        while not received_pong and timeout > 0:
-            time.sleep(sleep_time)
-            timeout -= sleep_time
-            with mininode_lock:
-                if self.last_pong.nonce == self.ping_counter:
-                    received_pong = True
-        self.ping_counter += 1
-        return received_pong
-
-
 class VersionBitsWarningTest(BitcoinTestFramework):
     def __init__(self):
         super().__init__()

test/functional/test_framework/mininode.py

@@ -1563,11 +1563,14 @@ def send_and_ping(self, message):
         self.sync_with_ping()
 
     # Sync up with the node
-    def sync_with_ping(self, timeout=30):
+    def sync_with_ping(self, timeout=60):
         def received_pong():
             return (self.last_pong.nonce == self.ping_counter)
         self.send_message(msg_ping(nonce=self.ping_counter))
         success = wait_until(received_pong, timeout=timeout)
+        if not success:
+            logger.error("sync_with_ping failed!")
+            raise AssertionError("sync_with_ping failed!")
         self.ping_counter += 1
 
         return success