Browse Source

[tests] TestNode: separate add_node from start_node

Separates the act of creating a TestNode object from starting the node.
The test_framework now keeps track of its list of TestNodes, and test
writers can call start_node() and stop_node() without having to update
the self.nodes list.

Github-Pull: #11121
Rebased-From: 36b6268670
tags/v0.15.1
John Newbery 4 years ago
parent
commit
4d3ba18386
36 changed files with 202 additions and 197 deletions
  1. 3
    3
      test/functional/abandonconflict.py
  2. 4
    5
      test/functional/assumevalid.py
  3. 1
    0
      test/functional/bip9-softforks.py
  4. 1
    1
      test/functional/blockchain.py
  5. 4
    7
      test/functional/bumpfee.py
  6. 0
    1
      test/functional/create_cache.py
  7. 3
    2
      test/functional/dbcrash.py
  8. 1
    1
      test/functional/disconnect_ban.py
  9. 3
    10
      test/functional/forknotify.py
  10. 2
    2
      test/functional/fundrawtransaction.py
  11. 2
    1
      test/functional/import-rescan.py
  12. 1
    1
      test/functional/importmulti.py
  13. 2
    2
      test/functional/keypool-topup.py
  14. 1
    1
      test/functional/keypool.py
  15. 0
    4
      test/functional/listtransactions.py
  16. 1
    1
      test/functional/maxuploadtarget.py
  17. 4
    7
      test/functional/mempool_persist.py
  18. 4
    4
      test/functional/multiwallet.py
  19. 1
    1
      test/functional/p2p-segwit.py
  20. 2
    2
      test/functional/p2p-versionbits-warning.py
  21. 2
    1
      test/functional/proxy_test.py
  22. 15
    9
      test/functional/pruning.py
  23. 0
    4
      test/functional/receivedby.py
  24. 1
    1
      test/functional/reindex.py
  25. 1
    1
      test/functional/resendwallettransactions.py
  26. 7
    6
      test/functional/rpcbind_test.py
  27. 45
    44
      test/functional/smartfees.py
  28. 33
    32
      test/functional/test_framework/test_framework.py
  29. 6
    2
      test/functional/test_framework/test_node.py
  30. 3
    2
      test/functional/wallet-dump.py
  31. 1
    1
      test/functional/wallet-encryption.py
  32. 4
    4
      test/functional/wallet-hd.py
  33. 35
    26
      test/functional/wallet.py
  34. 3
    3
      test/functional/walletbackup.py
  35. 3
    3
      test/functional/zapwallettxes.py
  36. 3
    2
      test/functional/zmq_test.py

+ 3
- 3
test/functional/abandonconflict.py View File

@@ -74,7 +74,7 @@ class AbandonConflictTest(BitcoinTestFramework):
# Restart the node with a higher min relay fee so the parent tx is no longer in mempool
# TODO: redo with eviction
self.stop_node(0)
self.nodes[0] = self.start_node(0, self.options.tmpdir, ["-minrelaytxfee=0.0001"])
self.start_node(0, extra_args=["-minrelaytxfee=0.0001"])

# Verify txs no longer in either node's mempool
assert_equal(len(self.nodes[0].getrawmempool()), 0)
@@ -101,7 +101,7 @@ class AbandonConflictTest(BitcoinTestFramework):

# Verify that even with a low min relay fee, the tx is not reaccepted from wallet on startup once abandoned
self.stop_node(0)
self.nodes[0] = self.start_node(0, self.options.tmpdir, ["-minrelaytxfee=0.00001"])
self.start_node(0, extra_args=["-minrelaytxfee=0.00001"])
assert_equal(len(self.nodes[0].getrawmempool()), 0)
assert_equal(self.nodes[0].getbalance(), balance)

@@ -121,7 +121,7 @@ class AbandonConflictTest(BitcoinTestFramework):

# Remove using high relay fee again
self.stop_node(0)
self.nodes[0] = self.start_node(0, self.options.tmpdir, ["-minrelaytxfee=0.0001"])
self.start_node(0, extra_args=["-minrelaytxfee=0.0001"])
assert_equal(len(self.nodes[0].getrawmempool()), 0)
newbalance = self.nodes[0].getbalance()
assert_equal(newbalance, balance - Decimal("24.9996"))

+ 4
- 5
test/functional/assumevalid.py View File

@@ -60,10 +60,11 @@ class AssumeValidTest(BitcoinTestFramework):
self.num_nodes = 3

def setup_network(self):
self.add_nodes(3, self.options.tmpdir)
# Start node0. We don't start the other nodes yet since
# we need to pre-mine a block with an invalid transaction
# signature so we can pass in the block hash as assumevalid.
self.nodes = [self.start_node(0, self.options.tmpdir)]
self.start_node(0)

def send_blocks_until_disconnected(self, node):
"""Keep sending blocks to the node until we're disconnected."""
@@ -162,15 +163,13 @@ class AssumeValidTest(BitcoinTestFramework):
height += 1

# Start node1 and node2 with assumevalid so they accept a block with a bad signature.
self.nodes.append(self.start_node(1, self.options.tmpdir,
["-assumevalid=" + hex(block102.sha256)]))
self.start_node(1, extra_args=["-assumevalid=" + hex(block102.sha256)])
node1 = BaseNode() # connects to node1
connections.append(NodeConn('127.0.0.1', p2p_port(1), self.nodes[1], node1))
node1.add_connection(connections[1])
node1.wait_for_verack()

self.nodes.append(self.start_node(2, self.options.tmpdir,
["-assumevalid=" + hex(block102.sha256)]))
self.start_node(2, extra_args=["-assumevalid=" + hex(block102.sha256)])
node2 = BaseNode() # connects to node2
connections.append(NodeConn('127.0.0.1', p2p_port(2), self.nodes[2], node2))
node2.add_connection(connections[2])

+ 1
- 0
test/functional/bip9-softforks.py View File

@@ -241,6 +241,7 @@ class BIP9SoftForksTest(ComparisonTestFramework):
# Restart all
self.test.clear_all_connections()
self.stop_nodes()
self.nodes = []
shutil.rmtree(self.options.tmpdir + "/node0")
self.setup_chain()
self.setup_network()

+ 1
- 1
test/functional/blockchain.py View File

@@ -146,7 +146,7 @@ class BlockchainTest(BitcoinTestFramework):
pass # The node already shut down before response
self.log.debug('Node should stop at this height...')
self.nodes[0].process.wait(timeout=BITCOIND_PROC_WAIT_TIMEOUT)
self.nodes[0] = self.start_node(0, self.options.tmpdir)
self.start_node(0)
assert_equal(self.nodes[0].getblockcount(), 207)



