maxmustermann/dogecoin
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge #19752: test: Update wait_until usage in tests not to use the one from utils

Browse source 
d841301010 test: Add docstring to wait_until() in util.py to warn about its usage (Seleme Topuz)
1343c86c7c test: Update wait_until usage in tests not to use the one from utils (Seleme Topuz)

Pull request description:

  Replace global (from [test_framework/util.py](https://github.com/bitcoin/bitcoin/blob/master/test/functional/test_framework/util.py#L228)) `wait_until()` usages with the ones provided by `BitcoinTestFramework` and `P2PInterface` classes.

  The motivation behind this change is that the `util.wait_until()` expects a timeout, timeout_factor and lock and it is not aware of the context of the test framework. `BitcoinTestFramework` offers a `wait_until()` which has an understandable amount of default `timeout` and a shared `timeout_factor`. Moreover, on top of these, `mininode.wait_until()` also has a shared lock.

  closes #19080

ACKs for top commit:
  MarcoFalke:
    ACK d841301010 🦆
  kallewoof:
    utACK d841301010

Tree-SHA512: 81604f4cfa87fed98071a80e4afe940b3897fe65cf680a69619a93e97d45f25b313c12227de7040e19517fa9c003291b232f1b40b2567aba0148f22c23c47a88
This commit is contained in:
MarcoFalke 2020-08-27 08:21:53 +02:00
commit 28f4e53e16
No known key found for this signature in database
GPG key ID: CE2B75697E69A548
27 changed files with 82 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
test/functional/example_test.py
View file

@ -26,7 +26,6 @@ from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
connect_nodes, connect_nodes,
wait_until,
) )
# P2PInterface is a class containing callbacks to be executed when a P2P # P2PInterface is a class containing callbacks to be executed when a P2P
@ -203,7 +202,7 @@ class ExampleTest(BitcoinTestFramework):
# wait_until() will loop until a predicate condition is met. Use it to test properties of the # wait_until() will loop until a predicate condition is met. Use it to test properties of the
# P2PInterface objects. # P2PInterface objects.
wait_until(lambda: sorted(blocks) == sorted(list(self.nodes[2].p2p.block_receive_map.keys())), timeout=5, lock=p2p_lock) self.nodes[2].p2p.wait_until(lambda: sorted(blocks) == sorted(list(self.nodes[2].p2p.block_receive_map.keys())), timeout=5)
self.log.info("Check that each block was received only once") self.log.info("Check that each block was received only once")
# The network thread uses a global lock on data access to the P2PConnection objects when sending and receiving # The network thread uses a global lock on data access to the P2PConnection objects when sending and receiving

4
test/functional/feature_abortnode.py
View file

@ -11,7 +11,7 @@
""" """
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import wait_until, get_datadir_path, connect_nodes from test_framework.util import get_datadir_path, connect_nodes
import os import os
@ -41,7 +41,7 @@ class AbortNodeTest(BitcoinTestFramework):
# Check that node0 aborted # Check that node0 aborted
self.log.info("Waiting for crash") self.log.info("Waiting for crash")
wait_until(lambda: self.nodes[0].is_node_stopped(), timeout=200) self.nodes[0].wait_until_stopped(timeout=200)
self.log.info("Node crashed - now verifying restart fails") self.log.info("Node crashed - now verifying restart fails")
self.nodes[0].assert_start_raises_init_error() self.nodes[0].assert_start_raises_init_error()

9
test/functional/feature_notifications.py
View file

@ -9,7 +9,6 @@ from test_framework.address import ADDRESS_BCRT1_UNSPENDABLE, keyhash_to_p2pkh
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
wait_until,
connect_nodes, connect_nodes,
disconnect_nodes, disconnect_nodes,
hex_str_to_bytes, hex_str_to_bytes,
@ -56,7 +55,7 @@ class NotificationsTest(BitcoinTestFramework):
blocks = self.nodes[1].generatetoaddress(block_count, self.nodes[1].getnewaddress() if self.is_wallet_compiled() else ADDRESS_BCRT1_UNSPENDABLE) blocks = self.nodes[1].generatetoaddress(block_count, self.nodes[1].getnewaddress() if self.is_wallet_compiled() else ADDRESS_BCRT1_UNSPENDABLE)
# wait at most 10 seconds for expected number of files before reading the content # wait at most 10 seconds for expected number of files before reading the content
wait_until(lambda: len(os.listdir(self.blocknotify_dir)) == block_count, timeout=10) self.wait_until(lambda: len(os.listdir(self.blocknotify_dir)) == block_count, timeout=10)
# directory content should equal the generated blocks hashes # directory content should equal the generated blocks hashes
assert_equal(sorted(blocks), sorted(os.listdir(self.blocknotify_dir))) assert_equal(sorted(blocks), sorted(os.listdir(self.blocknotify_dir)))
@ -64,7 +63,7 @@ class NotificationsTest(BitcoinTestFramework):
if self.is_wallet_compiled(): if self.is_wallet_compiled():
self.log.info("test -walletnotify") self.log.info("test -walletnotify")
# wait at most 10 seconds for expected number of files before reading the content # wait at most 10 seconds for expected number of files before reading the content
wait_until(lambda: len(os.listdir(self.walletnotify_dir)) == block_count, timeout=10) self.wait_until(lambda: len(os.listdir(self.walletnotify_dir)) == block_count, timeout=10)
# directory content should equal the generated transaction hashes # directory content should equal the generated transaction hashes
txids_rpc = list(map(lambda t: notify_outputname(self.wallet, t['txid']), self.nodes[1].listtransactions("*", block_count))) txids_rpc = list(map(lambda t: notify_outputname(self.wallet, t['txid']), self.nodes[1].listtransactions("*", block_count)))
@ -78,7 +77,7 @@ class NotificationsTest(BitcoinTestFramework):
self.start_node(1) self.start_node(1)
connect_nodes(self.nodes[0], 1) connect_nodes(self.nodes[0], 1)
wait_until(lambda: len(os.listdir(self.walletnotify_dir)) == block_count, timeout=10) self.wait_until(lambda: len(os.listdir(self.walletnotify_dir)) == block_count, timeout=10)
# directory content should equal the generated transaction hashes # directory content should equal the generated transaction hashes
txids_rpc = list(map(lambda t: notify_outputname(self.wallet, t['txid']), self.nodes[1].listtransactions("*", block_count))) txids_rpc = list(map(lambda t: notify_outputname(self.wallet, t['txid']), self.nodes[1].listtransactions("*", block_count)))
@ -140,7 +139,7 @@ class NotificationsTest(BitcoinTestFramework):
# TODO: add test for `-alertnotify` large fork notifications # TODO: add test for `-alertnotify` large fork notifications
def expect_wallet_notify(self, tx_ids): def expect_wallet_notify(self, tx_ids):
wait_until(lambda: len(os.listdir(self.walletnotify_dir)) >= len(tx_ids), timeout=10) self.wait_until(lambda: len(os.listdir(self.walletnotify_dir)) >= len(tx_ids), timeout=10)
assert_equal(sorted(notify_outputname(self.wallet, tx_id) for tx_id in tx_ids), sorted(os.listdir(self.walletnotify_dir))) assert_equal(sorted(notify_outputname(self.wallet, tx_id) for tx_id in tx_ids), sorted(os.listdir(self.walletnotify_dir)))
for tx_file in os.listdir(self.walletnotify_dir): for tx_file in os.listdir(self.walletnotify_dir):
os.remove(os.path.join(self.walletnotify_dir, tx_file)) os.remove(os.path.join(self.walletnotify_dir, tx_file))

