def test_monitor_chain_polling(block_processor_mock, monkeypatch):
# Monkeypatch the BlockProcessor so the best tip remains unchanged
fixed_tip = get_random_value_hex(32)
monkeypatch.setattr(block_processor_mock, "get_best_block_hash", lambda blocking: fixed_tip)
chain_monitor = ChainMonitor([Queue(), Queue()], block_processor_mock, bitcoind_feed_params)
chain_monitor.last_tips = [fixed_tip]
chain_monitor.polling_delta = 0.1
# monitor_chain_polling runs until not terminated
polling_thread = Thread(target=chain_monitor.monitor_chain_polling, daemon=True)
polling_thread.start()
# Check that nothing changes as long as a block is not generated
for _ in range(5):
assert chain_monitor.queue.empty()
time.sleep(0.1)
# And that it does if we generate a block
monkeypatch.setattr(block_processor_mock, "get_best_block_hash", lambda blocking: get_random_value_hex(32))
time.sleep(0.1)
chain_monitor.queue.get()
assert chain_monitor.queue.empty()
# Check that the bitcoind_reachable event is cleared if the connection is lost, and set once it's recovered
monkeypatch.setattr(block_processor_mock, "get_best_block_hash", mock_connection_refused_return)
time.sleep(0.5)
assert not chain_monitor.bitcoind_reachable.is_set()
monkeypatch.delattr(block_processor_mock, "get_best_block_hash")
time.sleep(0.5)
assert chain_monitor.bitcoind_reachable.is_set()
chain_monitor.terminate()
def test_enqueue(block_processor):
# The state is updated after receiving a new block (and only if the block is not already known).
# Let's start by adding some hashes to last_tips
chain_monitor = ChainMonitor([Queue(), Queue()], block_processor, bitcoind_feed_params)
chain_monitor.last_tips = [get_random_value_hex(32) for _ in range(5)]
# Now we can try to update the state with an hash already seen and see how it doesn't work
assert chain_monitor.enqueue(chain_monitor.last_tips[0]) is False
# The state should be correctly updated with a new block hash, which should be added as last element of last_tips
another_block_hash = get_random_value_hex(32)
assert chain_monitor.enqueue(another_block_hash) is True
assert chain_monitor.last_tips[-1] == another_block_hash
def test_monitor_chain_polling(block_processor):
chain_monitor = ChainMonitor([Queue(), Queue()], block_processor, bitcoind_feed_params)
chain_monitor.last_tips = [block_processor.get_best_block_hash()]
chain_monitor.polling_delta = 0.1
# monitor_chain_polling runs until not terminated
polling_thread = Thread(target=chain_monitor.monitor_chain_polling, daemon=True)
polling_thread.start()
# Check that nothing changes as long as a block is not generated
for _ in range(5):
assert chain_monitor.queue.empty()
time.sleep(0.1)
# And that it does if we generate a block
generate_blocks(1)
chain_monitor.queue.get()
assert chain_monitor.queue.empty()
chain_monitor.terminate()
def test_monitor_chain_zmq(block_processor):
responder_queue = Queue()
chain_monitor = ChainMonitor([Queue(), responder_queue], block_processor, bitcoind_feed_params)
chain_monitor.last_tips = [block_processor.get_best_block_hash()]
zmq_thread = Thread(target=chain_monitor.monitor_chain_zmq, daemon=True)
zmq_thread.start()
# the internal queue should start empty
assert chain_monitor.queue.empty()
# And have a new block every time we generate one
for _ in range(3):
generate_blocks(1)
chain_monitor.queue.get()
assert chain_monitor.queue.empty()
chain_monitor.terminate()
# The zmq thread needs a block generation to release from the recv method.
generate_blocks(1)
def test_update_state(block_processor):
# The state is updated after receiving a new block (and only if the block is not already known).
# Let's start by setting a best_tip and a couple of old tips
new_block_hash = get_random_value_hex(32)
chain_monitor = ChainMonitor(Queue(), Queue(), block_processor,
bitcoind_feed_params)
chain_monitor.best_tip = new_block_hash
chain_monitor.last_tips = [get_random_value_hex(32) for _ in range(5)]
# Now we can try to update the state with an old best_tip and see how it doesn't work
assert chain_monitor.update_state(chain_monitor.last_tips[0]) is False
# Same should happen with the current tip
assert chain_monitor.update_state(chain_monitor.best_tip) is False
# The state should be correctly updated with a new block hash, the chain tip should change and the old tip should
# have been added to the last_tips
another_block_hash = get_random_value_hex(32)
assert chain_monitor.update_state(another_block_hash) is True
assert chain_monitor.best_tip == another_block_hash and new_block_hash == chain_monitor.last_tips[
-1]