class TestChainController(unittest.TestCase):
def setUp(self):
self.blocks = BlockTreeManager()
self.gossip = MockNetwork()
self.executor = SynchronousExecutor()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.state_view_factory = MockStateViewFactory()
def chain_updated(head, committed_batches=None,
uncommitted_batches=None):
pass
self.chain_ctrl = ChainController(
consensus_module=mock_consensus,
block_cache=self.blocks.block_cache,
state_view_factory=self.state_view_factory,
block_sender=self.block_sender,
executor=self.executor,
transaction_executor=MockTransactionExecutor(),
on_chain_updated=chain_updated,
squash_handler=None)
def test_simple_case(self):
# TEST Run the simple case
block_1 = self.blocks.generate_block(self.blocks.chain_head)
self.chain_ctrl.on_block_received(block_1)
self.executor.process_all()
assert(self.chain_ctrl.chain_head.block.header_signature ==
block_1.header_signature)
def test_alternate_genesis(self):
# TEST Run generate and alternate genesis block
head = self.chain_ctrl.chain_head
for b in self.blocks.generate_chain(None, 5,
{"add_to_cache": True}):
self.chain_ctrl.on_block_received(b)
self.executor.process_all()
assert(self.chain_ctrl.chain_head.block.header_signature ==
head.block.header_signature)
def test_bad_block_signature(self):
# TEST Bad block extending current chain
# Bad due to signature
head = self.blocks.chain_head
block_bad = self.blocks.generate_block(self.blocks.chain_head.block,
invalid_signature=True)
self.chain_ctrl.on_block_received(block_bad)
assert (self.chain_ctrl.chain_head.block.header_signature ==
head.block.header_signature)
def test_bad_block_consensus(self):
# Bad due to consensus
pass
def test_bad_block_transaction(self):
# Bad due to transaction
pass
class TestChainController(unittest.TestCase):
def setUp(self):
self.blocks = BlockTreeManager()
self.gossip = MockNetwork()
self.executor = SynchronousExecutor()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
def chain_updated(head):
pass
self.chain_ctrl = ChainController(
consensus=TestModeVerifier(),
block_cache=self.blocks.block_cache,
block_sender=self.block_sender,
executor=self.executor,
transaction_executor=MockTransactionExecutor(),
on_chain_updated=chain_updated,
squash_handler=None)
def test_simple_case(self):
# TEST Run the simple case
block_1 = self.blocks.generate_block(self.blocks.chain_head)
self.chain_ctrl.on_block_received(block_1)
self.executor.process_all()
assert(self.chain_ctrl.chain_head.block.header_signature ==
block_1.header_signature)
def test_alternate_genesis(self):
# TEST Run generate and alternate genesis block
head = self.chain_ctrl.chain_head
other_genesis = self.blocks.generate_block(add_to_store=True)
for b in self.blocks.generate_chain(other_genesis, 5):
self.chain_ctrl.on_block_received(b)
self.executor.process_all()
assert(self.chain_ctrl.chain_head.block.header_signature ==
head.block.header_signature)
def test_bad_block_signature(self):
# TEST Bad block extending current chain
# Bad due to signature
head = self.blocks.chain_head
block_bad = self.blocks.generate_block(self.blocks.chain_head.block,
invalid_signature=True)
self.chain_ctrl.on_block_received(block_bad)
assert (self.chain_ctrl.chain_head.block.header_signature ==
head.block.header_signature)
def test_bad_block_consensus(self):
# Bad due to consensus
pass
def test_bad_block_transaction(self):
# Bad due to transaction
pass
class TestChainController(unittest.TestCase):
def setUp(self):
self.blocks = BlockTreeManager()
self.gossip = MockNetwork()
self.executor = SynchronousExecutor()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
def chain_updated(head):
pass
self.chain_ctrl = ChainController(
consensus=TestModeVerifier(),
block_store=self.blocks.block_store,
block_sender=self.block_sender,
executor=self.executor,
transaction_executor=MockTransactionExecutor(),
on_chain_updated=chain_updated,
squash_handler=None)
def test_simple_case(self):
# TEST Run the simple case
block_1 = self.blocks.generate_block(self.blocks.chain_head)
self.chain_ctrl.on_block_received(block_1.get_block())
self.executor.process_all()
assert(self.chain_ctrl.chain_head.block.header_signature ==
block_1.header_signature)
def test_alternate_genesis(self):
# TEST Run generate and alternate genesis block
head = self.chain_ctrl.chain_head
other_genesis = self.blocks.generate_block(add_to_store=True)
for b in self.blocks.generate_chain(other_genesis, 5):
self.chain_ctrl.on_block_received(b.get_block())
self.executor.process_all()
assert(self.chain_ctrl.chain_head.block.header_signature ==
head.block.header_signature)
def test_bad_block_signature(self):
# TEST Bad block extending current chain
# Bad due to signature
head = self.blocks.chain_head
block_bad = self.blocks.generate_block(self.blocks.chain_head.block,
invalid_signature=True)
self.chain_ctrl.on_block_received(block_bad.get_block())
assert (self.chain_ctrl.chain_head.block.header_signature ==
head.block.header_signature)
def test_bad_block_consensus(self):
# Bad due to consensus
pass
def test_bad_block_transaction(self):
# Bad due to transaction
pass
def test_publish_deltas_no_state_changes(self):
"""Given a block transition, where no state changes happened (e.g. it
only had transactions which did not change state), the
StateDeltaProcessor should still publish an event with the block change
information.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
database = DictDatabase()
delta_store = StateDeltaStore(database)
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=delta_store,
block_store=block_tree_manager.block_store)
delta_processor.add_subscriber(
'subscriber_conn_id', [block_tree_manager.chain_head.identifier],
['000000'])
next_block = block_tree_manager.generate_block()
delta_processor.publish_deltas(next_block)
mock_service.send.assert_called_with(
validator_pb2.Message.STATE_DELTA_EVENT,
StateDeltaEvent(
block_id=next_block.identifier,
block_num=next_block.header.block_num,
state_root_hash=next_block.header.state_root_hash,
previous_block_id=next_block.header.previous_block_id,
state_changes=[]).SerializeToString(),
connection_id='subscriber_conn_id')
def test_publish_deltas(self):
"""Tests that a subscriber filtering on an address prefix receives only
the changes in an event that match.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
database = DictDatabase()
delta_store = StateDeltaStore(database)
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=delta_store,
block_store=block_tree_manager.block_store)
delta_processor.add_subscriber(
'test_conn_id', [block_tree_manager.chain_head.identifier],
['deadbeef'])
next_block = block_tree_manager.generate_block()
# State added during context squash for our block
delta_store.save_state_deltas(next_block.header.state_root_hash, [
StateChange(address='deadbeef01',
value='my_state_Value'.encode(),
type=StateChange.SET),
StateChange(address='a14ea01',
value='some other state value'.encode(),
type=StateChange.SET)
])
# call to publish deltas for that block to the subscribers
delta_processor.publish_deltas(next_block)
mock_service.send.assert_called_with(
validator_pb2.Message.STATE_DELTA_EVENT,
StateDeltaEvent(
block_id=next_block.identifier,
block_num=next_block.header.block_num,
state_root_hash=next_block.header.state_root_hash,
previous_block_id=next_block.header.previous_block_id,
state_changes=[
StateChange(address='deadbeef01',
value='my_state_Value'.encode(),
type=StateChange.SET)
]).SerializeToString(),
connection_id='test_conn_id')
def test_publish_deltas_subscriber_matches_no_addresses(self):
"""Given a subscriber whose prefix filters don't match any addresses
in the current state delta, it should still receive an event with the
block change information.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
database = DictDatabase()
delta_store = StateDeltaStore(database)
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=delta_store,
block_store=block_tree_manager.block_store)
delta_processor.add_subscriber(
'settings_conn_id',
[block_tree_manager.chain_head.identifier],
['000000'])
next_block = block_tree_manager.generate_block()
# State added during context squash for our block
delta_store.save_state_deltas(
next_block.header.state_root_hash,
[StateChange(address='deadbeef01',
value='my_state_Value'.encode(),
type=StateChange.SET),
StateChange(address='a14ea01',
value='some other state value'.encode(),
type=StateChange.SET)])
# call to publish deltas for that block to the subscribers
delta_processor.publish_deltas(next_block)
mock_service.send.assert_called_with(
validator_pb2.Message.STATE_DELTA_EVENT,
StateDeltaEvent(
block_id=next_block.identifier,
block_num=next_block.header.block_num,
state_root_hash=next_block.header.state_root_hash,
state_changes=[]
).SerializeToString(),
connection_id='settings_conn_id')
class TestChainController(unittest.TestCase):
def setUp(self):
self.block_tree_manager = BlockTreeManager()
self.gossip = MockNetwork()
self.executor = SynchronousExecutor()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.chain_id_manager = MockChainIdManager()
self._chain_head_lock = RLock()
self.state_delta_processor = MockStateDeltaProcessor()
def chain_updated(head, committed_batches=None,
uncommitted_batches=None):
pass
self.chain_ctrl = ChainController(
block_cache=self.block_tree_manager.block_cache,
state_view_factory=MockStateViewFactory(
self.block_tree_manager.state_db),
block_sender=self.block_sender,
executor=self.executor,
transaction_executor=MockTransactionExecutor(),
chain_head_lock=self._chain_head_lock,
on_chain_updated=chain_updated,
squash_handler=None,
chain_id_manager=self.chain_id_manager,
state_delta_processor=self.state_delta_processor,
identity_signing_key=self.block_tree_manager.identity_signing_key,
data_dir=None,
config_dir=None)
init_root = self.chain_ctrl.chain_head
self.assert_is_chain_head(init_root)
# create a chain of length 5 extending the root
_, head = self.generate_chain(init_root, 5)
self.receive_and_process_blocks(head)
self.assert_is_chain_head(head)
self.init_head = head
def test_simple_case(self):
new_block = self.generate_block(self.init_head)
self.receive_and_process_blocks(new_block)
self.assert_is_chain_head(new_block)
# validate that the deltas for the new block are published
self.assertEqual(new_block, self.state_delta_processor.block)
def test_alternate_genesis(self):
'''Tests a fork extending an alternate genesis block
'''
chain, head = self.generate_chain(None, 5)
for block in chain:
self.receive_and_process_blocks(block)
# make sure initial head is still chain head
self.assert_is_chain_head(self.init_head)
def test_bad_blocks(self):
'''Tests bad blocks extending current chain
'''
# Bad due to consensus
bad_consen = self.generate_block(
previous_block=self.init_head,
invalid_consensus=True)
# chain head should be the same
self.receive_and_process_blocks(bad_consen)
self.assert_is_chain_head(self.init_head)
# Bad due to transaction
bad_batch = self.generate_block(
previous_block=self.init_head,
invalid_batch=True)
# chain head should be the same
self.receive_and_process_blocks(bad_batch)
self.assert_is_chain_head(self.init_head)
# # Ensure good block works
good_block = self.generate_block(
previous_block=self.init_head)
# chain head should be good_block
self.receive_and_process_blocks(good_block)
self.assert_is_chain_head(good_block)
def test_fork_weights(self):
'''Tests extending blocks of different weights
'''
weight_4 = self.generate_block(
previous_block=self.init_head,
weight=4)
weight_7 = self.generate_block(
previous_block=self.init_head,
weight=7)
weight_8 = self.generate_block(
previous_block=self.init_head,
weight=8)
self.receive_and_process_blocks(
weight_7,
weight_4,
weight_8)
self.assert_is_chain_head(weight_8)
def test_fork_lengths(self):
'''Tests competing forks of different lengths
'''
_, head_2 = self.generate_chain(self.init_head, 2)
_, head_7 = self.generate_chain(self.init_head, 7)
_, head_5 = self.generate_chain(self.init_head, 5)
self.receive_and_process_blocks(
head_2,
head_7,
head_5)
self.assert_is_chain_head(head_7)
def test_advancing_chain(self):
'''Tests the chain being advanced between a fork's
creation and validation
'''
_, fork_5 = self.generate_chain(self.init_head, 5)
_, fork_3 = self.generate_chain(self.init_head, 3)
self.receive_and_process_blocks(fork_3)
self.assert_is_chain_head(fork_3)
# fork_5 is longer than fork_3, so it should be accepted
self.receive_and_process_blocks(fork_5)
self.assert_is_chain_head(fork_5)
def test_fork_missing_block(self):
'''Tests a fork with a missing block
'''
# make new chain
new_chain, new_head = self.generate_chain(self.init_head, 5)
self.chain_ctrl.on_block_received(new_head)
# delete a block from the new chain
del self.chain_ctrl._block_cache[new_chain[3].identifier]
self.executor.process_all()
# chain shouldn't advance
self.assert_is_chain_head(self.init_head)
# try again, chain still shouldn't advance
self.receive_and_process_blocks(new_head)
self.assert_is_chain_head(self.init_head)
def test_fork_bad_block(self):
'''Tests a fork with a bad block in the middle
'''
# make two chains extending chain
good_chain, good_head = self.generate_chain(self.init_head, 5)
bad_chain, bad_head = self.generate_chain(self.init_head, 5)
self.chain_ctrl.on_block_received(bad_head)
self.chain_ctrl.on_block_received(good_head)
# invalidate block in the middle of bad_chain
bad_chain[3].status = BlockStatus.Invalid
self.executor.process_all()
# good_chain should be accepted
self.assert_is_chain_head(good_head)
def test_advancing_fork(self):
'''Tests a fork advancing before getting validated
'''
_, fork_head = self.generate_chain(self.init_head, 5)
self.chain_ctrl.on_block_received(fork_head)
# advance fork before it gets accepted
_, ext_head = self.generate_chain(fork_head, 3)
self.executor.process_all()
self.assert_is_chain_head(fork_head)
self.receive_and_process_blocks(ext_head)
self.assert_is_chain_head(ext_head)
def test_block_extends_in_validation(self):
'''Tests a block getting extended while being validated
'''
# create candidate block
candidate = self.block_tree_manager.generate_block(
previous_block=self.init_head)
self.assert_is_chain_head(self.init_head)
# queue up the candidate block, but don't process
self.chain_ctrl.on_block_received(candidate)
# create a new block extending the candidate block
extending_block = self.block_tree_manager.generate_block(
previous_block=candidate)
self.assert_is_chain_head(self.init_head)
# queue and process the extending block,
# which should be the new head
self.receive_and_process_blocks(extending_block)
self.assert_is_chain_head(extending_block)
def test_multiple_extended_forks(self):
'''A more involved example of competing forks
Three forks of varying lengths a_0, b_0, and c_0
are created extending the existing chain, with c_0
being the longest initially. The chains are extended
in the following sequence:
1. Extend all forks by 2. The c fork should remain the head.
2. Extend forks by lenths such that the b fork is the
longest. It should be the new head.
3. Extend all forks by 8. The b fork should remain the head.
4. Create a new fork of the initial chain longer than
any of the other forks. It should be the new head.
'''
# create forks of various lengths
_, a_0 = self.generate_chain(self.init_head, 3)
_, b_0 = self.generate_chain(self.init_head, 5)
_, c_0 = self.generate_chain(self.init_head, 7)
self.receive_and_process_blocks(a_0, b_0, c_0)
self.assert_is_chain_head(c_0)
# extend every fork by 2
_, a_1 = self.generate_chain(a_0, 2)
_, b_1 = self.generate_chain(b_0, 2)
_, c_1 = self.generate_chain(c_0, 2)
self.receive_and_process_blocks(a_1, b_1, c_1)
self.assert_is_chain_head(c_1)
# extend the forks by different lengths
_, a_2 = self.generate_chain(a_1, 1)
_, b_2 = self.generate_chain(b_1, 6)
_, c_2 = self.generate_chain(c_1, 3)
self.receive_and_process_blocks(a_2, b_2, c_2)
self.assert_is_chain_head(b_2)
# extend every fork by 2
_, a_3 = self.generate_chain(a_2, 8)
_, b_3 = self.generate_chain(b_2, 8)
_, c_3 = self.generate_chain(c_2, 8)
self.receive_and_process_blocks(a_3, b_3, c_3)
self.assert_is_chain_head(b_3)
# create a new longest chain
_, wow = self.generate_chain(self.init_head, 30)
self.receive_and_process_blocks(wow)
self.assert_is_chain_head(wow)
# next multi threaded
# next add block publisher
# next batch lists
# integrate with LMDB
# early vs late binding ( class member of consensus BlockPublisher)
# helpers
def assert_is_chain_head(self, block):
chain_head_sig = self.chain_ctrl.chain_head.header_signature
block_sig = block.header_signature
self.assertEqual(
chain_head_sig[:8],
block_sig[:8],
'Not chain head')
def generate_chain(self, root_block, num_blocks,
params={'add_to_cache': True}):
'''Returns (chain, chain_head).
Usually only the head is needed,
but occasionally the chain itself is used.
'''
chain = self.block_tree_manager.generate_chain(
root_block, num_blocks, params)
head = chain[-1]
return chain, head
def generate_block(self, *args, **kwargs):
return self.block_tree_manager.generate_block(
*args, **kwargs)
def receive_and_process_blocks(self, *blocks):
for block in blocks:
self.chain_ctrl.on_block_received(block)
self.executor.process_all()
class TestBlockValidator(unittest.TestCase):
def setUp(self):
self.state_view_factory = MockStateViewFactory()
self.block_tree_manager = BlockTreeManager()
self.root = self.block_tree_manager.chain_head
self.block_validation_handler = self.BlockValidationHandler()
# fork based tests
def test_fork_simple(self):
"""
Test a simple case of a new block extending the current root.
"""
new_block = self.block_tree_manager.generate_block(
previous_block=self.root,
add_to_store=True)
self.validate_block(new_block)
self.assert_valid_block(new_block)
self.assert_new_block_committed()
def test_good_fork_lower(self):
"""
Test case of a new block extending on a valid chain but not as long
as the current chain.
"""
# create a new valid chain 5 long from the current root
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_store': True})
self.block_tree_manager.set_chain_head(head)
# generate candidate chain 3 long from the same root
new_chain, new_head = self.generate_chain_with_head(
self.root, 3, {'add_to_cache': True})
self.validate_block(new_head)
self.assert_valid_block(new_head)
self.assert_new_block_not_committed()
def test_good_fork_higher(self):
"""
Test case of a new block extending on a valid chain but longer
than the current chain. ( similar to test_good_fork_lower but uses
a different code path when finding the common root )
"""
# create a new valid chain 5 long from the current root
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_store': True})
self.block_tree_manager.set_chain_head(head)
# generate candidate chain 8 long from the same root
new_chain, new_head = self.generate_chain_with_head(
head, 8, {'add_to_cache': True})
self.validate_block(new_head)
self.assert_valid_block(new_head)
self.assert_new_block_committed()
def test_fork_different_genesis(self):
""""
Test the case where new block is from a different genesis
"""
# create a new valid chain 5 long from the current root
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_store': True})
self.block_tree_manager.set_chain_head(head)
# generate candidate chain 5 long from its own genesis
new_chain, new_head = self.generate_chain_with_head(
None, 5, {'add_to_cache': True})
self.validate_block(new_head)
self.assert_invalid_block(new_head)
self.assert_new_block_not_committed()
def test_fork_missing_predecessor(self):
""""
Test the case where new block is missing the a predecessor
"""
# generate candidate chain 5 long off the current head.
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_cache': True})
# remove one of the new blocks
del self.block_tree_manager.block_cache[chain[1].identifier]
self.validate_block(head)
self.assert_invalid_block(head)
self.assert_new_block_not_committed()
def test_fork_invalid_predecessor(self):
""""
Test the case where new block has an invalid predecessor
"""
# generate candidate chain 5 long off the current head.
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_cache': True})
# Mark a predecessor as invalid
chain[1].status = BlockStatus.Invalid
self.validate_block(head)
self.assert_invalid_block(head)
self.assert_new_block_not_committed()
def test_block_bad_consensus(self):
"""
Test the case where the new block has a bad batch
"""
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_store': True})
new_block = self.block_tree_manager.generate_block(
previous_block=head,
add_to_cache=True,
invalid_consensus=True)
self.validate_block(new_block)
self.assert_invalid_block(new_block)
self.assert_new_block_not_committed()
def test_block_bad_batch(self):
"""
Test the case where the new block has a bad batch
"""
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_store': True})
new_block = self.block_tree_manager.generate_block(
previous_block=head,
add_to_cache=True,
invalid_batch=True)
self.validate_block(new_block)
self.assert_invalid_block(new_block)
self.assert_new_block_not_committed()
def test_block_missing_batch(self):
"""
Test the case where the new block is missing a batch.
"""
pass
def test_block_extra_batch(self):
"""
Test the case where the new block has an extra batch.
"""
pass
def test_block_batches_order(self):
"""
Test the case where the new block has batches that are
out of order.
"""
pass
def test_block_missing_batch_dependency(self):
"""
Test the case where the new block has a batch that is missing a
dependency.
"""
pass
# assertions
def assert_valid_block(self, block):
self.assertEqual(
block.status, BlockStatus.Valid,
"Block should be valid")
def assert_invalid_block(self, block):
self.assertEqual(
block.status, BlockStatus.Invalid,
"Block should be invalid")
def assert_new_block_committed(self):
self.assert_handler_has_result()
self.assertTrue(
self.block_validation_handler.result["commit_new_block"],
"New block not committed, should be")
def assert_new_block_not_committed(self):
self.assert_handler_has_result()
self.assertFalse(
self.block_validation_handler.result["commit_new_block"],
"New block committed, shouldn't be")
def assert_handler_has_result(self):
msg = "Validation handler doesn't have result"
self.assertTrue(self.block_validation_handler.has_result(), msg)
# block validation
def validate_block(self, block):
validator = self.create_block_validator(
block,
self.block_validation_handler.on_block_validated)
validator.run()
def create_block_validator(self, new_block, on_block_validated):
return BlockValidator(
consensus_module=mock_consensus,
new_block=new_block,
chain_head=self.block_tree_manager.chain_head,
state_view_factory=self.state_view_factory,
block_cache=self.block_tree_manager.block_cache,
done_cb=on_block_validated,
executor=MockTransactionExecutor(),
squash_handler=None,
identity_signing_key=self.block_tree_manager.identity_signing_key,
data_dir=None,
config_dir=None)
class BlockValidationHandler(object):
def __init__(self):
self.result = None
def on_block_validated(self, commit_new_block, result):
result["commit_new_block"] = commit_new_block
self.result = result
def has_result(self):
return self.result is not None
# block tree manager interface
def generate_chain_with_head(self, root_block, num_blocks, params=None):
chain = self.block_tree_manager.generate_chain(
root_block, num_blocks, params)
head = chain[-1]
return chain, head
class TestChainController():
def __init__(self):
self.block_tree_manager = BlockTreeManager()
self.gossip = MockNetwork()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.chain_id_manager = MockChainIdManager()
self._chain_head_lock = RLock()
self.permission_verifier = MockPermissionVerifier()
self.state_view_factory = MockStateViewFactory(
self.block_tree_manager.state_db)
self.transaction_executor = MockTransactionExecutor(
batch_execution_result=None)
self.executor = SynchronousExecutor()
self.block_validator = BlockValidator(
state_view_factory=self.state_view_factory,
block_cache=self.block_tree_manager.block_cache,
transaction_executor=self.transaction_executor,
squash_handler=None,
identity_signer=self.block_tree_manager.identity_signer,
data_dir=None,
config_dir=None,
permission_verifier=self.permission_verifier,
thread_pool=self.executor)
def chain_updated(head,
committed_batches=None,
uncommitted_batches=None):
pass
self.chain_ctrl = ChainController(
block_cache=self.block_tree_manager.block_cache,
block_validator=self.block_validator,
state_view_factory=self.state_view_factory,
chain_head_lock=self._chain_head_lock,
on_chain_updated=chain_updated,
chain_id_manager=self.chain_id_manager,
data_dir=None,
config_dir=None,
chain_observers=[])
init_root = self.chain_ctrl.chain_head
self.assert_is_chain_head(init_root)
# create a chain of length 5 extending the root
_, head = self.generate_chain(init_root, 5)
self.receive_and_process_blocks(head)
self.assert_is_chain_head(head)
self.init_head = head
# next multi threaded
# next add block publisher
# next batch lists
# integrate with LMDB
# early vs late binding ( class member of consensus BlockPublisher)
# helpers
def assert_is_chain_head(self, block):
chain_head_sig = self.chain_ctrl.chain_head.header_signature
block_sig = block.header_signature
# assert chain_head_sig[:8] == block_sig[:8]
def generate_chain(self, root_block, num_blocks, params=None):
'''Returns (chain, chain_head).
Usually only the head is needed,
but occasionally the chain itself is used.
'''
if params is None:
params = {'add_to_cache': True}
chain = self.block_tree_manager.generate_chain(root_block, num_blocks,
params)
head = chain[-1]
return chain, head
def generate_block(self, *args, **kwargs):
return self.block_tree_manager.generate_block(*args, **kwargs)
def receive_and_process_blocks(self, *blocks):
for block in blocks:
self.chain_ctrl.on_block_received(block)
self.executor.process_all()
class TestBlockValidator(unittest.TestCase):
def setUp(self):
self.btm = BlockTreeManager()
def create_block_validator(self, new_block, on_block_validated):
return BlockValidator(consensus=TestModeVerifier(),
new_block=new_block,
chain_head=self.btm.chain_head,
block_cache=self.btm.block_cache,
done_cb=on_block_validated,
executor=MockTransactionExecutor(),
squash_handler=None)
class BlockValidationHandler(object):
def __init__(self):
self.result = None
def on_block_validated(self, commit_new_block, result):
result["commit_new_block"] = commit_new_block
self.result = result
def has_result(self):
return self.result is not None
# fork based tests
def test_fork_simple(self):
"""
Test a simple case of a new block extending the current root.
"""
bvh = self.BlockValidationHandler()
new_block = self.btm.generate_block(previous_block=self.btm.chain_head,
add_to_store=True)
bv = self.create_block_validator(new_block, bvh.on_block_validated)
bv.run()
self.assertTrue(bvh.has_result())
self.assertTrue(new_block.status == BlockStatus.Valid)
self.assertTrue(bvh.result["commit_new_block"])
def test_good_fork_lower(self):
"""
Test case of a new block extending on a valid chain but not as long
as the current chain.
"""
bvh = self.BlockValidationHandler()
root = self.btm.chain_head
# create a new valid chain 5 long from the current root
new_head = self.btm.generate_chain(root, 5, {'add_to_store': True})
self.btm.set_chain_head(new_head[-1])
# generate candidate chain 3 long from the same root
new_block = self.btm.generate_chain(root, 3, {'add_to_cache': True})
bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)
bv.run()
self.assertTrue(bvh.has_result())
self.assertTrue(new_block[-1].status == BlockStatus.Valid)
self.assertFalse(bvh.result["commit_new_block"])
def test_good_fork_higher(self):
"""
Test case of a new block extending on a valid chain but longer
than the current chain. ( similar to test_good_fork_lower but uses
a different code path when finding the common root )
"""
bvh = self.BlockValidationHandler()
root = self.btm.chain_head
# create a new valid chain 5 long from the current root
new_head = self.btm.generate_chain(root, 5, {'add_to_store': True})
self.btm.set_chain_head(new_head[-1])
# generate candidate chain 8 long from the same root
new_block = self.btm.generate_chain(root, 8, {'add_to_cache': True})
bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)
bv.run()
self.assertTrue(bvh.has_result())
self.assertTrue(new_block[-1].status == BlockStatus.Valid)
self.assertTrue(bvh.result["commit_new_block"])
def test_fork_different_genesis(self):
""""
Test the case where new block is from a different genesis
"""
bvh = self.BlockValidationHandler()
# create a new valid chain 5 long from the current root
new_head = self.btm.generate_chain(self.btm.chain_head, 5,
{'add_to_store': True})
self.btm.set_chain_head(new_head[-1])
# generate candidate chain 5 long from it's own genesis
new_block = self.btm.generate_chain(None, 5, {'add_to_cache': True})
bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)
bv.run()
self.assertTrue(bvh.has_result())
self.assertTrue(new_block[-1].status == BlockStatus.Invalid)
self.assertFalse(bvh.result["commit_new_block"])
def test_fork_missing_predecessor(self):
""""
Test the case where new block is missing the a predecessor
"""
bvh = self.BlockValidationHandler()
root = self.btm.chain_head
# generate candidate chain 3 long off the current head.
new_block = self.btm.generate_chain(root, 3, {'add_to_cache': True})
# remove one of the new blocks
del self.btm.block_cache[new_block[1].identifier]
bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)
bv.run()
self.assertTrue(bvh.has_result())
self.assertTrue(new_block[-1].status == BlockStatus.Invalid)
self.assertFalse(bvh.result["commit_new_block"])
def test_fork_invalid_predecessor(self):
""""
Test the case where new block has an invalid predecessor
"""
bvh = self.BlockValidationHandler()
root = self.btm.chain_head
# generate candidate chain 3 long off the current head.
new_block = self.btm.generate_chain(root, 3, {'add_to_cache': True})
# Mark a predecessor as invalid
new_block[1].status = BlockStatus.Invalid
bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)
bv.run()
self.assertTrue(bvh.has_result())
self.assertTrue(new_block[-1].status == BlockStatus.Invalid)
self.assertFalse(bvh.result["commit_new_block"])
# block based tests
def test_block_bad_signature(self):
"""
Test the case where the new block has a bad signature.
"""
pass
def test_block_missing_batch(self):
"""
Test the case where the new block is missing a batch.
"""
pass
def test_block_extra_batch(self):
"""
Test the case where the new block has a batch.
"""
pass
def test_block_batches_order(self):
"""
Test the case where the new block has batches that are
out of order.
"""
pass
def test_block_bad_batch(self):
"""
Test the case where the new block has a bad batch
"""
pass
def test_block_missing_batch_dependency(self):
"""
Test the case where the new block has a batch that is missing a
dependency.
"""
pass
def test_block_bad_state(self):
"""
Test the case where the new block has a bad batch
"""
pass
def test_block_bad_consensus(self):
"""
Test the case where the new block has a bad batch
"""
pass
class TestChainController(unittest.TestCase):
def setUp(self):
self.blocks = BlockTreeManager()
self.gossip = MockNetwork()
self.executor = SynchronousExecutor()
self.txn_executor = MockTransactionExecutor()
def chain_updated(head):
pass
self.chain_ctrl = ChainController(
consensus=TestModeVerifier(),
block_store=self.blocks.block_store,
send_message=self.gossip.send_message,
executor=self.executor,
transaction_executor=MockTransactionExecutor(),
on_chain_updated=chain_updated,
squash_handler=None)
def test_simple_case(self):
# TEST Run the simple case
block_1 = self.blocks.generate_block(self.blocks.chain_head)
self.chain_ctrl.on_block_received(block_1.get_block())
self.executor.process_all()
assert (self.chain_ctrl.chain_head.block.header_signature ==
block_1.header_signature)
def test_alternate_genesis(self):
# TEST Run generate and alternate genesis block
head = self.chain_ctrl.chain_head
other_genesis = self.blocks.generate_block(add_to_store=True)
for b in self.blocks.generate_chain(other_genesis, 5):
self.chain_ctrl.on_block_received(b.get_block())
self.executor.process_all()
assert (self.chain_ctrl.chain_head.block.header_signature ==
head.block.header_signature)
def test_bad_block_signature(self):
# TEST Bad block extending current chain
# Bad due to signature
head = self.blocks.chain_head
block_bad = self.blocks.generate_block(self.blocks.chain_head.block,
invalid_signature=True)
self.chain_ctrl.on_block_received(block_bad.get_block())
assert (self.chain_ctrl.chain_head.block.header_signature ==
head.block.header_signature)
def test_bad_block_consensus(self):
# Bad due to consensus
pass
def test_bad_block_transaction(self):
# Bad due to transaction
pass
def test_missing_block(self):
# TEST Missing block G->missing->B
head = self.blocks.chain_head
new_blocks = self.blocks.generate_chain(head, 2)
self.chain_ctrl.on_block_received(new_blocks[1].get_block())
self.executor.process_all()
assert (len(self.gossip.messages) == 1)
block_id = self.gossip.messages[0]
assert (block_id == new_blocks[0].header_signature)
self.gossip.clear()
self.chain_ctrl.on_block_received(new_blocks[0].get_block())
self.executor.process_all()
assert (self.chain_ctrl.chain_head.block.header_signature ==
new_blocks[1].header_signature)
def test_missing_block_invalid_head(self):
# TEST Missing block G->missing->B
# B is invalid but Missing is valid
head = self.blocks.chain_head
new_blocks_def = self.blocks.generate_chain_definition(2)
new_blocks_def[1]["invalid_signature"] = True
new_blocks = self.blocks.generate_chain(head, new_blocks_def)
self.chain_ctrl.on_block_received(new_blocks[1].get_block())
self.executor.process_all()
assert (len(self.gossip.messages) == 1)
block_id = self.gossip.messages[0]
assert (block_id == new_blocks[0].header_signature)
self.gossip.clear()
self.chain_ctrl.on_block_received(new_blocks[0].get_block())
self.executor.process_all()
pp.pprint(new_blocks)
pp.pprint(self.blocks.block_store)
class TestChainController(unittest.TestCase):
def setUp(self):
self.block_tree_manager = BlockTreeManager()
self.gossip = MockNetwork()
self.executor = SynchronousExecutor()
self.txn_executor = MockTransactionExecutor()
self.block_sender = MockBlockSender()
self.chain_id_manager = MockChainIdManager()
self._chain_head_lock = RLock()
self.state_delta_processor = MockStateDeltaProcessor()
def chain_updated(head, committed_batches=None,
uncommitted_batches=None):
pass
self.chain_ctrl = ChainController(
block_cache=self.block_tree_manager.block_cache,
state_view_factory=MockStateViewFactory(
self.block_tree_manager.state_db),
block_sender=self.block_sender,
executor=self.executor,
transaction_executor=MockTransactionExecutor(
batch_execution_result=None),
chain_head_lock=self._chain_head_lock,
on_chain_updated=chain_updated,
squash_handler=None,
chain_id_manager=self.chain_id_manager,
state_delta_processor=self.state_delta_processor,
identity_signing_key=self.block_tree_manager.identity_signing_key,
data_dir=None,
config_dir=None)
init_root = self.chain_ctrl.chain_head
self.assert_is_chain_head(init_root)
# create a chain of length 5 extending the root
_, head = self.generate_chain(init_root, 5)
self.receive_and_process_blocks(head)
self.assert_is_chain_head(head)
self.init_head = head
def test_simple_case(self):
new_block = self.generate_block(self.init_head)
self.receive_and_process_blocks(new_block)
self.assert_is_chain_head(new_block)
# validate that the deltas for the new block are published
self.assertEqual(new_block, self.state_delta_processor.block)
def test_alternate_genesis(self):
'''Tests a fork extending an alternate genesis block
'''
chain, head = self.generate_chain(None, 5)
for block in chain:
self.receive_and_process_blocks(block)
# make sure initial head is still chain head
self.assert_is_chain_head(self.init_head)
def test_bad_blocks(self):
'''Tests bad blocks extending current chain
'''
# Bad due to consensus
bad_consen = self.generate_block(
previous_block=self.init_head,
invalid_consensus=True)
# chain head should be the same
self.receive_and_process_blocks(bad_consen)
self.assert_is_chain_head(self.init_head)
# Bad due to transaction
bad_batch = self.generate_block(
previous_block=self.init_head,
invalid_batch=True)
# chain head should be the same
self.receive_and_process_blocks(bad_batch)
self.assert_is_chain_head(self.init_head)
# # Ensure good block works
good_block = self.generate_block(
previous_block=self.init_head)
# chain head should be good_block
self.receive_and_process_blocks(good_block)
self.assert_is_chain_head(good_block)
def test_fork_weights(self):
'''Tests extending blocks of different weights
'''
weight_4 = self.generate_block(
previous_block=self.init_head,
weight=4)
weight_7 = self.generate_block(
previous_block=self.init_head,
weight=7)
weight_8 = self.generate_block(
previous_block=self.init_head,
weight=8)
self.receive_and_process_blocks(
weight_7,
weight_4,
weight_8)
self.assert_is_chain_head(weight_8)
def test_fork_lengths(self):
'''Tests competing forks of different lengths
'''
_, head_2 = self.generate_chain(self.init_head, 2)
_, head_7 = self.generate_chain(self.init_head, 7)
_, head_5 = self.generate_chain(self.init_head, 5)
self.receive_and_process_blocks(
head_2,
head_7,
head_5)
self.assert_is_chain_head(head_7)
def test_advancing_chain(self):
'''Tests the chain being advanced between a fork's
creation and validation
'''
_, fork_5 = self.generate_chain(self.init_head, 5)
_, fork_3 = self.generate_chain(self.init_head, 3)
self.receive_and_process_blocks(fork_3)
self.assert_is_chain_head(fork_3)
# fork_5 is longer than fork_3, so it should be accepted
self.receive_and_process_blocks(fork_5)
self.assert_is_chain_head(fork_5)
def test_fork_missing_block(self):
'''Tests a fork with a missing block
'''
# make new chain
new_chain, new_head = self.generate_chain(self.init_head, 5)
self.chain_ctrl.on_block_received(new_head)
# delete a block from the new chain
del self.chain_ctrl._block_cache[new_chain[3].identifier]
self.executor.process_all()
# chain shouldn't advance
self.assert_is_chain_head(self.init_head)
# try again, chain still shouldn't advance
self.receive_and_process_blocks(new_head)
self.assert_is_chain_head(self.init_head)
def test_fork_bad_block(self):
'''Tests a fork with a bad block in the middle
'''
# make two chains extending chain
good_chain, good_head = self.generate_chain(self.init_head, 5)
bad_chain, bad_head = self.generate_chain(self.init_head, 5)
self.chain_ctrl.on_block_received(bad_head)
self.chain_ctrl.on_block_received(good_head)
# invalidate block in the middle of bad_chain
bad_chain[3].status = BlockStatus.Invalid
self.executor.process_all()
# good_chain should be accepted
self.assert_is_chain_head(good_head)
def test_advancing_fork(self):
'''Tests a fork advancing before getting validated
'''
_, fork_head = self.generate_chain(self.init_head, 5)
self.chain_ctrl.on_block_received(fork_head)
# advance fork before it gets accepted
_, ext_head = self.generate_chain(fork_head, 3)
self.executor.process_all()
self.assert_is_chain_head(fork_head)
self.receive_and_process_blocks(ext_head)
self.assert_is_chain_head(ext_head)
def test_block_extends_in_validation(self):
'''Tests a block getting extended while being validated
'''
# create candidate block
candidate = self.block_tree_manager.generate_block(
previous_block=self.init_head)
self.assert_is_chain_head(self.init_head)
# queue up the candidate block, but don't process
self.chain_ctrl.on_block_received(candidate)
# create a new block extending the candidate block
extending_block = self.block_tree_manager.generate_block(
previous_block=candidate)
self.assert_is_chain_head(self.init_head)
# queue and process the extending block,
# which should be the new head
self.receive_and_process_blocks(extending_block)
self.assert_is_chain_head(extending_block)
def test_multiple_extended_forks(self):
'''A more involved example of competing forks
Three forks of varying lengths a_0, b_0, and c_0
are created extending the existing chain, with c_0
being the longest initially. The chains are extended
in the following sequence:
1. Extend all forks by 2. The c fork should remain the head.
2. Extend forks by lenths such that the b fork is the
longest. It should be the new head.
3. Extend all forks by 8. The b fork should remain the head.
4. Create a new fork of the initial chain longer than
any of the other forks. It should be the new head.
'''
# create forks of various lengths
_, a_0 = self.generate_chain(self.init_head, 3)
_, b_0 = self.generate_chain(self.init_head, 5)
_, c_0 = self.generate_chain(self.init_head, 7)
self.receive_and_process_blocks(a_0, b_0, c_0)
self.assert_is_chain_head(c_0)
# extend every fork by 2
_, a_1 = self.generate_chain(a_0, 2)
_, b_1 = self.generate_chain(b_0, 2)
_, c_1 = self.generate_chain(c_0, 2)
self.receive_and_process_blocks(a_1, b_1, c_1)
self.assert_is_chain_head(c_1)
# extend the forks by different lengths
_, a_2 = self.generate_chain(a_1, 1)
_, b_2 = self.generate_chain(b_1, 6)
_, c_2 = self.generate_chain(c_1, 3)
self.receive_and_process_blocks(a_2, b_2, c_2)
self.assert_is_chain_head(b_2)
# extend every fork by 2
_, a_3 = self.generate_chain(a_2, 8)
_, b_3 = self.generate_chain(b_2, 8)
_, c_3 = self.generate_chain(c_2, 8)
self.receive_and_process_blocks(a_3, b_3, c_3)
self.assert_is_chain_head(b_3)
# create a new longest chain
_, wow = self.generate_chain(self.init_head, 30)
self.receive_and_process_blocks(wow)
self.assert_is_chain_head(wow)
# next multi threaded
# next add block publisher
# next batch lists
# integrate with LMDB
# early vs late binding ( class member of consensus BlockPublisher)
# helpers
def assert_is_chain_head(self, block):
chain_head_sig = self.chain_ctrl.chain_head.header_signature
block_sig = block.header_signature
self.assertEqual(
chain_head_sig[:8],
block_sig[:8],
'Not chain head')
def generate_chain(self, root_block, num_blocks,
params={'add_to_cache': True}):
'''Returns (chain, chain_head).
Usually only the head is needed,
but occasionally the chain itself is used.
'''
chain = self.block_tree_manager.generate_chain(
root_block, num_blocks, params)
head = chain[-1]
return chain, head
def generate_block(self, *args, **kwargs):
return self.block_tree_manager.generate_block(
*args, **kwargs)
def receive_and_process_blocks(self, *blocks):
for block in blocks:
self.chain_ctrl.on_block_received(block)
self.executor.process_all()
class TestBlockValidator(unittest.TestCase):
def setUp(self):
self.state_view_factory = MockStateViewFactory()
self.block_tree_manager = BlockTreeManager()
self.root = self.block_tree_manager.chain_head
self.block_validation_handler = self.BlockValidationHandler()
# fork based tests
def test_fork_simple(self):
"""
Test a simple case of a new block extending the current root.
"""
new_block = self.block_tree_manager.generate_block(
previous_block=self.root)
self.validate_block(new_block)
self.assert_valid_block(new_block)
self.assert_new_block_committed()
def test_good_fork_lower(self):
"""
Test case of a new block extending on a valid chain but not as long
as the current chain.
"""
# create a new valid chain 5 long from the current root
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_store': True})
self.block_tree_manager.set_chain_head(head)
# generate candidate chain 3 long from the same root
new_chain, new_head = self.generate_chain_with_head(
self.root, 3, {'add_to_cache': True})
self.validate_block(new_head)
self.assert_valid_block(new_head)
self.assert_new_block_not_committed()
def test_good_fork_higher(self):
"""
Test case of a new block extending on a valid chain but longer
than the current chain. ( similar to test_good_fork_lower but uses
a different code path when finding the common root )
"""
# create a new valid chain 5 long from the current root
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_store': True})
self.block_tree_manager.set_chain_head(head)
# generate candidate chain 8 long from the same root
new_chain, new_head = self.generate_chain_with_head(
head, 8, {'add_to_cache': True})
self.validate_block(new_head)
self.assert_valid_block(new_head)
self.assert_new_block_committed()
def test_fork_different_genesis(self):
""""
Test the case where new block is from a different genesis
"""
# create a new valid chain 5 long from the current root
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_store': True})
self.block_tree_manager.set_chain_head(head)
# generate candidate chain 5 long from its own genesis
new_chain, new_head = self.generate_chain_with_head(
None, 5, {'add_to_cache': True})
self.validate_block(new_head)
self.assert_invalid_block(new_head)
self.assert_new_block_not_committed()
def test_fork_missing_predecessor(self):
""""
Test the case where new block is missing the a predecessor
"""
# generate candidate chain 5 long off the current head.
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_cache': True})
# remove one of the new blocks
del self.block_tree_manager.block_cache[chain[1].identifier]
self.validate_block(head)
self.assert_invalid_block(head)
self.assert_new_block_not_committed()
def test_fork_invalid_predecessor(self):
""""
Test the case where new block has an invalid predecessor
"""
# generate candidate chain 5 long off the current head.
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_cache': True})
# Mark a predecessor as invalid
chain[1].status = BlockStatus.Invalid
self.validate_block(head)
self.assert_invalid_block(head)
self.assert_new_block_not_committed()
def test_block_bad_consensus(self):
"""
Test the case where the new block has a bad batch
"""
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_store': True})
new_block = self.block_tree_manager.generate_block(
previous_block=head,
add_to_cache=True,
invalid_consensus=True)
self.validate_block(new_block)
self.assert_invalid_block(new_block)
self.assert_new_block_not_committed()
def test_block_bad_batch(self):
"""
Test the case where the new block has a bad batch
"""
chain, head = self.generate_chain_with_head(
self.root, 5, {'add_to_store': True})
new_block = self.block_tree_manager.generate_block(
previous_block=head,
add_to_cache=True,
invalid_batch=True)
self.validate_block(new_block)
self.assert_invalid_block(new_block)
self.assert_new_block_not_committed()
def test_block_missing_batch_dependency(self):
"""
Test the case where the new block has a batch that is missing a
dependency.
"""
pass
# assertions
def assert_valid_block(self, block):
self.assertEqual(
block.status, BlockStatus.Valid,
"Block should be valid")
def assert_invalid_block(self, block):
self.assertEqual(
block.status, BlockStatus.Invalid,
"Block should be invalid")
def assert_new_block_committed(self):
self.assert_handler_has_result()
self.assertTrue(
self.block_validation_handler.result["commit_new_block"],
"New block not committed, should be")
def assert_new_block_not_committed(self):
self.assert_handler_has_result()
self.assertFalse(
self.block_validation_handler.result["commit_new_block"],
"New block committed, shouldn't be")
def assert_handler_has_result(self):
msg = "Validation handler doesn't have result"
self.assertTrue(self.block_validation_handler.has_result(), msg)
# block validation
def validate_block(self, block):
validator = self.create_block_validator(
block,
self.block_validation_handler.on_block_validated)
validator.run()
def create_block_validator(self, new_block, on_block_validated):
return BlockValidator(
consensus_module=mock_consensus,
new_block=new_block,
chain_head=self.block_tree_manager.chain_head,
state_view_factory=self.state_view_factory,
block_cache=self.block_tree_manager.block_cache,
done_cb=on_block_validated,
executor=MockTransactionExecutor(batch_execution_result=None),
squash_handler=None,
identity_signing_key=self.block_tree_manager.identity_signing_key,
data_dir=None,
config_dir=None)
class BlockValidationHandler(object):
def __init__(self):
self.result = None
def on_block_validated(self, commit_new_block, result):
result["commit_new_block"] = commit_new_block
self.result = result
def has_result(self):
return self.result is not None
# block tree manager interface
def generate_chain_with_head(self, root_block, num_blocks, params=None):
chain = self.block_tree_manager.generate_chain(
root_block, num_blocks, params)
head = chain[-1]
return chain, head