Merge #18494: test: replace (send_message + sync_with_ping) with send_and_ping

6112a209828c43930f677c45461339cdf68a56e9 test: replace (send_message + sync_with_ping) with send_and_ping (Jon Atack)

Pull request description:

  This is a follow-up to faf1d047313e71658fb31f6b94fdd5d37705ab85 yesterday.

ACKs for top commit:
  vasild:
    utACK 6112a20
  MarcoFalke:
    ACK 6112a209828c43930f677c45461339cdf68a56e9 🎞

Tree-SHA512: 749644ac9a1ef0e1aa6c3ac5e899eb3fa7fb9c0909352f922a80412df2bc0e539692a7757af550eff4d4914cbe57b0c75ce3948f569acc7a52852e91a55ad457

test/functional/feature_maxuploadtarget.py

@@ -99,8 +99,7 @@ class MaxUploadTest(BitcoinTestFramework):
         # 144MB will be reserved for relaying new blocks, so expect this to
         # succeed for ~70 tries.
         for i in range(success_count):
-            p2p_conns[0].send_message(getdata_request)
+            p2p_conns[0].send_and_ping(getdata_request)
-            p2p_conns[0].sync_with_ping()
             assert_equal(p2p_conns[0].block_receive_map[big_old_block], i+1)
 
         assert_equal(len(self.nodes[0].getpeerinfo()), 3)
@@ -117,7 +116,7 @@ class MaxUploadTest(BitcoinTestFramework):
         # We'll try 200 times
         getdata_request.inv = [CInv(MSG_BLOCK, big_new_block)]
         for i in range(200):
-            p2p_conns[1].send_message(getdata_request)
+            p2p_conns[1].send_and_ping(getdata_request)
             p2p_conns[1].sync_with_ping()
             assert_equal(p2p_conns[1].block_receive_map[big_new_block], i+1)
 
@@ -137,8 +136,7 @@ class MaxUploadTest(BitcoinTestFramework):
         # and p2p_conns[2] should be able to retrieve the old block.
         self.nodes[0].setmocktime(current_mocktime)
         p2p_conns[2].sync_with_ping()
-        p2p_conns[2].send_message(getdata_request)
+        p2p_conns[2].send_and_ping(getdata_request)
-        p2p_conns[2].sync_with_ping()
         assert_equal(p2p_conns[2].block_receive_map[big_old_block], 1)
 
         self.log.info("Peer 2 able to download old block")
@@ -155,8 +153,7 @@ class MaxUploadTest(BitcoinTestFramework):
         #retrieve 20 blocks which should be enough to break the 1MB limit
         getdata_request.inv = [CInv(MSG_BLOCK, big_new_block)]
         for i in range(20):
-            self.nodes[0].p2p.send_message(getdata_request)
+            self.nodes[0].p2p.send_and_ping(getdata_request)
-            self.nodes[0].p2p.sync_with_ping()
             assert_equal(self.nodes[0].p2p.block_receive_map[big_new_block], i+1)
 
         getdata_request.inv = [CInv(MSG_BLOCK, big_old_block)]

test/functional/p2p_blockfilters.py

@@ -164,8 +164,7 @@ class CompactFiltersTest(BitcoinTestFramework):
             start_height=1,
             stop_hash=int(stop_hash, 16)
         )
-        node0.send_message(request)
+        node0.send_and_ping(request)
-        node0.sync_with_ping()
         response = node0.pop_cfilters()
         assert_equal(len(response), 10)
 
@@ -183,8 +182,7 @@ class CompactFiltersTest(BitcoinTestFramework):
             start_height=1000,
             stop_hash=int(stale_block_hash, 16)
         )
-        node0.send_message(request)
+        node0.send_and_ping(request)
-        node0.sync_with_ping()
         response = node0.pop_cfilters()
         assert_equal(len(response), 1)
 

test/functional/p2p_filter.py

@@ -61,8 +61,7 @@ class FilterTest(BitcoinTestFramework):
     def run_test(self):
         self.log.info('Add filtered P2P connection to the node')
         filter_node = self.nodes[0].add_p2p_connection(FilterNode())
-        filter_node.send_message(filter_node.watch_filter_init)
+        filter_node.send_and_ping(filter_node.watch_filter_init)
-        filter_node.sync_with_ping()
         filter_address = self.nodes[0].decodescript(filter_node.watch_script_pubkey)['addresses'][0]
 
         self.log.info('Check that we receive merkleblock and tx if the filter matches a tx in a block')
@@ -93,8 +92,7 @@ class FilterTest(BitcoinTestFramework):
         assert not filter_node.merkleblock_received
 
         self.log.info('Check that after deleting filter all txs get relayed again')
