@streamr/dht 101.1.2 → 102.0.0-beta.1

package/test/unit/PeerManager.test.ts

@@ -1,10 +1,10 @@
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { range, sample, sampleSize } from 'lodash'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { PeerManager } from '../../src/dht/PeerManager'
 import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
-import { DhtAddress, createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtAddress, randomDhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
+import { NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 import { createMockPeerDescriptor } from '../utils/utils'
 
@@ -16,7 +16,7 @@ const createDhtNodeRpcRemote = (
     const remote = new class extends DhtNodeRpcRemote {
         // eslint-disable-next-line class-methods-use-this
         async ping(): Promise<boolean> {
-            return !pingFailures.has(getNodeIdFromPeerDescriptor(peerDescriptor))
+            return !pingFailures.has(toNodeId(peerDescriptor))
         }
     }(localPeerDescriptor, peerDescriptor, undefined as any, new MockRpcCommunicator())
     return remote
@@ -28,13 +28,13 @@ const createPeerManager = (
     pingFailures: Set<DhtAddress> = new Set()
 ) => {
     const manager = new PeerManager({
-        localNodeId: getNodeIdFromPeerDescriptor(localPeerDescriptor),
+        localNodeId: toNodeId(localPeerDescriptor),
         localPeerDescriptor: localPeerDescriptor,
         isLayer0: true,
         createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => createDhtNodeRpcRemote(peerDescriptor, localPeerDescriptor, pingFailures),
         hasConnection: () => false
     } as any)
-    const contacts = nodeIds.map((n) => ({ nodeId: getRawFromDhtAddress(n), type: NodeType.NODEJS }))
+    const contacts = nodeIds.map((n) => ({ nodeId: toDhtAddressRaw(n), type: NodeType.NODEJS }))
     for (const contact of contacts) {
         manager.addContact(contact)
     }
@@ -44,29 +44,29 @@ const createPeerManager = (
 describe('PeerManager', () => {
 
     it('getNearbyContactCount', () => {
-        const nodeIds = range(10).map(() => createRandomDhtAddress())
+        const nodeIds = range(10).map(() => randomDhtAddress())
         const manager = createPeerManager(nodeIds)
         expect(manager.getNearbyContactCount()).toBe(10)
         expect(manager.getNearbyContactCount(new Set(sampleSize(nodeIds, 2)))).toBe(8)
-        expect(manager.getNearbyContactCount(new Set([sample(nodeIds)!, createRandomDhtAddress()]))).toBe(9)
+        expect(manager.getNearbyContactCount(new Set([sample(nodeIds)!, randomDhtAddress()]))).toBe(9)
     })
 
     it('addContact: ping fails', async () => {
         const localPeerDescriptor = createMockPeerDescriptor()
         const successContacts = range(5).map(() => createMockPeerDescriptor())
         const failureContact = createMockPeerDescriptor()
-        const manager = createPeerManager([], localPeerDescriptor, new Set([getNodeIdFromPeerDescriptor(failureContact)]))
+        const manager = createPeerManager([], localPeerDescriptor, new Set([toNodeId(failureContact)]))
         for (const successContact of successContacts) {
             manager.addContact(successContact)
-            manager.setContactActive(getNodeIdFromPeerDescriptor(successContact))
-            manager.removeNeighbor(getNodeIdFromPeerDescriptor(successContact))
+            manager.setContactActive(toNodeId(successContact))
+            manager.removeNeighbor(toNodeId(successContact))
         }
         expect(manager.getNeighborCount()).toBe(0)
         manager.addContact(failureContact)
-        const closesSuccessContact = getClosestNodes(getNodeIdFromPeerDescriptor(localPeerDescriptor), successContacts)[0]
-        await waitForCondition(() => {
+        const closesSuccessContact = getClosestNodes(toNodeId(localPeerDescriptor), successContacts)[0]
+        await until(() => {
             const neighborNodeIds = manager.getNeighbors().map((n) => n.getNodeId())
-            return neighborNodeIds.includes(getNodeIdFromPeerDescriptor(closesSuccessContact))
+            return neighborNodeIds.includes(toNodeId(closesSuccessContact))
         })
         expect(manager.getNeighborCount()).toBe(1)
         expect(manager.getNeighbors()[0].getPeerDescriptor()).toEqualPeerDescriptor(closesSuccessContact)
@@ -83,7 +83,7 @@ describe('PeerManager', () => {
         }
         manager.addContact(failureContact)
         expect(manager.getNeighborCount()).toBe(6)
-        failureSet.add(getNodeIdFromPeerDescriptor(failureContact))
+        failureSet.add(toNodeId(failureContact))
         await manager.pruneOfflineNodes(
             manager.getNeighbors().map((node) => createDhtNodeRpcRemote(node.getPeerDescriptor(), localPeerDescriptor, failureSet))
         )

package/test/unit/PendingConnection.test.ts

@@ -21,7 +21,7 @@ describe('PendingConnection', () => {
             throw new Error('disconnected')
         })
         pendingConnection.replaceAsDuplicate()
-        await pendingConnection.close(false)
+        pendingConnection.close(false)
         await wait(50)
     })
 

package/test/unit/ProtobufMessage.test.ts

@@ -1,6 +1,6 @@
 /*
 import { ProtobufMessage } from '../../src/protobufclasses/ProtobufMessage'
-import { Message, RpcMessage } from '../../src/proto/DhtRpc'
+import { Message, RpcMessage } from '../../generated/DhtRpc'
 import { v4 } from 'uuid'
 import { MessageType } from '@protobuf-ts/runtime'
 */

package/test/unit/RandomContactList.test.ts

@@ -1,9 +1,9 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
-import { DhtAddress, DhtAddressRaw, getDhtAddressFromRaw } from '../../src/identifiers'
+import { DhtAddress, DhtAddressRaw, toDhtAddress } from '../../src/identifiers'
 
 const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress } => {
     return { 
-        getNodeId: () => getDhtAddressFromRaw(nodeId)
+        getNodeId: () => toDhtAddress(nodeId)
     }
 }
 

package/test/unit/RecursiveOperationManager.test.ts

@@ -5,7 +5,7 @@ import {
     RouteMessageError,
     RouteMessageWrapper,
     RecursiveOperationRequest
-} from '../../src/proto/packages/dht/protos/DhtRpc'
+} from '../../generated/packages/dht/protos/DhtRpc'
 import {
     createWrappedClosestPeersRequest,
     createMockPeerDescriptor
@@ -18,7 +18,7 @@ import { MockTransport } from '../utils/mock/MockTransport'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
 import { Router } from '../../src/dht/routing/Router'
 import { ITransport } from '../../src/transport/ITransport'
-import { areEqualPeerDescriptors, createRandomDhtAddress } from '../../src/identifiers'
+import { areEqualPeerDescriptors, randomDhtAddress } from '../../src/identifiers'
 import { MockConnectionsView } from '../utils/mock/MockConnectionsView'
 
 const createMockRouter = (error?: RouteMessageError): Partial<Router> => {
@@ -94,7 +94,7 @@ describe('RecursiveOperationManager', () => {
 
     it('find closest nodes returns self if no peers', async () => {
         const recursiveOperationManager = createRecursiveOperationManager()
-        const res = await recursiveOperationManager.execute(createRandomDhtAddress(), RecursiveOperation.FIND_CLOSEST_NODES)
+        const res = await recursiveOperationManager.execute(randomDhtAddress(), RecursiveOperation.FIND_CLOSEST_NODES)
         expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
         recursiveOperationManager.stop()
     })

package/test/unit/RecursiveOperationSession.test.ts

@@ -1,11 +1,11 @@
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { range } from 'lodash'
 import { RecursiveOperationSession } from '../../src/dht/recursive-operation/RecursiveOperationSession'
 import { RecursiveOperationSessionRpcRemote } from '../../src/dht/recursive-operation/RecursiveOperationSessionRpcRemote'
 import { ServiceID } from '../../src/types/ServiceID'
-import { createRandomDhtAddress } from '../../src/identifiers'
-import { Message, PeerDescriptor, RecursiveOperation } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RecursiveOperationSessionRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { randomDhtAddress } from '../../src/identifiers'
+import { Message, PeerDescriptor, RecursiveOperation } from '../../generated/packages/dht/protos/DhtRpc'
+import { RecursiveOperationSessionRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
 import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
 import { FakeEnvironment } from '../utils/FakeTransport'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -36,7 +36,7 @@ describe('RecursiveOperationSession', () => {
         const doRouteRequest = jest.fn()
         const session = new RecursiveOperationSession({
             transport: environment.createTransport(localPeerDescriptor),
-            targetId: createRandomDhtAddress(),
+            targetId: randomDhtAddress(),
             localPeerDescriptor,
             waitedRoutingPathCompletions: 3,
             operation: RecursiveOperation.FIND_CLOSEST_NODES,
@@ -59,7 +59,7 @@ describe('RecursiveOperationSession', () => {
 
         // TODO now waits for the 4s timeout, could setup test so that it completes by receiving
         // all data it wants
-        await waitForCondition(() => onCompleted.mock.calls.length > 0)
+        await until(() => onCompleted.mock.calls.length > 0)
         const result = session.getResults()
         // TODO assert peer descriptors
         expect(result.closestNodes).toHaveLength(6)

package/test/unit/Router.test.ts

@@ -7,10 +7,10 @@ import {
     RouteMessageAck,
     RouteMessageError,
     RouteMessageWrapper
-} from '../../src/proto/packages/dht/protos/DhtRpc'
+} from '../../generated/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../utils/utils'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
-import { DhtAddress, getNodeIdFromPeerDescriptor, createRandomDhtAddress } from '../../src/identifiers'
+import { DhtAddress, toNodeId, randomDhtAddress } from '../../src/identifiers'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 
 describe('Router', () => {
@@ -73,7 +73,7 @@ describe('Router', () => {
     })
 
     it('doRouteMessage with connections', async () => {
-        connections.set(createRandomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(randomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
             message,
             target: peerDescriptor2.nodeId,
@@ -87,7 +87,7 @@ describe('Router', () => {
     })
 
     it('doRouteMessage with parallelRootNodeIds', async () => {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor2)
+        const nodeId = toNodeId(peerDescriptor2)
         connections.set(nodeId, createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
             message,
@@ -107,7 +107,7 @@ describe('Router', () => {
     })
 
     it('route server with connections', async () => {
-        connections.set(createRandomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(randomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toBeUndefined()
     })
@@ -124,7 +124,7 @@ describe('Router', () => {
     })
 
     it('forward server with connections', async () => {
-        connections.set(createRandomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(randomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toBeUndefined()
     })

package/test/unit/RoutingSession.test.ts

@@ -1,10 +1,10 @@
 import { v4 } from 'uuid'
 import { RoutingMode, RoutingSession } from '../../src/dht/routing/RoutingSession'
-import { Message, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message, PeerDescriptor, RouteMessageWrapper } from '../../generated/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../utils/utils'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
-import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { DhtAddress, toNodeId } from '../../src/identifiers'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 import { RoutingTablesCache } from '../../src/dht/routing/RoutingTablesCache'
 
@@ -63,17 +63,24 @@ describe('RoutingSession', () => {
     })
 
     it('findMoreContacts', () => {
-        connections.set(getNodeIdFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
+        connections.set(toNodeId(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
         const contacts = session.updateAndGetRoutablePeers()
         expect(contacts.length).toBe(1)
     })
 
     it('findMoreContacts peer disconnects', () => {
-        connections.set(getNodeIdFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
+        connections.set(toNodeId(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
         expect(session.updateAndGetRoutablePeers().length).toBe(1)
-        connections.delete(getNodeIdFromPeerDescriptor(mockPeerDescriptor2))
-        routingTablesCache.onNodeDisconnected(getNodeIdFromPeerDescriptor(mockPeerDescriptor2))
+        connections.delete(toNodeId(mockPeerDescriptor2))
+        routingTablesCache.onNodeDisconnected(toNodeId(mockPeerDescriptor2))
         expect(session.updateAndGetRoutablePeers().length).toBe(0)
     })
 
+    it('recalculates Routing Table if it is empty', () => {
+        connections.set(toNodeId(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
+        expect(session.updateAndGetRoutablePeers().length).toBe(1)
+        routingTablesCache.onNodeDisconnected(toNodeId(mockPeerDescriptor2))
+        expect(session.updateAndGetRoutablePeers().length).toBe(1)
+    })
+
 })

package/test/unit/SortedContactList.test.ts

@@ -1,9 +1,9 @@
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import { DhtAddress, DhtAddressRaw, createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
+import { DhtAddress, DhtAddressRaw, randomDhtAddress, toDhtAddress } from '../../src/identifiers'
 
 const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress } => {
     return { 
-        getNodeId: () => getDhtAddressFromRaw(nodeId)
+        getNodeId: () => toDhtAddress(nodeId)
     }
 }
 
@@ -38,7 +38,7 @@ describe('SortedContactList', () => {
         expect(list.getSize()).toEqual(3)
         expect(list.getClosestContacts()).toEqual([item1, item2, item3])
         expect(list.getContactIds()).toEqual([item1.getNodeId(), item2.getNodeId(), item3.getNodeId()])
-        expect(onContactRemoved).toBeCalledWith(item4)
+        expect(onContactRemoved).toHaveBeenCalledWith(item4)
         expect(list.getContact(item4.getNodeId())).toBeFalsy()
     })
 
@@ -46,7 +46,7 @@ describe('SortedContactList', () => {
         const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 8, allowToContainReferenceId: false })
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
-        list.removeContact(createRandomDhtAddress())
+        list.removeContact(randomDhtAddress())
         list.addContact(item3)
         list.removeContact(item3.getNodeId())
         list.addContact(item4)
@@ -58,10 +58,10 @@ describe('SortedContactList', () => {
         expect(list.getContact(item2.getNodeId())).toBeFalsy()
         expect(list.getContactIds()).toEqual(list.getContactIds().sort(list.compareIds))
         expect(list.getClosestContacts()).toEqual([item1, item3, item4])
-        const ret = list.removeContact(getDhtAddressFromRaw(Buffer.from([0, 0, 0, 6])))
+        const ret = list.removeContact(toDhtAddress(Buffer.from([0, 0, 0, 6])))
         expect(ret).toEqual(false)
         list.removeContact(item3.getNodeId())
-        list.removeContact(createRandomDhtAddress())
+        list.removeContact(randomDhtAddress())
         expect(list.getClosestContacts()).toEqual([item1, item4])
         expect(onContactRemoved).toHaveBeenNthCalledWith(1, item3)
         expect(onContactRemoved).toHaveBeenNthCalledWith(2, item2)
@@ -106,9 +106,9 @@ describe('SortedContactList', () => {
         list.on('contactAdded', onContactAdded)
         list.addContact(item1)
         list.addContact(item2)
-        expect(onContactAdded).toBeCalledTimes(2)
+        expect(onContactAdded).toHaveBeenCalledTimes(2)
         list.addContact(item3)
-        expect(onContactAdded).toBeCalledTimes(2)
+        expect(onContactAdded).toHaveBeenCalledTimes(2)
         expect(list.getClosestContacts().length).toEqual(2)
     })
 

package/test/unit/StoreManager.test.ts

@@ -1,26 +1,26 @@
-import { wait, waitForCondition } from '@streamr/utils'
+import { wait, until } from '@streamr/utils'
 import { range, without } from 'lodash'
 import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
 import { StoreManager } from '../../src/dht/store/StoreManager'
 import {
     DhtAddress,
-    createRandomDhtAddress,
-    getDhtAddressFromRaw,
-    getRawFromDhtAddress
+    randomDhtAddress,
+    toDhtAddress,
+    toDhtAddressRaw
 } from '../../src/identifiers'
-import { PeerDescriptor, ReplicateDataRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor, ReplicateDataRequest } from '../../generated/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const NODE_COUNT = 10
 
 const DATA_ENTRY = {
-    key: getRawFromDhtAddress(createRandomDhtAddress()),
-    creator: getRawFromDhtAddress(createRandomDhtAddress())
+    key: toDhtAddressRaw(randomDhtAddress()),
+    creator: toDhtAddressRaw(randomDhtAddress())
 }
 const ALL_NODES = range(NODE_COUNT).map(() => createMockPeerDescriptor())
 
 const getNodeCloseToData = (distanceIndex: number) => {
-    const dataKey = getDhtAddressFromRaw(DATA_ENTRY.key)
+    const dataKey = toDhtAddress(DATA_ENTRY.key)
     return getClosestNodes(dataKey, ALL_NODES)[distanceIndex]
 }
 
@@ -42,7 +42,7 @@ describe('StoreManager', () => {
                 recursiveOperationManager: undefined as any,
                 localPeerDescriptor,
                 localDataStore: { 
-                    keys: () => [getDhtAddressFromRaw(DATA_ENTRY.key)],
+                    keys: () => [toDhtAddress(DATA_ENTRY.key)],
                     values: () => [DATA_ENTRY],
                     setAllEntriesAsStale 
                 } as any,
@@ -67,10 +67,10 @@ describe('StoreManager', () => {
                     setAllEntriesAsStale
                 )
                 manager.onContactAdded(getNodeCloseToData(2))
-                await waitForCondition(() => replicateData.mock.calls.length === 1)
+                await until(() => replicateData.mock.calls.length === 1)
                 expect(replicateData).toHaveBeenCalledWith({
                     entry: DATA_ENTRY
-                })
+                }, true)
                 expect(setAllEntriesAsStale).not.toHaveBeenCalled()
             })
     
@@ -123,7 +123,7 @@ describe('StoreManager', () => {
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
                 expect(setAllEntriesAsStale).toHaveBeenCalledTimes(1)
-                expect(setAllEntriesAsStale).toHaveBeenCalledWith(getDhtAddressFromRaw(DATA_ENTRY.key))
+                expect(setAllEntriesAsStale).toHaveBeenCalledWith(toDhtAddress(DATA_ENTRY.key))
             })
 
             it('this node is within redundancy factor, the node has less than redundancyFactor neighbors', async () => {

package/test/unit/StoreRpcLocal.test.ts

@@ -1,7 +1,7 @@
 import { range } from 'lodash'
 import { StoreRpcLocal } from '../../src/dht/store/StoreRpcLocal'
-import { areEqualPeerDescriptors, createRandomDhtAddress, DhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../src/identifiers'
-import { DataEntry, PeerDescriptor, StoreDataRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { areEqualPeerDescriptors, randomDhtAddress, DhtAddress, toDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
+import { DataEntry, PeerDescriptor, StoreDataRequest } from '../../generated/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
 import { wait } from '@streamr/utils'
@@ -10,14 +10,14 @@ describe('StoreRpcLocal', () => {
 
     const NODE_COUNT = 5
     const DATA_ENTRY = {
-        key: getRawFromDhtAddress(createRandomDhtAddress()),
-        creator: getRawFromDhtAddress(createRandomDhtAddress())
+        key: toDhtAddressRaw(randomDhtAddress()),
+        creator: toDhtAddressRaw(randomDhtAddress())
     }
 
     const ALL_NODES = range(NODE_COUNT).map(() => createMockPeerDescriptor())
 
     const getNodeCloseToData = (distanceIndex: number) => {
-        const dataKey = getDhtAddressFromRaw(DATA_ENTRY.key)
+        const dataKey = toDhtAddress(DATA_ENTRY.key)
         return getClosestNodes(dataKey, ALL_NODES)[distanceIndex]
     }
 
@@ -41,7 +41,7 @@ describe('StoreRpcLocal', () => {
                 } as any,
                 localPeerDescriptor,
                 replicateDataToContact,
-                getStorers: () => getClosestNodes(getDhtAddressFromRaw(DATA_ENTRY.key), ALL_NODES)
+                getStorers: () => getClosestNodes(toDhtAddress(DATA_ENTRY.key), ALL_NODES)
             })
         })
 
@@ -76,7 +76,7 @@ describe('StoreRpcLocal', () => {
                 } as any,
                 localPeerDescriptor,
                 replicateDataToContact,
-                getStorers: () => getClosestNodes(getDhtAddressFromRaw(DATA_ENTRY.key), ALL_NODES)
+                getStorers: () => getClosestNodes(toDhtAddress(DATA_ENTRY.key), ALL_NODES)
             })
         })
 
@@ -110,7 +110,7 @@ describe('StoreRpcLocal', () => {
                 } as any,
                 localPeerDescriptor,
                 replicateDataToContact,
-                getStorers: () => getClosestNodes(getDhtAddressFromRaw(DATA_ENTRY.key), ALL_NODES)
+                getStorers: () => getClosestNodes(toDhtAddress(DATA_ENTRY.key), ALL_NODES)
                     .filter((peerDescriptor) => !areEqualPeerDescriptors(peerDescriptor, localPeerDescriptor))
             })
         })
@@ -147,7 +147,7 @@ describe('StoreRpcLocal', () => {
                 } as any,
                 localPeerDescriptor,
                 replicateDataToContact,
-                getStorers: () => getClosestNodes(getDhtAddressFromRaw(DATA_ENTRY.key), ALL_NODES)
+                getStorers: () => getClosestNodes(toDhtAddress(DATA_ENTRY.key), ALL_NODES)
             })
         })
 

package/test/unit/WebrtcConnection.test.ts

@@ -0,0 +1,29 @@
+import { waitForEvent3 } from '@streamr/utils'
+import { NodeWebrtcConnection } from '../../src/connection/webrtc/NodeWebrtcConnection'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { ConnectionEvents } from '../../src/connection/IConnection'
+
+describe('WebrtcConnection', () => {
+
+    let connection: NodeWebrtcConnection
+
+    beforeEach(() => {
+        const peerDescriptor = createMockPeerDescriptor()
+        connection = new NodeWebrtcConnection({
+            remotePeerDescriptor: peerDescriptor
+        })
+    })
+
+    afterEach(() => {
+        connection.close(true)
+    })
+
+    it('Disconnects early if remote descriptor is not set', async () => {
+        connection.start(true)
+        await waitForEvent3<ConnectionEvents>(connection as any, 'disconnected', 5001, (_graceful: boolean, _code: number, reason: string) => {
+            expect(reason).toBe('timed out due to remote descriptor not being set')
+            return true
+        })
+    })
+
+})

package/test/unit/WebsocketClientConnector.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable max-len */
 import { WebsocketClientConnector } from '../../src/connection/websocket/WebsocketClientConnector'
-import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { NodeType } from '../../generated/packages/dht/protos/DhtRpc'
 import { MockConnection } from '../utils/mock/MockConnection'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 import { createMockPeerDescriptor } from '../utils/utils'

package/test/unit/WebsocketServerConnector.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable max-len */
 import { WebsocketServerConnector } from '../../src/connection/websocket/WebsocketServerConnector'
-import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { NodeType } from '../../generated/packages/dht/protos/DhtRpc'
 import { MockConnection } from '../utils/mock/MockConnection'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 import { createMockPeerDescriptor } from '../utils/utils'

package/test/unit/connectivityRequestHandler.test.ts

@@ -1,11 +1,11 @@
-import { ipv4ToNumber, waitForCondition } from '@streamr/utils'
+import { ipv4ToNumber, until } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { once } from 'events'
 import { Server as HttpServer, createServer as createHttpServer } from 'http'
 import { server as WsServer } from 'websocket'
 import { CONNECTIVITY_CHECKER_SERVICE_ID } from '../../src/connection/connectivityChecker'
 import { attachConnectivityRequestHandler } from '../../src/connection/connectivityRequestHandler'
-import { Message } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message } from '../../generated/packages/dht/protos/DhtRpc'
 import { LOCAL_PROTOCOL_VERSION } from '../../src/helpers/version'
 
 const HOST = '127.0.0.1'
@@ -48,7 +48,7 @@ describe('connectivityRequestHandler', () => {
         }
         connection.emit('data', Message.toBinary(request))
 
-        await waitForCondition(() => connection.send.mock.calls.length > 0)
+        await until(() => connection.send.mock.calls.length > 0)
 
         const receivedMessage = Message.fromBinary(connection.send.mock.calls[0][0])
         expect(receivedMessage).toEqual({
@@ -62,7 +62,7 @@ describe('connectivityRequestHandler', () => {
                         tls: false
                     },
                     ipAddress: ipv4ToNumber(HOST),
-                    version: LOCAL_PROTOCOL_VERSION
+                    protocolVersion: LOCAL_PROTOCOL_VERSION
                 },
                 oneofKind: 'connectivityResponse'
             },
@@ -83,7 +83,7 @@ describe('connectivityRequestHandler', () => {
         }
         connection.emit('data', Message.toBinary(request))
 
-        await waitForCondition(() => connection.send.mock.calls.length > 0)
+        await until(() => connection.send.mock.calls.length > 0)
 
         const receivedMessage = Message.fromBinary(connection.send.mock.calls[0][0])
         expect(receivedMessage).toEqual({
@@ -92,7 +92,7 @@ describe('connectivityRequestHandler', () => {
                     host: HOST,
                     natType: 'unknown',
                     ipAddress: ipv4ToNumber(HOST),
-                    version: LOCAL_PROTOCOL_VERSION
+                    protocolVersion: LOCAL_PROTOCOL_VERSION
                 },
                 oneofKind: 'connectivityResponse'
             },

package/test/unit/createPeerDescriptor.test.ts

@@ -1,8 +1,8 @@
 import { ipv4ToNumber } from '@streamr/utils'
 import { createPeerDescriptor } from '../../src/helpers/createPeerDescriptor'
 import { isBrowserEnvironment } from '../../src/helpers/browser/isBrowserEnvironment'
-import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+import { NodeType } from '../../generated/packages/dht/protos/DhtRpc'
+import { randomDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
 import { getRandomRegion } from '../../dist/src/connection/simulator/pings'
 
 const IP_ADDRESS = '1.2.3.4'
@@ -52,13 +52,13 @@ describe('createPeerDescriptor', () => {
     })
 
     it('explicit nodeId', () => {
-        const nodeId = createRandomDhtAddress()
+        const nodeId = randomDhtAddress()
         const connectivityResponse = {
             ipAddress: ipv4ToNumber(IP_ADDRESS)
         } as any
         const peerDescriptor = createPeerDescriptor(connectivityResponse, region, nodeId)
         expect(peerDescriptor).toEqual({
-            nodeId: getRawFromDhtAddress(nodeId),
+            nodeId: toDhtAddressRaw(nodeId),
             type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
             ipAddress: ipv4ToNumber(IP_ADDRESS),
             publicKey: expect.any(Uint8Array),

package/test/unit/customMatchers.test.ts

@@ -13,4 +13,22 @@ describe('custom matchers', () => {
     it('no match', () => {
         expect(createMockPeerDescriptor()).not.toEqualPeerDescriptor(createMockPeerDescriptor())
     })
+
+    describe('error message', () => {
+
+        it('normal', () => {
+            const actual = createMockPeerDescriptor()
+            const expected = createMockPeerDescriptor()
+            expect(() => {
+                expect(actual).toEqualPeerDescriptor(expected)
+            }).toThrow('PeerDescriptor nodeId values don\'t match')
+        })
+
+        it('inverse', () => {
+            const peerDescriptor = createMockPeerDescriptor()
+            expect(() => {
+                expect(peerDescriptor).not.toEqualPeerDescriptor(peerDescriptor)
+            }).toThrow('PeerDescriptors are equal')
+        })
+    })
 })

package/test/unit/getClosestNodes.test.ts

@@ -1,7 +1,7 @@
 import { range, sampleSize, sortBy } from 'lodash'
 import { getDistance } from '../../src/dht/PeerManager'
 import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
-import { DhtAddress, createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
+import { DhtAddress, randomDhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { PeerDescriptor } from '../../src/exports'
 
@@ -9,8 +9,8 @@ describe('getClosestNodes', () => {
 
     it('happy path', () => {
         const peerDescriptors = range(10).map(() => createMockPeerDescriptor())
-        const referenceId = createRandomDhtAddress()
-        const excluded = new Set<DhtAddress>(sampleSize(peerDescriptors.map((n) => getNodeIdFromPeerDescriptor(n), 2)))
+        const referenceId = randomDhtAddress()
+        const excluded = new Set<DhtAddress>(sampleSize(peerDescriptors.map((n) => toNodeId(n)), 2))
 
         const actual = getClosestNodes(
             referenceId,
@@ -22,8 +22,8 @@ describe('getClosestNodes', () => {
         )
 
         const expected = sortBy(
-            peerDescriptors.filter((n) => !excluded.has(getNodeIdFromPeerDescriptor(n))),
-            (peerDescriptor: PeerDescriptor) => getDistance(peerDescriptor.nodeId, getRawFromDhtAddress(referenceId))
+            peerDescriptors.filter((n) => !excluded.has(toNodeId(n))),
+            (peerDescriptor: PeerDescriptor) => getDistance(peerDescriptor.nodeId, toDhtAddressRaw(referenceId))
         ).slice(0, 5)
         expect(actual).toEqual(expected)
     })