mirror/bitcoin
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge bitcoin/bitcoin#34003: test: interface_ipc.py minor fixes and cleanup

Browse Source 
d8fe5f0326 test: improve interface_ipc.py waitNext tests (Ryan Ofsky)
a5e61b1917 test: interface_ipc.py minor fixes and cleanup (Ryan Ofsky)
ded11fb04d test: fix interface_ipc.py template destruction (Ryan Ofsky)

Pull request description:

  This PR cleans up the `interface_ipc.py` test, fixing broken checks, fixing missing await calls, removing to_dict calls, renaming variables, reducing `.result` accesses, and giving template objects explicit lifetimes. More details are in the commit messages.

  The first commit changes a lot of indentation so is easiest to review ignoring whitespace.

ACKs for top commit:
  Sjors:
    ACK d8fe5f0326
  sedited:
    ACK d8fe5f0326

Tree-SHA512: f0de309a15cb23f109cf6909e51ddd132a60bd4d4cb25b20bdc74545516670f1cdb0c9cc98c397c2f24e67e2380c2dac9d00435009618a3c00b6b85cca5c3e2e
This commit is contained in:
merge-script committed 2025-12-16 14:05:20 +00:00
2 parents 4f11ef058b d8fe5f0326
commit ab643efc0a
1 file changed
+102 -76
Download Patch File Download Diff File Expand all files Collapse all files
test/functional/interface_ipc.py
+102 -76
View File
@@ -4,6 +4,8 @@
# file COPYING or http://www.opensource.org/licenses/mit-license.php. # file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test the IPC (multiprocess) interface.""" """Test the IPC (multiprocess) interface."""
import asyncio import asyncio
import inspect
from contextlib import asynccontextmanager, AsyncExitStack
from io import BytesIO from io import BytesIO
from pathlib import Path from pathlib import Path
import shutil import shutil
@@ -21,6 +23,44 @@ try:
except ImportError: except ImportError:
pass pass
@asynccontextmanager
async def destroying(obj, ctx):
"""Call obj.destroy(ctx) at end of with: block. Similar to contextlib.closing."""
try:
yield obj
finally:
await obj.destroy(ctx)
async def create_block_template(mining, stack, ctx, opts):
"""Call mining.createNewBlock() and return template, then call template.destroy() when stack exits."""
return await stack.enter_async_context(destroying((await mining.createNewBlock(opts)).result, ctx))
async def wait_next_template(template, stack, ctx, opts):
"""Call template.waitNext() and return template, then call template.destroy() when stack exits."""
return await stack.enter_async_context(destroying((await template.waitNext(ctx, opts)).result, ctx))
async def wait_and_do(wait_fn, do_fn):
"""Call wait_fn, then sleep, then call do_fn in a parallel task. Wait for
both tasks to complete."""
wait_started = asyncio.Event()
result = None
async def wait():
nonlocal result
wait_started.set()
result = await wait_fn
async def do():
await wait_started.wait()
await asyncio.sleep(0.1)
# Let do_fn be either a callable or an awaitable object
if inspect.isawaitable(do_fn):
await do_fn
else:
do_fn()
await asyncio.gather(wait(), do())
return result
class IPCInterfaceTest(BitcoinTestFramework): class IPCInterfaceTest(BitcoinTestFramework):
@@ -77,13 +117,13 @@ class IPCInterfaceTest(BitcoinTestFramework):
return ctx, init return ctx, init
async def parse_and_deserialize_block(self, block_template, ctx): async def parse_and_deserialize_block(self, block_template, ctx):
block_data = BytesIO((await block_template.result.getBlock(ctx)).result) block_data = BytesIO((await block_template.getBlock(ctx)).result)
block = CBlock() block = CBlock()
block.deserialize(block_data) block.deserialize(block_data)
return block return block
async def parse_and_deserialize_coinbase_tx(self, block_template, ctx): async def parse_and_deserialize_coinbase_tx(self, block_template, ctx):
coinbase_data = BytesIO((await block_template.result.getCoinbaseTx(ctx)).result) coinbase_data = BytesIO((await block_template.getCoinbaseTx(ctx)).result)
tx = CTransaction() tx = CTransaction()
tx.deserialize(coinbase_data) tx.deserialize(coinbase_data)
return tx return tx
@@ -112,107 +152,101 @@ class IPCInterfaceTest(BitcoinTestFramework):
async def async_routine(): async def async_routine():
ctx, init = await self.make_capnp_init_ctx() ctx, init = await self.make_capnp_init_ctx()
self.log.debug("Create Mining proxy object") self.log.debug("Create Mining proxy object")
mining = init.makeMining(ctx) mining = init.makeMining(ctx).result
self.log.debug("Test simple inspectors") self.log.debug("Test simple inspectors")
assert (await mining.result.isTestChain(ctx)) assert (await mining.isTestChain(ctx)).result
assert (await mining.result.isInitialBlockDownload(ctx)) assert not (await mining.isInitialBlockDownload(ctx)).result
blockref = await mining.result.getTip(ctx) blockref = await mining.getTip(ctx)
assert blockref.hasResult assert blockref.hasResult
assert_equal(len(blockref.result.hash), block_hash_size) assert_equal(len(blockref.result.hash), block_hash_size)
current_block_height = self.nodes[0].getchaintips()[0]["height"] current_block_height = self.nodes[0].getchaintips()[0]["height"]
assert blockref.result.height == current_block_height assert blockref.result.height == current_block_height
self.log.debug("Mine a block") self.log.debug("Mine a block")
wait = mining.result.waitTipChanged(ctx, blockref.result.hash, ) newblockref = (await wait_and_do(
self.generate(self.nodes[0], 1) mining.waitTipChanged(ctx, blockref.result.hash, timeout),
newblockref = await wait lambda: self.generate(self.nodes[0], 1))).result
assert_equal(len(newblockref.result.hash), block_hash_size) assert_equal(len(newblockref.hash), block_hash_size)
assert_equal(newblockref.result.height, current_block_height + 1) assert_equal(newblockref.height, current_block_height + 1)
self.log.debug("Wait for timeout") self.log.debug("Wait for timeout")
wait = mining.result.waitTipChanged(ctx, newblockref.result.hash, timeout) oldblockref = (await mining.waitTipChanged(ctx, newblockref.hash, timeout)).result
oldblockref = await wait assert_equal(len(newblockref.hash), block_hash_size)
assert_equal(len(newblockref.result.hash), block_hash_size) assert_equal(oldblockref.hash, newblockref.hash)
assert_equal(oldblockref.result.hash, newblockref.result.hash) assert_equal(oldblockref.height, newblockref.height)
assert_equal(oldblockref.result.height, newblockref.result.height)
async with AsyncExitStack() as stack:
self.log.debug("Create a template") self.log.debug("Create a template")
opts = self.capnp_modules['mining'].BlockCreateOptions() opts = self.capnp_modules['mining'].BlockCreateOptions()
opts.useMempool = True opts.useMempool = True
opts.blockReservedWeight = 4000 opts.blockReservedWeight = 4000
opts.coinbaseOutputMaxAdditionalSigops = 0 opts.coinbaseOutputMaxAdditionalSigops = 0
template = mining.result.createNewBlock(opts) template = await create_block_template(mining, stack, ctx, opts)
self.log.debug("Test some inspectors of Template") self.log.debug("Test some inspectors of Template")
header = await template.result.getBlockHeader(ctx) header = (await template.getBlockHeader(ctx)).result
assert_equal(len(header.result), block_header_size) assert_equal(len(header), block_header_size)
block = await self.parse_and_deserialize_block(template, ctx) block = await self.parse_and_deserialize_block(template, ctx)
assert_equal(ser_uint256(block.hashPrevBlock), newblockref.result.hash) assert_equal(ser_uint256(block.hashPrevBlock), newblockref.hash)
assert len(block.vtx) >= 1 assert len(block.vtx) >= 1
txfees = await template.result.getTxFees(ctx) txfees = await template.getTxFees(ctx)
assert_equal(len(txfees.result), 0) assert_equal(len(txfees.result), 0)
txsigops = await template.result.getTxSigops(ctx) txsigops = await template.getTxSigops(ctx)
assert_equal(len(txsigops.result), 0) assert_equal(len(txsigops.result), 0)
coinbase_data = BytesIO((await template.result.getCoinbaseTx(ctx)).result) coinbase_data = BytesIO((await template.getCoinbaseTx(ctx)).result)
coinbase = CTransaction() coinbase = CTransaction()
coinbase.deserialize(coinbase_data) coinbase.deserialize(coinbase_data)
assert_equal(coinbase.vin[0].prevout.hash, 0) assert_equal(coinbase.vin[0].prevout.hash, 0)
self.log.debug("Wait for a new template") self.log.debug("Wait for a new template")
waitoptions = self.capnp_modules['mining'].BlockWaitOptions() waitoptions = self.capnp_modules['mining'].BlockWaitOptions()
waitoptions.timeout = timeout waitoptions.timeout = timeout
waitoptions.feeThreshold = 1 waitoptions.feeThreshold = 1
waitnext = template.result.waitNext(ctx, waitoptions) template2 = await wait_and_do(
self.generate(self.nodes[0], 1) wait_next_template(template, stack, ctx, waitoptions),
template2 = await waitnext lambda: self.generate(self.nodes[0], 1))
block2 = await self.parse_and_deserialize_block(template2, ctx) block2 = await self.parse_and_deserialize_block(template2, ctx)
assert_equal(len(block2.vtx), 1) assert_equal(len(block2.vtx), 1)
self.log.debug("Wait for another, but time out") self.log.debug("Wait for another, but time out")
template3 = await template2.result.waitNext(ctx, waitoptions) template3 = await template2.waitNext(ctx, waitoptions)
assert_equal(template3.to_dict(), {}) assert_equal(template3._has("result"), False)
self.log.debug("Wait for another, get one after increase in fees in the mempool") self.log.debug("Wait for another, get one after increase in fees in the mempool")
waitnext = template2.result.waitNext(ctx, waitoptions) template4 = await wait_and_do(
miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]) wait_next_template(template2, stack, ctx, waitoptions),
template4 = await waitnext lambda: miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]))
block3 = await self.parse_and_deserialize_block(template4, ctx) block3 = await self.parse_and_deserialize_block(template4, ctx)
assert_equal(len(block3.vtx), 2) assert_equal(len(block3.vtx), 2)
self.log.debug("Wait again, this should return the same template, since the fee threshold is zero") self.log.debug("Wait again, this should return the same template, since the fee threshold is zero")
waitoptions.feeThreshold = 0 waitoptions.feeThreshold = 0
template5 = await template4.result.waitNext(ctx, waitoptions) template5 = await wait_next_template(template4, stack, ctx, waitoptions)
block4 = await self.parse_and_deserialize_block(template5, ctx) block4 = await self.parse_and_deserialize_block(template5, ctx)
assert_equal(len(block4.vtx), 2) assert_equal(len(block4.vtx), 2)
waitoptions.feeThreshold = 1 waitoptions.feeThreshold = 1
self.log.debug("Wait for another, get one after increase in fees in the mempool") self.log.debug("Wait for another, get one after increase in fees in the mempool")
waitnext = template5.result.waitNext(ctx, waitoptions) template6 = await wait_and_do(
miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]) wait_next_template(template5, stack, ctx, waitoptions),
template6 = await waitnext lambda: miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]))
block4 = await self.parse_and_deserialize_block(template6, ctx) block4 = await self.parse_and_deserialize_block(template6, ctx)
assert_equal(len(block4.vtx), 3) assert_equal(len(block4.vtx), 3)
self.log.debug("Wait for another, but time out, since the fee threshold is set now") self.log.debug("Wait for another, but time out, since the fee threshold is set now")
template7 = await template6.result.waitNext(ctx, waitoptions) template7 = await template6.waitNext(ctx, waitoptions)
assert_equal(template7.to_dict(), {}) assert_equal(template7._has("result"), False)
self.log.debug("interruptWait should abort the current wait") self.log.debug("interruptWait should abort the current wait")
wait_started = asyncio.Event()
async def wait_for_block(): async def wait_for_block():
new_waitoptions = self.capnp_modules['mining'].BlockWaitOptions() new_waitoptions = self.capnp_modules['mining'].BlockWaitOptions()
new_waitoptions.timeout = waitoptions.timeout * 60 # 1 minute wait new_waitoptions.timeout = waitoptions.timeout * 60 # 1 minute wait
new_waitoptions.feeThreshold = 1 new_waitoptions.feeThreshold = 1
wait_started.set() template7 = await template6.waitNext(ctx, new_waitoptions)
return await template6.result.waitNext(ctx, new_waitoptions) assert_equal(template7._has("result"), False)
await wait_and_do(wait_for_block(), template6.interruptWait())
async def interrupt_wait():
await wait_started.wait() # Wait for confirmation wait started
await asyncio.sleep(0.1) # Minimal buffer
template6.result.interruptWait()
miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
wait_task = asyncio.create_task(wait_for_block())
interrupt_task = asyncio.create_task(interrupt_wait())
result = await wait_task
await interrupt_task
assert_equal(result.to_dict(), {})
current_block_height = self.nodes[0].getchaintips()[0]["height"] current_block_height = self.nodes[0].getchaintips()[0]["height"]
check_opts = self.capnp_modules['mining'].BlockCheckOptions() check_opts = self.capnp_modules['mining'].BlockCheckOptions()
template = await mining.result.createNewBlock(opts) async with destroying((await mining.createNewBlock(opts)).result, ctx) as template:
block = await self.parse_and_deserialize_block(template, ctx) block = await self.parse_and_deserialize_block(template, ctx)
coinbase = await self.parse_and_deserialize_coinbase_tx(template, ctx) coinbase = await self.parse_and_deserialize_coinbase_tx(template, ctx)
balance = miniwallet.get_balance() balance = miniwallet.get_balance()
@@ -224,26 +258,26 @@ class IPCInterfaceTest(BitcoinTestFramework):
self.log.debug("Submit a block with a bad version") self.log.debug("Submit a block with a bad version")
block.nVersion = 0 block.nVersion = 0
block.solve() block.solve()
res = await mining.result.checkBlock(block.serialize(), check_opts) check = await mining.checkBlock(block.serialize(), check_opts)
assert_equal(res.result, False) assert_equal(check.result, False)
assert_equal(res.reason, "bad-version(0x00000000)") assert_equal(check.reason, "bad-version(0x00000000)")
res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize()) submitted = (await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())).result
assert_equal(res.result, False) assert_equal(submitted, False)
self.log.debug("Submit a valid block") self.log.debug("Submit a valid block")
block.nVersion = original_version block.nVersion = original_version
block.solve() block.solve()
self.log.debug("First call checkBlock()") self.log.debug("First call checkBlock()")
res = await mining.result.checkBlock(block.serialize(), check_opts) block_valid = (await mining.checkBlock(block.serialize(), check_opts)).result
assert_equal(res.result, True) assert_equal(block_valid, True)
# The remote template block will be mutated, capture the original: # The remote template block will be mutated, capture the original:
remote_block_before = await self.parse_and_deserialize_block(template, ctx) remote_block_before = await self.parse_and_deserialize_block(template, ctx)
self.log.debug("Submitted coinbase must include witness") self.log.debug("Submitted coinbase must include witness")
assert_not_equal(coinbase.serialize_without_witness().hex(), coinbase.serialize().hex()) assert_not_equal(coinbase.serialize_without_witness().hex(), coinbase.serialize().hex())
res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize_without_witness()) submitted = (await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize_without_witness())).result
assert_equal(res.result, False) assert_equal(submitted, False)
self.log.debug("Even a rejected submitBlock() mutates the template's block") self.log.debug("Even a rejected submitBlock() mutates the template's block")
# Can be used by clients to download and inspect the (rejected) # Can be used by clients to download and inspect the (rejected)
@@ -252,8 +286,8 @@ class IPCInterfaceTest(BitcoinTestFramework):
assert_not_equal(remote_block_before.serialize().hex(), remote_block_after.serialize().hex()) assert_not_equal(remote_block_before.serialize().hex(), remote_block_after.serialize().hex())
self.log.debug("Submit again, with the witness") self.log.debug("Submit again, with the witness")
res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize()) submitted = (await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())).result
assert_equal(res.result, True) assert_equal(submitted, True)
self.log.debug("Block should propagate") self.log.debug("Block should propagate")
# Check that the IPC node actually updates its own chain # Check that the IPC node actually updates its own chain
@@ -266,18 +300,10 @@ class IPCInterfaceTest(BitcoinTestFramework):
miniwallet.rescan_utxos() miniwallet.rescan_utxos()
assert_equal(miniwallet.get_balance(), balance + 1) assert_equal(miniwallet.get_balance(), balance + 1)
self.log.debug("Check block should fail now, since it is a duplicate") self.log.debug("Check block should fail now, since it is a duplicate")
res = await mining.result.checkBlock(block.serialize(), check_opts) check = await mining.checkBlock(block.serialize(), check_opts)
assert_equal(res.result, False) assert_equal(check.result, False)
assert_equal(res.reason, "inconclusive-not-best-prevblk") assert_equal(check.reason, "inconclusive-not-best-prevblk")
self.log.debug("Destroy template objects")
template.result.destroy(ctx)
template2.result.destroy(ctx)
template3.result.destroy(ctx)
template4.result.destroy(ctx)
template5.result.destroy(ctx)
template6.result.destroy(ctx)
template7.result.destroy(ctx)
asyncio.run(capnp.run(async_routine())) asyncio.run(capnp.run(async_routine()))
def run_test(self): def run_test(self):