kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

[tests] use TestNode p2p connection in tests

0.16
John Newbery 7 years ago
parent
5e5725cc2b
commit
32ae82f5c3
14 changed files with 160 additions and 249 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 46
      test/functional/assumevalid.py
  2. 39
      test/functional/bip65-cltv-p2p.py
  3. 40
      test/functional/bipdersig-p2p.py
  4. 71
      test/functional/maxuploadtarget.py
  5. 26
      test/functional/p2p-acceptblock.py
  6. 17
      test/functional/p2p-compactblocks.py
  7. 26
      test/functional/p2p-feefilter.py
  8. 7
      test/functional/p2p-fingerprint.py
  9. 35
      test/functional/p2p-leaktests.py
  10. 12
      test/functional/p2p-mempool.py
  11. 19
      test/functional/p2p-segwit.py
  12. 43
      test/functional/p2p-timeouts.py
  13. 12
      test/functional/p2p-versionbits-warning.py
  14. 16
      test/functional/sendheaders.py

46
test/functional/assumevalid.py
Unescape View File

@ -39,13 +39,12 @@ from test_framework.mininode import (CBlockHeader,
CTxIn, CTxIn,
CTxOut, CTxOut,
NetworkThread, NetworkThread,
NodeConn,
NodeConnCB, NodeConnCB,
msg_block, msg_block,
msg_headers) msg_headers)
from test_framework.script import (CScript, OP_TRUE) from test_framework.script import (CScript, OP_TRUE)
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import (p2p_port, assert_equal) from test_framework.util import assert_equal
class BaseNode(NodeConnCB): class BaseNode(NodeConnCB):
def send_header_for_blocks(self, new_blocks): def send_header_for_blocks(self, new_blocks):
@ -65,13 +64,13 @@ class AssumeValidTest(BitcoinTestFramework):
# signature so we can pass in the block hash as assumevalid. # signature so we can pass in the block hash as assumevalid.
self.start_node(0) self.start_node(0)
def send_blocks_until_disconnected(self, node): def send_blocks_until_disconnected(self, p2p_conn):
"""Keep sending blocks to the node until we're disconnected.""" """Keep sending blocks to the node until we're disconnected."""
for i in range(len(self.blocks)): for i in range(len(self.blocks)):
if not node.connection: if not p2p_conn.connection:
break break
try: try:
node.send_message(msg_block(self.blocks[i])) p2p_conn.send_message(msg_block(self.blocks[i]))
except IOError as e: except IOError as e:
assert str(e) == 'Not connected, no pushbuf' assert str(e) == 'Not connected, no pushbuf'
break break
@ -97,13 +96,10 @@ class AssumeValidTest(BitcoinTestFramework):
def run_test(self): def run_test(self):
# Connect to node0 # Connect to node0
node0 = BaseNode() p2p0 = self.nodes[0].add_p2p_connection(BaseNode())
connections = []
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
node0.add_connection(connections[0])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
node0.wait_for_verack() self.nodes[0].p2p.wait_for_verack()
# Build the blockchain # Build the blockchain
self.tip = int(self.nodes[0].getbestblockhash(), 16) self.tip = int(self.nodes[0].getbestblockhash(), 16)
@ -165,37 +161,33 @@ class AssumeValidTest(BitcoinTestFramework):
# Start node1 and node2 with assumevalid so they accept a block with a bad signature. # Start node1 and node2 with assumevalid so they accept a block with a bad signature.
self.start_node(1, extra_args=["-assumevalid=" + hex(block102.sha256)]) self.start_node(1, extra_args=["-assumevalid=" + hex(block102.sha256)])
node1 = BaseNode() # connects to node1 p2p1 = self.nodes[1].add_p2p_connection(BaseNode())
connections.append(NodeConn('127.0.0.1', p2p_port(1), self.nodes[1], node1)) p2p1.wait_for_verack()
node1.add_connection(connections[1])
node1.wait_for_verack()
self.start_node(2, extra_args=["-assumevalid=" + hex(block102.sha256)]) self.start_node(2, extra_args=["-assumevalid=" + hex(block102.sha256)])
node2 = BaseNode() # connects to node2 p2p2 = self.nodes[2].add_p2p_connection(BaseNode())
connections.append(NodeConn('127.0.0.1', p2p_port(2), self.nodes[2], node2)) p2p2.wait_for_verack()
node2.add_connection(connections[2])
node2.wait_for_verack()
# send header lists to all three nodes # send header lists to all three nodes
node0.send_header_for_blocks(self.blocks[0:2000]) p2p0.send_header_for_blocks(self.blocks[0:2000])
node0.send_header_for_blocks(self.blocks[2000:]) p2p0.send_header_for_blocks(self.blocks[2000:])
node1.send_header_for_blocks(self.blocks[0:2000]) p2p1.send_header_for_blocks(self.blocks[0:2000])
node1.send_header_for_blocks(self.blocks[2000:]) p2p1.send_header_for_blocks(self.blocks[2000:])
node2.send_header_for_blocks(self.blocks[0:200]) p2p2.send_header_for_blocks(self.blocks[0:200])
# Send blocks to node0. Block 102 will be rejected. # Send blocks to node0. Block 102 will be rejected.
self.send_blocks_until_disconnected(node0) self.send_blocks_until_disconnected(p2p0)
self.assert_blockchain_height(self.nodes[0], 101) self.assert_blockchain_height(self.nodes[0], 101)
# Send all blocks to node1. All blocks will be accepted. # Send all blocks to node1. All blocks will be accepted.
for i in range(2202): for i in range(2202):
node1.send_message(msg_block(self.blocks[i])) p2p1.send_message(msg_block(self.blocks[i]))
# Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync. # Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
node1.sync_with_ping(120) p2p1.sync_with_ping(120)
assert_equal(self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'], 2202) assert_equal(self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'], 2202)
# Send blocks to node2. Block 102 will be rejected. # Send blocks to node2. Block 102 will be rejected.
self.send_blocks_until_disconnected(node2) self.send_blocks_until_disconnected(p2p2)
self.assert_blockchain_height(self.nodes[2], 101) self.assert_blockchain_height(self.nodes[2], 101)
if __name__ == '__main__': if __name__ == '__main__':