5
test/functional/feature_pruning.py
View file

@ -20,7 +20,6 @@ from test_framework.util import (
assert_raises_rpc_error, assert_raises_rpc_error,
connect_nodes, connect_nodes,
disconnect_nodes, disconnect_nodes,
wait_until,
) )
# Rescans start at the earliest block up to 2 hours before a key timestamp, so # Rescans start at the earliest block up to 2 hours before a key timestamp, so
@ -136,7 +135,7 @@ class PruneTest(BitcoinTestFramework):
mine_large_blocks(self.nodes[0], 25) mine_large_blocks(self.nodes[0], 25)
# Wait for blk00000.dat to be pruned # Wait for blk00000.dat to be pruned
wait_until(lambda: not os.path.isfile(os.path.join(self.prunedir, "blk00000.dat")), timeout=30) self.wait_until(lambda: not os.path.isfile(os.path.join(self.prunedir, "blk00000.dat")), timeout=30)
self.log.info("Success") self.log.info("Success")
usage = calc_usage(self.prunedir) usage = calc_usage(self.prunedir)
@ -250,7 +249,7 @@ class PruneTest(BitcoinTestFramework):
self.log.info("Verify node 2 reorged back to the main chain, some blocks of which it had to redownload") self.log.info("Verify node 2 reorged back to the main chain, some blocks of which it had to redownload")
# Wait for Node 2 to reorg to proper height # Wait for Node 2 to reorg to proper height
wait_until(lambda: self.nodes[2].getblockcount() >= goalbestheight, timeout=900) self.wait_until(lambda: self.nodes[2].getblockcount() >= goalbestheight, timeout=900)
assert_equal(self.nodes[2].getbestblockhash(), goalbesthash) assert_equal(self.nodes[2].getbestblockhash(), goalbesthash)
# Verify we can now have the data for a block previously pruned # Verify we can now have the data for a block previously pruned
assert_equal(self.nodes[2].getblock(self.forkhash)["height"], self.forkheight) assert_equal(self.nodes[2].getblock(self.forkhash)["height"], self.forkheight)

4
test/functional/feature_shutdown.py
View file

@ -5,7 +5,7 @@
"""Test bitcoind shutdown.""" """Test bitcoind shutdown."""
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, get_rpc_proxy, wait_until from test_framework.util import assert_equal, get_rpc_proxy
from threading import Thread from threading import Thread
def test_long_call(node): def test_long_call(node):
@ -25,7 +25,7 @@ class ShutdownTest(BitcoinTestFramework):
node.getblockcount() node.getblockcount()
Thread(target=test_long_call, args=(node,)).start() Thread(target=test_long_call, args=(node,)).start()
# Wait until the server is executing the above `waitfornewblock`. # Wait until the server is executing the above `waitfornewblock`.
wait_until(lambda: len(self.nodes[0].getrpcinfo()['active_commands']) == 2) self.wait_until(lambda: len(self.nodes[0].getrpcinfo()['active_commands']) == 2)
# Wait 1 second after requesting shutdown but not before the `stop` call # Wait 1 second after requesting shutdown but not before the `stop` call
# finishes. This is to ensure event loop waits for current connections # finishes. This is to ensure event loop waits for current connections
# to close. # to close.

5
test/functional/feature_versionbits_warning.py
View file

@ -14,7 +14,6 @@ from test_framework.blocktools import create_block, create_coinbase
from test_framework.messages import msg_block from test_framework.messages import msg_block
from test_framework.p2p import p2p_lock, P2PInterface from test_framework.p2p import p2p_lock, P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import wait_until
VB_PERIOD = 144 # versionbits period length for regtest VB_PERIOD = 144 # versionbits period length for regtest
VB_THRESHOLD = 108 # versionbits activation threshold for regtest VB_THRESHOLD = 108 # versionbits activation threshold for regtest
@ -91,14 +90,14 @@ class VersionBitsWarningTest(BitcoinTestFramework):
# Generating one block guarantees that we'll get out of IBD # Generating one block guarantees that we'll get out of IBD
node.generatetoaddress(1, node_deterministic_address) node.generatetoaddress(1, node_deterministic_address)
wait_until(lambda: not node.getblockchaininfo()['initialblockdownload'], timeout=10, lock=p2p_lock) self.wait_until(lambda: not node.getblockchaininfo()['initialblockdownload'], timeout=10, lock=p2p_lock)
# Generating one more block will be enough to generate an error. # Generating one more block will be enough to generate an error.
node.generatetoaddress(1, node_deterministic_address) node.generatetoaddress(1, node_deterministic_address)
# Check that get*info() shows the versionbits unknown rules warning # Check that get*info() shows the versionbits unknown rules warning
assert WARN_UNKNOWN_RULES_ACTIVE in node.getmininginfo()["warnings"] assert WARN_UNKNOWN_RULES_ACTIVE in node.getmininginfo()["warnings"]
assert WARN_UNKNOWN_RULES_ACTIVE in node.getnetworkinfo()["warnings"] assert WARN_UNKNOWN_RULES_ACTIVE in node.getnetworkinfo()["warnings"]
# Check that the alert file shows the versionbits unknown rules warning # Check that the alert file shows the versionbits unknown rules warning
wait_until(lambda: self.versionbits_in_alert_file(), timeout=60) self.wait_until(lambda: self.versionbits_in_alert_file())
if __name__ == '__main__': if __name__ == '__main__':
VersionBitsWarningTest().main() VersionBitsWarningTest().main()

5
test/functional/mempool_packages.py
View file

