Skip to content

Commit 32ae82f

Browse files
jnewberyjnewbery
committed
[tests] use TestNode p2p connection in tests
1 parent 5e5725c commit 32ae82f

14 files changed

+160
-249
lines changed

‎test/functional/assumevalid.py‎

Lines changed: 19 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -39,13 +39,12 @@
3939
CTxIn,
4040
CTxOut,
4141
NetworkThread,
42-
NodeConn,
4342
NodeConnCB,
4443
msg_block,
4544
msg_headers)
4645
from test_framework.script import (CScript, OP_TRUE)
4746
from test_framework.test_framework import BitcoinTestFramework
48-
from test_framework.util import (p2p_port, assert_equal)
47+
from test_framework.util import assert_equal
4948

5049
class BaseNode(NodeConnCB):
5150
def send_header_for_blocks(self, new_blocks):
@@ -65,13 +64,13 @@ def setup_network(self):
6564
# signature so we can pass in the block hash as assumevalid.
6665
self.start_node(0)
6766

68-
def send_blocks_until_disconnected(self, node):
67+
def send_blocks_until_disconnected(self, p2p_conn):
6968
"""Keep sending blocks to the node until we're disconnected."""
7069
for i in range(len(self.blocks)):
71-
if not node.connection:
70+
if not p2p_conn.connection:
7271
break
7372
try:
74-
node.send_message(msg_block(self.blocks[i]))
73+
p2p_conn.send_message(msg_block(self.blocks[i]))
7574
except IOError as e:
7675
assert str(e) == 'Not connected, no pushbuf'
7776
break
@@ -97,13 +96,10 @@ def assert_blockchain_height(self, node, height):
9796
def run_test(self):
9897

9998
# Connect to node0
100-
node0 = BaseNode()
101-
connections = []
102-
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
103-
node0.add_connection(connections[0])
99+
p2p0 = self.nodes[0].add_p2p_connection(BaseNode())
104100

105101
NetworkThread().start() # Start up network handling in another thread
106-
node0.wait_for_verack()
102+
self.nodes[0].p2p.wait_for_verack()
107103

108104
# Build the blockchain
109105
self.tip = int(self.nodes[0].getbestblockhash(), 16)
@@ -165,37 +161,33 @@ def run_test(self):
165161

166162
# Start node1 and node2 with assumevalid so they accept a block with a bad signature.
167163
self.start_node(1, extra_args=["-assumevalid=" + hex(block102.sha256)])
168-
node1 = BaseNode() # connects to node1
169-
connections.append(NodeConn('127.0.0.1', p2p_port(1), self.nodes[1], node1))
170-
node1.add_connection(connections[1])
171-
node1.wait_for_verack()
164+
p2p1 = self.nodes[1].add_p2p_connection(BaseNode())
165+
p2p1.wait_for_verack()
172166

173167
self.start_node(2, extra_args=["-assumevalid=" + hex(block102.sha256)])
174-
node2 = BaseNode() # connects to node2
175-
connections.append(NodeConn('127.0.0.1', p2p_port(2), self.nodes[2], node2))
176-
node2.add_connection(connections[2])
177-
node2.wait_for_verack()
168+
p2p2 = self.nodes[2].add_p2p_connection(BaseNode())
169+
p2p2.wait_for_verack()
178170

179171
# send header lists to all three nodes
180-
node0.send_header_for_blocks(self.blocks[0:2000])
181-
node0.send_header_for_blocks(self.blocks[2000:])
182-
node1.send_header_for_blocks(self.blocks[0:2000])
183-
node1.send_header_for_blocks(self.blocks[2000:])
184-
node2.send_header_for_blocks(self.blocks[0:200])
172+
p2p0.send_header_for_blocks(self.blocks[0:2000])
173+
p2p0.send_header_for_blocks(self.blocks[2000:])
174+
p2p1.send_header_for_blocks(self.blocks[0:2000])
175+
p2p1.send_header_for_blocks(self.blocks[2000:])
176+
p2p2.send_header_for_blocks(self.blocks[0:200])
185177

186178
# Send blocks to node0. Block 102 will be rejected.
187-
self.send_blocks_until_disconnected(node0)
179+
self.send_blocks_until_disconnected(p2p0)
188180
self.assert_blockchain_height(self.nodes[0], 101)
189181