39
test/functional/bip65-cltv-p2p.py
Unescape View File

@ -66,15 +66,12 @@ class BIP65Test(BitcoinTestFramework):
self.setup_clean_chain = True self.setup_clean_chain = True
def run_test(self): def run_test(self):
node0 = NodeConnCB() self.nodes[0].add_p2p_connection(NodeConnCB())
connections = []
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
node0.add_connection(connections[0])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
# wait_for_verack ensures that the P2P connection is fully up. # wait_for_verack ensures that the P2P connection is fully up.
node0.wait_for_verack() self.nodes[0].p2p.wait_for_verack()
self.log.info("Mining %d blocks", CLTV_HEIGHT - 2) self.log.info("Mining %d blocks", CLTV_HEIGHT - 2)
self.coinbase_blocks = self.nodes[0].generate(CLTV_HEIGHT - 2) self.coinbase_blocks = self.nodes[0].generate(CLTV_HEIGHT - 2)
@ -95,7 +92,7 @@ class BIP65Test(BitcoinTestFramework):
block.hashMerkleRoot = block.calc_merkle_root() block.hashMerkleRoot = block.calc_merkle_root()
block.solve() block.solve()
node0.send_and_ping(msg_block(block)) self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(self.nodes[0].getbestblockhash(), block.hash) assert_equal(self.nodes[0].getbestblockhash(), block.hash)
self.log.info("Test that blocks must now be at least version 4") self.log.info("Test that blocks must now be at least version 4")
@ -104,15 +101,15 @@ class BIP65Test(BitcoinTestFramework):
block = create_block(tip, create_coinbase(CLTV_HEIGHT), block_time) block = create_block(tip, create_coinbase(CLTV_HEIGHT), block_time)
block.nVersion = 3 block.nVersion = 3
block.solve() block.solve()
node0.send_and_ping(msg_block(block)) self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip) assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
wait_until(lambda: "reject" in node0.last_message.keys(), lock=mininode_lock) wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(), lock=mininode_lock)
with mininode_lock: with mininode_lock:
assert_equal(node0.last_message["reject"].code, REJECT_OBSOLETE) assert_equal(self.nodes[0].p2p.last_message["reject"].code, REJECT_OBSOLETE)
assert_equal(node0.last_message["reject"].reason, b'bad-version(0x00000003)') assert_equal(self.nodes[0].p2p.last_message["reject"].reason, b'bad-version(0x00000003)')
assert_equal(node0.last_message["reject"].data, block.sha256) assert_equal(self.nodes[0].p2p.last_message["reject"].data, block.sha256)
del node0.last_message["reject"] del self.nodes[0].p2p.last_message["reject"]
self.log.info("Test that invalid-according-to-cltv transactions cannot appear in a block") self.log.info("Test that invalid-according-to-cltv transactions cannot appear in a block")
block.nVersion = 4 block.nVersion = 4
@ -125,7 +122,7 @@ class BIP65Test(BitcoinTestFramework):
# First we show that this tx is valid except for CLTV by getting it # First we show that this tx is valid except for CLTV by getting it
# accepted to the mempool (which we can achieve with # accepted to the mempool (which we can achieve with
# -promiscuousmempoolflags). # -promiscuousmempoolflags).
node0.send_and_ping(msg_tx(spendtx)) self.nodes[0].p2p.send_and_ping(msg_tx(spendtx))
assert spendtx.hash in self.nodes[0].getrawmempool() assert spendtx.hash in self.nodes[0].getrawmempool()
# Now we verify that a block with this transaction is invalid. # Now we verify that a block with this transaction is invalid.
@ -133,18 +130,18 @@ class BIP65Test(BitcoinTestFramework):
block.hashMerkleRoot = block.calc_merkle_root() block.hashMerkleRoot = block.calc_merkle_root()
block.solve() block.solve()
node0.send_and_ping(msg_block(block)) self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip) assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
wait_until(lambda: "reject" in node0.last_message.keys(), lock=mininode_lock) wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(), lock=mininode_lock)
with mininode_lock: with mininode_lock:
assert node0.last_message["reject"].code in [REJECT_INVALID, REJECT_NONSTANDARD] assert self.nodes[0].p2p.last_message["reject"].code in [REJECT_INVALID, REJECT_NONSTANDARD]
assert_equal(node0.last_message["reject"].data, block.sha256) assert_equal(self.nodes[0].p2p.last_message["reject"].data, block.sha256)
if node0.last_message["reject"].code == REJECT_INVALID: if self.nodes[0].p2p.last_message["reject"].code == REJECT_INVALID:
# Generic rejection when a block is invalid # Generic rejection when a block is invalid
assert_equal(node0.last_message["reject"].reason, b'block-validation-failed') assert_equal(self.nodes[0].p2p.last_message["reject"].reason, b'block-validation-failed')
else: else:
assert b'Negative locktime' in node0.last_message["reject"].reason assert b'Negative locktime' in self.nodes[0].p2p.last_message["reject"].reason
self.log.info("Test that a version 4 block with a valid-according-to-CLTV transaction is accepted") self.log.info("Test that a version 4 block with a valid-according-to-CLTV transaction is accepted")
spendtx = cltv_validate(self.nodes[0], spendtx, CLTV_HEIGHT - 1) spendtx = cltv_validate(self.nodes[0], spendtx, CLTV_HEIGHT - 1)
@ -155,7 +152,7 @@ class BIP65Test(BitcoinTestFramework):
block.hashMerkleRoot = block.calc_merkle_root() block.hashMerkleRoot = block.calc_merkle_root()
block.solve() block.solve()
node0.send_and_ping(msg_block(block)) self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256) assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256)

