def __init__(self, name: str, timer: TimerService, network: ExternalBus):
self.name = name
self.timer = timer
self.network = network
self.receive_timestamps = []
self.received = []
network.subscribe(SomeMessage, self.process_some_message)
def test_external_bus_forwards_received_messages_to_subscribers():
message = create_some_message()
handler = Mock()
bus = ExternalBus(Mock())
bus.subscribe(SomeMessage, handler)
bus.process_incoming(message, 'other_node')
handler.assert_called_once_with(message, 'other_node')
def __init__(self, data: ConsensusDataProvider, network: ExternalBus):
self._data = data
self._network = network
network.subscribe(ViewChange, self.process_view_change_message)
network.subscribe(ViewChangeAck, self.process_view_change_ack_message)
network.subscribe(NewView, self.process_new_view_message)
def __init__(self, data: ConsensusDataProvider, timer: TimerService,
bus: InternalBus, network: ExternalBus):
self._data = data
self._timer = timer
self._bus = bus
self._network = network
network.subscribe(ViewChange, self.process_view_change_message)
network.subscribe(ViewChangeAck, self.process_view_change_ack_message)
network.subscribe(NewView, self.process_new_view_message)
def test_external_bus_notifies_about_connection_changes():
connected = Mock()
disconnected = Mock()
bus = ExternalBus(Mock())
bus.subscribe(bus.Connected, connected)
bus.subscribe(bus.Disconnected, disconnected)
# Initial state
assert bus.connecteds == set()
connected.assert_not_called()
disconnected.assert_not_called()
# Add connections
bus.update_connecteds({'a', 'b'})
assert bus.connecteds == {'a', 'b'}
connected.assert_has_calls(
[call(bus.Connected(), 'a'),
call(bus.Connected(), 'b')],
any_order=True)
disconnected.assert_not_called()
connected.reset_mock()
# Add more connections
bus.update_connecteds({'a', 'b', 'c'})
assert bus.connecteds == {'a', 'b', 'c'}
connected.assert_called_once_with(bus.Connected(), 'c')
disconnected.assert_not_called()
connected.reset_mock()
# Change connections
bus.update_connecteds({'b', 'd', 'e'})
assert bus.connecteds == {'b', 'd', 'e'}
connected.assert_has_calls(
[call(bus.Connected(), 'd'),
call(bus.Connected(), 'e')],
any_order=True)
disconnected.assert_has_calls(
[call(bus.Disconnected(), 'a'),
call(bus.Disconnected(), 'c')],
any_order=True)
connected.reset_mock()
disconnected.reset_mock()
# Disconnect everything and reconnect to a
bus.update_connecteds({'a'})
assert bus.connecteds == {'a'}
connected.assert_called_once_with(bus.Connected(), 'a')
disconnected.assert_has_calls([
call(bus.Disconnected(), 'b'),
call(bus.Disconnected(), 'd'),
call(bus.Disconnected(), 'e')
],
any_order=True)
connected.reset_mock()
disconnected.reset_mock()
# Disconnect
bus.update_connecteds(set())
assert bus.connecteds == set()
connected.assert_not_called()
disconnected.assert_called_once_with(bus.Disconnected(), 'a')
disconnected.reset_mock()
# Disconnect again
bus.update_connecteds(set())
assert bus.connecteds == set()
connected.assert_not_called()
disconnected.assert_not_called()
def __init__(self, name: str, network: ExternalBus):
self.name = name
self.network = network
self.received = []
network.subscribe(SomeMessage, self.process_some_message)