190182
# Send all blocks to node1. All blocks will be accepted.
191183
for i in range(2202):
192-
node1.send_message(msg_block(self.blocks[i]))
184+
p2p1.send_message(msg_block(self.blocks[i]))
193185
# Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
194-
node1.sync_with_ping(120)
186+
p2p1.sync_with_ping(120)
195187
assert_equal(self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'], 2202)
196188

197189
# Send blocks to node2. Block 102 will be rejected.
198-
self.send_blocks_until_disconnected(node2)
190+
self.send_blocks_until_disconnected(p2p2)
199191
self.assert_blockchain_height(self.nodes[2], 101)
200192

201193
if __name__ == '__main__':

‎test/functional/bip65-cltv-p2p.py‎

Lines changed: 18 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -66,15 +66,12 @@ def set_test_params(self):
6666
self.setup_clean_chain = True
6767

6868
def run_test(self):
69-
node0 = NodeConnCB()
70-
connections = []
71-
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
72-
node0.add_connection(connections[0])
69+
self.nodes[0].add_p2p_connection(NodeConnCB())
7370

7471
NetworkThread().start() # Start up network handling in another thread
7572

7673
# wait_for_verack ensures that the P2P connection is fully up.
77-
node0.wait_for_verack()
74+
self.nodes[0].p2p.wait_for_verack()
7875

7976
self.log.info("Mining %d blocks", CLTV_HEIGHT - 2)
8077
self.coinbase_blocks = self.nodes[0].generate(CLTV_HEIGHT - 2)
@@ -95,7 +92,7 @@ def run_test(self):
9592
block.hashMerkleRoot = block.calc_merkle_root()
9693
block.solve()
9794

98-
node0.send_and_ping(msg_block(block))
95+
self.nodes[0].p2p.send_and_ping(msg_block(block))
9996
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
10097

10198
self.log.info("Test that blocks must now be at least version 4")
@@ -104,15 +101,15 @@ def run_test(self):
104101
block = create_block(tip, create_coinbase(CLTV_HEIGHT), block_time)
105102
block.nVersion = 3
106103
block.solve()
107-
node0.send_and_ping(msg_block(block))
104+
self.nodes[0].p2p.send_and_ping(msg_block(block))
108105
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
109106

110-
wait_until(lambda: "reject" in node0.last_message.keys(), lock=mininode_lock)
107+
wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(), lock=mininode_lock)
111108
with mininode_lock:
112-
assert_equal(node0.last_message["reject"].code, REJECT_OBSOLETE)
113-
assert_equal(node0.last_message["reject"].reason, b'bad-version(0x00000003)')
114-
assert_equal(node0.last_message["reject"].data, block.sha256)
115-
del node0.last_message["reject"]
109+
assert_equal(self.nodes[0].p2p.last_message["reject"].code, REJECT_OBSOLETE)
110+
assert_equal(self.nodes[0].p2p.last_message["reject"].reason, b'bad-version(0x00000003)')
111+
assert_equal(self.nodes[0].p2p.last_message["reject"].data, block.sha256)
112+
del self.nodes[0].p2p.last_message["reject"]
116113

117114
self.log.info("Test that invalid-according-to-cltv transactions cannot appear in a block")
118115
block.nVersion = 4
@@ -125,26 +122,26 @@ def run_test(self):
125122
# First we show that this tx is valid except for CLTV by getting it
126123
# accepted to the mempool (which we can achieve with
127124
# -promiscuousmempoolflags).
128-
node0.send_and_ping(msg_tx(spendtx))
125+
self.nodes[0].p2p.send_and_ping(msg_tx(spendtx))
129126
assert spendtx.hash in self.nodes[0].getrawmempool()
130127

131128
# Now we verify that a block with this transaction is invalid.
132129
block.vtx.append(spendtx)
133130
block.hashMerkleRoot = block.calc_merkle_root()
134131
block.solve()
135132

136-
node0.send_and_ping(msg_block(block))
133+
self.nodes[0].p2p.send_and_ping(msg_block(block))
137134
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
138135

139-
wait_until(lambda: "reject" in node0.last_message.keys(), lock=mininode_lock)
136+
wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(), lock=mininode_lock)
140137
with mininode_lock:
141-
assert node0.last_message["reject"].code in [REJECT_INVALID, REJECT_NONSTANDARD]
142-
assert_equal(node0.last_message["reject"].data, block.sha256)
143-
if node0.last_message["reject"].code == REJECT_INVALID:
138+
assert self.nodes[0].p2p.last_message["reject"].code in [REJECT_INVALID, REJECT_NONSTANDARD]
139+
assert_equal(self.nodes[0].p2p.last_message["reject"].data, block.sha256)
140+
if self.nodes[0].p2p.last_message["reject"].code == REJECT_INVALID:
144141
# Generic rejection when a block is invalid
145-
assert_equal(node0.last_message["reject"].reason, b'block-validation-failed')
142+
assert_equal(self.nodes[0].p2p.last_message["reject"].reason, b'block-validation-failed')
146143
else:
147-
assert b'Negative locktime' in node0.last_message["reject"].reason
144+
assert b'Negative locktime' in self.nodes[0].p2p.last_message["reject"].reason
148145

149146
self.log.info("Test that a version 4 block with a valid-according-to-CLTV transaction is accepted")
150147
spendtx = cltv_validate(self.nodes[0], spendtx, CLTV_HEIGHT - 1)
@@ -155,7 +152,7 @@ def run_test(self):
155152
block.hashMerkleRoot = block.calc_merkle_root()
156153
block.solve()
157154

158-
node0.send_and_ping(msg_block(block))
155+
self.nodes[0].p2p.send_and_ping(msg_block(block))
159156
assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256)
160157

161158

‎test/functional/bipdersig-p2p.py‎

Lines changed: 19 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -54,14 +54,12 @@ def set_test_params(self):
5454
self.setup_clean_chain = True
5555