40
test/functional/bipdersig-p2p.py
Unescape View File

@ -54,14 +54,12 @@ class BIP66Test(BitcoinTestFramework):
self.setup_clean_chain = True self.setup_clean_chain = True
def run_test(self): def run_test(self):
node0 = NodeConnCB() self.nodes[0].add_p2p_connection(NodeConnCB())
connections = []
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
node0.add_connection(connections[0])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
# wait_for_verack ensures that the P2P connection is fully up. # wait_for_verack ensures that the P2P connection is fully up.
node0.wait_for_verack() self.nodes[0].p2p.wait_for_verack()
self.log.info("Mining %d blocks", DERSIG_HEIGHT - 2) self.log.info("Mining %d blocks", DERSIG_HEIGHT - 2)
self.coinbase_blocks = self.nodes[0].generate(DERSIG_HEIGHT - 2) self.coinbase_blocks = self.nodes[0].generate(DERSIG_HEIGHT - 2)
@ -83,7 +81,7 @@ class BIP66Test(BitcoinTestFramework):
block.rehash() block.rehash()
block.solve() block.solve()
node0.send_and_ping(msg_block(block)) self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(self.nodes[0].getbestblockhash(), block.hash) assert_equal(self.nodes[0].getbestblockhash(), block.hash)
self.log.info("Test that blocks must now be at least version 3") self.log.info("Test that blocks must now be at least version 3")
@ -93,15 +91,15 @@ class BIP66Test(BitcoinTestFramework):
block.nVersion = 2 block.nVersion = 2
block.rehash() block.rehash()
block.solve() block.solve()
node0.send_and_ping(msg_block(block)) self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip) assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
wait_until(lambda: "reject" in node0.last_message.keys(), lock=mininode_lock) wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(), lock=mininode_lock)
with mininode_lock: with mininode_lock:
assert_equal(node0.last_message["reject"].code, REJECT_OBSOLETE) assert_equal(self.nodes[0].p2p.last_message["reject"].code, REJECT_OBSOLETE)
assert_equal(node0.last_message["reject"].reason, b'bad-version(0x00000002)') assert_equal(self.nodes[0].p2p.last_message["reject"].reason, b'bad-version(0x00000002)')
assert_equal(node0.last_message["reject"].data, block.sha256) assert_equal(self.nodes[0].p2p.last_message["reject"].data, block.sha256)
del node0.last_message["reject"] del self.nodes[0].p2p.last_message["reject"]
self.log.info("Test that transactions with non-DER signatures cannot appear in a block") self.log.info("Test that transactions with non-DER signatures cannot appear in a block")
block.nVersion = 3 block.nVersion = 3
@ -114,7 +112,7 @@ class BIP66Test(BitcoinTestFramework):
# First we show that this tx is valid except for DERSIG by getting it # First we show that this tx is valid except for DERSIG by getting it
# accepted to the mempool (which we can achieve with # accepted to the mempool (which we can achieve with
# -promiscuousmempoolflags). # -promiscuousmempoolflags).
node0.send_and_ping(msg_tx(spendtx)) self.nodes[0].p2p.send_and_ping(msg_tx(spendtx))
assert spendtx.hash in self.nodes[0].getrawmempool() assert spendtx.hash in self.nodes[0].getrawmempool()
# Now we verify that a block with this transaction is invalid. # Now we verify that a block with this transaction is invalid.
@ -123,23 +121,23 @@ class BIP66Test(BitcoinTestFramework):
block.rehash() block.rehash()
block.solve() block.solve()
node0.send_and_ping(msg_block(block)) self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip) assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
wait_until(lambda: "reject" in node0.last_message.keys(), lock=mininode_lock) wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(), lock=mininode_lock)
with mininode_lock: with mininode_lock:
# We can receive different reject messages depending on whether # We can receive different reject messages depending on whether
# bitcoind is running with multiple script check threads. If script # bitcoind is running with multiple script check threads. If script
# check threads are not in use, then transaction script validation # check threads are not in use, then transaction script validation
# happens sequentially, and bitcoind produces more specific reject # happens sequentially, and bitcoind produces more specific reject
# reasons. # reasons.
assert node0.last_message["reject"].code in [REJECT_INVALID, REJECT_NONSTANDARD] assert self.nodes[0].p2p.last_message["reject"].code in [REJECT_INVALID, REJECT_NONSTANDARD]
assert_equal(node0.last_message["reject"].data, block.sha256) assert_equal(self.nodes[0].p2p.last_message["reject"].data, block.sha256)
if node0.last_message["reject"].code == REJECT_INVALID: if self.nodes[0].p2p.last_message["reject"].code == REJECT_INVALID:
# Generic rejection when a block is invalid # Generic rejection when a block is invalid
assert_equal(node0.last_message["reject"].reason, b'block-validation-failed') assert_equal(self.nodes[0].p2p.last_message["reject"].reason, b'block-validation-failed')
else: else:
assert b'Non-canonical DER signature' in node0.last_message["reject"].reason assert b'Non-canonical DER signature' in self.nodes[0].p2p.last_message["reject"].reason
self.log.info("Test that a version 3 block with a DERSIG-compliant transaction is accepted") self.log.info("Test that a version 3 block with a DERSIG-compliant transaction is accepted")
block.vtx[1] = create_transaction(self.nodes[0], block.vtx[1] = create_transaction(self.nodes[0],
@ -148,7 +146,7 @@ class BIP66Test(BitcoinTestFramework):
block.rehash() block.rehash()
block.solve() block.solve()
node0.send_and_ping(msg_block(block)) self.nodes[0].p2p.send_and_ping(msg_block(block))
assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256) assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256)
if __name__ == '__main__': if __name__ == '__main__':