+ 4
- 7
test/functional/bumpfee.py View File

@@ -34,21 +34,18 @@ class BumpFeeTest(BitcoinTestFramework):
super().__init__()
self.num_nodes = 2
self.setup_clean_chain = True
self.extra_args = [["-prematurewitness", "-walletprematurewitness", "-walletrbf={}".format(i)]
for i in range(self.num_nodes)]

def setup_network(self, split=False):
extra_args = [["-prematurewitness", "-walletprematurewitness", "-walletrbf={}".format(i)]
for i in range(self.num_nodes)]
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, extra_args)

def run_test(self):
# Encrypt wallet for test_locked_wallet_fails test
self.nodes[1].node_encrypt_wallet(WALLET_PASSPHRASE)
self.nodes[1] = self.start_node(1, self.options.tmpdir, extra_args[1])
self.start_node(1)
self.nodes[1].walletpassphrase(WALLET_PASSPHRASE, WALLET_PASSPHRASE_TIMEOUT)

connect_nodes_bi(self.nodes, 0, 1)
self.sync_all()

def run_test(self):
peer_node, rbf_node = self.nodes
rbf_node_address = rbf_node.getnewaddress()


+ 0
- 1
test/functional/create_cache.py View File

@@ -18,7 +18,6 @@ class CreateCache(BitcoinTestFramework):

# Test network and test nodes are not required:
self.num_nodes = 0
self.nodes = []

def setup_network(self):
pass

+ 3
- 2
test/functional/dbcrash.py View File

@@ -65,7 +65,8 @@ class ChainstateWriteCrashTest(BitcoinTestFramework):

def setup_network(self):
# Need a bit of extra time for the nodes to start up for this test
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, self.extra_args, timewait=90)
self.add_nodes(self.num_nodes, self.options.tmpdir, self.extra_args, timewait=90)
self.start_nodes()
# Leave them unconnected, we'll use submitblock directly in this test

def restart_node(self, node_index, expected_tip):
@@ -78,7 +79,7 @@ class ChainstateWriteCrashTest(BitcoinTestFramework):
while time.time() - time_start < 120:
try:
# Any of these RPC calls could throw due to node crash
self.nodes[node_index] = self.start_node(node_index, self.options.tmpdir, self.extra_args[node_index], timewait=90)
self.start_node(node_index)
self.nodes[node_index].waitforblock(expected_tip)
utxo_hash = self.nodes[node_index].gettxoutsetinfo()['hash_serialized_2']
return utxo_hash

+ 1
- 1
test/functional/disconnect_ban.py View File

@@ -68,8 +68,8 @@ class DisconnectBanTest(BitcoinTestFramework):
assert_equal(len(self.nodes[1].listbanned()), 3)

self.stop_node(1)
self.start_node(1)

self.nodes[1] = self.start_node(1, self.options.tmpdir)
listAfterShutdown = self.nodes[1].listbanned()
assert_equal("127.0.0.0/24", listAfterShutdown[0]['address'])
assert_equal("127.0.0.0/32", listAfterShutdown[1]['address'])

+ 3
- 10
test/functional/forknotify.py View File

@@ -7,7 +7,6 @@ import os
import time

from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import *

class ForkNotifyTest(BitcoinTestFramework):

@@ -17,18 +16,12 @@ class ForkNotifyTest(BitcoinTestFramework):
self.setup_clean_chain = False

def setup_network(self):
self.nodes = []
self.alert_filename = os.path.join(self.options.tmpdir, "alert.txt")
with open(self.alert_filename, 'w', encoding='utf8'):
pass # Just open then close to create zero-length file
self.nodes.append(self.start_node(0, self.options.tmpdir,
["-blockversion=2", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""]))
# Node1 mines block.version=211 blocks
self.nodes.append(self.start_node(1, self.options.tmpdir,
["-blockversion=211"]))
connect_nodes(self.nodes[1], 0)

self.sync_all()
self.extra_args = [["-blockversion=2", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""],
["-blockversion=211"]]
super().setup_network()

def run_test(self):
# Mine 51 up-version blocks

+ 2
- 2
test/functional/fundrawtransaction.py View File

@@ -449,11 +449,11 @@ class RawTransactionsTest(BitcoinTestFramework):
############################################################
# locked wallet test
self.stop_node(0)
self.nodes[1].node_encrypt_wallet("test")
self.stop_node(2)
self.stop_node(3)
self.nodes[1].node_encrypt_wallet("test")

self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir)
self.start_nodes()
# This test is not meant to test fee estimation and we'd like
# to be sure all txs are sent at a consistent desired feerate
for node in self.nodes:

+ 2
- 1
test/functional/import-rescan.py View File

@@ -121,7 +121,8 @@ class ImportRescanTest(BitcoinTestFramework):
if import_node.prune:
extra_args[i] += ["-prune=1"]

self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, extra_args)
self.add_nodes(self.num_nodes, self.options.tmpdir, extra_args)
self.start_nodes()
for i in range(1, self.num_nodes):
connect_nodes(self.nodes[i], 0)


+ 1
- 1
test/functional/importmulti.py View File

@@ -429,7 +429,7 @@ class ImportMultiTest (BitcoinTestFramework):

# restart nodes to check for proper serialization/deserialization of watch only address
self.stop_nodes()
self.nodes = self.start_nodes(2, self.options.tmpdir)
self.start_nodes()
address_assert = self.nodes[1].validateaddress(watchonly_address)
assert_equal(address_assert['iswatchonly'], True)
assert_equal(address_assert['ismine'], False)

+ 2
- 2
test/functional/keypool-topup.py View File

@@ -35,7 +35,7 @@ class KeypoolRestoreTest(BitcoinTestFramework):
self.stop_node(1)

shutil.copyfile(self.tmpdir + "/node1/regtest/wallet.dat", self.tmpdir + "/wallet.bak")
self.nodes[1] = self.start_node(1, self.tmpdir, self.extra_args[1])
self.start_node(1, self.extra_args[1])
connect_nodes_bi(self.nodes, 0, 1)

self.log.info("Generate keys for wallet")
@@ -61,7 +61,7 @@ class KeypoolRestoreTest(BitcoinTestFramework):

self.log.info("Verify keypool is restored and balance is correct")

self.nodes[1] = self.start_node(1, self.tmpdir, self.extra_args[1])
self.start_node(1, self.extra_args[1])
connect_nodes_bi(self.nodes, 0, 1)
self.sync_all()


+ 1
- 1
test/functional/keypool.py View File

