def test_communication_direct(self): """Test communication direct (i.e. both clients registered to same peer).""" for i in range(len(PUBLIC_DHT_DELEGATE_URIS)): uri = PUBLIC_DHT_DELEGATE_URIS[i] peer_public_key = PUBLIC_DHT_PUBLIC_KEYS[i] multiplexers = [] try: temp_dir_1 = os.path.join(self.t, f"dir_{i}_1") os.mkdir(temp_dir_1) connection1 = _make_libp2p_client_connection( peer_public_key=peer_public_key, uri=uri, data_dir=temp_dir_1 ) multiplexer1 = Multiplexer([connection1]) multiplexer1.connect() multiplexers.append(multiplexer1) temp_dir_2 = os.path.join(self.t, f"dir_{i}_2") os.mkdir(temp_dir_2) connection2 = _make_libp2p_client_connection( peer_public_key=peer_public_key, uri=uri, data_dir=temp_dir_2 ) multiplexer2 = Multiplexer([connection2]) multiplexer2.connect() multiplexers.append(multiplexer2) addr_1 = connection1.address addr_2 = connection2.address msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) envelope = Envelope(to=addr_2, sender=addr_1, message=msg,) multiplexer1.put(envelope) delivered_envelope = multiplexer2.get(block=True, timeout=20) assert delivered_envelope is not None assert delivered_envelope.to == envelope.to assert delivered_envelope.sender == envelope.sender assert ( delivered_envelope.protocol_specification_id == envelope.protocol_specification_id ) assert delivered_envelope.message != envelope.message msg = DefaultMessage.serializer.decode(delivered_envelope.message) msg.to = delivered_envelope.to msg.sender = delivered_envelope.sender assert envelope.message == msg except Exception: raise finally: for mux in multiplexers: mux.disconnect()
def test_communication_indirect(self): assert (len(PUBLIC_DHT_DELEGATE_URIS) > 1), "Test requires at least 2 public dht node" for i in range(len(PUBLIC_DHT_DELEGATE_URIS)): connection1 = _make_libp2p_client_connection( uri=PUBLIC_DHT_DELEGATE_URIS[i]) multiplexer1 = Multiplexer([connection1]) multiplexer1.connect() addr_1 = connection1.address msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) for j in range(len(PUBLIC_DHT_DELEGATE_URIS)): if j == i: continue connection2 = _make_libp2p_client_connection( uri=PUBLIC_DHT_DELEGATE_URIS[j]) multiplexer2 = Multiplexer([connection2]) multiplexer2.connect() addr_2 = connection2.address envelope = Envelope( to=addr_2, sender=addr_1, protocol_id=DefaultMessage.protocol_id, message=msg, ) multiplexer1.put(envelope) delivered_envelope = multiplexer2.get(block=True, timeout=20) try: assert delivered_envelope is not None assert delivered_envelope.to == envelope.to assert delivered_envelope.sender == envelope.sender assert delivered_envelope.protocol_id == envelope.protocol_id assert delivered_envelope.message != envelope.message msg = DefaultMessage.serializer.decode( delivered_envelope.message) assert envelope.message == msg except Exception: multiplexer1.disconnect() raise finally: multiplexer2.disconnect() multiplexer1.disconnect()
def test_communication_direct(self): """Test communication direct.""" for uri in PUBLIC_DHT_DELEGATE_URIS: multiplexers = [] try: connection1 = _make_libp2p_client_connection(uri=uri) multiplexer1 = Multiplexer([connection1]) multiplexer1.connect() multiplexers.append(multiplexer1) connection2 = _make_libp2p_client_connection(uri=uri) multiplexer2 = Multiplexer([connection2]) multiplexer2.connect() multiplexers.append(multiplexer2) addr_1 = connection1.address addr_2 = connection2.address msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) envelope = Envelope( to=addr_2, sender=addr_1, protocol_id=DefaultMessage.protocol_id, message=msg, ) multiplexer1.put(envelope) delivered_envelope = multiplexer2.get(block=True, timeout=20) assert delivered_envelope is not None assert delivered_envelope.to == envelope.to assert delivered_envelope.sender == envelope.sender assert delivered_envelope.protocol_id == envelope.protocol_id assert delivered_envelope.message != envelope.message msg = DefaultMessage.serializer.decode( delivered_envelope.message) msg.to = delivered_envelope.to msg.sender = delivered_envelope.sender assert envelope.message == msg except Exception: raise finally: for mux in multiplexers: mux.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 = [] 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
async def test_node_not_running(self): """Test the node is not running.""" with tempfile.TemporaryDirectory() as dirname: conn = _make_libp2p_client_connection( data_dir=dirname, peer_public_key=make_crypto(DEFAULT_LEDGER).public_key ) with pytest.raises(Exception): await conn.connect()
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.connection_node = _make_libp2p_connection(delegate=True) cls.connection = _make_libp2p_client_connection()
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.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.log_files = [] cls.connection_node = _make_libp2p_connection(DEFAULT_PORT + 1, 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_1 = _make_libp2p_client_connection() cls.multiplexer_client_1 = Multiplexer([cls.connection_client_1]) cls.multiplexer_client_1.connect() cls.connection_client_2 = _make_libp2p_client_connection() cls.multiplexer_client_2 = Multiplexer([cls.connection_client_2]) cls.multiplexer_client_2.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.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.multiplexers.append(cls.multiplexer_node_1) entry_peer = cls.connection_node_1.node.multiaddrs[0] cls.connection_node_2 = _make_libp2p_connection( port=DEFAULT_PORT + 2, delegate_port=DEFAULT_DELEGATE_PORT + 2, entry_peers=[entry_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.multiplexers.append(cls.multiplexer_node_2) cls.connections = [cls.connection_node_1, cls.connection_node_2] cls.addresses = [ cls.connection_node_1.address, cls.connection_node_2.address, ] for _ in range(DEFAULT_CLIENTS_PER_NODE): for port in [DEFAULT_DELEGATE_PORT + 1, DEFAULT_DELEGATE_PORT + 2]: conn = _make_libp2p_client_connection(port) mux = Multiplexer([conn]) cls.connections.append(conn) cls.addresses.append(conn.address) mux.connect() cls.multiplexers.append(mux) except Exception: cls.teardown_class() raise
def test_connectivity(self): for uri in PUBLIC_DHT_DELEGATE_URIS: connection = _make_libp2p_client_connection(uri=uri) multiplexer = Multiplexer([connection]) multiplexer.connect() try: assert (connection.is_connected is True), "Couldn't connect to public node {}".format(uri) except Exception: raise finally: multiplexer.disconnect()
async def test_reconnect_on_receive_fail(): """Test reconnect on receive fails.""" with tempfile.TemporaryDirectory() as dirname: con = _make_libp2p_client_connection( data_dir=dirname, peer_public_key=make_crypto(DEFAULT_LEDGER).public_key ) mock_reader = Mock() mock_reader.readexactly.side_effect = ConnectionError("oops") con._reader = mock_reader con._in_queue = Mock() with patch.object( con, "_perform_connection_to_node", return_value=done_future ) as connect_mock: assert await con._receive() is None connect_mock.assert_called()
async def test_connect_attempts(): """Test connect attempts.""" # test connects with tempfile.TemporaryDirectory() as dirname: con = _make_libp2p_client_connection( data_dir=dirname, peer_public_key=make_crypto(DEFAULT_LEDGER).public_key ) con.connect_retries = 2 with patch( "asyncio.open_connection", side_effect=Exception("test exception on connect"), ) as open_connection_mock: with pytest.raises(Exception, match="test exception on connect"): await con.connect() assert open_connection_mock.call_count == con.connect_retries
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) temp_dir = os.path.join(cls.t, "temp_dir_node") os.mkdir(temp_dir) cls.connection_node = _make_libp2p_connection(data_dir=temp_dir, delegate=True) temp_dir_client = os.path.join(cls.t, "temp_dir_client") os.mkdir(temp_dir_client) cls.connection = _make_libp2p_client_connection( data_dir=temp_dir_client, peer_public_key=cls.connection_node.node.pub)
async def test_reconnect_on_send_fail(): """Test reconnect on send fails.""" with tempfile.TemporaryDirectory() as dirname: con = _make_libp2p_client_connection( data_dir=dirname, peer_public_key=make_crypto(DEFAULT_LEDGER).public_key ) # test reconnect on send fails with patch.object( con, "_perform_connection_to_node", return_value=done_future ) as connect_mock, patch.object( con, "_ensure_valid_envelope_for_external_comms" ): with pytest.raises(ValueError, match="Writer is not set."): await con.send(Mock()) connect_mock.assert_called()
def test_connectivity(self): """Test connectivity.""" for i in range(len(PUBLIC_DHT_DELEGATE_URIS)): uri = PUBLIC_DHT_DELEGATE_URIS[i] peer_public_key = PUBLIC_DHT_PUBLIC_KEYS[i] temp_dir = os.path.join(self.t, f"dir_{i}") os.mkdir(temp_dir) connection = _make_libp2p_client_connection( peer_public_key=peer_public_key, uri=uri, data_dir=temp_dir ) multiplexer = Multiplexer([connection]) try: multiplexer.connect() assert ( connection.is_connected is True ), "Couldn't connect to public node {}".format(uri) except Exception: raise finally: 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.multiplexers = [] try: 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.multiplexers.append(cls.multiplexer_node) cls.connection_client = _make_libp2p_client_connection() cls.multiplexer_client = Multiplexer([cls.connection_client]) cls.multiplexer_client.connect() cls.multiplexers.append(cls.multiplexer_client) except Exception: cls.teardown_class() raise
async def test_node_not_running(self): conn = _make_libp2p_client_connection() with pytest.raises(Exception): await conn.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.mutliplexers = [] temp_dir_node_1 = os.path.join(cls.t, "temp_dir_node_1") os.mkdir(temp_dir_node_1) cls.connection_node_1 = _make_libp2p_connection( data_dir=temp_dir_node_1, port=DEFAULT_PORT + 1, delegate_port=DEFAULT_DELEGATE_PORT + 1, delegate=True, ) cls.multiplexer_node_1 = Multiplexer( [cls.connection_node_1], protocols=[MockDefaultMessageProtocol]) 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] temp_dir_node_2 = os.path.join(cls.t, "temp_dir_node_2") os.mkdir(temp_dir_node_2) try: cls.connection_node_2 = _make_libp2p_connection( data_dir=temp_dir_node_2, 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], protocols=[MockDefaultMessageProtocol]) cls.log_files.append(cls.connection_node_2.node.log_file) cls.multiplexer_node_2.connect() cls.mutliplexers.append(cls.multiplexer_node_2) 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_1.node.pub, node_port=DEFAULT_DELEGATE_PORT + 1, ) cls.multiplexer_client_1 = Multiplexer( [cls.connection_client_1], protocols=[MockDefaultMessageProtocol]) cls.multiplexer_client_1.connect() cls.mutliplexers.append(cls.multiplexer_client_1) 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_2.node.pub, node_port=DEFAULT_DELEGATE_PORT + 2, ) cls.multiplexer_client_2 = Multiplexer( [cls.connection_client_2], protocols=[MockDefaultMessageProtocol]) 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_node_1 = os.path.join(cls.t, "temp_dir_node_1") os.mkdir(temp_dir_node_1) cls.connection_node_1 = _make_libp2p_connection( data_dir=temp_dir_node_1, port=DEFAULT_PORT + 1, delegate_port=DEFAULT_DELEGATE_PORT + 1, delegate=True, ) cls.multiplexer_node_1 = Multiplexer( [cls.connection_node_1], protocols=[MockDefaultMessageProtocol]) cls.log_files.append(cls.connection_node_1.node.log_file) cls.multiplexer_node_1.connect() cls.multiplexers.append(cls.multiplexer_node_1) entry_peer = cls.connection_node_1.node.multiaddrs[0] temp_dir_node_2 = os.path.join(cls.t, "temp_dir_node_2") os.mkdir(temp_dir_node_2) cls.connection_node_2 = _make_libp2p_connection( data_dir=temp_dir_node_2, port=DEFAULT_PORT + 2, delegate_port=DEFAULT_DELEGATE_PORT + 2, entry_peers=[entry_peer], delegate=True, ) cls.multiplexer_node_2 = Multiplexer( [cls.connection_node_2], protocols=[MockDefaultMessageProtocol]) cls.log_files.append(cls.connection_node_2.node.log_file) cls.multiplexer_node_2.connect() cls.multiplexers.append(cls.multiplexer_node_2) cls.connections = [cls.connection_node_1, cls.connection_node_2] cls.addresses = [ cls.connection_node_1.address, cls.connection_node_2.address, ] for j in range(DEFAULT_CLIENTS_PER_NODE): ports = [DEFAULT_DELEGATE_PORT + 1, DEFAULT_DELEGATE_PORT + 2] peers_public_keys = [ cls.connection_node_1.node.pub, cls.connection_node_2.node.pub, ] for i in range(len(ports)): port = ports[i] peer_public_key = peers_public_keys[i] temp_dir_client = os.path.join( cls.t, f"temp_dir_client__{j}_{i}") os.mkdir(temp_dir_client) conn = _make_libp2p_client_connection( data_dir=temp_dir_client, peer_public_key=peer_public_key, node_port=port, ) mux = Multiplexer([conn], protocols=[MockDefaultMessageProtocol]) cls.connections.append(conn) cls.addresses.append(conn.address) mux.connect() cls.multiplexers.append(mux) except Exception: cls.teardown_class() raise