Refactor/fix mocktime usage in tests

UdjinM6 · PastaPastaPasta · commit d0288fba5862 · 2019-08-12T09:07:03.000-05:00
diff --git a/test/functional/addressindex.py b/test/functional/addressindex.py
@@ -203,8 +203,8 @@ def run_test(self):
         self.nodes[2].invalidateblock(best_hash)
         self.nodes[3].invalidateblock(best_hash)
         # Allow some time for the reorg to start
-        set_mocktime(get_mocktime() + 2)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(2)
+        set_node_times(self.nodes, self.mocktime)
         self.sync_all()
 
         balance4 = self.nodes[1].getaddressbalance(address2)
@@ -247,8 +247,8 @@ def run_test(self):
         tx.rehash()
         signed_tx = self.nodes[2].signrawtransaction(binascii.hexlify(tx.serialize()).decode("utf-8"))
         memtxid1 = self.nodes[2].sendrawtransaction(signed_tx["hex"], True)
-        set_mocktime(get_mocktime() + 2)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(2)
+        set_node_times(self.nodes, self.mocktime)
 
         tx2 = CTransaction()
         tx2.vin = [CTxIn(COutPoint(int(unspent[1]["txid"], 16), unspent[1]["vout"]))]
@@ -262,8 +262,8 @@ def run_test(self):
         tx2.rehash()
         signed_tx2 = self.nodes[2].signrawtransaction(binascii.hexlify(tx2.serialize()).decode("utf-8"))
         memtxid2 = self.nodes[2].sendrawtransaction(signed_tx2["hex"], True)
-        set_mocktime(get_mocktime() + 2)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(2)
+        set_node_times(self.nodes, self.mocktime)
 
         mempool = self.nodes[2].getaddressmempool({"addresses": [address3]})
         assert_equal(len(mempool), 3)
@@ -290,8 +290,8 @@ def run_test(self):
         self.nodes[2].importprivkey(privKey3)
         signed_tx3 = self.nodes[2].signrawtransaction(binascii.hexlify(tx.serialize()).decode("utf-8"))
         memtxid3 = self.nodes[2].sendrawtransaction(signed_tx3["hex"], True)
-        set_mocktime(get_mocktime() + 2)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(2)
+        set_node_times(self.nodes, self.mocktime)
 
         mempool3 = self.nodes[2].getaddressmempool({"addresses": [address3]})
         assert_equal(len(mempool3), 2)
diff --git a/test/functional/assumevalid.py b/test/functional/assumevalid.py
@@ -183,8 +183,8 @@ def run_test(self):
         node2.wait_for_verack()
 
         # Make sure nodes actually accept the many headers
-        set_mocktime(self.block_time)
-        set_node_times(self.nodes, get_mocktime())
+        self.set_mocktime(self.block_time)
+        set_node_times(self.nodes, self.mocktime)
 
         # send header lists to all three nodes.
         # node0 does not need to receive all headers
diff --git a/test/functional/bip65-cltv-p2p.py b/test/functional/bip65-cltv-p2p.py
@@ -63,7 +63,7 @@ def get_tests(self):
         height = 3  # height of the next block to build
         self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
         self.nodeaddress = self.nodes[0].getnewaddress()
-        self.last_block_time = get_mocktime() + 1
+        self.last_block_time = self.mocktime + 1
 
         ''' 398 more version 3 blocks '''
         test_blocks = []