@@ -19,7 +19,7 @@ class KeyPoolTest(BitcoinTestFramework):
# Encrypt wallet and wait to terminate
nodes[0].node_encrypt_wallet('test')
# Restart node 0
nodes[0] = self.start_node(0, self.options.tmpdir)
self.start_node(0)
# Keep creating keys
addr = nodes[0].getnewaddress()
addr_data = nodes[0].validateaddress(addr)

+ 0
- 4
test/functional/listtransactions.py View File

@@ -20,11 +20,7 @@ class ListTransactionsTest(BitcoinTestFramework):
super().__init__()
self.num_nodes = 4
self.setup_clean_chain = False

def setup_nodes(self):
#This test requires mocktime
self.enable_mocktime()
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir)

def run_test(self):
# Simple send, 0 to 1:

+ 1
- 1
test/functional/maxuploadtarget.py View File

@@ -147,7 +147,7 @@ class MaxUploadTest(BitcoinTestFramework):
#stop and start node 0 with 1MB maxuploadtarget, whitelist 127.0.0.1
self.log.info("Restarting nodes with -whitelist=127.0.0.1")
self.stop_node(0)
self.nodes[0] = self.start_node(0, self.options.tmpdir, ["-whitelist=127.0.0.1", "-maxuploadtarget=1", "-blockmaxsize=999000"])
self.start_node(0, ["-whitelist=127.0.0.1", "-maxuploadtarget=1", "-blockmaxsize=999000"])

#recreate/reconnect a test node
test_nodes = [TestNode()]

+ 4
- 7
test/functional/mempool_persist.py View File

@@ -63,9 +63,8 @@ class MempoolPersistTest(BitcoinTestFramework):

self.log.debug("Stop-start node0 and node1. Verify that node0 has the transactions in its mempool and node1 does not.")
self.stop_nodes()
self.nodes = []
self.nodes.append(self.start_node(0, self.options.tmpdir))
self.nodes.append(self.start_node(1, self.options.tmpdir))
self.start_node(0)
self.start_node(1)
# Give bitcoind a second to reload the mempool
time.sleep(1)
wait_until(lambda: len(self.nodes[0].getrawmempool()) == 5)
@@ -73,16 +72,14 @@ class MempoolPersistTest(BitcoinTestFramework):

self.log.debug("Stop-start node0 with -persistmempool=0. Verify that it doesn't load its mempool.dat file.")
self.stop_nodes()
self.nodes = []
self.nodes.append(self.start_node(0, self.options.tmpdir, ["-persistmempool=0"]))
self.start_node(0, extra_args=["-persistmempool=0"])
# Give bitcoind a second to reload the mempool
time.sleep(1)
assert_equal(len(self.nodes[0].getrawmempool()), 0)

self.log.debug("Stop-start node0. Verify that it has the transactions in its mempool.")
self.stop_nodes()
self.nodes = []
self.nodes.append(self.start_node(0, self.options.tmpdir))
self.start_node(0)
wait_until(lambda: len(self.nodes[0].getrawmempool()) == 5)

if __name__ == '__main__':

+ 4
- 4
test/functional/multiwallet.py View File

@@ -23,17 +23,17 @@ class MultiWalletTest(BitcoinTestFramework):
self.stop_node(0)

# should not initialize if there are duplicate wallets
self.assert_start_raises_init_error(0, self.options.tmpdir, ['-wallet=w1', '-wallet=w1'], 'Error loading wallet w1. Duplicate -wallet filename specified.')
self.assert_start_raises_init_error(0, ['-wallet=w1', '-wallet=w1'], 'Error loading wallet w1. Duplicate -wallet filename specified.')

# should not initialize if wallet file is a directory
os.mkdir(os.path.join(self.options.tmpdir, 'node0', 'regtest', 'w11'))
self.assert_start_raises_init_error(0, self.options.tmpdir, ['-wallet=w11'], 'Error loading wallet w11. -wallet filename must be a regular file.')
self.assert_start_raises_init_error(0, ['-wallet=w11'], 'Error loading wallet w11. -wallet filename must be a regular file.')

# should not initialize if wallet file is a symlink
os.symlink(os.path.join(self.options.tmpdir, 'node0', 'regtest', 'w1'), os.path.join(self.options.tmpdir, 'node0', 'regtest', 'w12'))
self.assert_start_raises_init_error(0, self.options.tmpdir, ['-wallet=w12'], 'Error loading wallet w12. -wallet filename must be a regular file.')
self.assert_start_raises_init_error(0, ['-wallet=w12'], 'Error loading wallet w12. -wallet filename must be a regular file.')

self.nodes[0] = self.start_node(0, self.options.tmpdir, self.extra_args[0])
self.start_node(0, self.extra_args[0])

w1 = self.nodes[0].get_wallet_rpc("w1")
w2 = self.nodes[0].get_wallet_rpc("w2")

+ 1
- 1
test/functional/p2p-segwit.py View File

@@ -1496,7 +1496,7 @@ class SegWitTest(BitcoinTestFramework):

# Restart with the new binary
self.stop_node(node_id)
self.nodes[node_id] = self.start_node(node_id, self.options.tmpdir)
self.start_node(node_id, extra_args=[])
connect_nodes(self.nodes[0], node_id)

sync_blocks(self.nodes)

+ 2
- 2
test/functional/p2p-versionbits-warning.py View File

@@ -112,7 +112,7 @@ class VersionBitsWarningTest(BitcoinTestFramework):
# Empty out the alert file
with open(self.alert_filename, 'w', encoding='utf8') as _:
pass
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, self.extra_args)
self.start_nodes()

# Connecting one block should be enough to generate an error.
self.nodes[0].generate(1)
@@ -123,7 +123,7 @@ class VersionBitsWarningTest(BitcoinTestFramework):
self.test_versionbits_in_alert_file()

# Test framework expects the node to still be running...
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, self.extra_args)
self.start_nodes()

if __name__ == '__main__':
VersionBitsWarningTest().main()

+ 2
- 1
test/functional/proxy_test.py View File

@@ -89,7 +89,8 @@ class ProxyTest(BitcoinTestFramework):
]
if self.have_ipv6:
args[3] = ['-listen', '-proxy=[%s]:%i' % (self.conf3.addr),'-proxyrandomize=0', '-noonion']
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, extra_args=args)
self.add_nodes(self.num_nodes, self.options.tmpdir, extra_args=args)
self.start_nodes()

def node_test(self, node, proxies, auth, test_onion=True):
rv = []

+ 15
- 9
test/functional/pruning.py View File

@@ -56,6 +56,10 @@ class PruneTest(BitcoinTestFramework):
connect_nodes(self.nodes[0], 4)
sync_blocks(self.nodes[0:5])

def setup_nodes(self):
self.add_nodes(self.num_nodes, self.options.tmpdir, self.extra_args, timewait=900)
self.start_nodes()

