def test_internal_bus_sequentially_routes_multiple_messages_of_different_types(
):
all_messages = [
create_some_message() if random() < 0.5 else create_other_message()
for _ in range(100)
]
some_handler1 = Mock()
some_handler2 = Mock()
other_handler = Mock()
bus = InternalBus()
bus.subscribe(SomeMessage, some_handler1)
bus.subscribe(SomeMessage, some_handler2)
bus.subscribe(OtherMessage, other_handler)
for message in all_messages:
bus.send(message)
assert some_handler1.mock_calls == [
call(msg) for msg in all_messages if isinstance(msg, SomeMessage)
]
assert some_handler2.mock_calls == [
call(msg) for msg in all_messages if isinstance(msg, SomeMessage)
]
assert other_handler.mock_calls == [
call(msg) for msg in all_messages if isinstance(msg, OtherMessage)
]
def internal_bus():
def rp_handler(ib, msg):
ib.msgs.setdefault(type(msg), []).append(msg)
ib = InternalBus()
ib.msgs = {}
ib.subscribe(RequestPropagates, rp_handler)
return ib
def test_internal_bus_doesnt_route_unregistered_message():
handler = Mock()
bus = InternalBus()
bus.subscribe(SomeMessage, handler)
bus.send(create_other_message())
handler.assert_not_called()
def __init__(self,
name: str,
validators: List[str],
primary_name: str,
timer: TimerService,
bus: InternalBus,
network: ExternalBus,
write_manager: WriteRequestManager,
bls_bft_replica: BlsBftReplica = None):
# ToDo: Maybe ConsensusSharedData should be initiated before and passed already prepared?
self._internal_bus = bus
self._data = ConsensusSharedData(name, validators, 0)
self._data.primary_name = generateName(primary_name,
self._data.inst_id)
self.config = getConfig()
self.stasher = StashingRouter(self.config.REPLICA_STASH_LIMIT,
buses=[bus, network])
self._write_manager = write_manager
self._primaries_selector = RoundRobinNodeRegPrimariesSelector(
self._write_manager.node_reg_handler)
self._orderer = OrderingService(
data=self._data,
timer=timer,
bus=bus,
network=network,
write_manager=self._write_manager,
bls_bft_replica=bls_bft_replica,
freshness_checker=FreshnessChecker(
freshness_timeout=self.config.STATE_FRESHNESS_UPDATE_INTERVAL),
primaries_selector=self._primaries_selector,
stasher=self.stasher)
self._checkpointer = CheckpointService(self._data, bus, network,
self.stasher,
write_manager.database_manager)
self._view_changer = ViewChangeService(self._data, timer, bus, network,
self.stasher,
self._primaries_selector)
self._message_requestor = MessageReqService(self._data, bus, network)
self._add_ledgers()
# TODO: This is just for testing purposes only
self._data.checkpoints.append(
Checkpoint(instId=0,
viewNo=0,
seqNoStart=0,
seqNoEnd=0,
digest='4F7BsTMVPKFshM1MwLf6y23cid6fL3xMpazVoF9krzUw'))
# ToDo: it should be done in Zero-view stage.
write_manager.on_catchup_finished()
self._data.primaries = self._view_changer._primaries_selector.select_primaries(
self._data.view_no)
# ToDo: ugly way to understand node_reg changing
self._previous_node_reg = self._write_manager.node_reg_handler.committed_node_reg
bus.subscribe(Ordered, self.emulate_ordered_processing)
def test_event_bus_routes_no_params_message():
message = NoParamsMessage()
handler = Mock()
bus = InternalBus()
bus.subscribe(NoParamsMessage, handler)
bus.send(message)
handler.assert_called_once_with(message)
def test_event_bus_routes_registered_message():
message = create_some_message()
handler = Mock()
bus = InternalBus()
bus.subscribe(SomeMessage, handler)
bus.send(message)
handler.assert_called_once_with(message)
def test_internal_bus_can_route_messages_with_side_arguments():
message = create_some_message()
handler = Mock()
bus = InternalBus()
bus.subscribe(SomeMessage, handler)
bus.send(message, 'some_arg', 'other_arg')
handler.assert_called_once_with(message, 'some_arg', 'other_arg')
def test_internal_bus_routes_messages_to_all_subscribers():
message = create_some_message()
handler1 = Mock()
handler2 = Mock()
bus = InternalBus()
bus.subscribe(SomeMessage, handler1)
bus.subscribe(SomeMessage, handler2)
bus.send(message)
handler1.assert_called_once_with(message)
handler2.assert_called_once_with(message)
def test_event_bus_understands_different_no_params_messages():
a = NoParamsMessage()
b = OtherNoParamsMessage()
handler_a = Mock()
handler_b = Mock()
bus = InternalBus()
bus.subscribe(NoParamsMessage, handler_a)
bus.subscribe(OtherNoParamsMessage, handler_b)
bus.send(b)
handler_a.assert_not_called()
handler_b.assert_called_once_with(b)
bus.send(a)
handler_a.assert_called_once_with(a)
handler_b.assert_called_once_with(b)