71
test/functional/maxuploadtarget.py
Unescape View File

@ -49,19 +49,17 @@ class MaxUploadTest(BitcoinTestFramework):
# Generate some old blocks # Generate some old blocks
self.nodes[0].generate(130) self.nodes[0].generate(130)
# test_nodes[0] will only request old blocks # p2p_conns[0] will only request old blocks
# test_nodes[1] will only request new blocks # p2p_conns[1] will only request new blocks
# test_nodes[2] will test resetting the counters # p2p_conns[2] will test resetting the counters
test_nodes = [] p2p_conns = []
connections = []
for i in range(3): for i in range(3):
test_nodes.append(TestNode()) p2p_conns.append(self.nodes[0].add_p2p_connection(TestNode()))
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_nodes[i]))
test_nodes[i].add_connection(connections[i])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
[x.wait_for_verack() for x in test_nodes] for p2pc in p2p_conns:
p2pc.wait_for_verack()
# Test logic begins here # Test logic begins here
@ -83,7 +81,7 @@ class MaxUploadTest(BitcoinTestFramework):
big_new_block = self.nodes[0].getbestblockhash() big_new_block = self.nodes[0].getbestblockhash()
big_new_block = int(big_new_block, 16) big_new_block = int(big_new_block, 16)
# test_nodes[0] will test what happens if we just keep requesting the # p2p_conns[0] will test what happens if we just keep requesting the
# the same big old block too many times (expect: disconnect) # the same big old block too many times (expect: disconnect)
getdata_request = msg_getdata() getdata_request = msg_getdata()
@ -97,34 +95,34 @@ class MaxUploadTest(BitcoinTestFramework):
# 576MB will be reserved for relaying new blocks, so expect this to # 576MB will be reserved for relaying new blocks, so expect this to
# succeed for ~235 tries. # succeed for ~235 tries.
for i in range(success_count): for i in range(success_count):
test_nodes[0].send_message(getdata_request) p2p_conns[0].send_message(getdata_request)
test_nodes[0].sync_with_ping() p2p_conns[0].sync_with_ping()
assert_equal(test_nodes[0].block_receive_map[big_old_block], i+1) assert_equal(p2p_conns[0].block_receive_map[big_old_block], i+1)
assert_equal(len(self.nodes[0].getpeerinfo()), 3) assert_equal(len(self.nodes[0].getpeerinfo()), 3)
# At most a couple more tries should succeed (depending on how long # At most a couple more tries should succeed (depending on how long
# the test has been running so far). # the test has been running so far).
for i in range(3): for i in range(3):
test_nodes[0].send_message(getdata_request) p2p_conns[0].send_message(getdata_request)
test_nodes[0].wait_for_disconnect() p2p_conns[0].wait_for_disconnect()
assert_equal(len(self.nodes[0].getpeerinfo()), 2) assert_equal(len(self.nodes[0].getpeerinfo()), 2)
self.log.info("Peer 0 disconnected after downloading old block too many times") self.log.info("Peer 0 disconnected after downloading old block too many times")
# Requesting the current block on test_nodes[1] should succeed indefinitely, # Requesting the current block on p2p_conns[1] should succeed indefinitely,
# even when over the max upload target. # even when over the max upload target.
# We'll try 800 times # We'll try 800 times
getdata_request.inv = [CInv(2, big_new_block)] getdata_request.inv = [CInv(2, big_new_block)]
for i in range(800): for i in range(800):
test_nodes[1].send_message(getdata_request) p2p_conns[1].send_message(getdata_request)
test_nodes[1].sync_with_ping() p2p_conns[1].sync_with_ping()
assert_equal(test_nodes[1].block_receive_map[big_new_block], i+1) assert_equal(p2p_conns[1].block_receive_map[big_new_block], i+1)
self.log.info("Peer 1 able to repeatedly download new block") self.log.info("Peer 1 able to repeatedly download new block")
# But if test_nodes[1] tries for an old block, it gets disconnected too. # But if p2p_conns[1] tries for an old block, it gets disconnected too.
getdata_request.inv = [CInv(2, big_old_block)] getdata_request.inv = [CInv(2, big_old_block)]
test_nodes[1].send_message(getdata_request) p2p_conns[1].send_message(getdata_request)
test_nodes[1].wait_for_disconnect() p2p_conns[1].wait_for_disconnect()
assert_equal(len(self.nodes[0].getpeerinfo()), 1) assert_equal(len(self.nodes[0].getpeerinfo()), 1)
self.log.info("Peer 1 disconnected after trying to download old block") self.log.info("Peer 1 disconnected after trying to download old block")
@ -132,39 +130,38 @@ class MaxUploadTest(BitcoinTestFramework):
self.log.info("Advancing system time on node to clear counters...") self.log.info("Advancing system time on node to clear counters...")
# If we advance the time by 24 hours, then the counters should reset, # If we advance the time by 24 hours, then the counters should reset,
# and test_nodes[2] should be able to retrieve the old block. # and p2p_conns[2] should be able to retrieve the old block.
self.nodes[0].setmocktime(int(time.time())) self.nodes[0].setmocktime(int(time.time()))
test_nodes[2].sync_with_ping() p2p_conns[2].sync_with_ping()
test_nodes[2].send_message(getdata_request) p2p_conns[2].send_message(getdata_request)
test_nodes[2].sync_with_ping() p2p_conns[2].sync_with_ping()
assert_equal(test_nodes[2].block_receive_map[big_old_block], 1) assert_equal(p2p_conns[2].block_receive_map[big_old_block], 1)
self.log.info("Peer 2 able to download old block") self.log.info("Peer 2 able to download old block")
[c.disconnect_node() for c in connections] for i in range(3):
self.nodes[0].disconnect_p2p()
#stop and start node 0 with 1MB maxuploadtarget, whitelist 127.0.0.1 #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.log.info("Restarting nodes with -whitelist=127.0.0.1")
self.stop_node(0) self.stop_node(0)
self.start_node(0, ["-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 # Reconnect to self.nodes[0]
test_nodes = [TestNode()] self.nodes[0].add_p2p_connection(TestNode())
connections = [NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_nodes[0])]
test_nodes[0].add_connection(connections[0])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
test_nodes[0].wait_for_verack() self.nodes[0].p2p.wait_for_verack()
#retrieve 20 blocks which should be enough to break the 1MB limit #retrieve 20 blocks which should be enough to break the 1MB limit
getdata_request.inv = [CInv(2, big_new_block)] getdata_request.inv = [CInv(2, big_new_block)]
for i in range(20): for i in range(20):
test_nodes[0].send_message(getdata_request) self.nodes[0].p2p.send_message(getdata_request)
test_nodes[0].sync_with_ping() self.nodes[0].p2p.sync_with_ping()
assert_equal(test_nodes[0].block_receive_map[big_new_block], i+1) assert_equal(self.nodes[0].p2p.block_receive_map[big_new_block], i+1)
getdata_request.inv = [CInv(2, big_old_block)] getdata_request.inv = [CInv(2, big_old_block)]
test_nodes[0].send_and_ping(getdata_request) self.nodes[0].p2p.send_and_ping(getdata_request)
assert_equal(len(self.nodes[0].getpeerinfo()), 1) #node is still connected because of the whitelist assert_equal(len(self.nodes[0].getpeerinfo()), 1) #node is still connected because of the whitelist
self.log.info("Peer still connected after trying to download old block (whitelisted)") self.log.info("Peer still connected after trying to download old block (whitelisted)")

26
test/functional/p2p-acceptblock.py
Unescape View File

@ -78,14 +78,10 @@ class AcceptBlockTest(BitcoinTestFramework):
def run_test(self): def run_test(self):
# Setup the p2p connections and start up the network thread. # Setup the p2p connections and start up the network thread.
test_node = NodeConnCB() # connects to node0 # test_node connects to node0 (not whitelisted)
min_work_node = NodeConnCB() # connects to node1 test_node = self.nodes[0].add_p2p_connection(NodeConnCB())
# min_work_node connects to node1
connections = [] min_work_node = self.nodes[1].add_p2p_connection(NodeConnCB())
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node))
connections.append(NodeConn('127.0.0.1', p2p_port(1), self.nodes[1], min_work_node))
test_node.add_connection(connections[0])
min_work_node.add_connection(connections[1])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
@ -209,12 +205,9 @@ class AcceptBlockTest(BitcoinTestFramework):
# The node should have requested the blocks at some point, so # The node should have requested the blocks at some point, so
# disconnect/reconnect first # disconnect/reconnect first
connections[0].disconnect_node()
test_node.wait_for_disconnect()
test_node = NodeConnCB() # connects to node (not whitelisted) self.nodes[0].disconnect_p2p()
connections[0] = NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node) test_node = self.nodes[0].add_p2p_connection(NodeConnCB())
test_node.add_connection(connections[0])
test_node.wait_for_verack() test_node.wait_for_verack()
test_node.send_message(msg_block(block_h1f)) test_node.send_message(msg_block(block_h1f))
@ -298,9 +291,8 @@ class AcceptBlockTest(BitcoinTestFramework):
except AssertionError: except AssertionError:
test_node.wait_for_disconnect() test_node.wait_for_disconnect()
test_node = NodeConnCB() # connects to node (not whitelisted) self.nodes[0].disconnect_p2p()
connections[0] = NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node) test_node = self.nodes[0].add_p2p_connection(NodeConnCB())
test_node.add_connection(connections[0])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
test_node.wait_for_verack() test_node.wait_for_verack()
@ -323,7 +315,5 @@ class AcceptBlockTest(BitcoinTestFramework):
sync_blocks([self.nodes[0], self.nodes[1]]) sync_blocks([self.nodes[0], self.nodes[1]])
self.log.info("Successfully synced nodes 1 and 0") self.log.info("Successfully synced nodes 1 and 0")
[ c.disconnect_node() for c in connections ]
if __name__ == '__main__': if __name__ == '__main__':
AcceptBlockTest().main() AcceptBlockTest().main()

