@streamr/dht 101.1.2 → 102.0.0-beta.1

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -1,7 +1,7 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { Message, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { Message, NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { ITransport } from '../../src/transport/ITransport'
 import * as Err from '../../src/helpers/errors'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
@@ -15,7 +15,8 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
             transport,
             createLocalPeerDescriptor: async () => localPeerDescriptor
         }),
-        metricsContext: new MetricsContext()
+        metricsContext: new MetricsContext(),
+        allowIncomingPrivateConnections: false
     })
 }
 
@@ -161,34 +162,6 @@ describe('WebRTC Connection Management', () => {
 
     }, 20000)
 
-    it('Disconnects webrtcconnection while being connected', async () => {
-        const msg: Message = {
-            serviceId,
-            messageId: '1',
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            },
-        }
-
-        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', () => {
-                resolve()
-            })
-        })
-
-        msg.targetDescriptor = peerDescriptor2
-        manager1.send(msg).catch((e) => {
-            expect(e.code).toEqual('SEND_FAILED')
-        })
-
-        // @ts-expect-error private field
-        manager1.closeConnection(peerDescriptor2)
-
-        await disconnectedPromise1
-
-    }, 20000)
-
     it('failed connections are cleaned up', async () => {
         const msg: Message = {
             serviceId,

package/test/integration/WebrtcConnectorRpc.test.ts

@@ -1,16 +1,16 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebrtcConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { WebrtcConnectorRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
 import {
     IceCandidate,
     RtcAnswer,
     RtcOffer,
     WebrtcConnectionRequest
-} from '../../src/proto/packages/dht/protos/DhtRpc'
-import { Empty } from '../../src/proto/google/protobuf/empty'
+} from '../../generated/packages/dht/protos/DhtRpc'
+import { Empty } from '../../generated/google/protobuf/empty'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { IWebrtcConnectorRpc } from '../../src/proto/packages/dht/protos/DhtRpc.server'
-import { waitForCondition } from '@streamr/utils'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { IWebrtcConnectorRpc } from '../../generated/packages/dht/protos/DhtRpc.server'
+import { until } from '@streamr/utils'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
 describe('WebRTC rpc messages', () => {
@@ -64,12 +64,12 @@ describe('WebRTC rpc messages', () => {
         rpcCommunicator2.registerRpcNotification(IceCandidate, 'iceCandidate', serverFunctions.iceCandidate)
         rpcCommunicator2.registerRpcNotification(WebrtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message)
+        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
+            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
         })
 
-        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage) => {
-            rpcCommunicator1.handleIncomingMessage(message)
+        rpcCommunicator2.setOutgoingMessageListener(async (message: RpcMessage) => {
+            rpcCommunicator1.handleIncomingMessage(message, new DhtCallContext())
         })
 
         client = toProtoRpcClient(new WebrtcConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
@@ -86,7 +86,7 @@ describe('WebRTC rpc messages', () => {
         { targetDescriptor, notification: true }
         )
 
-        await waitForCondition(() => requestConnectionCounter === 1)
+        await until(() => requestConnectionCounter === 1)
     })
 
     it('send rtcOffer', async () => {
@@ -97,7 +97,7 @@ describe('WebRTC rpc messages', () => {
         { targetDescriptor, notification: true }
         )
 
-        await waitForCondition(() => rtcOfferCounter === 1)
+        await until(() => rtcOfferCounter === 1)
     })
 
     it('send rtcAnswer', async () => {
@@ -108,7 +108,7 @@ describe('WebRTC rpc messages', () => {
         { targetDescriptor, notification: true }
         )
 
-        await waitForCondition(() => rtcAnswerCounter === 1)
+        await until(() => rtcAnswerCounter === 1)
     })
 
     it('send iceCandidate', async () => {
@@ -120,6 +120,6 @@ describe('WebRTC rpc messages', () => {
         { targetDescriptor, notification: true }
         )
 
-        await waitForCondition(() => iceCandidateCounter === 1)
+        await until(() => iceCandidateCounter === 1)
     })
 })

package/test/integration/Websocket.test.ts

@@ -1,5 +1,3 @@
-/* eslint-disable no-console */
-
 import { WebsocketServer } from '../../src/connection/websocket/WebsocketServer'
 import { IConnection } from '../../src/connection/IConnection'
 import { WebsocketClientConnection } from '../../src/connection/websocket/NodeWebsocketClientConnection'

package/test/integration/WebsocketClientConnectorRpc.test.ts

@@ -1,9 +1,9 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebsocketClientConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { WebsocketClientConnectorRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
 import { createMockPeerDescriptor, mockWebsocketClientConnectorRpc } from '../utils/utils'
-import { WebsocketConnectionRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Empty } from '../../src/proto/google/protobuf/empty'
+import { WebsocketConnectionRequest } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
+import { Empty } from '../../generated/google/protobuf/empty'
 import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
 describe('WebsocketClientConnectorRpc', () => {
@@ -32,12 +32,12 @@ describe('WebsocketClientConnectorRpc', () => {
             mockWebsocketClientConnectorRpc.requestConnection
         )
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message)
+        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
+            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
         })
 
-        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage) => {
-            rpcCommunicator1.handleIncomingMessage(message)
+        rpcCommunicator2.setOutgoingMessageListener(async (message: RpcMessage) => {
+            rpcCommunicator1.handleIncomingMessage(message, new DhtCallContext())
         })
 
         client1 = toProtoRpcClient(new WebsocketClientConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -1,15 +1,13 @@
-/* eslint-disable promise/no-nesting */
-
-import { MetricsContext, waitForCondition, waitForEvent3 } from '@streamr/utils'
+import { MetricsContext, until, waitForEvent3 } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import * as Err from '../../src/helpers/errors'
-import { Message, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { Message, NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { TransportEvents } from '../../src/transport/ITransport'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { toNodeId } from '../../src/identifiers'
 
 const SERVICE_ID = 'test'
 
@@ -19,7 +17,8 @@ const createOptions = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultCo
             createLocalPeerDescriptor: async () => localPeerDescriptor,
             ...opts
         }),
-        metricsContext: new MetricsContext()
+        metricsContext: new MetricsContext(),
+        allowIncomingPrivateConnections: false
     }
 }
 
@@ -145,7 +144,7 @@ describe('Websocket Connection Management', () => {
             waitForEvent3<TransportEvents>(wsServerManager, 'disconnected', 15000),
             wsServerManager.send(dummyMessage)
         ])
-        expect(wsServerManager.hasConnection(getNodeIdFromPeerDescriptor(dummyMessage.targetDescriptor!))).toBeFalse()
+        expect(wsServerManager.hasConnection(toNodeId(dummyMessage.targetDescriptor!))).toBeFalse()
     }, 20000)
     
     it('Can open connections to peer with server', async () => {
@@ -159,14 +158,14 @@ describe('Websocket Connection Management', () => {
             targetDescriptor: wsServerConnectorPeerDescriptor
         }
         await noWsServerManager.send(dummyMessage)
-        await waitForCondition(
+        await until(
             () => {
-                const nodeId = getNodeIdFromPeerDescriptor(noWsServerConnectorPeerDescriptor)
+                const nodeId = toNodeId(noWsServerConnectorPeerDescriptor)
                 return wsServerManager.hasConnection(nodeId)
             }
         )
-        await waitForCondition(
-            () => noWsServerManager.hasConnection(getNodeIdFromPeerDescriptor(wsServerConnectorPeerDescriptor))
+        await until(
+            () => noWsServerManager.hasConnection(toNodeId(wsServerConnectorPeerDescriptor))
         )
     })
 

package/test/integration/{rpc-connections-over-webrpc.test.ts → rpc-connections-over-webrtc.test.ts}

@@ -6,8 +6,8 @@ import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTran
 import { DhtRpcOptions } from '../../src/rpc-protocol/DhtRpcOptions'
 import { ListeningRpcCommunicator } from '../../src/transport/ListeningRpcCommunicator'
 import { ProtoRpcClient, toProtoRpcClient } from '@streamr/proto-rpc'
-import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { PeerDescriptor, PingRequest, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtNodeRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
+import { PeerDescriptor, PingRequest, PingResponse } from '../../generated/packages/dht/protos/DhtRpc'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { MetricsContext } from '@streamr/utils'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -20,7 +20,8 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
             transport,
             createLocalPeerDescriptor: async () => localPeerDescriptor
         }),
-        metricsContext: new MetricsContext()
+        metricsContext: new MetricsContext(),
+        allowIncomingPrivateConnections: false
     })
 }
 
@@ -50,7 +51,6 @@ describe('RPC connections over WebRTC', () => {
         await connectorTransport2.start()
         manager2 = createConnectionManager(peerDescriptor2, connectorTransport2)
         rpcCommunicator2 = new ListeningRpcCommunicator(SERVICE_ID, manager2)
-        //client2 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator2.getRpcClientTransport()))
 
         await manager1.start()
         await manager2.start()
@@ -87,7 +87,7 @@ describe('RPC connections over WebRTC', () => {
         const response = await client1.ping(request, options)
 
         expect(response.requestId).toEqual(request.requestId)
-    }, 60000)
+    })
 
     it('Throws an exception if RPC method is not defined', async () => {
 
@@ -101,57 +101,23 @@ describe('RPC connections over WebRTC', () => {
 
         await expect(client1.ping(request, options))
             .rejects.toThrow('Server does not implement method ping')
-    }, 60000)
-
-    /*
-    
-    TODO enable these tests (NET-1177)
+    })
 
-    it.only('Throws a client-side exception if WebRTC connection fails', async () => {
+    it('Throws a client-side exception if WebRTC connection fails', async () => {
 
         const request: PingRequest = {
             requestId: v4()
         }
         const options: DhtRpcOptions = {
             sourceDescriptor: peerDescriptor1,
-            targetDescriptor: peerDescriptor2
+            targetDescriptor: peerDescriptor2,
+            timeout: 10000
         }
-        await connectorTransport1.stop()
         await manager2.stop()
         
-        const result = await client1.ping(request, options)
-        
-    }, 60000)
-
-    it('Disconnects WebrtcConnection while being connected', async () => {
-        
-        const rpcMessage: RpcMessage = {
-            header: {},
-            body: new Uint8Array(10),
-            requestId: v4()
-        }
-
-        const msg: Message = {
-            serviceId,
-            messageId: '1',
-            body: RpcMessage.toBinary(rpcMessage)
-        }
+        await expect(client1.ping(request, options))
+            .rejects.toThrow('Peer disconnected')
 
-        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', () => {
-                //expect(message.body.oneofKind).toBe('rpcMessage')
-                resolve()
-            })
-        })
-
-        msg.targetDescriptor = peerDescriptor2
-        manager1.send(msg).catch((e) => {
-            expect(e.code).toEqual('CONNECTION_FAILED')
-        })
-        
-        manager1.disconnect(peerDescriptor2!, undefined, 100)
-        await disconnectedPromise1
+    }, 10000)
 
-    }, 20000)
-    */
 })

package/test/unit/AutoCertifierClientFacade.test.ts

@@ -42,17 +42,17 @@ describe('AutoCertifierClientFacade', () => {
 
     it('start', async () => {
         await client.start()
-        expect(setHost).toBeCalled()
-        expect(updateCertificate).toBeCalled()
+        expect(setHost).toHaveBeenCalled()
+        expect(updateCertificate).toHaveBeenCalled()
     })
 
     it('updated events are processed', async () => {
         await client.start()
-        expect(setHost).toBeCalledTimes(1)
-        expect(updateCertificate).toBeCalledTimes(1);
+        expect(setHost).toHaveBeenCalledTimes(1)
+        expect(updateCertificate).toHaveBeenCalledTimes(1);
         (mockClient as MockAutoCertifierClient).emitUpdateSubdomain()
-        expect(setHost).toBeCalledTimes(2)
-        expect(updateCertificate).toBeCalledTimes(2)
+        expect(setHost).toHaveBeenCalledTimes(2)
+        expect(updateCertificate).toHaveBeenCalledTimes(2)
     })
 
 })

package/test/unit/ConnectionManager.test.ts

@@ -1,6 +1,6 @@
 import { MetricsContext } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { getNodeIdFromPeerDescriptor, PendingConnection } from '../../src/exports'
+import { toNodeId, PendingConnection } from '../../src/exports'
 import { FakeConnectorFacade } from '../utils/FakeConnectorFacade'
 import { MockConnection } from '../utils/mock/MockConnection'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -15,6 +15,7 @@ describe('ConnetionManager', () => {
     beforeEach(async () => {
         connectionManager = new ConnectionManager({
             metricsContext: new MetricsContext(),
+            allowIncomingPrivateConnections: false,
             createConnectorFacade: () => { 
                 fakeConnectorFacade = new FakeConnectorFacade(localPeerDescriptor)
                 return fakeConnectorFacade
@@ -30,7 +31,7 @@ describe('ConnetionManager', () => {
     it('should replace a duplicate connecting connection', () => {
         const remotePeerDescriptor = createMockPeerDescriptor()
         const pendingConnection1 = new PendingConnection(remotePeerDescriptor)
-        const offerer = getOfferer(getNodeIdFromPeerDescriptor(localPeerDescriptor), getNodeIdFromPeerDescriptor(remotePeerDescriptor))
+        const offerer = getOfferer(toNodeId(localPeerDescriptor), toNodeId(remotePeerDescriptor))
         const accepted1 = fakeConnectorFacade.callOnNewConnection(pendingConnection1)
         expect(accepted1).toBeTrue()
         const pendingConnection2 = new PendingConnection(remotePeerDescriptor)
@@ -45,7 +46,7 @@ describe('ConnetionManager', () => {
     it('should replace a duplicate connected connection', () => {
         const remotePeerDescriptor = createMockPeerDescriptor()
         const pendingConnection1 = new PendingConnection(remotePeerDescriptor)
-        const offerer = getOfferer(getNodeIdFromPeerDescriptor(localPeerDescriptor), getNodeIdFromPeerDescriptor(remotePeerDescriptor))
+        const offerer = getOfferer(toNodeId(localPeerDescriptor), toNodeId(remotePeerDescriptor))
         const accepted1 = fakeConnectorFacade.callOnNewConnection(pendingConnection1)
         expect(accepted1).toBeTrue()
         pendingConnection1.onHandshakeCompleted(new MockConnection())

package/test/unit/ConnectivityHelpers.test.ts

@@ -1,4 +1,4 @@
-import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { NodeType } from '../../generated/packages/dht/protos/DhtRpc'
 import { expectedConnectionType } from '../../src/helpers/Connectivity'
 import { ConnectionType } from '../../src/connection/IConnection'
 import { createMockPeerDescriptor } from '../utils/utils'

package/test/unit/DiscoverySession.test.ts

@@ -3,8 +3,8 @@ import { sampleSize } from 'lodash'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { PeerManager, getDistance } from '../../src/dht/PeerManager'
 import { DiscoverySession } from '../../src/dht/discovery/DiscoverySession'
-import { DhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
+import { NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { createTestTopology } from '../utils/topology'
 import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
 
@@ -16,7 +16,7 @@ const QUERY_BATCH_SIZE = 5  // the default value in DhtNode's options, not relev
 
 const createPeerDescriptor = (nodeId: DhtAddress): PeerDescriptor => {
     return {
-        nodeId: getRawFromDhtAddress(nodeId),
+        nodeId: toDhtAddressRaw(nodeId),
         type: NodeType.NODEJS
     }
 }
@@ -45,9 +45,9 @@ describe('DiscoverySession', () => {
     }
 
     const createMockRpcRemote = (peerDescriptor: PeerDescriptor): Partial<DhtNodeRpcRemote> => {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         return {
-            id: getRawFromDhtAddress(nodeId),
+            id: toDhtAddressRaw(nodeId),
             getPeerDescriptor: () => peerDescriptor,
             getNodeId: () => nodeId,
             getClosestPeers: async (referenceId: DhtAddress) => {
@@ -79,7 +79,7 @@ describe('DiscoverySession', () => {
         // Each queried node should closer to the target than the previous queried node, because we
         // use parallelism=1 and noProgressLimit=1
         const distancesToTarget = queriedNodes
-            .map((nodeId) => getDistance(getRawFromDhtAddress(nodeId), getRawFromDhtAddress(targetId)))
+            .map((nodeId) => getDistance(toDhtAddressRaw(nodeId), toDhtAddressRaw(targetId)))
         for (let i = 1; i < distancesToTarget.length ; i++) {
             expect(distancesToTarget[i]).toBeLessThan(distancesToTarget[i - 1])
         }

package/test/unit/Handshaker.test.ts

@@ -10,7 +10,7 @@ import {
 } from '../../src/connection/Handshaker'
 import { ConnectionEvents, IConnection } from '../../src/connection/IConnection'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { HandshakeError, Message } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { HandshakeError, Message } from '../../generated/packages/dht/protos/DhtRpc'
 import { PendingConnection } from '../../src/connection/PendingConnection'
 
 describe('Handshaker', () => {
@@ -104,7 +104,7 @@ describe('Handshaker', () => {
         })
 
         it('onHandshakeFailed unsupported version', () => {
-            handshaker.emit('handshakeFailed', HandshakeError.UNSUPPORTED_VERSION)
+            handshaker.emit('handshakeFailed', HandshakeError.UNSUPPORTED_PROTOCOL_VERSION)
             expect(mockOnHandshakeCompleted).not.toHaveBeenCalled()
             expect(mockPendingConnectionClose).toHaveBeenCalledTimes(1)
         })

package/test/unit/ListeningRpcCommunicator.test.ts

@@ -0,0 +1,52 @@
+import { until } from '@streamr/utils'
+import { ListeningRpcCommunicator } from '../../src/transport/ListeningRpcCommunicator'
+import { MockTransport } from '../utils/mock/MockTransport'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { RpcMessage } from '@streamr/proto-rpc'
+import { Deferred, RpcMetadata, RpcStatus } from '@protobuf-ts/runtime-rpc'
+
+const createDeferredPromises = () => {
+
+    const defHeader = new Deferred<RpcMetadata>()
+    const defMessage = new Deferred<any>()
+    const defStatus = new Deferred<RpcStatus>()
+    const defTrailer = new Deferred<RpcMetadata>()
+    
+    const deferredParser = () => {}
+    return {
+        message: defMessage,
+        header: defHeader,
+        trailer: defTrailer,
+        status: defStatus,
+        messageParser: deferredParser as any
+    }
+}
+
+describe('ListeningRpcCommunicator', () => {
+    const SERVICE_ID = 'test'
+    let rpcCommunicator: ListeningRpcCommunicator
+    let transport: MockTransport
+
+    beforeEach(() => {
+        transport = new MockTransport()
+        rpcCommunicator = new ListeningRpcCommunicator(SERVICE_ID, transport)
+    })
+
+    afterEach(() => {
+        rpcCommunicator.destroy()
+        transport.stop()
+    })
+
+    it('rejects requests on disconnect event to the target', async () => {
+        const peerDescriptor = createMockPeerDescriptor()
+        rpcCommunicator.getRpcClientTransport().emit(
+            'rpcRequest',
+            RpcMessage.create(),
+            { targetDescriptor: peerDescriptor }, createDeferredPromises()
+        )
+        await until(() => rpcCommunicator.getRequestIds(() => true).length > 0)
+        transport.emit('disconnected', peerDescriptor, false)
+        await until(() => rpcCommunicator.getRequestIds(() => true).length === 0)
+    }, 10000)
+
+})

package/test/unit/LocalDataStore.test.ts

@@ -2,7 +2,7 @@ import { wait } from '@streamr/utils'
 import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { createMockDataEntry } from '../utils/mock/mockDataEntry'
-import { createRandomDhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { randomDhtAddress, toDhtAddress, toNodeId } from '../../src/identifiers'
 
 describe('LocalDataStore', () => {
 
@@ -19,14 +19,14 @@ describe('LocalDataStore', () => {
     it('can store', () => {
         const storedEntry = createMockDataEntry()
         localDataStore.storeEntry(storedEntry)
-        const fetchedEntries = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+        const fetchedEntries = Array.from(localDataStore.values(toDhtAddress(storedEntry.key)))
         expect(fetchedEntries).toIncludeSameMembers([storedEntry])
     })
 
     it('multiple storers behind one key', () => {
-        const creator1 = createRandomDhtAddress()
-        const creator2 = createRandomDhtAddress()
-        const key = createRandomDhtAddress()
+        const creator1 = randomDhtAddress()
+        const creator2 = randomDhtAddress()
+        const key = randomDhtAddress()
         const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
         const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
         localDataStore.storeEntry(storedEntry1)
@@ -36,9 +36,9 @@ describe('LocalDataStore', () => {
     })
 
     it('can remove data entries', () => {
-        const creator1 = createRandomDhtAddress()
-        const creator2 = createRandomDhtAddress()
-        const key = createRandomDhtAddress()
+        const creator1 = randomDhtAddress()
+        const creator2 = randomDhtAddress()
+        const key = randomDhtAddress()
         const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
         const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
         localDataStore.storeEntry(storedEntry1)
@@ -49,9 +49,9 @@ describe('LocalDataStore', () => {
     })
 
     it('can remove all data entries', () => {
-        const creator1 = createRandomDhtAddress()
-        const creator2 = createRandomDhtAddress()
-        const key = createRandomDhtAddress()
+        const creator1 = randomDhtAddress()
+        const creator2 = randomDhtAddress()
+        const key = randomDhtAddress()
         const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
         const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
         localDataStore.storeEntry(storedEntry1)
@@ -64,33 +64,33 @@ describe('LocalDataStore', () => {
     it('data is deleted after TTL', async () => {
         const storedEntry = createMockDataEntry({ ttl: 1000 })
         localDataStore.storeEntry(storedEntry)
-        expect(Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))).toHaveLength(1)
+        expect(Array.from(localDataStore.values(toDhtAddress(storedEntry.key)))).toHaveLength(1)
         await wait(1100)
-        expect(Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))).toHaveLength(0)
+        expect(Array.from(localDataStore.values(toDhtAddress(storedEntry.key)))).toHaveLength(0)
     })
 
     describe('mark data as deleted', () => {
 
         it('happy path', () => {
-            const creator1 = createRandomDhtAddress()
+            const creator1 = randomDhtAddress()
             const storedEntry = createMockDataEntry({ creator: creator1 })
             localDataStore.storeEntry(storedEntry)
-            const notDeletedData = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+            const notDeletedData = Array.from(localDataStore.values(toDhtAddress(storedEntry.key)))
             expect(notDeletedData[0].deleted).toBeFalse()
             const returnValue = localDataStore.markAsDeleted(
-                getDhtAddressFromRaw(storedEntry.key),
+                toDhtAddress(storedEntry.key),
                 creator1
             )
             expect(returnValue).toBe(true)
-            const deletedData = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+            const deletedData = Array.from(localDataStore.values(toDhtAddress(storedEntry.key)))
             expect(deletedData[0].deleted).toBeTrue()
         })
 
         it('data not stored', () => {
-            const key = createRandomDhtAddress()
+            const key = randomDhtAddress()
             const returnValue = localDataStore.markAsDeleted(
                 key,
-                getNodeIdFromPeerDescriptor(createMockPeerDescriptor())
+                toNodeId(createMockPeerDescriptor())
             )
             expect(returnValue).toBe(false)
         })
@@ -99,8 +99,8 @@ describe('LocalDataStore', () => {
             const storedEntry = createMockDataEntry()
             localDataStore.storeEntry(storedEntry)
             const returnValue = localDataStore.markAsDeleted(
-                getDhtAddressFromRaw(storedEntry.key),
-                getNodeIdFromPeerDescriptor(createMockPeerDescriptor())
+                toDhtAddress(storedEntry.key),
+                toNodeId(createMockPeerDescriptor())
             )
             expect(returnValue).toBe(false)
         })