@ -13,7 +13,6 @@ from test_framework.util import (
assert_equal, assert_equal,
assert_raises_rpc_error, assert_raises_rpc_error,
satoshi_round, satoshi_round,
wait_until,
) )
# default limits # default limits
@ -269,8 +268,8 @@ class MempoolPackagesTest(BitcoinTestFramework):
# - txs from previous ancestor test (-> custom ancestor limit) # - txs from previous ancestor test (-> custom ancestor limit)
# - parent tx for descendant test # - parent tx for descendant test
# - txs chained off parent tx (-> custom descendant limit) # - txs chained off parent tx (-> custom descendant limit)
wait_until(lambda: len(self.nodes[1].getrawmempool(False)) == self.wait_until(lambda: len(self.nodes[1].getrawmempool(False)) ==
MAX_ANCESTORS_CUSTOM + 1 + MAX_DESCENDANTS_CUSTOM, timeout=10) MAX_ANCESTORS_CUSTOM + 1 + MAX_DESCENDANTS_CUSTOM, timeout=10)
mempool0 = self.nodes[0].getrawmempool(False) mempool0 = self.nodes[0].getrawmempool(False)
mempool1 = self.nodes[1].getrawmempool(False) mempool1 = self.nodes[1].getrawmempool(False)
assert set(mempool1).issubset(set(mempool0)) assert set(mempool1).issubset(set(mempool0))

3
test/functional/mempool_persist.py
View file

@ -47,7 +47,6 @@ from test_framework.util import (
assert_raises_rpc_error, assert_raises_rpc_error,
connect_nodes, connect_nodes,
disconnect_nodes, disconnect_nodes,
wait_until,
) )
@ -172,7 +171,7 @@ class MempoolPersistTest(BitcoinTestFramework):
# check that txn gets broadcast due to unbroadcast logic # check that txn gets broadcast due to unbroadcast logic
conn = node0.add_p2p_connection(P2PTxInvStore()) conn = node0.add_p2p_connection(P2PTxInvStore())
node0.mockscheduler(16*60) # 15 min + 1 for buffer node0.mockscheduler(16*60) # 15 min + 1 for buffer
wait_until(lambda: len(conn.get_invs()) == 1) self.wait_until(lambda: len(conn.get_invs()) == 1)
if __name__ == '__main__': if __name__ == '__main__':
MempoolPersistTest().main() MempoolPersistTest().main()

5
test/functional/p2p_blockfilters.py
View file

@ -24,7 +24,6 @@ from test_framework.util import (
assert_equal, assert_equal,
connect_nodes, connect_nodes,
disconnect_nodes, disconnect_nodes,
wait_until,
) )
class CFiltersClient(P2PInterface): class CFiltersClient(P2PInterface):
@ -65,11 +64,11 @@ class CompactFiltersTest(BitcoinTestFramework):
disconnect_nodes(self.nodes[0], 1) disconnect_nodes(self.nodes[0], 1)
self.nodes[0].generate(1) self.nodes[0].generate(1)
wait_until(lambda: self.nodes[0].getblockcount() == 1000) self.wait_until(lambda: self.nodes[0].getblockcount() == 1000)
stale_block_hash = self.nodes[0].getblockhash(1000) stale_block_hash = self.nodes[0].getblockhash(1000)
self.nodes[1].generate(1001) self.nodes[1].generate(1001)
wait_until(lambda: self.nodes[1].getblockcount() == 2000) self.wait_until(lambda: self.nodes[1].getblockcount() == 2000)
# Check that nodes have signalled NODE_COMPACT_FILTERS correctly. # Check that nodes have signalled NODE_COMPACT_FILTERS correctly.
assert node0.nServices & NODE_COMPACT_FILTERS != 0 assert node0.nServices & NODE_COMPACT_FILTERS != 0

28
test/functional/p2p_compactblocks.py
View file

