def test_get_from_multiplexer_when_empty(): """Test that getting an envelope from the multiplexer when the input queue is empty raises an exception.""" connection = _make_dummy_connection() multiplexer = Multiplexer([connection]) with pytest.raises(aea.mail.base.Empty): multiplexer.get()
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] cls.multiplexers = [] temp_node_dir = os.path.join(cls.t, "node_dir") os.mkdir(temp_node_dir) try: cls.connection_node = _make_libp2p_connection( data_dir=temp_node_dir, delegate=True ) cls.multiplexer_node = Multiplexer([cls.connection_node]) cls.log_files.append(cls.connection_node.node.log_file) cls.multiplexer_node.connect() cls.multiplexers.append(cls.multiplexer_node) temp_client_dir = os.path.join(cls.t, "client_dir") os.mkdir(temp_client_dir) cls.connection_client = _make_libp2p_client_connection( data_dir=temp_client_dir, peer_public_key=cls.connection_node.node.pub ) cls.multiplexer_client = Multiplexer([cls.connection_client]) cls.multiplexer_client.connect() cls.multiplexers.append(cls.multiplexer_client) except Exception: cls.teardown_class() raise
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] port_genesis = DEFAULT_PORT + 10 cls.connection_genesis = _make_libp2p_connection(port_genesis) cls.multiplexer_genesis = Multiplexer([cls.connection_genesis]) cls.log_files.append(cls.connection_genesis.node.log_file) cls.multiplexer_genesis.connect() genesis_peer = cls.connection_genesis.node.multiaddrs[0] cls.connections = [cls.connection_genesis] cls.multiplexers = [cls.multiplexer_genesis] port = port_genesis for _ in range(DEFAULT_NET_SIZE): port += 1 conn = _make_libp2p_connection(port=port, entry_peers=[genesis_peer]) muxer = Multiplexer([conn]) cls.connections.append(conn) cls.multiplexers.append(muxer) cls.log_files.append(conn.node.log_file) muxer.connect()
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] cls.multiplexers = [] try: cls.connection1 = _make_libp2p_connection(DEFAULT_PORT + 1) cls.multiplexer1 = Multiplexer([cls.connection1]) cls.log_files.append(cls.connection1.node.log_file) cls.multiplexer1.connect() cls.multiplexers.append(cls.multiplexer1) genesis_peer = cls.connection1.node.multiaddrs[0] cls.connection2 = _make_libp2p_connection( port=DEFAULT_PORT + 2, entry_peers=[genesis_peer]) cls.multiplexer2 = Multiplexer([cls.connection2]) cls.log_files.append(cls.connection2.node.log_file) cls.multiplexer2.connect() cls.multiplexers.append(cls.multiplexer2) except Exception as e: cls.teardown_class() raise e
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] cls.relay = _make_libp2p_connection(DEFAULT_PORT + 1) cls.multiplexer = Multiplexer([cls.relay]) cls.log_files.append(cls.relay.node.log_file) cls.multiplexer.connect() relay_peer = cls.relay.node.multiaddrs[0] cls.connection1 = _make_libp2p_connection(DEFAULT_PORT + 2, relay=False, entry_peers=[relay_peer]) cls.multiplexer1 = Multiplexer([cls.connection1]) cls.log_files.append(cls.connection1.node.log_file) cls.multiplexer1.connect() cls.connection2 = _make_libp2p_connection(port=DEFAULT_PORT + 3, entry_peers=[relay_peer]) cls.multiplexer2 = Multiplexer([cls.connection2]) cls.log_files.append(cls.connection2.node.log_file) cls.multiplexer2.connect()
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] cls.multiplexers = [] try: port_relay_1 = DEFAULT_PORT + 10 cls.connection_relay_1 = _make_libp2p_connection(port_relay_1) cls.multiplexer_relay_1 = Multiplexer([cls.connection_relay_1]) cls.log_files.append(cls.connection_relay_1.node.log_file) cls.multiplexer_relay_1.connect() cls.multiplexers.append(cls.multiplexer_relay_1) relay_peer_1 = cls.connection_relay_1.node.multiaddrs[0] port_relay_2 = DEFAULT_PORT + 100 cls.connection_relay_2 = _make_libp2p_connection( port=port_relay_2, entry_peers=[relay_peer_1]) cls.multiplexer_relay_2 = Multiplexer([cls.connection_relay_2]) cls.log_files.append(cls.connection_relay_2.node.log_file) cls.multiplexer_relay_2.connect() cls.multiplexers.append(cls.multiplexer_relay_2) relay_peer_2 = cls.connection_relay_2.node.multiaddrs[0] cls.connections = [cls.connection_relay_1, cls.connection_relay_2] port = port_relay_1 for _ in range(int(DEFAULT_NET_SIZE / 2) + 1): port += 1 conn = _make_libp2p_connection(port=port, relay=False, entry_peers=[relay_peer_1]) mux = Multiplexer([conn]) cls.connections.append(conn) cls.log_files.append(conn.node.log_file) mux.connect() cls.multiplexers.append(mux) port = port_relay_2 for _ in range(int(DEFAULT_NET_SIZE / 2) + 1): port += 1 conn = _make_libp2p_connection(port=port, relay=False, entry_peers=[relay_peer_2]) mux = Multiplexer([conn]) cls.connections.append(conn) cls.log_files.append(conn.node.log_file) mux.connect() cls.multiplexers.append(mux) except Exception as e: cls.teardown_class() raise e
def test_autoset_default_connection(): """Set default connection automatically.""" connection_1 = _make_dummy_connection() connection_2 = _make_dummy_connection() connections = [connection_1, connection_2] multiplexer = Multiplexer(connections) multiplexer._default_connection = None multiplexer._set_default_connection_if_none() assert multiplexer._default_connection == connections[0]
def setup(self): """Set the test up.""" self.connection = _make_oef_connection( FETCHAI_ADDRESS_ONE, oef_addr="127.0.0.1", oef_port=10000, ) self.multiplexer = Multiplexer([self.connection]) self.multiplexer.connect() self.oef_search_dialogues = OefSearchDialogues(FETCHAI_ADDRESS_ONE)
def test_protocol_not_resolved(): """Test multiplexer raises ValueError on protocol not resolved.""" multiplexer = Multiplexer([Mock()]) envelope = Envelope( to="1", sender="2", protocol_specification_id=FipaMessage.protocol_specification_id, message=b"some bytes", ) with pytest.raises(ValueError): multiplexer._get_protocol_id_for_envelope(envelope)
def setup_class(cls): """Set up the test class.""" cls.connection1 = _make_oef_connection( FETCHAI_ADDRESS_ONE, oef_addr="127.0.0.1", oef_port=10000, ) cls.connection2 = _make_oef_connection( FETCHAI_ADDRESS_TWO, oef_addr="127.0.0.1", oef_port=10000, ) cls.multiplexer1 = Multiplexer([cls.connection1]) cls.multiplexer2 = Multiplexer([cls.connection2]) cls.multiplexer1.connect() cls.multiplexer2.connect()
def test_send_message_no_supported_protocol(): """Test the case when we send an envelope with a specific connection that does not support the protocol.""" with LocalNode() as node: identity_1 = Identity("", address="address_1") connection_1 = _make_local_connection( identity_1.address, node, restricted_to_protocols={DefaultMessage.protocol_id}, excluded_protocols={FipaMessage.protocol_id}, ) multiplexer = Multiplexer( [connection_1], protocols=[DefaultMessage, FipaMessage, UnknownProtocolMock]) multiplexer.connect() with mock.patch.object(multiplexer.logger, "warning") as mock_logger_warning: envelope = Envelope( to=identity_1.address, sender=identity_1.address, protocol_specification_id=FipaMessage. protocol_specification_id, message=b"some bytes", ) multiplexer.put(envelope) time.sleep(0.5) mock_logger_warning.assert_called_with( "Connection {} does not support protocol {}. It is explicitly excluded." .format(connection_1.connection_id, FipaMessage.protocol_id)) with mock.patch.object(multiplexer.logger, "warning") as mock_logger_warning: envelope = Envelope( to=identity_1.address, sender=identity_1.address, protocol_specification_id=UnknownProtocolMock. protocol_specification_id, message=b"some bytes", ) multiplexer.put(envelope) time.sleep(0.5) mock_logger_warning.assert_called_with( "Connection {} does not support protocol {}. The connection is restricted to protocols in {}." .format( connection_1.connection_id, UnknownProtocolMock.protocol_id, connection_1.restricted_to_protocols, )) multiplexer.disconnect()
def setup(self): """Set the test up.""" self.cwd = os.getcwd() self.tmpdir = Path(tempfile.mkdtemp()) d = self.tmpdir / "test_stub" d.mkdir(parents=True) self.input_file_path = d / "input_file.csv" self.output_file_path = d / "output_file.csv" self.connection = _make_stub_connection(self.input_file_path, self.output_file_path) self.multiplexer = Multiplexer([self.connection]) self.multiplexer.connect() os.chdir(self.tmpdir)
def test_connect_twice_with_loop(): """Test that connecting twice the multiplexer behaves correctly.""" running_loop = asyncio.new_event_loop() thread_loop = Thread(target=running_loop.run_forever) thread_loop.start() try: multiplexer = Multiplexer([_make_dummy_connection()], loop=running_loop) with unittest.mock.patch.object(multiplexer.logger, "debug") as mock_logger_debug: assert not multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected mock_logger_debug.assert_called_with( "Multiplexer already connected.") multiplexer.disconnect() running_loop.call_soon_threadsafe(running_loop.stop) finally: thread_loop.join()
def test_send_message_no_supported_protocol(): """Test the case when we send an envelope with a specific connection that does not support the protocol.""" with LocalNode() as node: identity_1 = Identity("", address="address_1") public_id = PublicId.from_str("fetchai/my_private_protocol:0.1.0") connection_1 = _make_local_connection( identity_1.address, node, restricted_to_protocols={public_id}, excluded_protocols={public_id}, ) multiplexer = Multiplexer([connection_1]) multiplexer.connect() with mock.patch.object(aea.mail.base.logger, "warning") as mock_logger_warning: protocol_id = UNKNOWN_PROTOCOL_PUBLIC_ID envelope = Envelope( to=identity_1.address, sender=identity_1.address, protocol_id=protocol_id, message=b"some bytes", ) multiplexer.put(envelope) time.sleep(0.5) mock_logger_warning.assert_called_with( "Connection {} cannot handle protocol {}. Cannot send the envelope.".format( connection_1.connection_id, protocol_id ) ) multiplexer.disconnect()
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] cls.mutliplexers = [] cls.connection_node_1 = _make_libp2p_connection( port=DEFAULT_PORT + 1, delegate_port=DEFAULT_DELEGATE_PORT + 1, delegate=True, ) cls.multiplexer_node_1 = Multiplexer([cls.connection_node_1]) cls.log_files.append(cls.connection_node_1.node.log_file) cls.multiplexer_node_1.connect() cls.mutliplexers.append(cls.multiplexer_node_1) genesis_peer = cls.connection_node_1.node.multiaddrs[0] try: cls.connection_node_2 = _make_libp2p_connection( port=DEFAULT_PORT + 2, delegate_port=DEFAULT_DELEGATE_PORT + 2, entry_peers=[genesis_peer], delegate=True, ) cls.multiplexer_node_2 = Multiplexer([cls.connection_node_2]) cls.log_files.append(cls.connection_node_2.node.log_file) cls.multiplexer_node_2.connect() cls.mutliplexers.append(cls.multiplexer_node_2) cls.connection_client_1 = _make_libp2p_client_connection( DEFAULT_DELEGATE_PORT + 1 ) cls.multiplexer_client_1 = Multiplexer([cls.connection_client_1]) cls.multiplexer_client_1.connect() cls.mutliplexers.append(cls.multiplexer_client_1) cls.connection_client_2 = _make_libp2p_client_connection( DEFAULT_DELEGATE_PORT + 2 ) cls.multiplexer_client_2 = Multiplexer([cls.connection_client_2]) cls.multiplexer_client_2.connect() cls.mutliplexers.append(cls.multiplexer_client_2) except Exception: cls.teardown_class() raise
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] cls.multiplexers = [] try: temp_dir_rel = os.path.join(cls.t, "temp_dir_rel") os.mkdir(temp_dir_rel) cls.relay = _make_libp2p_connection(data_dir=temp_dir_rel, port=DEFAULT_PORT + 1) cls.multiplexer = Multiplexer([cls.relay]) cls.log_files.append(cls.relay.node.log_file) cls.multiplexer.connect() cls.multiplexers.append(cls.multiplexer) relay_peer = cls.relay.node.multiaddrs[0] temp_dir_1 = os.path.join(cls.t, "temp_dir_1") os.mkdir(temp_dir_1) cls.connection1 = _make_libp2p_connection( data_dir=temp_dir_1, port=DEFAULT_PORT + 2, relay=False, entry_peers=[relay_peer], ) cls.multiplexer1 = Multiplexer( [cls.connection1], protocols=[MockDefaultMessageProtocol]) cls.log_files.append(cls.connection1.node.log_file) cls.multiplexer1.connect() cls.multiplexers.append(cls.multiplexer1) temp_dir_2 = os.path.join(cls.t, "temp_dir_2") os.mkdir(temp_dir_2) cls.connection2 = _make_libp2p_connection(data_dir=temp_dir_2, port=DEFAULT_PORT + 3, entry_peers=[relay_peer]) cls.multiplexer2 = Multiplexer( [cls.connection2], protocols=[MockDefaultMessageProtocol]) cls.log_files.append(cls.connection2.node.log_file) cls.multiplexer2.connect() cls.multiplexers.append(cls.multiplexer2) except Exception as e: cls.teardown_class() raise e
def setup_class(cls): """Set up the test.""" cls.node = LocalNode() cls.node.start() cls.address_1 = "address_1" cls.multiplexer1 = Multiplexer( [_make_local_connection(cls.address_1, cls.node,)] ) cls.address_2 = "address_2" cls.multiplexer2 = Multiplexer( [_make_local_connection(cls.address_2, cls.node,)] ) cls.multiplexer1.connect() cls.multiplexer2.connect() cls.dialogues = OefSearchDialogues(cls.address_1)
def setup(self): """Set up test case.""" self.connection = _make_dummy_connection() self.multiplexer = Multiplexer([self.connection], protocols=[DefaultProtocolMock]) self.multiplexer.connect() self.envelope = Envelope( to="", sender="", protocol_specification_id=DefaultMessage.protocol_specification_id, message=b"", context=EnvelopeContext( connection_id=self.connection.connection_id), ) self.exception = ValueError("expected")
def setup_class(cls): """Set the test up.""" cls.connection = _make_oef_connection( FETCHAI_ADDRESS_ONE, oef_addr="127.0.0.1", oef_port=10000, ) cls.multiplexer = Multiplexer([cls.connection]) cls.multiplexer.connect()
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] cls.connection_node = _make_libp2p_connection(delegate=True) cls.multiplexer_node = Multiplexer([cls.connection_node]) cls.log_files.append(cls.connection_node.node.log_file) cls.multiplexer_node.connect() cls.connection_client = _make_libp2p_client_connection() cls.multiplexer_client = Multiplexer([cls.connection_client]) cls.multiplexer_client.connect()
def make_multiplexer_and_dialogues( ) -> Tuple[Multiplexer, OefSearchDialogues, Crypto, SOEFConnection]: """Return multplexer, dialogues and crypto instances.""" crypto = make_crypto(DEFAULT_LEDGER) identity = Identity("", address=crypto.address) oef_search_dialogues = OefSearchDialogues(crypto.address) # create the connection and multiplexer objects configuration = ConnectionConfig( api_key="TwiCIriSl0mLahw17pyqoA", soef_addr="s-oef.fetch.ai", soef_port=443, restricted_to_protocols={ OefSearchMessage.protocol_specification_id, OefSearchMessage.protocol_id, }, connection_id=SOEFConnection.connection_id, ) soef_connection = SOEFConnection( configuration=configuration, data_dir=MagicMock(), identity=identity, ) multiplexer = Multiplexer([soef_connection]) return multiplexer, oef_search_dialogues, crypto, soef_connection
def test_inbox_get_raises_exception_when_empty(): """Test that getting an envelope from an empty inbox raises an exception.""" multiplexer = Multiplexer([_make_dummy_connection()]) inbox = InBox(multiplexer) with pytest.raises(aea.mail.base.Empty): with unittest.mock.patch.object(multiplexer, "get", return_value=None): inbox.get()
def setup_class(cls): """Set the test up.""" cls.connection = _make_oef_connection( FETCHAI_ADDRESS_ONE, oef_addr="127.0.0.1", oef_port=10000, ) cls.multiplexer = Multiplexer([cls.connection]) cls.multiplexer.connect() cls.oef_search_dialogues = OefSearchDialogues("agent_address")
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] cls.multiplexers = [] try: cls.genesis = _make_libp2p_connection(DEFAULT_PORT + 1) cls.multiplexer_genesis = Multiplexer([cls.genesis]) cls.log_files.append(cls.genesis.node.log_file) cls.multiplexer_genesis.connect() cls.multiplexers.append(cls.multiplexer_genesis) genesis_peer = cls.genesis.node.multiaddrs[0] with open("node_key", "wb") as f: make_crypto(DEFAULT_LEDGER).dump(f) cls.relay_key_path = "node_key" cls.relay = _make_libp2p_connection( port=DEFAULT_PORT + 2, entry_peers=[genesis_peer], node_key_file=cls.relay_key_path, ) cls.multiplexer_relay = Multiplexer([cls.relay]) cls.log_files.append(cls.relay.node.log_file) cls.multiplexer_relay.connect() cls.multiplexers.append(cls.multiplexer_relay) relay_peer = cls.relay.node.multiaddrs[0] cls.connection = _make_libp2p_connection(DEFAULT_PORT + 3, relay=False, entry_peers=[relay_peer]) cls.multiplexer = Multiplexer([cls.connection]) cls.log_files.append(cls.connection.node.log_file) cls.multiplexer.connect() cls.multiplexers.append(cls.multiplexer) except Exception as e: cls.teardown_class() raise e
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] cls.multiplexers = [] try: port_genesis = DEFAULT_PORT + 10 temp_dir_gen = os.path.join(cls.t, "temp_dir_gen") os.mkdir(temp_dir_gen) cls.connection_genesis = _make_libp2p_connection( data_dir=temp_dir_gen, port=port_genesis) cls.multiplexer_genesis = Multiplexer( [cls.connection_genesis], protocols=[MockDefaultMessageProtocol]) cls.log_files.append(cls.connection_genesis.node.log_file) cls.multiplexer_genesis.connect() cls.multiplexers.append(cls.multiplexer_genesis) genesis_peer = cls.connection_genesis.node.multiaddrs[0] cls.connections = [cls.connection_genesis] port = port_genesis for i in range(DEFAULT_NET_SIZE): port += 1 temp_dir = os.path.join(cls.t, f"temp_dir_{i}") os.mkdir(temp_dir) conn = _make_libp2p_connection(data_dir=temp_dir, port=port, entry_peers=[genesis_peer]) mux = Multiplexer([conn], protocols=[MockDefaultMessageProtocol]) cls.connections.append(conn) cls.log_files.append(conn.node.log_file) mux.connect() cls.multiplexers.append(mux) except Exception as e: cls.teardown_class() raise e
def run(): # Ensure the input and output files do not exist initially if os.path.isfile(INPUT_FILE): os.remove(INPUT_FILE) if os.path.isfile(OUTPUT_FILE): os.remove(OUTPUT_FILE) # create the connection and multiplexer objects configuration = ConnectionConfig( input_file=INPUT_FILE, output_file=OUTPUT_FILE, connection_id=StubConnection.connection_id, ) stub_connection = StubConnection(configuration=configuration, identity=Identity("some_agent", "some_address")) multiplexer = Multiplexer([stub_connection]) try: # Set the multiplexer running in a different thread t = Thread(target=multiplexer.connect) t.start() # Wait for everything to start up time.sleep(3) # Create a message inside an envelope and get the stub connection to pass it into the multiplexer message_text = ( "multiplexer,some_agent,fetchai/default:0.4.0,\x08\x01*\x07\n\x05hello," ) with open(INPUT_FILE, "w") as f: write_with_lock(f, message_text) # Wait for the envelope to get processed time.sleep(2) # get the envelope envelope = multiplexer.get() # type: Optional[Envelope] assert envelope is not None # Inspect its contents print( "Envelope received by Multiplexer: sender={}, to={}, protocol_id={}, message={}" .format(envelope.sender, envelope.to, envelope.protocol_id, envelope.message)) # Create a mirrored response envelope response_envelope = copy(envelope) response_envelope.to = envelope.sender response_envelope.sender = envelope.to # Send the envelope back multiplexer.put(response_envelope) # Read the output envelope generated by the multiplexer with open(OUTPUT_FILE, "r") as f: print("Envelope received from Multiplexer: " + f.readline()) finally: # Shut down the multiplexer multiplexer.disconnect() t.join()
async def test_sending_loop_does_not_start_if_multiplexer_not_connected(): """Test that the sending loop is stopped does not start if the multiplexer is not connected.""" multiplexer = Multiplexer([_make_dummy_connection()]) with unittest.mock.patch.object(aea.mail.base.logger, "debug") as mock_logger_debug: await multiplexer._send_loop() mock_logger_debug.assert_called_with( "Sending loop not started. The multiplexer is not connected." )
def test_connect_twice(): """Test that connecting twice the multiplexer behaves correctly.""" multiplexer = Multiplexer([_make_dummy_connection()]) assert not multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.disconnect()
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] temp_dir = os.path.join(cls.t, "temp_dir_node") os.mkdir(temp_dir) cls.connection_node = _make_libp2p_connection(data_dir=temp_dir, port=DEFAULT_PORT + 1, delegate=True) cls.multiplexer_node = Multiplexer( [cls.connection_node], protocols=[MockDefaultMessageProtocol]) cls.log_files.append(cls.connection_node.node.log_file) cls.multiplexer_node.connect() try: temp_dir_client_1 = os.path.join(cls.t, "temp_dir_client_1") os.mkdir(temp_dir_client_1) cls.connection_client_1 = _make_libp2p_client_connection( data_dir=temp_dir_client_1, peer_public_key=cls.connection_node.node.pub, ledger_api_id=FetchAICrypto.identifier, ) cls.multiplexer_client_1 = Multiplexer( [cls.connection_client_1], protocols=[MockDefaultMessageProtocol]) cls.multiplexer_client_1.connect() temp_dir_client_2 = os.path.join(cls.t, "temp_dir_client_2") os.mkdir(temp_dir_client_2) cls.connection_client_2 = _make_libp2p_client_connection( data_dir=temp_dir_client_2, peer_public_key=cls.connection_node.node.pub, ledger_api_id=EthereumCrypto.identifier, ) cls.multiplexer_client_2 = Multiplexer( [cls.connection_client_2], protocols=[MockDefaultMessageProtocol]) cls.multiplexer_client_2.connect() except Exception: cls.multiplexer_node.disconnect() raise
def setup_class(cls): """Set the test up.""" cls.connection = _make_oef_connection( FETCHAI_ADDRESS_ONE, oef_addr="127.0.0.1", oef_port=10000, ) cls.multiplexer = Multiplexer([cls.connection], protocols=[FipaMessage, DefaultMessage]) cls.multiplexer.connect()