mirror of
https://github.com/aljazceru/python-teos.git
synced 2025-12-17 14:14:22 +01:00
223 lines
8.1 KiB
Python
223 lines
8.1 KiB
Python
import pytest
|
|
from uuid import uuid4
|
|
from queue import Queue
|
|
|
|
from pisa.builder import Builder
|
|
from pisa.watcher import Watcher
|
|
from test.pisa.unit.conftest import (
|
|
get_random_value_hex,
|
|
generate_dummy_appointment,
|
|
generate_dummy_tracker,
|
|
generate_block,
|
|
bitcoin_cli,
|
|
get_config,
|
|
)
|
|
|
|
|
|
def test_build_appointments():
|
|
appointments_data = {}
|
|
|
|
# Create some appointment data
|
|
for i in range(10):
|
|
appointment, _ = generate_dummy_appointment(real_height=False)
|
|
uuid = uuid4().hex
|
|
|
|
appointments_data[uuid] = appointment.to_dict()
|
|
|
|
# Add some additional appointments that share the same locator to test all the builder's cases
|
|
if i % 2 == 0:
|
|
locator = appointment.locator
|
|
appointment, _ = generate_dummy_appointment(real_height=False)
|
|
uuid = uuid4().hex
|
|
appointment.locator = locator
|
|
|
|
appointments_data[uuid] = appointment.to_dict()
|
|
|
|
# Use the builder to create the data structures
|
|
appointments, locator_uuid_map = Builder.build_appointments(appointments_data)
|
|
|
|
# Check that the created appointments match the data
|
|
for uuid, appointment in appointments.items():
|
|
assert uuid in appointments_data.keys()
|
|
assert appointments_data[uuid].get("locator") == appointment.get("locator")
|
|
assert appointments_data[uuid].get("end_time") == appointment.get("end_time")
|
|
assert uuid in locator_uuid_map[appointment.get("locator")]
|
|
|
|
|
|
def test_build_trackers():
|
|
trackers_data = {}
|
|
|
|
# Create some trackers data
|
|
for i in range(10):
|
|
tracker = generate_dummy_tracker()
|
|
|
|
trackers_data[uuid4().hex] = tracker.to_dict()
|
|
|
|
# Add some additional trackers that share the same locator to test all the builder's cases
|
|
if i % 2 == 0:
|
|
penalty_txid = tracker.penalty_txid
|
|
tracker = generate_dummy_tracker()
|
|
tracker.penalty_txid = penalty_txid
|
|
|
|
trackers_data[uuid4().hex] = tracker.to_dict()
|
|
|
|
trackers, tx_tracker_map = Builder.build_trackers(trackers_data)
|
|
|
|
# Check that the built trackers match the data
|
|
for uuid, tracker in trackers.items():
|
|
assert uuid in trackers_data.keys()
|
|
|
|
assert tracker.get("penalty_txid") == trackers_data[uuid].get("penalty_txid")
|
|
assert tracker.get("locator") == trackers_data[uuid].get("locator")
|
|
assert tracker.get("appointment_end") == trackers_data[uuid].get("appointment_end")
|
|
assert uuid in tx_tracker_map[tracker.get("penalty_txid")]
|
|
|
|
|
|
def test_populate_block_queue():
|
|
# Create some random block hashes and construct the queue with them
|
|
blocks = [get_random_value_hex(32) for _ in range(10)]
|
|
queue = Queue()
|
|
Builder.populate_block_queue(queue, blocks)
|
|
|
|
# Make sure every block is in the queue and that there are not additional ones
|
|
while not queue.empty():
|
|
block = queue.get()
|
|
assert block in blocks
|
|
blocks.remove(block)
|
|
|
|
assert len(blocks) == 0
|
|
|
|
|
|
def test_update_states_empty_list(db_manager):
|
|
w = Watcher(db_manager=db_manager, chain_monitor=None, sk_der=None, config=None)
|
|
|
|
missed_blocks_watcher = []
|
|
missed_blocks_responder = [get_random_value_hex(32)]
|
|
|
|
# Any combination of empty list must raise a ValueError
|
|
with pytest.raises(ValueError):
|
|
Builder.update_states(w, missed_blocks_watcher, missed_blocks_responder)
|
|
|
|
with pytest.raises(ValueError):
|
|
Builder.update_states(w, missed_blocks_responder, missed_blocks_watcher)
|
|
|
|
|
|
def test_update_states_different_sizes(run_bitcoind, db_manager, chain_monitor):
|
|
w = Watcher(db_manager=db_manager, chain_monitor=chain_monitor, sk_der=None, config=get_config())
|
|
chain_monitor.attach_watcher(w.responder, True)
|
|
chain_monitor.attach_responder(w.responder, True)
|
|
|
|
# For the states to be updated data needs to be present in the actors (either appointments or trackers).
|
|
# Let's start from the Watcher. We add one appointment and mine some blocks that both are gonna miss.
|
|
w.appointments[uuid4().hex] = {"locator": get_random_value_hex(16), "end_time": 200}
|
|
|
|
blocks = []
|
|
for _ in range(5):
|
|
generate_block()
|
|
blocks.append(bitcoin_cli().getbestblockhash())
|
|
|
|
# Updating the states should bring both to the same last known block. The Watcher's is stored in the db since it has
|
|
# gone over do_watch, whereas the Responders in only updated by update state.
|
|
Builder.update_states(w, blocks, blocks[1:])
|
|
|
|
assert db_manager.load_last_block_hash_watcher() == blocks[-1]
|
|
assert w.responder.last_known_block == blocks[-1]
|
|
|
|
# If both have work, both last known blocks are updated
|
|
w.sleep()
|
|
w.responder.sleep()
|
|
|
|
w.responder.trackers[uuid4().hex] = {
|
|
"penalty_txid": get_random_value_hex(32),
|
|
"locator": get_random_value_hex(16),
|
|
"appointment_end": 200,
|
|
}
|
|
|
|
blocks = []
|
|
for _ in range(5):
|
|
generate_block()
|
|
blocks.append(bitcoin_cli().getbestblockhash())
|
|
|
|
Builder.update_states(w, blocks[1:], blocks)
|
|
assert db_manager.load_last_block_hash_watcher() == blocks[-1]
|
|
assert db_manager.load_last_block_hash_responder() == blocks[-1]
|
|
|
|
# Let's try the opposite of the first test (Responder with data, Watcher without)
|
|
w.sleep()
|
|
w.responder.sleep()
|
|
|
|
w.appointments = {}
|
|
last_block_prev = blocks[-1]
|
|
|
|
blocks = []
|
|
for _ in range(5):
|
|
generate_block()
|
|
blocks.append(bitcoin_cli().getbestblockhash())
|
|
|
|
# The Responder should have been brought up to date via do_watch, whereas the Watcher's last known block hash't
|
|
# change. The Watcher does not keep track of reorgs, so if he has no work to do he does not even update the last
|
|
# known block.
|
|
Builder.update_states(w, blocks[1:], blocks)
|
|
assert db_manager.load_last_block_hash_watcher() == last_block_prev
|
|
assert db_manager.load_last_block_hash_responder() == blocks[-1]
|
|
|
|
|
|
def test_update_states_same_sizes(db_manager, chain_monitor):
|
|
# The exact same behaviour of the last test is expected here, since different sizes are even using
|
|
# populate_block_queue and then run with the same list size.
|
|
w = Watcher(db_manager=db_manager, chain_monitor=chain_monitor, sk_der=None, config=get_config())
|
|
chain_monitor.attach_watcher(w.responder, True)
|
|
chain_monitor.attach_responder(w.responder, True)
|
|
|
|
# For the states to be updated data needs to be present in the actors (either appointments or trackers).
|
|
# Let's start from the Watcher. We add one appointment and mine some blocks that both are gonna miss.
|
|
w.appointments[uuid4().hex] = {"locator": get_random_value_hex(16), "end_time": 200}
|
|
|
|
blocks = []
|
|
for _ in range(5):
|
|
generate_block()
|
|
blocks.append(bitcoin_cli().getbestblockhash())
|
|
|
|
Builder.update_states(w, blocks, blocks)
|
|
|
|
assert db_manager.load_last_block_hash_watcher() == blocks[-1]
|
|
assert w.responder.last_known_block == blocks[-1]
|
|
|
|
# If both have work, both last known blocks are updated
|
|
w.sleep()
|
|
w.responder.sleep()
|
|
|
|
w.responder.trackers[uuid4().hex] = {
|
|
"penalty_txid": get_random_value_hex(32),
|
|
"locator": get_random_value_hex(16),
|
|
"appointment_end": 200,
|
|
}
|
|
|
|
blocks = []
|
|
for _ in range(5):
|
|
generate_block()
|
|
blocks.append(bitcoin_cli().getbestblockhash())
|
|
|
|
Builder.update_states(w, blocks, blocks)
|
|
assert db_manager.load_last_block_hash_watcher() == blocks[-1]
|
|
assert db_manager.load_last_block_hash_responder() == blocks[-1]
|
|
|
|
# Let's try the opposite of the first test (Responder with data, Watcher without)
|
|
w.sleep()
|
|
w.responder.sleep()
|
|
|
|
w.appointments = {}
|
|
last_block_prev = blocks[-1]
|
|
|
|
blocks = []
|
|
for _ in range(5):
|
|
generate_block()
|
|
blocks.append(bitcoin_cli().getbestblockhash())
|
|
|
|
# The Responder should have been brought up to date via do_watch, whereas the Watcher's last known block hash't
|
|
# change. The Watcher does not keep track of reorgs, so if he has no work to do he does not even update the last
|
|
# known block.
|
|
Builder.update_states(w, blocks, blocks)
|
|
assert db_manager.load_last_block_hash_watcher() == last_block_prev
|
|
assert db_manager.load_last_block_hash_responder() == blocks[-1]
|