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_add_subscriber(self):
"""Test adding a subscriber, who has no known blocks.
This scenerio is valid for subscribers who have never connected and
would need to receive all deltas since the genesis block.
On registration, the subscriber should receive one event, comprised
of the state changes for the genesis block.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
delta_store = StateDeltaStore(DictDatabase())
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=delta_store,
block_store=block_tree_manager.block_store)
delta_store.save_state_deltas(
block_tree_manager.chain_head.state_root_hash,
[StateChange(address='deadbeef0000000',
value='my_genesis_value'.encode(),
type=StateChange.SET),
StateChange(address='a14ea01',
value='some other state value'.encode(),
type=StateChange.SET)])
delta_processor.add_subscriber(
'test_conn_id',
[],
['deadbeef'])
self.assertEqual(['test_conn_id'], delta_processor.subscriber_ids)
# test that it catches up, and receives the events from the chain head.
# In this case, it should just be once, as the chain head is the
# genesis block
chain_head = block_tree_manager.chain_head
mock_service.send.assert_called_with(
validator_pb2.Message.STATE_DELTA_EVENT,
StateDeltaEvent(
block_id=chain_head.identifier,
block_num=chain_head.block_num,
state_root_hash=chain_head.state_root_hash,
previous_block_id=chain_head.previous_block_id,
state_changes=[StateChange(address='deadbeef0000000',
value='my_genesis_value'.encode(),
type=StateChange.SET)]
).SerializeToString(),
connection_id='test_conn_id')
def test_add_subscriber_unknown_block_id(self):
"""Test adding a subscriber, whose known block id is not in the
current chain.
"""
block_tree_manager = BlockTreeManager()
delta_processor = StateDeltaProcessor(
service=Mock(),
state_delta_store=Mock(),
block_store=block_tree_manager.block_store)
with self.assertRaises(NoKnownBlockError):
delta_processor.add_subscriber('test_conn_id', ['deadbeefb10c4'],
['deadbeef'])
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_add_subscriber(self):
"""Test adding a subscriber, who has no known blocks.
This scenerio is valid for subscribers who have never connected and
would need to receive all deltas since the genesis block.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=Mock(),
block_store=block_tree_manager.block_store)
delta_processor.add_subscriber('test_conn_id', [], ['deadbeef'])
self.assertEqual(['test_conn_id'], delta_processor.subscriber_ids)
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')
def test_add_subscriber_known_block_id(self):
"""Test adding a subscriber, whose known block id is the current
chainhead.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=Mock(),
block_store=block_tree_manager.block_store)
delta_processor.add_subscriber(
'test_conn_id', [block_tree_manager.chain_head.identifier],
['deadbeef'])
self.assertEqual(['test_conn_id'], delta_processor.subscriber_ids)
self.assertTrue(not mock_service.send.called)
def test_remove_subscriber(self):
"""Test adding a subscriber, whose known block id is the current
chainhead, followed by removing the subscriber.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=Mock(),
block_store=block_tree_manager.block_store)
delta_processor.add_subscriber(
'test_conn_id', [block_tree_manager.chain_head.identifier],
['deadbeef'
'beefdead'])
self.assertEqual(['test_conn_id'], delta_processor.subscriber_ids)
delta_processor.remove_subscriber('test_conn_id')
self.assertEqual([], delta_processor.subscriber_ids)