17
test/functional/p2p-compactblocks.py
Unescape View File

@ -788,23 +788,12 @@ class CompactBlocksTest(BitcoinTestFramework):
def run_test(self): def run_test(self):
# Setup the p2p connections and start up the network thread. # Setup the p2p connections and start up the network thread.
self.test_node = TestNode() self.test_node = self.nodes[0].add_p2p_connection(TestNode())
self.segwit_node = TestNode() self.segwit_node = self.nodes[1].add_p2p_connection(TestNode(), services=NODE_NETWORK|NODE_WITNESS)
self.old_node = TestNode() # version 1 peer <--> segwit node self.old_node = self.nodes[1].add_p2p_connection(TestNode(), services=NODE_NETWORK)
connections = []
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.test_node))
connections.append(NodeConn('127.0.0.1', p2p_port(1), self.nodes[1],
self.segwit_node, services=NODE_NETWORK|NODE_WITNESS))
connections.append(NodeConn('127.0.0.1', p2p_port(1), self.nodes[1],
self.old_node, services=NODE_NETWORK))
self.test_node.add_connection(connections[0])
self.segwit_node.add_connection(connections[1])
self.old_node.add_connection(connections[2])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
# Test logic begins here
self.test_node.wait_for_verack() self.test_node.wait_for_verack()
# We will need UTXOs to construct transactions in later tests. # We will need UTXOs to construct transactions in later tests.

