test: replace (send_message + sync_with_ping) with send_and_ping
This commit is contained in:
parent
b97e3a7349
commit
6112a20982
8 changed files with 27 additions and 56 deletions
|
@ -94,8 +94,7 @@ class MaxUploadTest(BitcoinTestFramework):
|
|||
# 576MB will be reserved for relaying new blocks, so expect this to
|
||||
# succeed for ~235 tries.
|
||||
for i in range(success_count):
|
||||
p2p_conns[0].send_message(getdata_request)
|
||||
p2p_conns[0].sync_with_ping()
|
||||
p2p_conns[0].send_and_ping(getdata_request)
|
||||
assert_equal(p2p_conns[0].block_receive_map[big_old_block], i+1)
|
||||
|
||||
assert_equal(len(self.nodes[0].getpeerinfo()), 3)
|
||||
|
@ -112,8 +111,7 @@ class MaxUploadTest(BitcoinTestFramework):
|
|||
# We'll try 800 times
|
||||
getdata_request.inv = [CInv(2, big_new_block)]
|
||||
for i in range(800):
|
||||
p2p_conns[1].send_message(getdata_request)
|
||||
p2p_conns[1].sync_with_ping()
|
||||
p2p_conns[1].send_and_ping(getdata_request)
|
||||
assert_equal(p2p_conns[1].block_receive_map[big_new_block], i+1)
|
||||
|
||||
self.log.info("Peer 1 able to repeatedly download new block")
|
||||
|
@ -132,8 +130,7 @@ class MaxUploadTest(BitcoinTestFramework):
|
|||
# and p2p_conns[2] should be able to retrieve the old block.
|
||||
self.nodes[0].setmocktime(int(time.time()))
|
||||
p2p_conns[2].sync_with_ping()
|
||||
p2p_conns[2].send_message(getdata_request)
|
||||
p2p_conns[2].sync_with_ping()
|
||||
p2p_conns[2].send_and_ping(getdata_request)
|
||||
assert_equal(p2p_conns[2].block_receive_map[big_old_block], 1)
|
||||
|
||||
self.log.info("Peer 2 able to download old block")
|
||||
|
@ -150,8 +147,7 @@ class MaxUploadTest(BitcoinTestFramework):
|
|||
#retrieve 20 blocks which should be enough to break the 1MB limit
|
||||
getdata_request.inv = [CInv(2, big_new_block)]
|
||||
for i in range(20):
|
||||
self.nodes[0].p2p.send_message(getdata_request)
|
||||
self.nodes[0].p2p.sync_with_ping()
|
||||
self.nodes[0].p2p.send_and_ping(getdata_request)
|
||||
assert_equal(self.nodes[0].p2p.block_receive_map[big_new_block], i+1)
|
||||
|
||||
getdata_request.inv = [CInv(2, big_old_block)]
|
||||
|
|
|
@ -64,8 +64,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.sync_with_ping()
|
||||
filter_node.send_and_ping(filter_node.watch_filter_init)
|
||||
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')
|
||||
|
@ -99,8 +98,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.sync_with_ping()
|
||||
filter_node.send_and_ping(msg_filterclear())
|
||||
for _ in range(5):
|
||||
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 7)
|
||||
filter_node.wait_for_tx(txid)
|
||||
|
|
|
@ -39,8 +39,7 @@ class P2PLeakTxTest(BitcoinTestFramework):
|
|||
want_tx = msg_getdata()
|
||||
want_tx.inv.append(CInv(t=1, h=int(txid, 16)))
|
||||
inbound_peer.last_message.pop('notfound', None)
|
||||
inbound_peer.send_message(want_tx)
|
||||
inbound_peer.sync_with_ping()
|
||||
inbound_peer.send_and_ping(want_tx)
|
||||
|
||||
if inbound_peer.last_message.get('notfound'):
|
||||
self.log.debug('tx {} was not yet announced to us.'.format(txid))
|
||||
|
|
|
@ -303,8 +303,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
|
||||
block = self.build_next_block(version=1)
|
||||
block.solve()
|
||||
self.test_node.send_message(msg_no_witness_block(block))
|
||||
self.test_node.sync_with_ping() # make sure the block was processed
|
||||
self.test_node.send_and_ping(msg_no_witness_block(block)) # make sure the block was processed
|
||||
txid = block.vtx[0].sha256
|
||||
|
||||
self.nodes[0].generate(99) # let the block mature
|
||||
|
@ -319,8 +318,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
# This is a sanity check of our testing framework.
|
||||
assert_equal(msg_no_witness_tx(tx).serialize(), msg_tx(tx).serialize())
|
||||
|
||||
self.test_node.send_message(msg_tx(tx))
|
||||
self.test_node.sync_with_ping() # make sure the tx was processed
|
||||
self.test_node.send_and_ping(msg_tx(tx)) # make sure the block was processed
|
||||
assert tx.hash in self.nodes[0].getrawmempool()
|
||||
# Save this transaction for later
|
||||
self.utxo.append(UTXO(tx.sha256, 0, 49 * 100000000))
|
||||
|
@ -350,8 +348,7 @@ class SegWitTest(BitcoinTestFramework):
|
|||
|
||||
# But it should not be permanently marked bad...
|
||||
# Resend without witness information.
|
||||
self.test_node.send_message(msg_no_witness_block(block))
|
||||
self.test_node.sync_with_ping()
|
||||
self.test_node.send_and_ping(msg_no_witness_block(block)) # make sure the block was processed
|
||||
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
|
||||
|
||||
# Update our utxo list; we spent the first entry.
|
||||
|
@ -2054,16 +2051,14 @@ class SegWitTest(BitcoinTestFramework):
|
|||
tx = FromHex(CTransaction(), raw)
|
||||
assert_raises_rpc_error(-22, "TX decode failed", self.nodes[0].decoderawtransaction, serialize_with_bogus_witness(tx).hex())
|
||||
with self.nodes[0].assert_debug_log(['Superfluous witness record']):
|
||||
self.nodes[0].p2p.send_message(msg_bogus_tx(tx))
|
||||
self.nodes[0].p2p.sync_with_ping()
|
||||
self.nodes[0].p2p.send_and_ping(msg_bogus_tx(tx))
|
||||
raw = self.nodes[0].signrawtransactionwithwallet(raw)
|
||||
assert raw['complete']
|
||||
raw = raw['hex']
|
||||
tx = FromHex(CTransaction(), raw)
|
||||
assert_raises_rpc_error(-22, "TX decode failed", self.nodes[0].decoderawtransaction, serialize_with_bogus_witness(tx).hex())
|
||||
with self.nodes[0].assert_debug_log(['Unknown transaction optional data']):
|
||||
self.nodes[0].p2p.send_message(msg_bogus_tx(tx))
|
||||
self.nodes[0].p2p.sync_with_ping()
|
||||
self.nodes[0].p2p.send_and_ping(msg_bogus_tx(tx))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
@ -307,8 +307,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.sync_with_ping() # make sure this block is processed
|
||||
test_node.send_and_ping(msg_block(new_block)) # 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()
|
||||
|
|
|
@ -65,8 +65,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.sync_with_ping()
|
||||
p.send_and_ping(msg)
|
||||
|
||||
outstanding_peer_index = [i for i in range(len(self.nodes[0].p2ps))]
|
||||
|
||||
|
@ -107,8 +106,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.sync_with_ping()
|
||||
p.send_and_ping(msg)
|
||||
|
||||
self.log.info("Put the tx in node 0's mempool")
|
||||
self.nodes[0].sendrawtransaction(tx)
|
||||
|
|
|
@ -97,11 +97,9 @@ class AcceptBlockTest(BitcoinTestFramework):
|
|||
blocks_h2.append(create_block(tips[i], create_coinbase(2), block_time))
|
||||
blocks_h2[i].solve()
|
||||
block_time += 1
|
||||
test_node.send_message(msg_block(blocks_h2[0]))
|
||||
min_work_node.send_message(msg_block(blocks_h2[1]))
|
||||
test_node.send_and_ping(msg_block(blocks_h2[0]))
|
||||
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")
|
||||
|
@ -110,9 +108,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:
|
||||
|
@ -125,9 +122,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
|
||||
|
@ -144,9 +140,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
|
||||
|
@ -172,8 +167,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.sync_with_ping()
|
||||
test_node.send_and_ping(msg_block(all_blocks[1]))
|
||||
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)
|
||||
|
||||
|
@ -181,8 +175,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.sync_with_ping()
|
||||
test_node.send_and_ping(msg_block(all_blocks[1]))
|
||||
self.nodes[0].getblock(all_blocks[1].hash)
|
||||
|
||||
# Now send the blocks in all_blocks
|
||||
|
@ -207,9 +200,7 @@ class AcceptBlockTest(BitcoinTestFramework):
|
|||
|
||||
test_node = self.nodes[0].add_p2p_connection(P2PInterface())
|
||||
|
||||
test_node.send_message(msg_block(block_h1f))
|
||||
|
||||
test_node.sync_with_ping()
|
||||
test_node.send_and_ping(msg_block(block_h1f))
|
||||
assert_equal(self.nodes[0].getblockcount(), 2)
|
||||
self.log.info("Unrequested block that would complete more-work chain was ignored")
|
||||
|
||||
|
@ -230,9 +221,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.sync_with_ping()
|
||||
test_node.send_and_ping(msg_block(block_h1f))
|
||||
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)
|
||||
|
@ -259,9 +248,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:
|
||||
|
@ -271,9 +259,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)
|
||||
|
||||
|
|
|
@ -315,8 +315,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.sync_with_ping()
|
||||
node.p2p.send_and_ping(msg_block(b))
|
||||
return b
|
||||
|
||||
b21f = solve_and_send_block(int(b20hash, 16), 21, b20['time'] + 1)
|
||||
|
|
Loading…
Reference in a new issue