def test_broadcast_events(self):
"""Test that broadcast_events works with a single subscriber to the
block_commit event type and that the subscriber does not receive events
until it is enabled.
"""
mock_service = Mock()
event_broadcaster = EventBroadcaster(mock_service)
block = create_block()
event_broadcaster.chain_update(block, [])
mock_service.send.assert_not_called()
event_broadcaster.add_subscriber("test_conn_id",
[create_block_commit_subscription()],
[])
event_broadcaster.chain_update(block, [])
mock_service.send.assert_not_called()
event_broadcaster.enable_subscriber("test_conn_id")
event_broadcaster.chain_update(block, [])
event_list = events_pb2.EventList(
events=BlockEventExtractor(block).extract(
[create_block_commit_subscription()])).SerializeToString()
mock_service.send.assert_called_with(
validator_pb2.Message.CLIENT_EVENTS,
event_list,
connection_id="test_conn_id")
def test_catchup_subscriber(self):
"""Test that catch subscriber handles the case of:
- no blocks (i.e. the genesis block has not been produced or received
- a block that has some receipts exists and sends results
"""
mock_service = Mock()
mock_block_store = MagicMock()
mock_block_store.chain_head = None
mock_block_store.get_predecessor_iter.return_value = []
mock_receipt_store = Mock()
event_broadcaster = EventBroadcaster(mock_service,
mock_block_store,
mock_receipt_store)
event_broadcaster.add_subscriber(
"test_conn_id", [create_block_commit_subscription()], [])
event_broadcaster.catchup_subscriber("test_conn_id")
mock_service.send.assert_not_called()
block = create_block()
mock_block_store.chain_head = block
mock_block_store.get_predecessor_iter.return_value = [block]
mock_block_store.__getitem__.return_value = block
event_broadcaster.catchup_subscriber("test_conn_id")
event_list = events_pb2.EventList(
events=BlockEventExtractor(block).extract(
[create_block_commit_subscription()])).SerializeToString()
mock_service.send.assert_called_with(
validator_pb2.Message.CLIENT_EVENTS,
event_list, connection_id="test_conn_id", one_way=True)
def test_get_events(self):
"""Tests that block commit events are properly received on block
boundaries."""
self._subscribe()
self.batch_submitter.submit_next_batch()
msg = self.stream.receive().result()
self._unsubscribe()
event_list = events_pb2.EventList()
event_list.ParseFromString(msg.content)
events = event_list.events
block_commit_event = events[0]
block_id = list(filter(
lambda attr: attr.key == "block_id",
block_commit_event.attributes))[0].value
block_num = list(filter(
lambda attr: attr.key == "block_num",
block_commit_event.attributes))[0].value
response = self._get_events(
block_id,
[events_pb2.EventSubscription(event_type="sawtooth/block-commit")])
events = self.assert_events_get_response(response)
self.assert_block_commit_event(events[0], block_num)
def test_catchup(self):
"""Tests that a subscriber correctly receives catchup events."""
self._subscribe()
blocks = []
for i in range(4):
self.batch_submitter.submit_next_batch()
msg = self.stream.receive().result()
event_list = events_pb2.EventList()
event_list.ParseFromString(msg.content)
events = event_list.events
block_commit_event = events[0]
block_id = list(filter(
lambda attr: attr.key == "block_id",
block_commit_event.attributes))[0].value
block_num = list(filter(
lambda attr: attr.key == "block_num",
block_commit_event.attributes))[0].value
blocks.append((block_num, block_id))
self._unsubscribe()
self.assert_subscribe_response(
self._subscribe(last_known_block_ids=[blocks[0][1]]))
LOGGER.warning("Waiting for catchup events")
for i in range(3):
msg = self.stream.receive().result()
LOGGER.warning("Got catchup events: ")
event_list = events_pb2.EventList()
event_list.ParseFromString(msg.content)
events = event_list.events
self.assertEqual(len(events), 2)
block_commit_event = events[0]
block_id = list(filter(
lambda attr: attr.key == "block_id",
block_commit_event.attributes))[0].value
block_num = list(filter(
lambda attr: attr.key == "block_num",
block_commit_event.attributes))[0].value
self.assertEqual((block_num, block_id), blocks[i + 1])
self._unsubscribe()
def test_block_commit_event_received(self):
"""Tests that block commit events are properly received on block
boundaries."""
self._subscribe()
for i in range(1, 5):
self.batch_submitter.submit_next_batch()
msg = self.stream.receive().result()
self.assertEqual(msg.message_type,
validator_pb2.Message.CLIENT_EVENTS)
event_list = events_pb2.EventList()
event_list.ParseFromString(msg.content)
events = event_list.events
self.assertEqual(len(events), 1)
self.assert_block_commit_event(events[0], i)
def test_subscribe_and_unsubscribe_with_catch_up(self):
"""Tests that a client can subscribe and unsubscribe from events."""
response = self._subscribe(
last_known_block_ids=[NULL_BLOCK_IDENTIFIER])
self.assert_subscribe_response(response)
# Ensure that it receives the genesis block
msg = self.stream.receive().result()
self.assertEqual(
msg.message_type,
validator_pb2.Message.CLIENT_EVENTS)
event_list = events_pb2.EventList()
event_list.ParseFromString(msg.content)
events = event_list.events
self.assertEqual(len(events), 2)
self.assert_block_commit_event(events[0], 0)
self.assert_state_event(events[1], '000000')
response = self._unsubscribe()
self.assert_unsubscribe_response(response)