-        filter_node.send_message(msg_filterclear())
+        filter_node.send_and_ping(msg_filterclear())
-        filter_node.sync_with_ping()
         for _ in range(5):
             txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 7)
             filter_node.wait_for_tx(txid)

test/functional/p2p_leak_tx.py

@@ -39,8 +39,7 @@ class P2PLeakTxTest(BitcoinTestFramework):
             want_tx = msg_getdata()
             want_tx.inv.append(CInv(t=MSG_TX, h=int(txid, 16)))
             inbound_peer.last_message.pop('notfound', None)
-            inbound_peer.send_message(want_tx)
+            inbound_peer.send_and_ping(want_tx)
-            inbound_peer.sync_with_ping()
 
             if inbound_peer.last_message.get('notfound'):
                 self.log.debug('tx {} was not yet announced to us.'.format(txid))

test/functional/p2p_sendheaders.py

@@ -300,8 +300,7 @@ class SendHeadersTest(BitcoinTestFramework):
                 new_block.solve()
                 test_node.send_header_for_blocks([new_block])
                 test_node.wait_for_getdata([new_block.sha256])
-                test_node.send_message(msg_block(new_block))
+                test_node.send_and_ping(msg_block(new_block))  # make sure this block is processed
-                test_node.sync_with_ping()  # make sure this block is processed
                 wait_until(lambda: inv_node.block_announced, timeout=60, lock=mininode_lock)
                 inv_node.clear_block_announcements()
                 test_node.clear_block_announcements()

test/functional/p2p_sendheaders_compressed.py

@@ -303,8 +303,7 @@ class SendHeadersTest(BitcoinTestFramework):
                 new_block.solve()
                 test_node.send_header_for_blocks([new_block])
                 test_node.wait_for_getdata([new_block.sha256])
-                test_node.send_message(msg_block(new_block))
+                test_node.send_and_ping(msg_block(new_block))  # make sure this block is processed
-                test_node.sync_with_ping()  # make sure this block is processed
                 wait_until(lambda: inv_node.block_announced, timeout=60, lock=mininode_lock)
                 inv_node.clear_block_announcements()
                 test_node.clear_block_announcements()

test/functional/p2p_tx_download.py

@@ -63,8 +63,7 @@ class TxDownloadTest(BitcoinTestFramework):
         self.log.info("Announce the txid from each incoming peer to node 0")
         msg = msg_inv([CInv(t=1, h=txid)])
         for p in self.nodes[0].p2ps:
-            p.send_message(msg)
+            p.send_and_ping(msg)
-            p.sync_with_ping()
 
         outstanding_peer_index = [i for i in range(len(self.nodes[0].p2ps))]
 
@@ -102,7 +101,7 @@ class TxDownloadTest(BitcoinTestFramework):
             "Announce the transaction to all nodes from all {} incoming peers, but never send it".format(NUM_INBOUND))
         msg = msg_inv([CInv(t=1, h=txid)])
         for p in self.peers:
-            p.send_message(msg)
+            p.send_and_ping(msg)
             p.sync_with_ping()
             self.bump_mocktime(1)
 

test/functional/p2p_unrequested_blocks.py

@@ -84,11 +84,9 @@ class AcceptBlockTest(BitcoinTestFramework):
             blocks_h2.append(create_block(tips[i], create_coinbase(2), block_time + 1))
             blocks_h2[i].solve()
             block_time += 1
-        test_node.send_message(msg_block(blocks_h2[0]))
+        test_node.send_and_ping(msg_block(blocks_h2[0]))
-        min_work_node.send_message(msg_block(blocks_h2[1]))
+        min_work_node.send_and_ping(msg_block(blocks_h2[1]))
 
-        for x in [test_node, min_work_node]:
-            x.sync_with_ping()
         assert_equal(self.nodes[0].getblockcount(), 2)
         assert_equal(self.nodes[1].getblockcount(), 1)
         self.log.info("First height 2 block accepted by node0; correctly rejected by node1")
@@ -97,9 +95,8 @@ class AcceptBlockTest(BitcoinTestFramework):
         block_h1f = create_block(int("0x" + self.nodes[0].getblockhash(0), 0), create_coinbase(1), block_time)
         block_time += 1
         block_h1f.solve()
-        test_node.send_message(msg_block(block_h1f))
+        test_node.send_and_ping(msg_block(block_h1f))
 
-        test_node.sync_with_ping()
         tip_entry_found = False
         for x in self.nodes[0].getchaintips():
             if x['hash'] == block_h1f.hash:
@@ -112,9 +109,8 @@ class AcceptBlockTest(BitcoinTestFramework):
         block_h2f = create_block(block_h1f.sha256, create_coinbase(2), block_time)
         block_time += 1
         block_h2f.solve()