26
test/functional/p2p-feefilter.py
Unescape View File

@ -48,25 +48,23 @@ class FeeFilterTest(BitcoinTestFramework):
sync_blocks(self.nodes) sync_blocks(self.nodes)
# Setup the p2p connections and start up the network thread. # Setup the p2p connections and start up the network thread.
test_node = TestNode() self.nodes[0].add_p2p_connection(TestNode())
connection = NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node)
test_node.add_connection(connection)
NetworkThread().start() NetworkThread().start()
test_node.wait_for_verack() self.nodes[0].p2p.wait_for_verack()
# Test that invs are received for all txs at feerate of 20 sat/byte # Test that invs are received for all txs at feerate of 20 sat/byte
node1.settxfee(Decimal("0.00020000")) node1.settxfee(Decimal("0.00020000"))
txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)] txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
assert(allInvsMatch(txids, test_node)) assert(allInvsMatch(txids, self.nodes[0].p2p))
test_node.clear_invs() self.nodes[0].p2p.clear_invs()
# Set a filter of 15 sat/byte # Set a filter of 15 sat/byte
test_node.send_and_ping(msg_feefilter(15000)) self.nodes[0].p2p.send_and_ping(msg_feefilter(15000))
# Test that txs are still being received (paying 20 sat/byte) # Test that txs are still being received (paying 20 sat/byte)
txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)] txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
assert(allInvsMatch(txids, test_node)) assert(allInvsMatch(txids, self.nodes[0].p2p))
test_node.clear_invs() self.nodes[0].p2p.clear_invs()
# Change tx fee rate to 10 sat/byte and test they are no longer received # Change tx fee rate to 10 sat/byte and test they are no longer received
node1.settxfee(Decimal("0.00010000")) node1.settxfee(Decimal("0.00010000"))
@ -82,14 +80,14 @@ class FeeFilterTest(BitcoinTestFramework):
# as well. # as well.
node0.settxfee(Decimal("0.00020000")) node0.settxfee(Decimal("0.00020000"))
txids = [node0.sendtoaddress(node0.getnewaddress(), 1)] txids = [node0.sendtoaddress(node0.getnewaddress(), 1)]
assert(allInvsMatch(txids, test_node)) assert(allInvsMatch(txids, self.nodes[0].p2p))
test_node.clear_invs() self.nodes[0].p2p.clear_invs()
# Remove fee filter and check that txs are received again # Remove fee filter and check that txs are received again
test_node.send_and_ping(msg_feefilter(0)) self.nodes[0].p2p.send_and_ping(msg_feefilter(0))
txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)] txids = [node1.sendtoaddress(node1.getnewaddress(), 1) for x in range(3)]
assert(allInvsMatch(txids, test_node)) assert(allInvsMatch(txids, self.nodes[0].p2p))
test_node.clear_invs() self.nodes[0].p2p.clear_invs()
if __name__ == '__main__': if __name__ == '__main__':
FeeFilterTest().main() FeeFilterTest().main()

7
test/functional/p2p-fingerprint.py
Unescape View File

@ -14,7 +14,6 @@ from test_framework.blocktools import (create_block, create_coinbase)
from test_framework.mininode import ( from test_framework.mininode import (
CInv, CInv,
NetworkThread, NetworkThread,
NodeConn,
NodeConnCB, NodeConnCB,
msg_headers, msg_headers,
msg_block, msg_block,
@ -77,11 +76,7 @@ class P2PFingerprintTest(BitcoinTestFramework):
# This does not currently test that stale blocks timestamped within the # This does not currently test that stale blocks timestamped within the
# last month but that have over a month's worth of work are also withheld. # last month but that have over a month's worth of work are also withheld.
def run_test(self): def run_test(self):
node0 = NodeConnCB() node0 = self.nodes[0].add_p2p_connection(NodeConnCB())
connections = []
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
node0.add_connection(connections[0])
NetworkThread().start() NetworkThread().start()
node0.wait_for_verack() node0.wait_for_verack()

35
test/functional/p2p-leaktests.py
Unescape View File

@ -97,24 +97,13 @@ class P2PLeakTest(BitcoinTestFramework):
self.extra_args = [['-banscore='+str(banscore)]] self.extra_args = [['-banscore='+str(banscore)]]
def run_test(self): def run_test(self):
no_version_bannode = CNodeNoVersionBan()
no_version_idlenode = CNodeNoVersionIdle()
no_verack_idlenode = CNodeNoVerackIdle()
unsupported_service_bit5_node = CLazyNode()
unsupported_service_bit7_node = CLazyNode()
self.nodes[0].setmocktime(1501545600) # August 1st 2017 self.nodes[0].setmocktime(1501545600) # August 1st 2017
connections = []
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_version_bannode, send_version=False)) no_version_bannode = self.nodes[0].add_p2p_connection(CNodeNoVersionBan(), send_version=False)
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_version_idlenode, send_version=False)) no_version_idlenode = self.nodes[0].add_p2p_connection(CNodeNoVersionIdle(), send_version=False)
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], no_verack_idlenode)) no_verack_idlenode = self.nodes[0].add_p2p_connection(CNodeNoVerackIdle())
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], unsupported_service_bit5_node, services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_5)) unsupported_service_bit5_node = self.nodes[0].add_p2p_connection(CLazyNode(), services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_5)
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], unsupported_service_bit7_node, services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_7)) unsupported_service_bit7_node = self.nodes[0].add_p2p_connection(CLazyNode(), services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_7)
no_version_bannode.add_connection(connections[0])
no_version_idlenode.add_connection(connections[1])
no_verack_idlenode.add_connection(connections[2])
unsupported_service_bit5_node.add_connection(connections[3])
unsupported_service_bit7_node.add_connection(connections[4])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
@ -137,7 +126,8 @@ class P2PLeakTest(BitcoinTestFramework):
assert not unsupported_service_bit5_node.connected assert not unsupported_service_bit5_node.connected
assert not unsupported_service_bit7_node.connected assert not unsupported_service_bit7_node.connected
[conn.disconnect_node() for conn in connections] for _ in range(5):
self.nodes[0].disconnect_p2p()
# Wait until all connections are closed # Wait until all connections are closed
wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 0) wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 0)
@ -152,13 +142,8 @@ class P2PLeakTest(BitcoinTestFramework):
self.log.info("Service bits 5 and 7 are allowed after August 1st 2018") self.log.info("Service bits 5 and 7 are allowed after August 1st 2018")
self.nodes[0].setmocktime(1533168000) # August 2nd 2018 self.nodes[0].setmocktime(1533168000) # August 2nd 2018
allowed_service_bit5_node = NodeConnCB() allowed_service_bit5_node = self.nodes[0].add_p2p_connection(NodeConnCB(), services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_5)
allowed_service_bit7_node = NodeConnCB() allowed_service_bit7_node = self.nodes[0].add_p2p_connection(NodeConnCB(), services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_7)
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], allowed_service_bit5_node, services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_5))
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], allowed_service_bit7_node, services=NODE_NETWORK|NODE_UNSUPPORTED_SERVICE_BIT_7))
allowed_service_bit5_node.add_connection(connections[5])
allowed_service_bit7_node.add_connection(connections[6])
NetworkThread().start() # Network thread stopped when all previous NodeConnCBs disconnected. Restart it NetworkThread().start() # Network thread stopped when all previous NodeConnCBs disconnected. Restart it

