Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

test: improve rpc_blockchain.py tests and assert on time and mediantime #22520

Merged
merged 4 commits into from
Jul 30, 2021
Merged

test: improve rpc_blockchain.py tests and assert on time and mediantime #22520

Changes from 1 commit
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
0a9129c
test: assert on the value of getblockchaininfo#time
jonatack Jul 21, 2021
78c3610
test: assert on mediantime in getblockheader and getblockchaininfo
jonatack Jul 21, 2021
d548dc7
test: replace magic values by constants in rpc_blockchain.py
jonatack Jul 21, 2021
ef5e930
test: update logging and docstring in rpc_blockchain.py
jonatack Jul 21, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
test: replace magic values by constants in rpc_blockchain.py
  • Loading branch information
@jonatack
jonatack committed Jul 21, 2021
commit d548dc71e4849f638fccaea6be86ac4fa5304f01
49 changes: 25 additions & 24 deletions test/functional/rpc_blockchain.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -49,9 +49,10 @@
from test_framework.wallet import MiniWallet


HEIGHT = 200 # blocks mined
TIME_RANGE_STEP = 600 # ten-minute steps
TIME_RANGE_MTP = TIME_GENESIS_BLOCK + 194 * TIME_RANGE_STEP
TIME_RANGE_END = TIME_GENESIS_BLOCK + 200 * TIME_RANGE_STEP
TIME_RANGE_MTP = TIME_GENESIS_BLOCK + (HEIGHT - 6) * TIME_RANGE_STEP
TIME_RANGE_END = TIME_GENESIS_BLOCK + HEIGHT * TIME_RANGE_STEP


class BlockchainTest(BitcoinTestFramework):
Expand All @@ -76,11 +77,11 @@ def run_test(self):
assert self.nodes[0].verifychain(4, 0)

def mine_chain(self):
self.log.info("Generate 200 blocks after the genesis block in ten-minute steps")
self.log.info(f"Generate {HEIGHT} blocks after the genesis block in ten-minute steps")
for t in range(TIME_GENESIS_BLOCK, TIME_RANGE_END, TIME_RANGE_STEP):
self.nodes[0].setmocktime(t)
self.nodes[0].generatetoaddress(1, ADDRESS_BCRT1_P2WSH_OP_TRUE)
assert_equal(self.nodes[0].getblockchaininfo()['blocks'], 200)
assert_equal(self.nodes[0].getblockchaininfo()['blocks'], HEIGHT)

def _test_getblockchaininfo(self):
self.log.info("Test getblockchaininfo")
Expand Down Expand Up @@ -153,8 +154,8 @@ def _test_getblockchaininfo(self):
'statistics': {
'period': 144,
'threshold': 108,
'elapsed': 57,
'count': 57,
'elapsed': HEIGHT - 143,
'count': HEIGHT - 143,
'possible': True,
},
'min_activation_height': 0,
Expand Down Expand Up @@ -191,33 +192,33 @@ def _test_getchaintxstats(self):
assert_raises_rpc_error(-8, "blockhash must be of length 64 (not 1, for '0')", self.nodes[0].getchaintxstats, blockhash='0')
assert_raises_rpc_error(-8, "blockhash must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')", self.nodes[0].getchaintxstats, blockhash='ZZZ0000000000000000000000000000000000000000000000000000000000000')
assert_raises_rpc_error(-5, "Block not found", self.nodes[0].getchaintxstats, blockhash='0000000000000000000000000000000000000000000000000000000000000000')
blockhash = self.nodes[0].getblockhash(200)
blockhash = self.nodes[0].getblockhash(HEIGHT)
self.nodes[0].invalidateblock(blockhash)
assert_raises_rpc_error(-8, "Block is not in main chain", self.nodes[0].getchaintxstats, blockhash=blockhash)
self.nodes[0].reconsiderblock(blockhash)

chaintxstats = self.nodes[0].getchaintxstats(nblocks=1)
# 200 txs plus genesis tx
assert_equal(chaintxstats['txcount'], 201)
assert_equal(chaintxstats['txcount'], HEIGHT + 1)
# tx rate should be 1 per 10 minutes, or 1/600
# we have to round because of binary math
assert_equal(round(chaintxstats['txrate'] * 600, 10), Decimal(1))
assert_equal(round(chaintxstats['txrate'] * TIME_RANGE_STEP, 10), Decimal(1))