def create_big_chain(self):
# Start by creating some coinbases we can spend later
self.nodes[1].generate(200)
@@ -98,7 +102,7 @@ class PruneTest(BitcoinTestFramework):
# Node 2 stays connected, so it hears about the stale blocks and then reorg's when node0 reconnects
# Stopping node 0 also clears its mempool, so it doesn't have node1's transactions to accidentally mine
self.stop_node(0)
self.nodes[0]=self.start_node(0, self.options.tmpdir, self.full_node_default_args, timewait=900)
self.start_node(0, extra_args=self.full_node_default_args)
# Mine 24 blocks in node 1
for i in range(24):
if j == 0:
@@ -126,7 +130,7 @@ class PruneTest(BitcoinTestFramework):
# Reboot node 1 to clear its mempool (hopefully make the invalidate faster)
# Lower the block max size so we don't keep mining all our big mempool transactions (from disconnected blocks)
self.stop_node(1)
self.nodes[1] = self.start_node(1, self.options.tmpdir, ["-maxreceivebuffer=20000","-blockmaxsize=5000", "-checkblocks=5", "-disablesafemode"], timewait=900)
self.start_node(1, extra_args=["-maxreceivebuffer=20000","-blockmaxsize=5000", "-checkblocks=5", "-disablesafemode"])

height = self.nodes[1].getblockcount()
self.log.info("Current block height: %d" % height)
@@ -149,7 +153,7 @@ class PruneTest(BitcoinTestFramework):

# Reboot node1 to clear those giant tx's from mempool
self.stop_node(1)
self.nodes[1] = self.start_node(1, self.options.tmpdir, ["-maxreceivebuffer=20000","-blockmaxsize=5000", "-checkblocks=5", "-disablesafemode"], timewait=900)
self.start_node(1, extra_args=["-maxreceivebuffer=20000","-blockmaxsize=5000", "-checkblocks=5", "-disablesafemode"])

self.log.info("Generating new longer chain of 300 more blocks")
self.nodes[1].generate(300)
@@ -227,13 +231,15 @@ class PruneTest(BitcoinTestFramework):

def manual_test(self, node_number, use_timestamp):
# at this point, node has 995 blocks and has not yet run in prune mode
node = self.nodes[node_number] = self.start_node(node_number, self.options.tmpdir, timewait=900)
self.start_node(node_number)
node = self.nodes[node_number]
assert_equal(node.getblockcount(), 995)
assert_raises_jsonrpc(-1, "not in prune mode", node.pruneblockchain, 500)
self.stop_node(node_number)

# now re-start in manual pruning mode
node = self.nodes[node_number] = self.start_node(node_number, self.options.tmpdir, ["-prune=1"], timewait=900)
self.stop_node(node_number)
self.start_node(node_number, extra_args=["-prune=1"])
node = self.nodes[node_number]
assert_equal(node.getblockcount(), 995)

def height(index):
@@ -307,7 +313,7 @@ class PruneTest(BitcoinTestFramework):

# stop node, start back up with auto-prune at 550MB, make sure still runs
self.stop_node(node_number)
self.nodes[node_number] = self.start_node(node_number, self.options.tmpdir, ["-prune=550"], timewait=900)
self.start_node(node_number, extra_args=["-prune=550"])

self.log.info("Success")

@@ -315,7 +321,7 @@ class PruneTest(BitcoinTestFramework):
# check that the pruning node's wallet is still in good shape
self.log.info("Stop and start pruning node to trigger wallet rescan")
self.stop_node(2)
self.nodes[2] = self.start_node(2, self.options.tmpdir, ["-prune=550"])
self.start_node(2, extra_args=["-prune=550"])
self.log.info("Success")

# check that wallet loads successfully when restarting a pruned node after IBD.
@@ -325,7 +331,7 @@ class PruneTest(BitcoinTestFramework):
nds = [self.nodes[0], self.nodes[5]]
sync_blocks(nds, wait=5, timeout=300)
self.stop_node(5) #stop and start to trigger rescan
self.nodes[5] = self.start_node(5, self.options.tmpdir, ["-prune=550"])
self.start_node(5, extra_args=["-prune=550"])
self.log.info("Success")

def run_test(self):

+ 0
- 4
test/functional/receivedby.py View File

@@ -28,11 +28,7 @@ class ReceivedByTest(BitcoinTestFramework):
super().__init__()
self.num_nodes = 4
self.setup_clean_chain = False

def setup_nodes(self):
#This test requires mocktime
self.enable_mocktime()
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir)

def run_test(self):
'''

+ 1
- 1
test/functional/reindex.py View File

@@ -25,7 +25,7 @@ class ReindexTest(BitcoinTestFramework):
blockcount = self.nodes[0].getblockcount()
self.stop_nodes()
extra_args = [["-reindex-chainstate" if justchainstate else "-reindex", "-checkblockindex=1"]]
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, extra_args)
self.start_nodes(extra_args)
while self.nodes[0].getblockcount() < blockcount:
time.sleep(0.1)
assert_equal(self.nodes[0].getblockcount(), blockcount)

+ 1
- 1
test/functional/resendwallettransactions.py View File

@@ -20,7 +20,7 @@ class ResendWalletTransactionsTest(BitcoinTestFramework):

# Should return an empty array if there aren't unconfirmed wallet transactions.
self.stop_node(0)
self.nodes[0] = self.start_node(0, self.options.tmpdir)
self.start_node(0, extra_args=[])
assert_equal(self.nodes[0].resendwallettransactions(), [])

# Should return an array with the unconfirmed wallet transaction.

+ 7
- 6
test/functional/rpcbind_test.py View File

@@ -20,10 +20,7 @@ class RPCBindTest(BitcoinTestFramework):
self.num_nodes = 1

def setup_network(self):
pass

def setup_nodes(self):
pass
self.add_nodes(self.num_nodes, self.options.tmpdir, None)

def run_bind_test(self, allow_ips, connect_to, addresses, expected):
'''
@@ -31,12 +28,14 @@ class RPCBindTest(BitcoinTestFramework):
then try to connect, and check if the set of bound addresses
matches the expected set.
'''
self.log.info("Bind test for %s" % str(addresses))
expected = [(addr_to_hex(addr), port) for (addr, port) in expected]
base_args = ['-disablewallet', '-nolisten']
if allow_ips:
base_args += ['-rpcallowip=' + x for x in allow_ips]
binds = ['-rpcbind='+addr for addr in addresses]
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, [base_args + binds], connect_to)
self.nodes[0].rpchost = connect_to
self.start_node(0, base_args + binds)
pid = self.nodes[0].process.pid
assert_equal(set(get_bind_addrs(pid)), set(expected))
self.stop_nodes()
@@ -46,8 +45,10 @@ class RPCBindTest(BitcoinTestFramework):
Start a node with rpcallow IP, and request getnetworkinfo
at a non-localhost IP.
'''
self.log.info("Allow IP test for %s:%d" % (rpchost, rpcport))
base_args = ['-disablewallet', '-nolisten'] + ['-rpcallowip='+x for x in allow_ips]
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, [base_args])
self.nodes[0].rpchost = None
self.start_nodes([base_args])
# connect to node through non-loopback interface
node = get_rpc_proxy(rpc_url(get_datadir_path(self.options.tmpdir, 0), 0, "%s:%d" % (rpchost, rpcport)), 0, coveragedir=self.options.coveragedir)
node.getnetworkinfo()