12
test/functional/p2p-mempool.py
Unescape View File

@ -19,16 +19,14 @@ class P2PMempoolTests(BitcoinTestFramework):
self.extra_args = [["-peerbloomfilters=0"]] self.extra_args = [["-peerbloomfilters=0"]]
def run_test(self): def run_test(self):
#connect a mininode # Add a p2p connection
aTestNode = NodeConnCB() self.nodes[0].add_p2p_connection(NodeConnCB())
node = NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], aTestNode)
aTestNode.add_connection(node)
NetworkThread().start() NetworkThread().start()
aTestNode.wait_for_verack() self.nodes[0].p2p.wait_for_verack()
#request mempool #request mempool
aTestNode.send_message(msg_mempool()) self.nodes[0].p2p.send_message(msg_mempool())
aTestNode.wait_for_disconnect() self.nodes[0].p2p.wait_for_disconnect()
#mininode must be disconnected at this point #mininode must be disconnected at this point
assert_equal(len(self.nodes[0].getpeerinfo()), 0) assert_equal(len(self.nodes[0].getpeerinfo()), 0)

19
test/functional/p2p-segwit.py
Unescape View File

@ -1868,19 +1868,12 @@ class SegWitTest(BitcoinTestFramework):
def run_test(self): def run_test(self):
# Setup the p2p connections and start up the network thread. # Setup the p2p connections and start up the network thread.
self.test_node = TestNode() # sets NODE_WITNESS|NODE_NETWORK # self.test_node sets NODE_WITNESS|NODE_NETWORK
self.old_node = TestNode() # only NODE_NETWORK self.test_node = self.nodes[0].add_p2p_connection(TestNode(), services=NODE_NETWORK|NODE_WITNESS)
self.std_node = TestNode() # for testing node1 (fRequireStandard=true) # self.old_node sets only NODE_NETWORK
self.old_node = self.nodes[0].add_p2p_connection(TestNode(), services=NODE_NETWORK)
self.p2p_connections = [self.test_node, self.old_node] # self.std_node is for testing node1 (fRequireStandard=true)
self.std_node = self.nodes[1].add_p2p_connection(TestNode(), services=NODE_NETWORK|NODE_WITNESS)
self.connections = []
self.connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.test_node, services=NODE_NETWORK|NODE_WITNESS))
self.connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.old_node, services=NODE_NETWORK))
self.connections.append(NodeConn('127.0.0.1', p2p_port(1), self.nodes[1], self.std_node, services=NODE_NETWORK|NODE_WITNESS))
self.test_node.add_connection(self.connections[0])
self.old_node.add_connection(self.connections[1])
self.std_node.add_connection(self.connections[2])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread

43
test/functional/p2p-timeouts.py
Unescape View File

@ -39,46 +39,37 @@ class TimeoutsTest(BitcoinTestFramework):
def run_test(self): def run_test(self):
# Setup the p2p connections and start up the network thread. # Setup the p2p connections and start up the network thread.
self.no_verack_node = TestNode() # never send verack no_verack_node = self.nodes[0].add_p2p_connection(TestNode())
self.no_version_node = TestNode() # never send version (just ping) no_version_node = self.nodes[0].add_p2p_connection(TestNode(), send_version=False)
self.no_send_node = TestNode() # never send anything no_send_node = self.nodes[0].add_p2p_connection(TestNode(), send_version=False)
connections = []
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.no_verack_node))
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.no_version_node, send_version=False))
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.no_send_node, send_version=False))
self.no_verack_node.add_connection(connections[0])
self.no_version_node.add_connection(connections[1])
self.no_send_node.add_connection(connections[2])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
sleep(1) sleep(1)
assert(self.no_verack_node.connected) assert no_verack_node.connected
assert(self.no_version_node.connected) assert no_version_node.connected
assert(self.no_send_node.connected) assert no_send_node.connected
ping_msg = msg_ping() no_verack_node.send_message(msg_ping())
connections[0].send_message(ping_msg) no_version_node.send_message(msg_ping())
connections[1].send_message(ping_msg)
sleep(30) sleep(30)
assert "version" in self.no_verack_node.last_message assert "version" in no_verack_node.last_message
assert(self.no_verack_node.connected) assert no_verack_node.connected
assert(self.no_version_node.connected) assert no_version_node.connected
assert(self.no_send_node.connected) assert no_send_node.connected
connections[0].send_message(ping_msg) no_verack_node.send_message(msg_ping())
connections[1].send_message(ping_msg) no_version_node.send_message(msg_ping())
sleep(31) sleep(31)
assert(not self.no_verack_node.connected) assert not no_verack_node.connected
assert(not self.no_version_node.connected) assert not no_version_node.connected
assert(not self.no_send_node.connected) assert not no_send_node.connected
if __name__ == '__main__': if __name__ == '__main__':
TimeoutsTest().main() TimeoutsTest().main()