@ -14,7 +14,7 @@ from test_framework.messages import BlockTransactions, BlockTransactionsRequest,
from test_framework.p2p import p2p_lock, P2PInterface from test_framework.p2p import p2p_lock, P2PInterface
from test_framework.script import CScript, OP_TRUE, OP_DROP from test_framework.script import CScript, OP_TRUE, OP_DROP
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, wait_until, softfork_active from test_framework.util import assert_equal, softfork_active
# TestP2PConn: A peer we use to send messages to bitcoind, and store responses. # TestP2PConn: A peer we use to send messages to bitcoind, and store responses.
class TestP2PConn(P2PInterface): class TestP2PConn(P2PInterface):
@ -73,7 +73,7 @@ class TestP2PConn(P2PInterface):
def request_headers_and_sync(self, locator, hashstop=0): def request_headers_and_sync(self, locator, hashstop=0):
self.clear_block_announcement() self.clear_block_announcement()
self.get_headers(locator, hashstop) self.get_headers(locator, hashstop)
wait_until(self.received_block_announcement, timeout=30, lock=p2p_lock) self.wait_until(self.received_block_announcement, timeout=30)
self.clear_block_announcement() self.clear_block_announcement()
# Block until a block announcement for a particular block hash is # Block until a block announcement for a particular block hash is
@ -81,7 +81,7 @@ class TestP2PConn(P2PInterface):
def wait_for_block_announcement(self, block_hash, timeout=30): def wait_for_block_announcement(self, block_hash, timeout=30):
def received_hash(): def received_hash():
return (block_hash in self.announced_blockhashes) return (block_hash in self.announced_blockhashes)
wait_until(received_hash, timeout=timeout, lock=p2p_lock) self.wait_until(received_hash, timeout=timeout)
def send_await_disconnect(self, message, timeout=30): def send_await_disconnect(self, message, timeout=30):
"""Sends a message to the node and wait for disconnect. """Sends a message to the node and wait for disconnect.
@ -89,7 +89,7 @@ class TestP2PConn(P2PInterface):
This is used when we want to send a message into the node that we expect This is used when we want to send a message into the node that we expect
will get us disconnected, eg an invalid block.""" will get us disconnected, eg an invalid block."""
self.send_message(message) self.send_message(message)
wait_until(lambda: not self.is_connected, timeout=timeout, lock=p2p_lock) self.wait_for_disconnect(timeout)
class CompactBlocksTest(BitcoinTestFramework): class CompactBlocksTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
@ -154,7 +154,7 @@ class CompactBlocksTest(BitcoinTestFramework):
# Make sure we get a SENDCMPCT message from our peer # Make sure we get a SENDCMPCT message from our peer
def received_sendcmpct(): def received_sendcmpct():
return (len(test_node.last_sendcmpct) > 0) return (len(test_node.last_sendcmpct) > 0)
wait_until(received_sendcmpct, timeout=30, lock=p2p_lock) test_node.wait_until(received_sendcmpct, timeout=30)
with p2p_lock: with p2p_lock:
# Check that the first version received is the preferred one # Check that the first version received is the preferred one
assert_equal(test_node.last_sendcmpct[0].version, preferred_version) assert_equal(test_node.last_sendcmpct[0].version, preferred_version)
@ -294,7 +294,7 @@ class CompactBlocksTest(BitcoinTestFramework):
block.rehash() block.rehash()
# Wait until the block was announced (via compact blocks) # Wait until the block was announced (via compact blocks)
wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=p2p_lock) test_node.wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30)
# Now fetch and check the compact block # Now fetch and check the compact block
header_and_shortids = None header_and_shortids = None
@ -308,7 +308,7 @@ class CompactBlocksTest(BitcoinTestFramework):
inv = CInv(MSG_CMPCT_BLOCK, block_hash) inv = CInv(MSG_CMPCT_BLOCK, block_hash)
test_node.send_message(msg_getdata([inv])) test_node.send_message(msg_getdata([inv]))
wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=p2p_lock) test_node.wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30)
# Now fetch and check the compact block # Now fetch and check the compact block
header_and_shortids = None header_and_shortids = None
@ -378,7 +378,7 @@ class CompactBlocksTest(BitcoinTestFramework):
if announce == "inv": if announce == "inv":
test_node.send_message(msg_inv([CInv(MSG_BLOCK, block.sha256)])) test_node.send_message(msg_inv([CInv(MSG_BLOCK, block.sha256)]))
wait_until(lambda: "getheaders" in test_node.last_message, timeout=30, lock=p2p_lock) test_node.wait_until(lambda: "getheaders" in test_node.last_message, timeout=30)
test_node.send_header_for_blocks([block]) test_node.send_header_for_blocks([block])
else: else:
test_node.send_header_for_blocks([block]) test_node.send_header_for_blocks([block])
@ -588,7 +588,7 @@ class CompactBlocksTest(BitcoinTestFramework):
num_to_request = random.randint(1, len(block.vtx)) num_to_request = random.randint(1, len(block.vtx))
msg.block_txn_request.from_absolute(sorted(random.sample(range(len(block.vtx)), num_to_request))) msg.block_txn_request.from_absolute(sorted(random.sample(range(len(block.vtx)), num_to_request)))
test_node.send_message(msg) test_node.send_message(msg)
wait_until(lambda: "blocktxn" in test_node.last_message, timeout=10, lock=p2p_lock) test_node.wait_until(lambda: "blocktxn" in test_node.last_message, timeout=10)
[tx.calc_sha256() for tx in block.vtx] [tx.calc_sha256() for tx in block.vtx]
with p2p_lock: with p2p_lock:
@ -628,20 +628,20 @@ class CompactBlocksTest(BitcoinTestFramework):
for _ in range(MAX_CMPCTBLOCK_DEPTH + 1): for _ in range(MAX_CMPCTBLOCK_DEPTH + 1):
test_node.clear_block_announcement() test_node.clear_block_announcement()
new_blocks.append(node.generate(1)[0]) new_blocks.append(node.generate(1)[0])
wait_until(test_node.received_block_announcement, timeout=30, lock=p2p_lock) test_node.wait_until(test_node.received_block_announcement, timeout=30)
test_node.clear_block_announcement() test_node.clear_block_announcement()
test_node.send_message(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))])) test_node.send_message(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))]))
wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=p2p_lock) test_node.wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30)
test_node.clear_block_announcement() test_node.clear_block_announcement()
node.generate(1) node.generate(1)
wait_until(test_node.received_block_announcement, timeout=30, lock=p2p_lock) test_node.wait_until(test_node.received_block_announcement, timeout=30)
test_node.clear_block_announcement() test_node.clear_block_announcement()
with p2p_lock: with p2p_lock:
test_node.last_message.pop("block", None) test_node.last_message.pop("block", None)
test_node.send_message(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))])) test_node.send_message(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))]))
wait_until(lambda: "block" in test_node.last_message, timeout=30, lock=p2p_lock) test_node.wait_until(lambda: "block" in test_node.last_message, timeout=30)
with p2p_lock: with p2p_lock:
test_node.last_message["block"].block.calc_sha256() test_node.last_message["block"].block.calc_sha256()
assert_equal(test_node.last_message["block"].block.sha256, int(new_blocks[0], 16)) assert_equal(test_node.last_message["block"].block.sha256, int(new_blocks[0], 16))
@ -689,7 +689,7 @@ class CompactBlocksTest(BitcoinTestFramework):
node.submitblock(ToHex(block)) node.submitblock(ToHex(block))
for l in listeners: for l in listeners:
wait_until(lambda: "cmpctblock" in l.last_message, timeout=30, lock=p2p_lock) l.wait_until(lambda: "cmpctblock" in l.last_message, timeout=30)
with p2p_lock: with p2p_lock:
for l in listeners: for l in listeners:
l.last_message["cmpctblock"].header_and_shortids.header.calc_sha256() l.last_message["cmpctblock"].header_and_shortids.header.calc_sha256()

7
test/functional/p2p_disconnect_ban.py
View file

@ -10,7 +10,6 @@ from test_framework.util import (
assert_equal, assert_equal,
assert_raises_rpc_error, assert_raises_rpc_error,
connect_nodes, connect_nodes,
wait_until,
) )
class DisconnectBanTest(BitcoinTestFramework): class DisconnectBanTest(BitcoinTestFramework):
@ -28,7 +27,7 @@ class DisconnectBanTest(BitcoinTestFramework):
self.log.info("setban: successfully ban single IP address") self.log.info("setban: successfully ban single IP address")
assert_equal(len(self.nodes[1].getpeerinfo()), 2) # node1 should have 2 connections to node0 at this point assert_equal(len(self.nodes[1].getpeerinfo()), 2) # node1 should have 2 connections to node0 at this point
self.nodes[1].setban(subnet="127.0.0.1", command="add") self.nodes[1].setban(subnet="127.0.0.1", command="add")
wait_until(lambda: len(self.nodes[1].getpeerinfo()) == 0, timeout=10) self.wait_until(lambda: len(self.nodes[1].getpeerinfo()) == 0, timeout=10)
assert_equal(len(self.nodes[1].getpeerinfo()), 0) # all nodes must be disconnected at this point assert_equal(len(self.nodes[1].getpeerinfo()), 0) # all nodes must be disconnected at this point
assert_equal(len(self.nodes[1].listbanned()), 1) assert_equal(len(self.nodes[1].listbanned()), 1)
@ -95,7 +94,7 @@ class DisconnectBanTest(BitcoinTestFramework):
self.log.info("disconnectnode: successfully disconnect node by address") self.log.info("disconnectnode: successfully disconnect node by address")
address1 = self.nodes[0].getpeerinfo()[0]['addr'] address1 = self.nodes[0].getpeerinfo()[0]['addr']
self.nodes[0].disconnectnode(address=address1) self.nodes[0].disconnectnode(address=address1)
wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 1, timeout=10) self.wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 1, timeout=10)
assert not [node for node in self.nodes[0].getpeerinfo() if node['addr'] == address1] assert not [node for node in self.nodes[0].getpeerinfo() if node['addr'] == address1]
self.log.info("disconnectnode: successfully reconnect node") self.log.info("disconnectnode: successfully reconnect node")
@ -106,7 +105,7 @@ class DisconnectBanTest(BitcoinTestFramework):
self.log.info("disconnectnode: successfully disconnect node by node id") self.log.info("disconnectnode: successfully disconnect node by node id")
id1 = self.nodes[0].getpeerinfo()[0]['id'] id1 = self.nodes[0].getpeerinfo()[0]['id']
self.nodes[0].disconnectnode(nodeid=id1) self.nodes[0].disconnectnode(nodeid=id1)
wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 1, timeout=10) self.wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 1, timeout=10)
assert not [node for node in self.nodes[0].getpeerinfo() if node['id'] == id1] assert not [node for node in self.nodes[0].getpeerinfo() if node['id'] == id1]
if __name__ == '__main__': if __name__ == '__main__':