5656
def run_test(self):
57-
node0 = NodeConnCB()
58-
connections = []
59-
connections.append(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
60-
node0.add_connection(connections[0])
57+
self.nodes[0].add_p2p_connection(NodeConnCB())
58+
6159
NetworkThread().start() # Start up network handling in another thread
6260

6361
# wait_for_verack ensures that the P2P connection is fully up.
64-
node0.wait_for_verack()
62+
self.nodes[0].p2p.wait_for_verack()
6563

6664
self.log.info("Mining %d blocks", DERSIG_HEIGHT - 2)
6765
self.coinbase_blocks = self.nodes[0].generate(DERSIG_HEIGHT - 2)
@@ -83,7 +81,7 @@ def run_test(self):
8381
block.rehash()
8482
block.solve()
8583

86-
node0.send_and_ping(msg_block(block))
84+
self.nodes[0].p2p.send_and_ping(msg_block(block))
8785
assert_equal(self.nodes[0].getbestblockhash(), block.hash)
8886

8987
self.log.info("Test that blocks must now be at least version 3")
@@ -93,15 +91,15 @@ def run_test(self):
9391
block.nVersion = 2
9492
block.rehash()
9593
block.solve()
96-
node0.send_and_ping(msg_block(block))
94+
self.nodes[0].p2p.send_and_ping(msg_block(block))
9795
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
9896

99-
wait_until(lambda: "reject" in node0.last_message.keys(), lock=mininode_lock)
97+
wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(), lock=mininode_lock)
10098
with mininode_lock:
101-
assert_equal(node0.last_message["reject"].code, REJECT_OBSOLETE)
102-
assert_equal(node0.last_message["reject"].reason, b'bad-version(0x00000002)')
103-
assert_equal(node0.last_message["reject"].data, block.sha256)
104-
del node0.last_message["reject"]
99+
assert_equal(self.nodes[0].p2p.last_message["reject"].code, REJECT_OBSOLETE)
100+
assert_equal(self.nodes[0].p2p.last_message["reject"].reason, b'bad-version(0x00000002)')
101+
assert_equal(self.nodes[0].p2p.last_message["reject"].data, block.sha256)
102+
del self.nodes[0].p2p.last_message["reject"]
105103

106104
self.log.info("Test that transactions with non-DER signatures cannot appear in a block")
107105
block.nVersion = 3
@@ -114,7 +112,7 @@ def run_test(self):
114112
# First we show that this tx is valid except for DERSIG by getting it
115113
# accepted to the mempool (which we can achieve with
116114
# -promiscuousmempoolflags).
117-
node0.send_and_ping(msg_tx(spendtx))
115+
self.nodes[0].p2p.send_and_ping(msg_tx(spendtx))
118116
assert spendtx.hash in self.nodes[0].getrawmempool()
119117

120118
# Now we verify that a block with this transaction is invalid.
@@ -123,23 +121,23 @@ def run_test(self):
123121
block.rehash()
124122
block.solve()
125123

126-
node0.send_and_ping(msg_block(block))
124+
self.nodes[0].p2p.send_and_ping(msg_block(block))
127125
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
128126

129-
wait_until(lambda: "reject" in node0.last_message.keys(), lock=mininode_lock)
127+
wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(), lock=mininode_lock)
130128
with mininode_lock:
131129
# We can receive different reject messages depending on whether
132130
# bitcoind is running with multiple script check threads. If script
133131
# check threads are not in use, then transaction script validation
134132
# happens sequentially, and bitcoind produces more specific reject
135133
# reasons.
136-
assert node0.last_message["reject"].code in [REJECT_INVALID, REJECT_NONSTANDARD]
137-
assert_equal(node0.last_message["reject"].data, block.sha256)
138-
if node0.last_message["reject"].code == REJECT_INVALID:
134+
assert self.nodes[0].p2p.last_message["reject"].code in [REJECT_INVALID, REJECT_NONSTANDARD]
135+
assert_equal(self.nodes[0].p2p.last_message["reject"].data, block.sha256)
136+
if self.nodes[0].p2p.last_message["reject"].code == REJECT_INVALID:
139137
# Generic rejection when a block is invalid
140-
assert_equal(node0.last_message["reject"].reason, b'block-validation-failed')
138+
assert_equal(self.nodes[0].p2p.last_message["reject"].reason, b'block-validation-failed')
141139
else:
142-
assert b'Non-canonical DER signature' in node0.last_message["reject"].reason
140+
assert b'Non-canonical DER signature' in self.nodes[0].p2p.last_message["reject"].reason
143141

144142
self.log.info("Test that a version 3 block with a DERSIG-compliant transaction is accepted")
145143
block.vtx[1] = create_transaction(self.nodes[0],
@@ -148,7 +146,7 @@ def run_test(self):
148146
block.rehash()
149147
block.solve()
150148

151-
node0.send_and_ping(msg_block(block))
149+
self.nodes[0].p2p.send_and_ping(msg_block(block))
152150
assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256)
153151

154152
if __name__ == '__main__':

0 commit comments

Comments
 (0)