12
test/functional/p2p-versionbits-warning.py
Unescape View File

@ -64,16 +64,12 @@ class VersionBitsWarningTest(BitcoinTestFramework):
def run_test(self): def run_test(self):
# Setup the p2p connection and start up the network thread. # Setup the p2p connection and start up the network thread.
test_node = TestNode() self.nodes[0].add_p2p_connection(TestNode())
connections = []
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node))
test_node.add_connection(connections[0])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread
# Test logic begins here # Test logic begins here
test_node.wait_for_verack() self.nodes[0].p2p.wait_for_verack()
# 1. Have the node mine one period worth of blocks # 1. Have the node mine one period worth of blocks
self.nodes[0].generate(VB_PERIOD) self.nodes[0].generate(VB_PERIOD)
@ -81,7 +77,7 @@ class VersionBitsWarningTest(BitcoinTestFramework):
# 2. Now build one period of blocks on the tip, with < VB_THRESHOLD # 2. Now build one period of blocks on the tip, with < VB_THRESHOLD
# blocks signaling some unknown bit. # blocks signaling some unknown bit.
nVersion = VB_TOP_BITS | (1<<VB_UNKNOWN_BIT) nVersion = VB_TOP_BITS | (1<<VB_UNKNOWN_BIT)
self.send_blocks_with_version(test_node, VB_THRESHOLD-1, nVersion) self.send_blocks_with_version(self.nodes[0].p2p, VB_THRESHOLD-1, nVersion)
# Fill rest of period with regular version blocks # Fill rest of period with regular version blocks
self.nodes[0].generate(VB_PERIOD - VB_THRESHOLD + 1) self.nodes[0].generate(VB_PERIOD - VB_THRESHOLD + 1)
@ -92,7 +88,7 @@ class VersionBitsWarningTest(BitcoinTestFramework):
# 3. Now build one period of blocks with >= VB_THRESHOLD blocks signaling # 3. Now build one period of blocks with >= VB_THRESHOLD blocks signaling
# some unknown bit # some unknown bit
self.send_blocks_with_version(test_node, VB_THRESHOLD, nVersion) self.send_blocks_with_version(self.nodes[0].p2p, VB_THRESHOLD, nVersion)
self.nodes[0].generate(VB_PERIOD - VB_THRESHOLD) self.nodes[0].generate(VB_PERIOD - VB_THRESHOLD)
# Might not get a versionbits-related alert yet, as we should # Might not get a versionbits-related alert yet, as we should
# have gotten a different alert due to more than 51/100 blocks # have gotten a different alert due to more than 51/100 blocks

16
test/functional/sendheaders.py
Unescape View File

@ -181,7 +181,7 @@ class SendHeadersTest(BitcoinTestFramework):
# mine count blocks and return the new tip # mine count blocks and return the new tip
def mine_blocks(self, count): def mine_blocks(self, count):
# Clear out last block announcement from each p2p listener # Clear out last block announcement from each p2p listener
[ x.clear_last_announcement() for x in self.p2p_connections ] [x.clear_last_announcement() for x in self.nodes[0].p2ps]
self.nodes[0].generate(count) self.nodes[0].generate(count)
return int(self.nodes[0].getbestblockhash(), 16) return int(self.nodes[0].getbestblockhash(), 16)
@ -193,7 +193,7 @@ class SendHeadersTest(BitcoinTestFramework):
def mine_reorg(self, length): def mine_reorg(self, length):
self.nodes[0].generate(length) # make sure all invalidated blocks are node0's self.nodes[0].generate(length) # make sure all invalidated blocks are node0's
sync_blocks(self.nodes, wait=0.1) sync_blocks(self.nodes, wait=0.1)
for x in self.p2p_connections: for x in self.nodes[0].p2ps:
x.wait_for_block_announcement(int(self.nodes[0].getbestblockhash(), 16)) x.wait_for_block_announcement(int(self.nodes[0].getbestblockhash(), 16))
x.clear_last_announcement() x.clear_last_announcement()
@ -206,18 +206,10 @@ class SendHeadersTest(BitcoinTestFramework):
def run_test(self): def run_test(self):
# Setup the p2p connections and start up the network thread. # Setup the p2p connections and start up the network thread.
inv_node = TestNode() inv_node = self.nodes[0].add_p2p_connection(TestNode())
test_node = TestNode()
self.p2p_connections = [inv_node, test_node]
connections = []
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], inv_node))
# Set nServices to 0 for test_node, so no block download will occur outside of # Set nServices to 0 for test_node, so no block download will occur outside of
# direct fetching # direct fetching
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], test_node, services=NODE_WITNESS)) test_node = self.nodes[0].add_p2p_connection(TestNode(), services=NODE_WITNESS)
inv_node.add_connection(connections[0])
test_node.add_connection(connections[1])
NetworkThread().start() # Start up network handling in another thread NetworkThread().start() # Start up network handling in another thread

Write Preview
Loading…
Cancel
Save