4
test/functional/p2p_eviction.py
View file

@ -19,7 +19,7 @@ from test_framework.blocktools import create_block, create_coinbase
from test_framework.messages import CTransaction, FromHex, msg_pong, msg_tx from test_framework.messages import CTransaction, FromHex, msg_pong, msg_tx
from test_framework.p2p import P2PDataStore, P2PInterface from test_framework.p2p import P2PDataStore, P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, wait_until from test_framework.util import assert_equal
class SlowP2PDataStore(P2PDataStore): class SlowP2PDataStore(P2PDataStore):
@ -92,7 +92,7 @@ class P2PEvict(BitcoinTestFramework):
for _ in range(8): for _ in range(8):
fastpeer = node.add_p2p_connection(P2PInterface()) fastpeer = node.add_p2p_connection(P2PInterface())
current_peer += 1 current_peer += 1
wait_until(lambda: "ping" in fastpeer.last_message, timeout=10) self.wait_until(lambda: "ping" in fastpeer.last_message, timeout=10)
# Make sure by asking the node what the actual min pings are # Make sure by asking the node what the actual min pings are
peerinfo = node.getpeerinfo() peerinfo = node.getpeerinfo()

2
test/functional/p2p_feefilter.py
View file

@ -39,7 +39,7 @@ class TestP2PConn(P2PInterface):
def wait_for_invs_to_match(self, invs_expected): def wait_for_invs_to_match(self, invs_expected):
invs_expected.sort() invs_expected.sort()
self.wait_until(lambda: invs_expected == sorted(self.txinvs), timeout=60) self.wait_until(lambda: invs_expected == sorted(self.txinvs))
def clear_invs(self): def clear_invs(self):
with p2p_lock: with p2p_lock:

10
test/functional/p2p_fingerprint.py
View file

@ -22,9 +22,9 @@ from test_framework.p2p import (
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
wait_until,
) )
class P2PFingerprintTest(BitcoinTestFramework): class P2PFingerprintTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
self.setup_clean_chain = True self.setup_clean_chain = True
@ -102,12 +102,12 @@ class P2PFingerprintTest(BitcoinTestFramework):
# Check that getdata request for stale block succeeds # Check that getdata request for stale block succeeds
self.send_block_request(stale_hash, node0) self.send_block_request(stale_hash, node0)
test_function = lambda: self.last_block_equals(stale_hash, node0) test_function = lambda: self.last_block_equals(stale_hash, node0)
wait_until(test_function, timeout=3) self.wait_until(test_function, timeout=3)
# Check that getheader request for stale block header succeeds # Check that getheader request for stale block header succeeds
self.send_header_request(stale_hash, node0) self.send_header_request(stale_hash, node0)
test_function = lambda: self.last_header_equals(stale_hash, node0) test_function = lambda: self.last_header_equals(stale_hash, node0)
wait_until(test_function, timeout=3) self.wait_until(test_function, timeout=3)
# Longest chain is extended so stale is much older than chain tip # Longest chain is extended so stale is much older than chain tip
self.nodes[0].setmocktime(0) self.nodes[0].setmocktime(0)
@ -138,11 +138,11 @@ class P2PFingerprintTest(BitcoinTestFramework):
self.send_block_request(block_hash, node0) self.send_block_request(block_hash, node0)
test_function = lambda: self.last_block_equals(block_hash, node0) test_function = lambda: self.last_block_equals(block_hash, node0)
wait_until(test_function, timeout=3) self.wait_until(test_function, timeout=3)
self.send_header_request(block_hash, node0) self.send_header_request(block_hash, node0)
test_function = lambda: self.last_header_equals(block_hash, node0) test_function = lambda: self.last_header_equals(block_hash, node0)
wait_until(test_function, timeout=3) self.wait_until(test_function, timeout=3)
if __name__ == '__main__': if __name__ == '__main__':
P2PFingerprintTest().main() P2PFingerprintTest().main()

3
test/functional/p2p_invalid_messages.py
View file

@ -24,7 +24,6 @@ from test_framework.p2p import (
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
wait_until,
) )
VALID_DATA_LIMIT = MAX_PROTOCOL_MESSAGE_LENGTH - 5 # Account for the 5-byte length prefix VALID_DATA_LIMIT = MAX_PROTOCOL_MESSAGE_LENGTH - 5 # Account for the 5-byte length prefix
@ -70,7 +69,7 @@ class InvalidMessagesTest(BitcoinTestFramework):
before = int(self.nodes[0].getnettotals()['totalbytesrecv']) before = int(self.nodes[0].getnettotals()['totalbytesrecv'])
conn.send_raw_message(msg[:cut_pos]) conn.send_raw_message(msg[:cut_pos])
# Wait until node has processed the first half of the message # Wait until node has processed the first half of the message
wait_until(lambda: int(self.nodes[0].getnettotals()['totalbytesrecv']) != before) self.wait_until(lambda: int(self.nodes[0].getnettotals()['totalbytesrecv']) != before)
middle = int(self.nodes[0].getnettotals()['totalbytesrecv']) middle = int(self.nodes[0].getnettotals()['totalbytesrecv'])
# If this assert fails, we've hit an unlikely race # If this assert fails, we've hit an unlikely race
# where the test framework sent a message in between the two halves # where the test framework sent a message in between the two halves

3
test/functional/p2p_invalid_tx.py
View file

@ -17,7 +17,6 @@ from test_framework.p2p import P2PDataStore
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
wait_until,
) )
from data import invalid_txs from data import invalid_txs
@ -146,7 +145,7 @@ class InvalidTxRequestTest(BitcoinTestFramework):
# tx_orphan_no_fee, because it has too low fee (p2ps[0] is not disconnected for relaying that tx) # tx_orphan_no_fee, because it has too low fee (p2ps[0] is not disconnected for relaying that tx)
# tx_orphan_invaid, because it has negative fee (p2ps[1] is disconnected for relaying that tx) # tx_orphan_invaid, because it has negative fee (p2ps[1] is disconnected for relaying that tx)
wait_until(lambda: 1 == len(node.getpeerinfo()), timeout=12) # p2ps[1] is no longer connected self.wait_until(lambda: 1 == len(node.getpeerinfo()), timeout=12) # p2ps[1] is no longer connected
assert_equal(expected_mempool, set(node.getrawmempool())) assert_equal(expected_mempool, set(node.getrawmempool()))
self.log.info('Test orphan pool overflow') self.log.info('Test orphan pool overflow')

7
test/functional/p2p_leak.py
View file