+ 45
- 44
test/functional/smartfees.py View File

@@ -153,57 +153,16 @@ class EstimateFeeTest(BitcoinTestFramework):
But first we need to use one node to create a lot of outputs
which we will use to generate our transactions.
"""
self.nodes = []
self.add_nodes(3, self.options.tmpdir, extra_args=[["-maxorphantx=1000", "-whitelist=127.0.0.1"],
["-blockmaxsize=17000", "-maxorphantx=1000"],
["-blockmaxsize=8000", "-maxorphantx=1000"]])
# Use node0 to mine blocks for input splitting
self.nodes.append(self.start_node(0, self.options.tmpdir, ["-maxorphantx=1000",
"-whitelist=127.0.0.1"]))

self.log.info("This test is time consuming, please be patient")
self.log.info("Splitting inputs so we can generate tx's")
self.txouts = []
self.txouts2 = []
# Split a coinbase into two transaction puzzle outputs
split_inputs(self.nodes[0], self.nodes[0].listunspent(0), self.txouts, True)

# Mine
while (len(self.nodes[0].getrawmempool()) > 0):
self.nodes[0].generate(1)

# Repeatedly split those 2 outputs, doubling twice for each rep
# Use txouts to monitor the available utxo, since these won't be tracked in wallet
reps = 0
while (reps < 5):
#Double txouts to txouts2
while (len(self.txouts)>0):
split_inputs(self.nodes[0], self.txouts, self.txouts2)
while (len(self.nodes[0].getrawmempool()) > 0):
self.nodes[0].generate(1)
#Double txouts2 to txouts
while (len(self.txouts2)>0):
split_inputs(self.nodes[0], self.txouts2, self.txouts)
while (len(self.nodes[0].getrawmempool()) > 0):
self.nodes[0].generate(1)
reps += 1
self.log.info("Finished splitting")

# Now we can connect the other nodes, didn't want to connect them earlier
# so the estimates would not be affected by the splitting transactions
# Node1 mines small blocks but that are bigger than the expected transaction rate.
# NOTE: the CreateNewBlock code starts counting block size at 1,000 bytes,
# (17k is room enough for 110 or so transactions)
self.nodes.append(self.start_node(1, self.options.tmpdir,
["-blockmaxsize=17000", "-maxorphantx=1000"]))
connect_nodes(self.nodes[1], 0)

# Node2 is a stingy miner, that
# produces too small blocks (room for only 55 or so transactions)
node2args = ["-blockmaxsize=8000", "-maxorphantx=1000"]

self.nodes.append(self.start_node(2, self.options.tmpdir, node2args))
connect_nodes(self.nodes[0], 2)
connect_nodes(self.nodes[2], 1)

self.sync_all()

def transact_and_mine(self, numblocks, mining_node):
min_fee = Decimal("0.00001")
@@ -232,9 +191,51 @@ class EstimateFeeTest(BitcoinTestFramework):
self.memutxo = newmem

def run_test(self):
self.log.info("This test is time consuming, please be patient")
self.log.info("Splitting inputs so we can generate tx's")

# Make log handler available to helper functions
global log
log = self.log

# Start node0
self.start_node(0)
self.txouts = []
self.txouts2 = []
# Split a coinbase into two transaction puzzle outputs
split_inputs(self.nodes[0], self.nodes[0].listunspent(0), self.txouts, True)

# Mine
while (len(self.nodes[0].getrawmempool()) > 0):
self.nodes[0].generate(1)

# Repeatedly split those 2 outputs, doubling twice for each rep
# Use txouts to monitor the available utxo, since these won't be tracked in wallet
reps = 0
while (reps < 5):
#Double txouts to txouts2
while (len(self.txouts)>0):
split_inputs(self.nodes[0], self.txouts, self.txouts2)
while (len(self.nodes[0].getrawmempool()) > 0):
self.nodes[0].generate(1)
#Double txouts2 to txouts
while (len(self.txouts2)>0):
split_inputs(self.nodes[0], self.txouts2, self.txouts)
while (len(self.nodes[0].getrawmempool()) > 0):
self.nodes[0].generate(1)
reps += 1
self.log.info("Finished splitting")

# Now we can connect the other nodes, didn't want to connect them earlier
# so the estimates would not be affected by the splitting transactions
self.start_node(1)
self.start_node(2)
connect_nodes(self.nodes[1], 0)
connect_nodes(self.nodes[0], 2)
connect_nodes(self.nodes[2], 1)

self.sync_all()

self.fees_per_kb = []
self.memutxo = []
self.confutxo = self.txouts # Start with the set of confirmed txouts after splitting

+ 33
- 32
test/functional/test_framework/test_framework.py View File

@@ -91,7 +91,8 @@ class BitcoinTestFramework(object):
extra_args = None
if hasattr(self, "extra_args"):
extra_args = self.extra_args
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, extra_args)
self.add_nodes(self.num_nodes, self.options.tmpdir, extra_args)
self.start_nodes()

def run_test(self):
raise NotImplementedError
@@ -204,37 +205,39 @@ class BitcoinTestFramework(object):

# Public helper methods. These can be accessed by the subclass test scripts.

def start_node(self, i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None, stderr=None):
"""Start a bitcoind and return RPC connection to it"""
def add_nodes(self, num_nodes, dirname, extra_args=None, rpchost=None, timewait=None, binary=None):
"""Instantiate TestNode objects"""

if extra_args is None:
extra_args = []
extra_args = [[]] * num_nodes
if binary is None:
binary = os.getenv("BITCOIND", "bitcoind")
node = TestNode(i, dirname, extra_args, rpchost, timewait, binary, stderr, self.mocktime, coverage_dir=self.options.coveragedir)
node.start()
binary = [None] * num_nodes
assert_equal(len(extra_args), num_nodes)
assert_equal(len(binary), num_nodes)
for i in range(num_nodes):
self.nodes.append(TestNode(i, dirname, extra_args[i], rpchost, timewait=timewait, binary=binary[i], stderr=None, mocktime=self.mocktime, coverage_dir=self.options.coveragedir))

def start_node(self, i, extra_args=None, stderr=None):
"""Start a bitcoind"""

node = self.nodes[i]

node.start(extra_args, stderr)
node.wait_for_rpc_connection()

if self.options.coveragedir is not None:
coverage.write_all_rpc_commands(self.options.coveragedir, node.rpc)

return node

def start_nodes(self, num_nodes, dirname, extra_args=None, rpchost=None, timewait=None, binary=None):
"""Start multiple bitcoinds, return RPC connections to them"""
def start_nodes(self, extra_args=None):
"""Start multiple bitcoinds"""

if extra_args is None:
extra_args = [[]] * num_nodes
if binary is None:
binary = [None] * num_nodes
assert_equal(len(extra_args), num_nodes)
assert_equal(len(binary), num_nodes)
nodes = []
extra_args = [None] * self.num_nodes
assert_equal(len(extra_args), self.num_nodes)
try:
for i in range(num_nodes):
nodes.append(TestNode(i, dirname, extra_args[i], rpchost, timewait=timewait, binary=binary[i], stderr=None, mocktime=self.mocktime, coverage_dir=self.options.coveragedir))
nodes[i].start()
for node in nodes:
for i, node in enumerate(self.nodes):
node.start(extra_args[i])
for node in self.nodes:
node.wait_for_rpc_connection()
except:
# If one node failed to start, stop the others
@@ -242,11 +245,9 @@ class BitcoinTestFramework(object):
raise

if self.options.coveragedir is not None:
for node in nodes:
for node in self.nodes:
coverage.write_all_rpc_commands(self.options.coveragedir, node.rpc)

return nodes

def stop_node(self, i):
"""Stop a bitcoind test node"""
self.nodes[i].stop_node()
@@ -264,10 +265,10 @@ class BitcoinTestFramework(object):
while not node.is_node_stopped():
time.sleep(0.1)

def assert_start_raises_init_error(self, i, dirname, extra_args=None, expected_msg=None):
def assert_start_raises_init_error(self, i, extra_args=None, expected_msg=None):
with tempfile.SpooledTemporaryFile(max_size=2**16) as log_stderr:
try:
self.start_node(i, dirname, extra_args, stderr=log_stderr)
self.start_node(i, extra_args, stderr=log_stderr)
self.stop_node(i)
except Exception as e:
assert 'bitcoind exited' in str(e) # node must have shutdown
@@ -385,7 +386,7 @@ class BitcoinTestFramework(object):
args.append("-connect=127.0.0.1:" + str(p2p_port(0)))
self.nodes.append(TestNode(i, cachedir, extra_args=[], rpchost=None, timewait=None, binary=None, stderr=None, mocktime=self.mocktime, coverage_dir=None))
self.nodes[i].args = args
self.nodes[i].start()
self.start_node(i)

# Wait for RPC connections to be ready
for node in self.nodes:
@@ -455,13 +456,13 @@ class ComparisonTestFramework(BitcoinTestFramework):
help="bitcoind binary to use for reference nodes (if any)")

def setup_network(self):
extra_args = [['-whitelist=127.0.0.1']]*self.num_nodes
extra_args = [['-whitelist=127.0.0.1']] * self.num_nodes
if hasattr(self, "extra_args"):
extra_args = self.extra_args
self.nodes = self.start_nodes(
self.num_nodes, self.options.tmpdir, extra_args,
binary=[self.options.testbinary] +
[self.options.refbinary] * (self.num_nodes - 1))
self.add_nodes(self.num_nodes, self.options.tmpdir, extra_args,
binary=[self.options.testbinary] +
[self.options.refbinary] * (self.num_nodes - 1))
self.start_nodes()

class SkipTest(Exception):
"""This exception is raised to skip a test"""

+ 6
- 2
test/functional/test_framework/test_node.py View File

@@ -65,9 +65,13 @@ class TestNode():
assert self.rpc_connected and self.rpc is not None, "Error: no RPC connection"
return self.rpc.__getattr__(*args, **kwargs)

def start(self):
def start(self, extra_args=None, stderr=None):
"""Start the node."""
self.process = subprocess.Popen(self.args + self.extra_args, stderr=self.stderr)
if extra_args is None:
extra_args = self.extra_args
if stderr is None:
stderr = self.stderr
self.process = subprocess.Popen(self.args + extra_args, stderr=stderr)
self.running = True
self.log.debug("bitcoind started, waiting for RPC to come up")


+ 3
- 2
test/functional/wallet-dump.py View File

@@ -68,7 +68,8 @@ class WalletDumpTest(BitcoinTestFramework):
# longer than the default 30 seconds due to an expensive
# CWallet::TopUpKeyPool call, and the encryptwallet RPC made later in
# the test often takes even longer.
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, self.extra_args, timewait=60)
self.add_nodes(self.num_nodes, self.options.tmpdir, self.extra_args, timewait=60)
self.start_nodes()

def run_test (self):
tmpdir = self.options.tmpdir
@@ -95,7 +96,7 @@ class WalletDumpTest(BitcoinTestFramework):

#encrypt wallet, restart, unlock and dump
self.nodes[0].node_encrypt_wallet('test')
self.nodes[0] = self.start_node(0, self.options.tmpdir, self.extra_args[0])
self.start_node(0)
self.nodes[0].walletpassphrase('test', 10)
# Should be a no-op:
self.nodes[0].keypoolrefill()

+ 1
- 1
test/functional/wallet-encryption.py View File

@@ -31,7 +31,7 @@ class WalletEncryptionTest(BitcoinTestFramework):

# Encrypt the wallet
self.nodes[0].node_encrypt_wallet(passphrase)
self.nodes[0] = self.start_node(0, self.options.tmpdir)
self.start_node(0)

# Test that the wallet is encrypted
assert_raises_jsonrpc(-13, "Please enter the wallet passphrase with walletpassphrase first", self.nodes[0].dumpprivkey, address)

+ 4
- 4
test/functional/wallet-hd.py View File

@@ -25,8 +25,8 @@ class WalletHDTest(BitcoinTestFramework):

# Make sure can't switch off usehd after wallet creation
self.stop_node(1)
self.assert_start_raises_init_error(1, self.options.tmpdir, ['-usehd=0'], 'already existing HD wallet')
self.nodes[1] = self.start_node(1, self.options.tmpdir, self.extra_args[1])
self.assert_start_raises_init_error(1, ['-usehd=0'], 'already existing HD wallet')
self.start_node(1)
connect_nodes_bi(self.nodes, 0, 1)

# Make sure we use hd, keep masterkeyid
@@ -76,7 +76,7 @@ class WalletHDTest(BitcoinTestFramework):
shutil.rmtree(tmpdir + "/node1/regtest/blocks")
shutil.rmtree(tmpdir + "/node1/regtest/chainstate")
shutil.copyfile(tmpdir + "/hd.bak", tmpdir + "/node1/regtest/wallet.dat")
self.nodes[1] = self.start_node(1, self.options.tmpdir, self.extra_args[1])
self.start_node(1)

# Assert that derivation is deterministic
hd_add_2 = None
@@ -91,7 +91,7 @@ class WalletHDTest(BitcoinTestFramework):

# Needs rescan
self.stop_node(1)
self.nodes[1] = self.start_node(1, self.options.tmpdir, self.extra_args[1] + ['-rescan'])
self.start_node(1, extra_args=self.extra_args[1] + ['-rescan'])
assert_equal(self.nodes[1].getbalance(), num_hd_adds + 1)

# send a tx and make sure its using the internal chain for the changeoutput

+ 35
- 26
test/functional/wallet.py View File

@@ -21,11 +21,14 @@ class WalletTest(BitcoinTestFramework):
self.extra_args = [['-usehd={:d}'.format(i%2==0)] for i in range(4)]

def setup_network(self):
self.nodes = self.start_nodes(3, self.options.tmpdir, self.extra_args[:3])
self.add_nodes(4, self.options.tmpdir, self.extra_args)
self.start_node(0)
self.start_node(1)
self.start_node(2)
connect_nodes_bi(self.nodes,0,1)
connect_nodes_bi(self.nodes,1,2)
connect_nodes_bi(self.nodes,0,2)
self.sync_all()
self.sync_all([self.nodes[0:3]])

def run_test(self):

@@ -42,9 +45,9 @@ class WalletTest(BitcoinTestFramework):
assert_equal(walletinfo['immature_balance'], 50)
assert_equal(walletinfo['balance'], 0)

self.sync_all()
self.sync_all([self.nodes[0:3]])
self.nodes[1].generate(101)
self.sync_all()
self.sync_all([self.nodes[0:3]])

assert_equal(self.nodes[0].getbalance(), 50)
assert_equal(self.nodes[1].getbalance(), 50)
@@ -96,7 +99,7 @@ class WalletTest(BitcoinTestFramework):

# Have node0 mine a block, thus it will collect its own fee.
self.nodes[0].generate(1)
self.sync_all()
self.sync_all([self.nodes[0:3]])

# Exercise locking of unspent outputs
unspent_0 = self.nodes[2].listunspent()[0]
@@ -109,7 +112,7 @@ class WalletTest(BitcoinTestFramework):

# Have node1 generate 100 blocks (so node0 can recover the fee)
self.nodes[1].generate(100)
self.sync_all()
self.sync_all([self.nodes[0:3]])

# node0 should end up with 100 btc in block rewards plus fees, but
# minus the 21 plus fees sent to node2
@@ -138,7 +141,7 @@ class WalletTest(BitcoinTestFramework):

# Have node1 mine a block to confirm transactions:
self.nodes[1].generate(1)
self.sync_all()
self.sync_all([self.nodes[0:3]])

assert_equal(self.nodes[0].getbalance(), 0)
assert_equal(self.nodes[2].getbalance(), 94)
@@ -150,14 +153,14 @@ class WalletTest(BitcoinTestFramework):
self.nodes[2].settxfee(fee_per_byte * 1000)
txid = self.nodes[2].sendtoaddress(address, 10, "", "", False)
self.nodes[2].generate(1)
self.sync_all()
self.sync_all([self.nodes[0:3]])
node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), Decimal('84'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
assert_equal(self.nodes[0].getbalance(), Decimal('10'))

# Send 10 BTC with subtract fee from amount
txid = self.nodes[2].sendtoaddress(address, 10, "", "", True)
self.nodes[2].generate(1)
self.sync_all()
self.sync_all([self.nodes[0:3]])
node_2_bal -= Decimal('10')
assert_equal(self.nodes[2].getbalance(), node_2_bal)
node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal('20'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
@@ -165,7 +168,7 @@ class WalletTest(BitcoinTestFramework):
# Sendmany 10 BTC
txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [])
self.nodes[2].generate(1)
self.sync_all()
self.sync_all([self.nodes[0:3]])
node_0_bal += Decimal('10')
node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), node_2_bal - Decimal('10'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
assert_equal(self.nodes[0].getbalance(), node_0_bal)
@@ -173,7 +176,7 @@ class WalletTest(BitcoinTestFramework):
# Sendmany 10 BTC with subtract fee from amount
txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [address])
self.nodes[2].generate(1)
self.sync_all()
self.sync_all([self.nodes[0:3]])
node_2_bal -= Decimal('10')
assert_equal(self.nodes[2].getbalance(), node_2_bal)
node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), node_0_bal + Decimal('10'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
@@ -184,9 +187,9 @@ class WalletTest(BitcoinTestFramework):
# EXPECT: nodes[3] should have those transactions in its mempool.
txid1 = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1)
txid2 = self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1)
sync_mempools(self.nodes)
sync_mempools(self.nodes[0:2])

self.nodes.append(self.start_node(3, self.options.tmpdir, self.extra_args[3]))
self.start_node(3)
connect_nodes_bi(self.nodes, 0, 3)
sync_blocks(self.nodes)

@@ -230,22 +233,24 @@ class WalletTest(BitcoinTestFramework):

#do some -walletbroadcast tests
self.stop_nodes()
self.nodes = self.start_nodes(3, self.options.tmpdir, [["-walletbroadcast=0"],["-walletbroadcast=0"],["-walletbroadcast=0"]])
self.start_node(0, ["-walletbroadcast=0"])
self.start_node(1, ["-walletbroadcast=0"])
self.start_node(2, ["-walletbroadcast=0"])
connect_nodes_bi(self.nodes,0,1)
connect_nodes_bi(self.nodes,1,2)
connect_nodes_bi(self.nodes,0,2)
self.sync_all()
self.sync_all([self.nodes[0:3]])

txIdNotBroadcasted = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 2)
txObjNotBroadcasted = self.nodes[0].gettransaction(txIdNotBroadcasted)
self.nodes[1].generate(1) #mine a block, tx should not be in there
self.sync_all()
self.sync_all([self.nodes[0:3]])
assert_equal(self.nodes[2].getbalance(), node_2_bal) #should not be changed because tx was not broadcasted

#now broadcast from another node, mine a block, sync, and check the balance
self.nodes[1].sendrawtransaction(txObjNotBroadcasted['hex'])
self.nodes[1].generate(1)
self.sync_all()
self.sync_all([self.nodes[0:3]])
node_2_bal += 2
txObjNotBroadcasted = self.nodes[0].gettransaction(txIdNotBroadcasted)
assert_equal(self.nodes[2].getbalance(), node_2_bal)
@@ -255,14 +260,16 @@ class WalletTest(BitcoinTestFramework):

#restart the nodes with -walletbroadcast=1
self.stop_nodes()
self.nodes = self.start_nodes(3, self.options.tmpdir)
self.start_node(0)
self.start_node(1)
self.start_node(2)
connect_nodes_bi(self.nodes,0,1)
connect_nodes_bi(self.nodes,1,2)
connect_nodes_bi(self.nodes,0,2)
sync_blocks(self.nodes)
sync_blocks(self.nodes[0:3])

self.nodes[0].generate(1)
sync_blocks(self.nodes)
sync_blocks(self.nodes[0:3])
node_2_bal += 2

#tx should be added to balance because after restarting the nodes tx should be broadcastet
@@ -293,7 +300,7 @@ class WalletTest(BitcoinTestFramework):
address_to_import = self.nodes[2].getnewaddress()
txid = self.nodes[0].sendtoaddress(address_to_import, 1)
self.nodes[0].generate(1)
self.sync_all()
self.sync_all([self.nodes[0:3]])

# 2. Import address from node2 to node1
self.nodes[1].importaddress(address_to_import)
@@ -319,15 +326,15 @@ class WalletTest(BitcoinTestFramework):
cbAddr = self.nodes[1].getnewaddress()
blkHash = self.nodes[0].generatetoaddress(1, cbAddr)[0]
cbTxId = self.nodes[0].getblock(blkHash)['tx'][0]
self.sync_all()
self.sync_all([self.nodes[0:3]])

# Check that the txid and balance is found by node1
self.nodes[1].gettransaction(cbTxId)

# check if wallet or blockchain maintenance changes the balance
self.sync_all()
self.sync_all([self.nodes[0:3]])
blocks = self.nodes[0].generate(2)
self.sync_all()
self.sync_all([self.nodes[0:3]])
balance_nodes = [self.nodes[i].getbalance() for i in range(3)]
block_count = self.nodes[0].getblockcount()

@@ -358,7 +365,9 @@ class WalletTest(BitcoinTestFramework):
self.log.info("check " + m)
self.stop_nodes()
# set lower ancestor limit for later
self.nodes = self.start_nodes(3, self.options.tmpdir, [[m, "-limitancestorcount="+str(chainlimit)]] * 3)
self.start_node(0, [m, "-limitancestorcount="+str(chainlimit)])
self.start_node(1, [m, "-limitancestorcount="+str(chainlimit)])
self.start_node(2, [m, "-limitancestorcount="+str(chainlimit)])
while m == '-reindex' and [block_count] * 3 != [self.nodes[i].getblockcount() for i in range(3)]:
# reindex will leave rpc warm up "early"; Wait for it to finish
time.sleep(0.1)
@@ -406,7 +415,7 @@ class WalletTest(BitcoinTestFramework):
# Try with walletrejectlongchains
# Double chain limit but require combining inputs, so we pass SelectCoinsMinConf
self.stop_node(0)
self.nodes[0] = self.start_node(0, self.options.tmpdir, ["-walletrejectlongchains", "-limitancestorcount="+str(2*chainlimit)])
self.start_node(0, extra_args=["-walletrejectlongchains", "-limitancestorcount="+str(2*chainlimit)])

# wait for loadmempool
timeout = 10

+ 3
- 3
test/functional/walletbackup.py View File

@@ -78,9 +78,9 @@ class WalletBackupTest(BitcoinTestFramework):

# As above, this mirrors the original bash test.
def start_three(self):
self.nodes[0] = self.start_node(0, self.options.tmpdir)
self.nodes[1] = self.start_node(1, self.options.tmpdir)
self.nodes[2] = self.start_node(2, self.options.tmpdir)
self.start_node(0)
self.start_node(1)
self.start_node(2)
connect_nodes(self.nodes[0], 3)
connect_nodes(self.nodes[1], 3)
connect_nodes(self.nodes[2], 3)

+ 3
- 3
test/functional/zapwallettxes.py View File

@@ -48,7 +48,7 @@ class ZapWalletTXesTest (BitcoinTestFramework):

# Stop-start node0. Both confirmed and unconfirmed transactions remain in the wallet.
self.stop_node(0)
self.nodes[0] = self.start_node(0, self.options.tmpdir)
self.start_node(0)

assert_equal(self.nodes[0].gettransaction(txid1)['txid'], txid1)
assert_equal(self.nodes[0].gettransaction(txid2)['txid'], txid2)
@@ -56,7 +56,7 @@ class ZapWalletTXesTest (BitcoinTestFramework):
# Stop node0 and restart with zapwallettxes and persistmempool. The unconfirmed
# transaction is zapped from the wallet, but is re-added when the mempool is reloaded.
self.stop_node(0)
self.nodes[0] = self.start_node(0, self.options.tmpdir, ["-persistmempool=1", "-zapwallettxes=2"])
self.start_node(0, ["-persistmempool=1", "-zapwallettxes=2"])

assert_equal(self.nodes[0].gettransaction(txid1)['txid'], txid1)
assert_equal(self.nodes[0].gettransaction(txid2)['txid'], txid2)
@@ -64,7 +64,7 @@ class ZapWalletTXesTest (BitcoinTestFramework):
# Stop node0 and restart with zapwallettxes, but not persistmempool.
# The unconfirmed transaction is zapped and is no longer in the wallet.
self.stop_node(0)
self.nodes[0] = self.start_node(0, self.options.tmpdir, ["-zapwallettxes=2"])
self.start_node(0, ["-zapwallettxes=2"])

# tx1 is still be available because it was confirmed
assert_equal(self.nodes[0].gettransaction(txid1)['txid'], txid1)

+ 3
- 2
test/functional/zmq_test.py View File

@@ -41,8 +41,9 @@ class ZMQTest (BitcoinTestFramework):
self.zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashtx")
ip_address = "tcp://127.0.0.1:28332"
self.zmqSubSocket.connect(ip_address)
extra_args = [['-zmqpubhashtx=%s' % ip_address, '-zmqpubhashblock=%s' % ip_address], []]
self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, extra_args)
self.extra_args = [['-zmqpubhashtx=%s' % ip_address, '-zmqpubhashblock=%s' % ip_address], []]
self.add_nodes(self.num_nodes, self.options.tmpdir, self.extra_args)
self.start_nodes()

def run_test(self):
try:

Loading…
Cancel
Save