diff --git a/test/functional/bip68-112-113-p2p.py b/test/functional/bip68-112-113-p2p.py
@@ -43,7 +43,7 @@
 bip112tx_special - test negative argument to OP_CSV
 """
 
-from test_framework.test_framework import ComparisonTestFramework
+from test_framework.test_framework import (ComparisonTestFramework, GENESISTIME)
 from test_framework.util import *
 from test_framework.mininode import ToHex, CTransaction, NetworkThread
 from test_framework.blocktools import create_coinbase, create_block
diff --git a/test/functional/bip68-sequence.py b/test/functional/bip68-sequence.py
@@ -242,7 +242,7 @@ def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
         # Now mine some blocks, but make sure tx2 doesn't get mined.
         # Use prioritisetransaction to lower the effective feerate to 0
         self.nodes[0].prioritisetransaction(tx2.hash, int(-self.relayfee*COIN))
-        cur_time = get_mocktime()
+        cur_time = self.mocktime
         for i in range(10):
             self.nodes[0].setmocktime(cur_time + 600)
             self.nodes[0].generate(1)
@@ -318,7 +318,7 @@ def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
         assert(tx2.hash in mempool)
 
         # Reset the chain and get rid of the mocktimed-blocks
-        self.nodes[0].setmocktime(get_mocktime())
+        self.nodes[0].setmocktime(self.mocktime)
         self.nodes[0].invalidateblock(self.nodes[0].getblockhash(cur_height+1))
         self.nodes[0].generate(10)
 
@@ -359,7 +359,7 @@ def test_bip68_not_consensus(self):
 
         # make a block that violates bip68; ensure that the tip updates
         tip = int(self.nodes[0].getbestblockhash(), 16)
-        block = create_block(tip, create_coinbase(self.nodes[0].getblockcount()+1), get_mocktime() + 600)
+        block = create_block(tip, create_coinbase(self.nodes[0].getblockcount()+1), self.mocktime + 600)
         block.nVersion = 3
         block.vtx.extend([tx1, tx2, tx3])
         block.hashMerkleRoot = block.calc_merkle_root()
diff --git a/test/functional/bip9-softforks.py b/test/functional/bip9-softforks.py
@@ -82,7 +82,7 @@ def test_BIP(self, bipName, activated_version, invalidate, invalidatePostSignatu
         self.height = 3  # height of the next block to build
         self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
         self.nodeaddress = self.nodes[0].getnewaddress()
-        self.last_block_time = get_mocktime() + 1
+        self.last_block_time = self.mocktime + 1
 
         assert_equal(self.get_bip9_status(bipName)['status'], 'defined')
         assert_equal(self.get_bip9_status(bipName)['since'], 0)
diff --git a/test/functional/bipdersig-p2p.py b/test/functional/bipdersig-p2p.py
@@ -70,7 +70,7 @@ def get_tests(self):
         height = 3  # height of the next block to build
         self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
         self.nodeaddress = self.nodes[0].getnewaddress()
-        self.last_block_time = get_mocktime() + 1
+        self.last_block_time = self.mocktime + 1
 
         ''' 298 more version 2 blocks '''
         test_blocks = []
diff --git a/test/functional/dip3-deterministicmns.py b/test/functional/dip3-deterministicmns.py
@@ -28,7 +28,7 @@ def __init__(self):
 
 
     def setup_network(self):
-        disable_mocktime()
+        self.disable_mocktime()
         self.start_controller_node()
 
     def start_controller_node(self, extra_args=None):
diff --git a/test/functional/dip4-coinbasemerkleroots.py b/test/functional/dip4-coinbasemerkleroots.py
@@ -269,8 +269,8 @@ def test_dip8_quorum_merkle_root_activation(self, with_initial_quorum):
         else:
             assert_equal(merkleRootQuorums, 0)
 
-        set_mocktime(get_mocktime() + 1)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(1)
+        set_node_times(self.nodes, self.mocktime)
         self.nodes[0].spork("SPORK_17_QUORUM_DKG_ENABLED", 0)
         self.wait_for_sporks_same()
 
diff --git a/test/functional/disconnect_ban.py b/test/functional/disconnect_ban.py
@@ -9,8 +9,6 @@
 from test_framework.util import (assert_equal,
                                  assert_raises_jsonrpc,
                                  connect_nodes_bi,
-                                 set_mocktime,
-                                 get_mocktime,
                                  set_node_times,
                                  )
 
@@ -61,8 +59,8 @@ def run_test(self):
         self.nodes[1].setban("2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/19", "add", 1000)  # ban for 1000 seconds
         listBeforeShutdown = self.nodes[1].listbanned()
         assert_equal("192.168.0.1/32", listBeforeShutdown[2]['address'])
-        set_mocktime(get_mocktime() + 2)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(2)
+        set_node_times(self.nodes, self.mocktime)
         assert wait_until(lambda: len(self.nodes[1].listbanned()) == 3, timeout=10)
 
         self.stop_node(1)
diff --git a/test/functional/invalidblockrequest.py b/test/functional/invalidblockrequest.py
@@ -38,7 +38,7 @@ def run_test(self):
     def get_tests(self):
         if self.tip is None:
             self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
-        self.block_time = get_mocktime() + 1
+        self.block_time = self.mocktime + 1
 
         '''
         Create a new block with an anyone-can-spend coinbase
diff --git a/test/functional/invalidtxrequest.py b/test/functional/invalidtxrequest.py
@@ -10,8 +10,6 @@
 from test_framework.test_framework import ComparisonTestFramework
 from test_framework.comptool import TestManager, TestInstance, RejectResult
 from test_framework.blocktools import *
-from test_framework.util import get_mocktime
-
 
 
 # Use the ComparisonTestFramework with 1 node: only use --testbinary.
@@ -34,7 +32,7 @@ def run_test(self):
     def get_tests(self):
         if self.tip is None:
             self.tip = int("0x" + self.nodes[0].getbestblockhash(), 0)
-        self.block_time = get_mocktime() + 1
+        self.block_time = self.mocktime + 1
 
         '''
         Create a new block with an anyone-can-spend coinbase
diff --git a/test/functional/llmq-dkgerrors.py b/test/functional/llmq-dkgerrors.py
@@ -93,8 +93,8 @@ def heal_masternodes(self, blockCount):
         self.nodes[0].spork("SPORK_17_QUORUM_DKG_ENABLED", 4070908800)
         self.wait_for_sporks_same()
         for i in range(blockCount):
-            set_mocktime(get_mocktime() + 1)
-            set_node_times(self.nodes, get_mocktime())
+            self.bump_mocktime(1)
+            set_node_times(self.nodes, self.mocktime)
             self.nodes[0].generate(1)
         self.sync_all()
         self.nodes[0].spork("SPORK_17_QUORUM_DKG_ENABLED", 0)
diff --git a/test/functional/llmq-is-cl-conflicts.py b/test/functional/llmq-is-cl-conflicts.py
@@ -168,8 +168,8 @@ def test_islock_overrides_nonchainlock(self):
         self.nodes[0].sendrawtransaction(rawtx1)
 
         # fast forward 11 minutes, so that the TX is considered safe and included in the next block
-        set_mocktime(get_mocktime() + int(60 * 11))
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(int(60 * 11))
+        set_node_times(self.nodes, self.mocktime)
 
         # Mine the conflicting TX into a block
         good_tip = self.nodes[0].getbestblockhash()
diff --git a/test/functional/llmq-signing.py b/test/functional/llmq-signing.py
@@ -76,13 +76,13 @@ def assert_sigs_nochange(hasrecsigs, isconflicting1, isconflicting2, timeout):
         assert_sigs_nochange(True, False, True, 3)
 
         # fast forward 6.5 days, recovered sig should still be valid
-        set_mocktime(get_mocktime() + int(60 * 60 * 24 * 6.5))
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(int(60 * 60 * 24 * 6.5))
+        set_node_times(self.nodes, self.mocktime)
         # Cleanup starts every 5 seconds
         wait_for_sigs(True, False, True, 15)
         # fast forward 1 day, recovered sig should not be valid anymore
-        set_mocktime(get_mocktime() + int(60 * 60 * 24 * 1))
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(int(60 * 60 * 24 * 1))
+        set_node_times(self.nodes, self.mocktime)
         # Cleanup starts every 5 seconds
         wait_for_sigs(False, False, False, 15)
 
diff --git a/test/functional/maxuploadtarget.py b/test/functional/maxuploadtarget.py
@@ -42,9 +42,9 @@ def __init__(self):
 
     def run_test(self):
         # Advance all nodes 2 weeks in the future
-        old_mocktime = get_mocktime()
+        old_mocktime = self.mocktime
         current_mocktime = old_mocktime + 2*60*60*24*7
-        set_mocktime(current_mocktime)
+        self.set_mocktime(current_mocktime)
         set_node_times(self.nodes, current_mocktime)
 
         # Before we connect anything, we first set the time on the node
diff --git a/test/functional/multikeysporks.py b/test/functional/multikeysporks.py
@@ -121,8 +121,8 @@ def run_test(self):
         for node in self.nodes:
             assert(self.get_test_spork_state(node) == 4070908800)
 
-        set_mocktime(get_mocktime() + 1)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(1)
+        set_node_times(self.nodes, self.mocktime)
         # first and second signers set spork value
         self.set_test_spork_state(self.nodes[0], 1)
         self.set_test_spork_state(self.nodes[1], 1)
@@ -136,8 +136,8 @@ def run_test(self):
         for node in self.nodes:
             assert(self.wait_for_test_spork_state(node, 1))
 
-        set_mocktime(get_mocktime() + 1)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(1)
+        set_node_times(self.nodes, self.mocktime)
         # now set the spork again with other signers to test
         # old and new spork messages interaction
         self.set_test_spork_state(self.nodes[2], 2)
diff --git a/test/functional/nulldummy.py b/test/functional/nulldummy.py
@@ -55,7 +55,7 @@ def run_test(self):
         self.lastblockhash = self.nodes[0].getbestblockhash()
         self.tip = int("0x" + self.lastblockhash, 0)
         self.lastblockheight = 429
-        self.lastblocktime = get_mocktime() + 429
+        self.lastblocktime = self.mocktime + 429
 
         self.log.info("Test 1: NULLDUMMY compliant base transactions should be accepted to mempool and mined before activation [430]")
         test1txs = [self.create_transaction(self.nodes[0], coinbase_txid[0], self.ms_address, 49)]
diff --git a/test/functional/p2p-acceptblock.py b/test/functional/p2p-acceptblock.py
@@ -96,7 +96,7 @@ def run_test(self):
         # 2. Send one block that builds on each tip.
         # This should be accepted.
         blocks_h2 = []  # the height 2 blocks on each node's chain
-        block_time = get_mocktime() + 1
+        block_time = self.mocktime + 1
         for i in range(2):
             blocks_h2.append(create_block(tips[i], create_coinbase(2), block_time + 1))
             blocks_h2[i].solve()
@@ -168,8 +168,8 @@ def run_test(self):
                     headers_message.headers.append(CBlockHeader(next_block))
                 tips[j] = next_block
 
-        set_mocktime(get_mocktime() + 2)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(2)
+        set_node_times(self.nodes, self.mocktime)
         # Blocks 1-287 should be accepted, block 288 should be ignored because it's too far ahead
         for x in all_blocks[:-1]:
             self.nodes[0].getblock(x.hash)
diff --git a/test/functional/p2p-fullblocktest.py b/test/functional/p2p-fullblocktest.py
@@ -106,7 +106,7 @@ def create_and_sign_transaction(self, spend_tx, n, value, script=CScript([OP_TRU
     def next_block(self, number, spend=None, additional_coinbase_value=0, script=CScript([OP_TRUE]), solve=True):
         if self.tip == None:
             base_block_hash = self.genesis_hash
-            block_time = get_mocktime() + 1
+            block_time = self.mocktime + 1
         else:
             base_block_hash = self.tip.sha256
             block_time = self.tip.nTime + 1
@@ -676,7 +676,7 @@ def update_block(block_number, new_transactions):
         # A block with timestamp > 2 hrs in the future
         tip(44)
         b48 = block(48, solve=False)
-        b48.nTime = get_mocktime() + 60 * 60 * 3
+        b48.nTime = self.mocktime + 60 * 60 * 3
         b48.solve()
         yield rejected(RejectResult(16, b'time-too-new'))
 
diff --git a/test/functional/p2p-instantsend.py b/test/functional/p2p-instantsend.py
@@ -56,8 +56,8 @@ def test_block_doublespend(self):
         # send doublespend transaction to isolated node
         isolated.sendrawtransaction(dblspnd_tx['hex'])
         # generate block on isolated node with doublespend transaction
-        set_mocktime(get_mocktime() + 1)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(1)
+        set_node_times(self.nodes, self.mocktime)
         isolated.generate(1)
         wrong_block = isolated.getbestblockhash()
         # connect isolated block to network
@@ -73,8 +73,8 @@ def test_block_doublespend(self):
             timeout = 1
         # mine more blocks
         # TODO: mine these blocks on an isolated node
-        set_mocktime(get_mocktime() + 1)
-        set_node_times(self.nodes, get_mocktime())
+        self.bump_mocktime(1)
+        set_node_times(self.nodes, self.mocktime)
         self.nodes[0].generate(2)
         self.sync_all()
 
diff --git a/test/functional/prioritise_transaction.py b/test/functional/prioritise_transaction.py
@@ -117,11 +117,10 @@ def run_test(self):
 
         # Test that calling prioritisetransaction is sufficient to trigger
         # getblocktemplate to (eventually) return a new block.
-        mock_time = get_mocktime()
-        self.nodes[0].setmocktime(mock_time)
+        self.nodes[0].setmocktime(self.mocktime)
         template = self.nodes[0].getblocktemplate()
         self.nodes[0].prioritisetransaction(tx_id, -int(self.relayfee*COIN))
-        self.nodes[0].setmocktime(mock_time+10)
+        self.nodes[0].setmocktime(self.mocktime+10)
         new_template = self.nodes[0].getblocktemplate()
 
         assert(template != new_template)
diff --git a/test/functional/sporks.py b/test/functional/sporks.py
@@ -19,7 +19,7 @@ def __init__(self):
         self.extra_args = [["-sporkkey=cP4EKFyJsHT39LDqgdcB43Y3YXjNyjb5Fuas1GQSeAtjnZWmZEQK"], [], []]
 
     def setup_network(self):
-        disable_mocktime()
+        self.disable_mocktime()
         self.setup_nodes()
         # connect only 2 first nodes at start
         connect_nodes(self.nodes[0], 1)
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
diff --git a/test/functional/wallet-dump.py b/test/functional/wallet-dump.py