@ -22,7 +22,6 @@ from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
assert_greater_than_or_equal, assert_greater_than_or_equal,
wait_until,
) )
DISCOURAGEMENT_THRESHOLD = 100 DISCOURAGEMENT_THRESHOLD = 100
@ -114,9 +113,9 @@ class P2PLeakTest(BitcoinTestFramework):
# verack, since we never sent one # verack, since we never sent one
no_verack_idle_peer.wait_for_verack() no_verack_idle_peer.wait_for_verack()
wait_until(lambda: no_version_disconnect_peer.ever_connected, timeout=10, lock=p2p_lock) self.wait_until(lambda: no_version_disconnect_peer.ever_connected, timeout=10, lock=p2p_lock)
wait_until(lambda: no_version_idle_peer.ever_connected, timeout=10, lock=p2p_lock) self.wait_until(lambda: no_version_idle_peer.ever_connected, timeout=10, lock=p2p_lock)
wait_until(lambda: no_verack_idle_peer.version_received, timeout=10, lock=p2p_lock) self.wait_until(lambda: no_verack_idle_peer.version_received, timeout=10, lock=p2p_lock)
# Mine a block and make sure that it's not sent to the connected peers # Mine a block and make sure that it's not sent to the connected peers
self.nodes[0].generate(nblocks=1) self.nodes[0].generate(nblocks=1)

5
test/functional/p2p_node_network_limited.py
View file

@ -9,13 +9,12 @@ and that it responds to getdata requests for blocks correctly:
- send a block within 288 + 2 of the tip - send a block within 288 + 2 of the tip
- disconnect peers who request blocks older than that.""" - disconnect peers who request blocks older than that."""
from test_framework.messages import CInv, MSG_BLOCK, msg_getdata, msg_verack, NODE_NETWORK_LIMITED, NODE_WITNESS from test_framework.messages import CInv, MSG_BLOCK, msg_getdata, msg_verack, NODE_NETWORK_LIMITED, NODE_WITNESS
from test_framework.p2p import P2PInterface, p2p_lock from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
disconnect_nodes, disconnect_nodes,
connect_nodes, connect_nodes,
wait_until,
) )
@ -28,7 +27,7 @@ class P2PIgnoreInv(P2PInterface):
self.firstAddrnServices = message.addrs[0].nServices self.firstAddrnServices = message.addrs[0].nServices
def wait_for_addr(self, timeout=5): def wait_for_addr(self, timeout=5):
test_function = lambda: self.last_message.get("addr") test_function = lambda: self.last_message.get("addr")
wait_until(test_function, timeout=timeout, lock=p2p_lock) self.wait_until(test_function, timeout=timeout)
def send_getdata_for_block(self, blockhash): def send_getdata_for_block(self, blockhash):
getdata_request = msg_getdata() getdata_request = msg_getdata()
getdata_request.inv.append(CInv(MSG_BLOCK, int(blockhash, 16))) getdata_request.inv.append(CInv(MSG_BLOCK, int(blockhash, 16)))

3
test/functional/p2p_permissions.py
View file

@ -24,7 +24,6 @@ from test_framework.util import (
assert_equal, assert_equal,
connect_nodes, connect_nodes,
p2p_port, p2p_port,
wait_until,
) )
@ -137,7 +136,7 @@ class P2PPermissionsTests(BitcoinTestFramework):
connect_nodes(self.nodes[1], 0) connect_nodes(self.nodes[1], 0)
with self.nodes[1].assert_debug_log(["Force relaying tx {} from peer=0".format(txid)]): with self.nodes[1].assert_debug_log(["Force relaying tx {} from peer=0".format(txid)]):
p2p_rebroadcast_wallet.send_txs_and_test([tx], self.nodes[1]) p2p_rebroadcast_wallet.send_txs_and_test([tx], self.nodes[1])
wait_until(lambda: txid in self.nodes[0].getrawmempool()) self.wait_until(lambda: txid in self.nodes[0].getrawmempool())
self.log.debug("Check that node[1] will not send an invalid tx to node[0]") self.log.debug("Check that node[1] will not send an invalid tx to node[0]")
tx.vout[0].nValue += 1 tx.vout[0].nValue += 1

3
test/functional/p2p_segwit.py
View file

@ -83,7 +83,6 @@ from test_framework.util import (
softfork_active, softfork_active,
hex_str_to_bytes, hex_str_to_bytes,
assert_raises_rpc_error, assert_raises_rpc_error,
wait_until,
) )
# The versionbit bit used to signal activation of SegWit # The versionbit bit used to signal activation of SegWit
@ -2114,7 +2113,7 @@ class SegWitTest(BitcoinTestFramework):
# Check wtxidrelay feature negotiation message through connecting a new peer # Check wtxidrelay feature negotiation message through connecting a new peer
def received_wtxidrelay(): def received_wtxidrelay():
return (len(self.wtx_node.last_wtxidrelay) > 0) return (len(self.wtx_node.last_wtxidrelay) > 0)
wait_until(received_wtxidrelay, timeout=60, lock=p2p_lock) self.wtx_node.wait_until(received_wtxidrelay)
# Create a Segwit output from the latest UTXO # Create a Segwit output from the latest UTXO
# and announce it to the network # and announce it to the network

9
test/functional/p2p_sendheaders.py
View file

@ -104,7 +104,6 @@ from test_framework.p2p import (
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
wait_until,
) )
DIRECT_FETCH_RESPONSE_TIME = 0.05 DIRECT_FETCH_RESPONSE_TIME = 0.05
@ -147,7 +146,7 @@ class BaseNode(P2PInterface):
def wait_for_block_announcement(self, block_hash, timeout=60): def wait_for_block_announcement(self, block_hash, timeout=60):
test_function = lambda: self.last_blockhash_announced == block_hash test_function = lambda: self.last_blockhash_announced == block_hash
wait_until(test_function, timeout=timeout, lock=p2p_lock) self.wait_until(test_function, timeout=timeout)
def on_inv(self, message): def on_inv(self, message):
self.block_announced = True self.block_announced = True
@ -174,7 +173,7 @@ class BaseNode(P2PInterface):
"""Test whether the last headers announcements received are right. """Test whether the last headers announcements received are right.
Headers may be announced across more than one message.""" Headers may be announced across more than one message."""
test_function = lambda: (len(self.recent_headers_announced) >= len(headers)) test_function = lambda: (len(self.recent_headers_announced) >= len(headers))
wait_until(test_function, timeout=60, lock=p2p_lock) self.wait_until(test_function)
with p2p_lock: with p2p_lock:
assert_equal(self.recent_headers_announced, headers) assert_equal(self.recent_headers_announced, headers)
self.block_announced = False self.block_announced = False
@ -186,7 +185,7 @@ class BaseNode(P2PInterface):
inv should be a list of block hashes.""" inv should be a list of block hashes."""
test_function = lambda: self.block_announced test_function = lambda: self.block_announced
wait_until(test_function, timeout=60, lock=p2p_lock) self.wait_until(test_function)
with p2p_lock: with p2p_lock:
compare_inv = [] compare_inv = []
@ -298,7 +297,7 @@ class SendHeadersTest(BitcoinTestFramework):
test_node.send_header_for_blocks([new_block]) test_node.send_header_for_blocks([new_block])
test_node.wait_for_getdata([new_block.sha256]) test_node.wait_for_getdata([new_block.sha256])
test_node.send_and_ping(msg_block(new_block)) # 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=p2p_lock) inv_node.wait_until(lambda: inv_node.block_announced)
inv_node.clear_block_announcements() inv_node.clear_block_announcements()
test_node.clear_block_announcements() test_node.clear_block_announcements()