b1_hash = self.nodes[0].getblockhash(1)
b1 = self.nodes[0].getblock(b1_hash)
b200_hash = self.nodes[0].getblockhash(200)
b200_hash = self.nodes[0].getblockhash(HEIGHT)
b200 = self.nodes[0].getblock(b200_hash)
time_diff = b200['mediantime'] - b1['mediantime']

chaintxstats = self.nodes[0].getchaintxstats()
assert_equal(chaintxstats['time'], b200['time'])
assert_equal(chaintxstats['txcount'], 201)
assert_equal(chaintxstats['txcount'], HEIGHT + 1)
assert_equal(chaintxstats['window_final_block_hash'], b200_hash)
assert_equal(chaintxstats['window_final_block_height'], 200)
assert_equal(chaintxstats['window_block_count'], 199)
assert_equal(chaintxstats['window_tx_count'], 199)
assert_equal(chaintxstats['window_final_block_height'], HEIGHT )
assert_equal(chaintxstats['window_block_count'], HEIGHT - 1)
assert_equal(chaintxstats['window_tx_count'], HEIGHT - 1)
assert_equal(chaintxstats['window_interval'], time_diff)
assert_equal(round(chaintxstats['txrate'] * time_diff, 10), Decimal(199))
assert_equal(round(chaintxstats['txrate'] * time_diff, 10), Decimal(HEIGHT - 1))

chaintxstats = self.nodes[0].getchaintxstats(blockhash=b1_hash)
assert_equal(chaintxstats['time'], b1['time'])
Expand All @@ -234,11 +235,11 @@ def _test_gettxoutsetinfo(self):
res = node.gettxoutsetinfo()

assert_equal(res['total_amount'], Decimal('8725.00000000'))
assert_equal(res['transactions'], 200)
assert_equal(res['height'], 200)
assert_equal(res['txouts'], 200)
assert_equal(res['transactions'], HEIGHT)
assert_equal(res['height'], HEIGHT)
assert_equal(res['txouts'], HEIGHT)
assert_equal(res['bogosize'], 16800),
assert_equal(res['bestblock'], node.getblockhash(200))
assert_equal(res['bestblock'], node.getblockhash(HEIGHT))
size = res['disk_size']
assert size > 6400
assert size < 64000
Expand Down Expand Up @@ -298,11 +299,11 @@ def _test_getblockheader(self):
assert_raises_rpc_error(-5, "Block not found", node.getblockheader, "0cf7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844")

besthash = node.getbestblockhash()
secondbesthash = node.getblockhash(199)
secondbesthash = node.getblockhash(HEIGHT - 1)
header = node.getblockheader(blockhash=besthash)

assert_equal(header['hash'], besthash)
assert_equal(header['height'], 200)
assert_equal(header['height'], HEIGHT)
assert_equal(header['confirmations'], 1)
assert_equal(header['previousblockhash'], secondbesthash)
assert_is_hex_string(header['chainwork'])
Expand Down Expand Up @@ -341,9 +342,9 @@ def _test_getnetworkhashps(self):
assert abs(hashes_per_second * 300 - 1) < 0.0001

def _test_stopatheight(self):
assert_equal(self.nodes[0].getblockcount(), 200)
assert_equal(self.nodes[0].getblockcount(), HEIGHT)
self.nodes[0].generatetoaddress(6, ADDRESS_BCRT1_P2WSH_OP_TRUE)
assert_equal(self.nodes[0].getblockcount(), 206)
assert_equal(self.nodes[0].getblockcount(), HEIGHT + 6)
self.log.debug('Node should not stop at this height')
assert_raises(subprocess.TimeoutExpired, lambda: self.nodes[0].process.wait(timeout=3))
try:
Expand All @@ -353,7 +354,7 @@ def _test_stopatheight(self):
self.log.debug('Node should stop at this height...')
self.nodes[0].wait_until_stopped()
self.start_node(0)
assert_equal(self.nodes[0].getblockcount(), 207)
assert_equal(self.nodes[0].getblockcount(), HEIGHT + 7)

def _test_waitforblockheight(self):
self.log.info("Test waitforblockheight")
Expand Down