-        test_node.send_message(msg_block(block_h2f))
+        test_node.send_and_ping(msg_block(block_h2f))
 
-        test_node.sync_with_ping()
         # Since the earlier block was not processed by node, the new block
         # can't be fully validated.
         tip_entry_found = False
@@ -131,9 +127,8 @@ class AcceptBlockTest(BitcoinTestFramework):
         # 4b. Now send another block that builds on the forking chain.
         block_h3 = create_block(block_h2f.sha256, create_coinbase(3), block_h2f.nTime+1)
         block_h3.solve()
-        test_node.send_message(msg_block(block_h3))
+        test_node.send_and_ping(msg_block(block_h3))
 
-        test_node.sync_with_ping()
         # Since the earlier block was not processed by node, the new block
         # can't be fully validated.
         tip_entry_found = False
@@ -159,8 +154,7 @@ class AcceptBlockTest(BitcoinTestFramework):
             tip = next_block
 
         # Now send the block at height 5 and check that it wasn't accepted (missing header)
-        test_node.send_message(msg_block(all_blocks[1]))
+        test_node.send_and_ping(msg_block(all_blocks[1]))
-        test_node.sync_with_ping()
         assert_raises_rpc_error(-5, "Block not found", self.nodes[0].getblock, all_blocks[1].hash)
         assert_raises_rpc_error(-5, "Block not found", self.nodes[0].getblockheader, all_blocks[1].hash)
 
@@ -168,8 +162,7 @@ class AcceptBlockTest(BitcoinTestFramework):
         headers_message = msg_headers()
         headers_message.headers.append(CBlockHeader(all_blocks[0]))
         test_node.send_message(headers_message)
-        test_node.send_message(msg_block(all_blocks[1]))
+        test_node.send_and_ping(msg_block(all_blocks[1]))
-        test_node.sync_with_ping()
         self.nodes[0].getblock(all_blocks[1].hash)
 
         # Now send the blocks in all_blocks
@@ -194,9 +187,7 @@ class AcceptBlockTest(BitcoinTestFramework):
 
         test_node = self.nodes[0].add_p2p_connection(P2PInterface())
 
-        test_node.send_message(msg_block(block_h1f))
+        test_node.send_and_ping(msg_block(block_h1f))
-
-        test_node.sync_with_ping()
         assert_equal(self.nodes[0].getblockcount(), 2)
         self.log.info("Unrequested block that would complete more-work chain was ignored")
 
@@ -217,9 +208,7 @@ class AcceptBlockTest(BitcoinTestFramework):
         self.log.info("Inv at tip triggered getdata for unprocessed block")
 
         # 7. Send the missing block for the third time (now it is requested)
-        test_node.send_message(msg_block(block_h1f))
+        test_node.send_and_ping(msg_block(block_h1f))
-
-        test_node.sync_with_ping()
         assert_equal(self.nodes[0].getblockcount(), 290)
         self.nodes[0].getblock(all_blocks[286].hash)
         assert_equal(self.nodes[0].getbestblockhash(), all_blocks[286].hash)
@@ -246,9 +235,8 @@ class AcceptBlockTest(BitcoinTestFramework):
         headers_message.headers.append(CBlockHeader(block_290f))
         headers_message.headers.append(CBlockHeader(block_291))
         headers_message.headers.append(CBlockHeader(block_292))
-        test_node.send_message(headers_message)
+        test_node.send_and_ping(headers_message)
 
-        test_node.sync_with_ping()
         tip_entry_found = False
         for x in self.nodes[0].getchaintips():
             if x['hash'] == block_292.hash:
@@ -258,9 +246,8 @@ class AcceptBlockTest(BitcoinTestFramework):
         assert_raises_rpc_error(-1, "Block not found on disk", self.nodes[0].getblock, block_292.hash)
 
         test_node.send_message(msg_block(block_289f))
-        test_node.send_message(msg_block(block_290f))
+        test_node.send_and_ping(msg_block(block_290f))
 
-        test_node.sync_with_ping()
         self.nodes[0].getblock(block_289f.hash)
         self.nodes[0].getblock(block_290f.hash)
 

test/functional/rpc_blockchain.py

@@ -390,8 +390,7 @@ class BlockchainTest(BitcoinTestFramework):
         def solve_and_send_block(prevhash, height, time):
             b = create_block(prevhash, create_coinbase(height), time)
             b.solve()
-            node.p2p.send_message(msg_block(b))
+            node.p2p.send_and_ping(msg_block(b))
-            node.p2p.sync_with_ping()
             return b
 
         b21f = solve_and_send_block(int(b20hash, 16), 21, b20['time'] + 1)