9
test/functional/p2p_tx_download.py
View file

@ -23,7 +23,6 @@ from test_framework.p2p import (
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
wait_until,
) )
from test_framework.address import ADDRESS_BCRT1_UNSPENDABLE from test_framework.address import ADDRESS_BCRT1_UNSPENDABLE
@ -80,7 +79,7 @@ class TxDownloadTest(BitcoinTestFramework):
while outstanding_peer_index: while outstanding_peer_index:
node_0_mocktime += MAX_GETDATA_INBOUND_WAIT node_0_mocktime += MAX_GETDATA_INBOUND_WAIT
self.nodes[0].setmocktime(node_0_mocktime) self.nodes[0].setmocktime(node_0_mocktime)
wait_until(lambda: any(getdata_found(i) for i in outstanding_peer_index)) self.wait_until(lambda: any(getdata_found(i) for i in outstanding_peer_index))
for i in outstanding_peer_index: for i in outstanding_peer_index:
if getdata_found(i): if getdata_found(i):
outstanding_peer_index.remove(i) outstanding_peer_index.remove(i)
@ -138,20 +137,20 @@ class TxDownloadTest(BitcoinTestFramework):
p.tx_getdata_count = 0 p.tx_getdata_count = 0
p.send_message(msg_inv([CInv(t=MSG_WTX, h=i) for i in txids])) p.send_message(msg_inv([CInv(t=MSG_WTX, h=i) for i in txids]))
wait_until(lambda: p.tx_getdata_count >= MAX_GETDATA_IN_FLIGHT, lock=p2p_lock) p.wait_until(lambda: p.tx_getdata_count >= MAX_GETDATA_IN_FLIGHT)
with p2p_lock: with p2p_lock:
assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT) assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT)
self.log.info("Now check that if we send a NOTFOUND for a transaction, we'll get one more request") self.log.info("Now check that if we send a NOTFOUND for a transaction, we'll get one more request")
p.send_message(msg_notfound(vec=[CInv(t=MSG_WTX, h=txids[0])])) p.send_message(msg_notfound(vec=[CInv(t=MSG_WTX, h=txids[0])]))
wait_until(lambda: p.tx_getdata_count >= MAX_GETDATA_IN_FLIGHT + 1, timeout=10, lock=p2p_lock) p.wait_until(lambda: p.tx_getdata_count >= MAX_GETDATA_IN_FLIGHT + 1, timeout=10)
with p2p_lock: with p2p_lock:
assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT + 1) assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT + 1)
WAIT_TIME = TX_EXPIRY_INTERVAL // 2 + TX_EXPIRY_INTERVAL WAIT_TIME = TX_EXPIRY_INTERVAL // 2 + TX_EXPIRY_INTERVAL
self.log.info("if we wait about {} minutes, we should eventually get more requests".format(WAIT_TIME / 60)) self.log.info("if we wait about {} minutes, we should eventually get more requests".format(WAIT_TIME / 60))
self.nodes[0].setmocktime(int(time.time() + WAIT_TIME)) self.nodes[0].setmocktime(int(time.time() + WAIT_TIME))
wait_until(lambda: p.tx_getdata_count == MAX_GETDATA_IN_FLIGHT + 2) p.wait_until(lambda: p.tx_getdata_count == MAX_GETDATA_IN_FLIGHT + 2)
self.nodes[0].setmocktime(0) self.nodes[0].setmocktime(0)
def test_spurious_notfound(self): def test_spurious_notfound(self):

7
test/functional/rpc_invalidateblock.py
View file

@ -9,7 +9,6 @@ from test_framework.address import ADDRESS_BCRT1_UNSPENDABLE_DESCRIPTOR
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
connect_nodes, connect_nodes,
wait_until,
) )
@ -57,9 +56,9 @@ class InvalidateTest(BitcoinTestFramework):
self.log.info("..and then mine a block") self.log.info("..and then mine a block")
self.nodes[2].generatetoaddress(1, self.nodes[2].get_deterministic_priv_key().address) self.nodes[2].generatetoaddress(1, self.nodes[2].get_deterministic_priv_key().address)
self.log.info("Verify all nodes are at the right height") self.log.info("Verify all nodes are at the right height")
wait_until(lambda: self.nodes[2].getblockcount() == 3, timeout=5) self.wait_until(lambda: self.nodes[2].getblockcount() == 3, timeout=5)
wait_until(lambda: self.nodes[0].getblockcount() == 4, timeout=5) self.wait_until(lambda: self.nodes[0].getblockcount() == 4, timeout=5)
wait_until(lambda: self.nodes[1].getblockcount() == 4, timeout=5) self.wait_until(lambda: self.nodes[1].getblockcount() == 4, timeout=5)
self.log.info("Verify that we reconsider all ancestors as well") self.log.info("Verify that we reconsider all ancestors as well")
blocks = self.nodes[1].generatetodescriptor(10, ADDRESS_BCRT1_UNSPENDABLE_DESCRIPTOR) blocks = self.nodes[1].generatetodescriptor(10, ADDRESS_BCRT1_UNSPENDABLE_DESCRIPTOR)

7
test/functional/rpc_net.py
View file

@ -26,7 +26,6 @@ from test_framework.util import (
assert_raises_rpc_error, assert_raises_rpc_error,
connect_nodes, connect_nodes,
p2p_port, p2p_port,
wait_until,
) )
@ -93,8 +92,8 @@ class NetTest(BitcoinTestFramework):
# the bytes sent/received should change # the bytes sent/received should change
# note ping and pong are 32 bytes each # note ping and pong are 32 bytes each
self.nodes[0].ping() self.nodes[0].ping()
wait_until(lambda: (self.nodes[0].getnettotals()['totalbytessent'] >= net_totals_after['totalbytessent'] + 32 * 2), timeout=1) self.wait_until(lambda: (self.nodes[0].getnettotals()['totalbytessent'] >= net_totals_after['totalbytessent'] + 32 * 2), timeout=1)
wait_until(lambda: (self.nodes[0].getnettotals()['totalbytesrecv'] >= net_totals_after['totalbytesrecv'] + 32 * 2), timeout=1) self.wait_until(lambda: (self.nodes[0].getnettotals()['totalbytesrecv'] >= net_totals_after['totalbytesrecv'] + 32 * 2), timeout=1)
peer_info_after_ping = self.nodes[0].getpeerinfo() peer_info_after_ping = self.nodes[0].getpeerinfo()
for before, after in zip(peer_info, peer_info_after_ping): for before, after in zip(peer_info, peer_info_after_ping):
@ -110,7 +109,7 @@ class NetTest(BitcoinTestFramework):
self.nodes[0].setnetworkactive(state=False) self.nodes[0].setnetworkactive(state=False)
assert_equal(self.nodes[0].getnetworkinfo()['networkactive'], False) assert_equal(self.nodes[0].getnetworkinfo()['networkactive'], False)
# Wait a bit for all sockets to close # Wait a bit for all sockets to close
wait_until(lambda: self.nodes[0].getnetworkinfo()['connections'] == 0, timeout=3) self.wait_until(lambda: self.nodes[0].getnetworkinfo()['connections'] == 0, timeout=3)
with self.nodes[0].assert_debug_log(expected_msgs=['SetNetworkActive: true\n']): with self.nodes[0].assert_debug_log(expected_msgs=['SetNetworkActive: true\n']):
self.nodes[0].setnetworkactive(state=True) self.nodes[0].setnetworkactive(state=True)

8
test/functional/test_framework/util.py
View file

@ -226,6 +226,14 @@ def satoshi_round(amount):
def wait_until(predicate, *, attempts=float('inf'), timeout=float('inf'), lock=None, timeout_factor=1.0): def wait_until(predicate, *, attempts=float('inf'), timeout=float('inf'), lock=None, timeout_factor=1.0):
"""Sleep until the predicate resolves to be True.
Warning: Note that this method is not recommended to be used in tests as it is
not aware of the context of the test framework. Using `wait_until()` counterpart
from `BitcoinTestFramework` or `P2PInterface` class ensures an understandable
amount of timeout and a common shared timeout_factor. Furthermore, `wait_until()`
from `P2PInterface` class in `mininode.py` has a preset lock.
"""
if attempts == float('inf') and timeout == float('inf'): if attempts == float('inf') and timeout == float('inf'):
timeout = 60 timeout = 60
timeout = timeout * timeout_factor timeout = timeout * timeout_factor

12
test/functional/wallet_resendwallettransactions.py
View file

@ -7,9 +7,9 @@ import time
from test_framework.blocktools import create_block, create_coinbase from test_framework.blocktools import create_block, create_coinbase
from test_framework.messages import ToHex from test_framework.messages import ToHex
from test_framework.p2p import P2PTxInvStore, p2p_lock from test_framework.p2p import P2PTxInvStore
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, wait_until from test_framework.util import assert_equal
class ResendWalletTransactionsTest(BitcoinTestFramework): class ResendWalletTransactionsTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
@ -24,7 +24,7 @@ class ResendWalletTransactionsTest(BitcoinTestFramework):
node.add_p2p_connection(P2PTxInvStore()) node.add_p2p_connection(P2PTxInvStore())
self.log.info("Create a new transaction and wait until it's broadcast") self.log.info("Create a new transaction and wait until it's broadcast")
txid = int(node.sendtoaddress(node.getnewaddress(), 1), 16) txid = node.sendtoaddress(node.getnewaddress(), 1)
# Wallet rebroadcast is first scheduled 1 sec after startup (see # Wallet rebroadcast is first scheduled 1 sec after startup (see
# nNextResend in ResendWalletTransactions()). Sleep for just over a # nNextResend in ResendWalletTransactions()). Sleep for just over a
@ -33,7 +33,7 @@ class ResendWalletTransactionsTest(BitcoinTestFramework):
time.sleep(1.1) time.sleep(1.1)
# Can take a few seconds due to transaction trickling # Can take a few seconds due to transaction trickling
wait_until(lambda: node.p2p.tx_invs_received[txid] >= 1, lock=p2p_lock) node.p2p.wait_for_broadcast([txid])
# Add a second peer since txs aren't rebroadcast to the same peer (see filterInventoryKnown) # Add a second peer since txs aren't rebroadcast to the same peer (see filterInventoryKnown)
node.add_p2p_connection(P2PTxInvStore()) node.add_p2p_connection(P2PTxInvStore())
@ -58,13 +58,13 @@ class ResendWalletTransactionsTest(BitcoinTestFramework):
two_min = 2 * 60 two_min = 2 * 60
node.setmocktime(now + twelve_hrs - two_min) node.setmocktime(now + twelve_hrs - two_min)
time.sleep(2) # ensure enough time has passed for rebroadcast attempt to occur time.sleep(2) # ensure enough time has passed for rebroadcast attempt to occur
assert_equal(txid in node.p2ps[1].get_invs(), False) assert_equal(int(txid, 16) in node.p2ps[1].get_invs(), False)
self.log.info("Bump time & check that transaction is rebroadcast") self.log.info("Bump time & check that transaction is rebroadcast")
# Transaction should be rebroadcast approximately 24 hours in the future, # Transaction should be rebroadcast approximately 24 hours in the future,
# but can range from 12-36. So bump 36 hours to be sure. # but can range from 12-36. So bump 36 hours to be sure.
node.setmocktime(now + 36 * 60 * 60) node.setmocktime(now + 36 * 60 * 60)
wait_until(lambda: node.p2ps[1].tx_invs_received[txid] >= 1, lock=p2p_lock) node.p2p.wait_for_broadcast([txid])
if __name__ == '__main__': if __name__ == '__main__':

4
test/functional/wallet_zapwallettxes.py
View file

@ -18,9 +18,9 @@ from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
assert_raises_rpc_error, assert_raises_rpc_error,
wait_until,
) )
class ZapWalletTXesTest (BitcoinTestFramework): class ZapWalletTXesTest (BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
self.setup_clean_chain = True self.setup_clean_chain = True
@ -59,7 +59,7 @@ class ZapWalletTXesTest (BitcoinTestFramework):
# transaction is zapped from the wallet, but is re-added when the mempool is reloaded. # transaction is zapped from the wallet, but is re-added when the mempool is reloaded.
self.restart_node(0, ["-persistmempool=1", "-zapwallettxes=2"]) self.restart_node(0, ["-persistmempool=1", "-zapwallettxes=2"])
wait_until(lambda: self.nodes[0].getmempoolinfo()['size'] == 1, timeout=3) self.wait_until(lambda: self.nodes[0].getmempoolinfo()['size'] == 1, timeout=3)
self.nodes[0].syncwithvalidationinterfacequeue() # Flush mempool to wallet self.nodes[0].syncwithvalidationinterfacequeue() # Flush mempool to wallet
assert_equal(self.nodes[0].gettransaction(txid1)['txid'], txid1) assert_equal(self.nodes[0].gettransaction(txid1)['txid'], txid1)