@streamr/trackerless-network 101.1.2 → 102.0.0-beta.1

package/test/integration/stream-without-default-entrypoints.test.ts

@@ -1,9 +1,10 @@
 import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
+import { randomUserId } from '@streamr/test-utils'
+import { StreamPartIDUtils, hexToBinary, toUserIdRaw, utf8ToBinary, until } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-import { ContentType, EncryptionType, SignatureType, StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ContentType, EncryptionType, SignatureType, StreamMessage } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
@@ -21,7 +22,7 @@ describe('stream without default entrypoints', () => {
             streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
             timestamp: 666,
             sequenceNumber: 0,
-            publisherId: hexToBinary('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'),
+            publisherId: toUserIdRaw(randomUserId()),
             messageChainId: 'msgChainId'
         },
         previousMessageRef: {
@@ -85,7 +86,7 @@ describe('stream without default entrypoints', () => {
             receivedMessageCount += 1
         })
         await Promise.all([
-            waitForCondition(() => receivedMessageCount === 1, 10000),
+            until(() => receivedMessageCount === 1, 10000),
             nodes[1].broadcast(streamMessage)
         ])
     })
@@ -95,7 +96,7 @@ describe('stream without default entrypoints', () => {
             receivedMessageCount += 1
         })
         await Promise.all([
-            waitForCondition(() => receivedMessageCount === 1, 15000),
+            until(() => receivedMessageCount === 1, 15000),
             nodes[0].join(STREAM_PART_ID),
             nodes[1].broadcast(streamMessage),
         ])
@@ -111,14 +112,14 @@ describe('stream without default entrypoints', () => {
         }))
         const nonjoinedNode = nodes[subscriberCount]
         await nonjoinedNode.broadcast(streamMessage)
-        await waitForCondition(() => receivedMessageCount === subscriberCount, 15000)
+        await until(() => receivedMessageCount === subscriberCount, 15000)
     }, 45000)
 
     it('nodes store themselves as entrypoints on streamPart if number of entrypoints is low', async () => {
         for (let i = 0; i < 10; i++) {
             await nodes[i].join(STREAM_PART_ID, { minCount: (i > 0) ? 1 : 0, timeout: 15000 })
         }
-        await waitForCondition(async () => {
+        await until(async () => {
             const entryPointData = await nodes[15].stack.getControlLayerNode().fetchDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
             return entryPointData.length >= 7
         }, 15000)

package/test/integration/streamEntryPointReplacing.test.ts

@@ -1,10 +1,10 @@
 import { LatencyType, Simulator, SimulatorTransport } from '@streamr/dht'
-import { randomEthereumAddress } from '@streamr/test-utils'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, until } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
 import { MAX_NODE_COUNT } from '../../src/logic/PeerDescriptorStoreManager'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 describe('Stream Entry Points are replaced when known entry points leave streams', () => {
     
@@ -82,16 +82,16 @@ describe('Stream Entry Points are replaced when known entry points leave streams
         }
 
         await Promise.all(initialNodesOnStream.map((node) => node.getContentDeliveryManager().leaveStreamPart(STREAM_PART_ID)))
-        await waitForCondition(() => 
+        await until(() => 
             laterNodesOnStream.every((node) => node.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length >= 4), 60000, 1000
         )
 
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
             STREAM_PART_ID,
-            randomEthereumAddress()
+            randomUserId()
         )
         newNodeInStream.getContentDeliveryManager().broadcast(msg)
-        await waitForCondition(() => receivedMessages === NUM_OF_LATER_NODES, 30000)
+        await until(() => receivedMessages === NUM_OF_LATER_NODES, 30000)
     }, 200000)
 })

package/test/types/global.d.ts

@@ -0,0 +1 @@
+import '@streamr/test-utils/customMatcherTypes'

package/test/unit/ContentDeliveryLayerNode.test.ts

@@ -1,5 +1,5 @@
-import { getNodeIdFromPeerDescriptor } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { toNodeId } from '@streamr/dht'
+import { StreamPartIDUtils, until } from '@streamr/utils'
 import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { NodeList } from '../../src/logic/NodeList'
 import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
@@ -22,7 +22,7 @@ describe('ContentDeliveryLayerNode', () => {
     let discoveryLayerNode: MockDiscoveryLayerNode
 
     beforeEach(async () => {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
 
         neighbors = new NodeList(nodeId, 10)
         randomNodeView = new NodeList(nodeId, 10)
@@ -54,14 +54,14 @@ describe('ContentDeliveryLayerNode', () => {
         const mockRemote = createMockContentDeliveryRpcRemote()
         neighbors.add(mockRemote)
         const result = contentDeliveryLayerNode.getNeighbors()
-        expect(getNodeIdFromPeerDescriptor(result[0])).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
+        expect(toNodeId(result[0])).toEqual(toNodeId(mockRemote.getPeerDescriptor()))
     })
 
     it('getNearbyNodeView', () => {
         const mockRemote = createMockContentDeliveryRpcRemote()
         nearbyNodeView.add(mockRemote)
         const ids = contentDeliveryLayerNode.getNearbyNodeView().getIds()
-        expect(ids[0]).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
+        expect(ids[0]).toEqual(toNodeId(mockRemote.getPeerDescriptor()))
     })
 
     it('Adds Closest Nodes from layer1 nearbyContactAdded event to nearbyNodeView', async () => {
@@ -69,9 +69,9 @@ describe('ContentDeliveryLayerNode', () => {
         const peerDescriptor2 = createMockPeerDescriptor()
         discoveryLayerNode.setClosestContacts([peerDescriptor1, peerDescriptor2])
         discoveryLayerNode.emit('nearbyContactAdded', peerDescriptor1)
-        await waitForCondition(() => nearbyNodeView.size() === 2)
-        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        await until(() => nearbyNodeView.size() === 2)
+        expect(nearbyNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
+        expect(nearbyNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
     })
 
     it('Adds Random Nodes from layer1 randomContactAdded event to randomNodeView', async () => {
@@ -79,9 +79,9 @@ describe('ContentDeliveryLayerNode', () => {
         const peerDescriptor2 = createMockPeerDescriptor()
         discoveryLayerNode.setRandomContacts([peerDescriptor1, peerDescriptor2])
         discoveryLayerNode.emit('randomContactAdded', peerDescriptor1)
-        await waitForCondition(() => randomNodeView.size() === 2)
-        expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        await until(() => randomNodeView.size() === 2)
+        expect(randomNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
+        expect(randomNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
     })
 
     it('Adds Nodes from layer1 neighbors to nearbyNodeView if its size is below nodeViewSize', async () => {
@@ -90,11 +90,23 @@ describe('ContentDeliveryLayerNode', () => {
         discoveryLayerNode.addNewRandomPeerToKBucket()
         discoveryLayerNode.setClosestContacts([peerDescriptor1, peerDescriptor2])
         discoveryLayerNode.emit('nearbyContactAdded', peerDescriptor1)
-        await waitForCondition(() => {
+        await until(() => {
             return nearbyNodeView.size() === 3
         }, 20000)
-        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        expect(nearbyNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
+        expect(nearbyNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
     }, 25000)
 
+    it('getInfo', () => {
+        const nodeWithRtt = createMockContentDeliveryRpcRemote()
+        neighbors.add(nodeWithRtt)
+        const nodeWithoutRtt = createMockContentDeliveryRpcRemote()
+        neighbors.add(nodeWithoutRtt)
+        nodeWithRtt.setRtt(100)
+        const info = contentDeliveryLayerNode.getInfos()
+        expect(info[0].rtt).toEqual(100)
+        expect(info[0].peerDescriptor).toEqual(nodeWithRtt.getPeerDescriptor())
+        expect(info[1].rtt).toBeUndefined()
+        expect(info[1].peerDescriptor).toEqual(nodeWithoutRtt.getPeerDescriptor())
+    })
 })

package/test/unit/ContentDeliveryManager.test.ts

@@ -1,11 +1,11 @@
 import { areEqualPeerDescriptors } from '@streamr/dht'
-import { randomEthereumAddress } from '@streamr/test-utils'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, until } from '@streamr/utils'
 import { ContentDeliveryManager } from '../../src/logic/ContentDeliveryManager'
-import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyDirection } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { MockControlLayerNode } from '../utils/mock/MockControlLayerNode'
 import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor, createStreamMessage, mockConnectionLocker } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 describe('ContentDeliveryManager', () => {
 
@@ -23,7 +23,8 @@ describe('ContentDeliveryManager', () => {
     })
 
     it('PeerDescriptor is correct', () => {
-        expect(areEqualPeerDescriptors(peerDescriptor, manager.getPeerDescriptor()))
+        // TODO could use toEqualPeerDescriptor from dht package if we export that custom matcher
+        expect(areEqualPeerDescriptors(peerDescriptor, manager.getPeerDescriptor())).toBe(true)
     })
 
     describe('join and leave', () => {
@@ -32,7 +33,7 @@ describe('ContentDeliveryManager', () => {
         const message = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
             streamPartId,
-            randomEthereumAddress()
+            randomUserId()
         )
 
         beforeEach(async () => {
@@ -53,7 +54,7 @@ describe('ContentDeliveryManager', () => {
 
         it('broadcast joins stream', async () => {
             manager.broadcast(message)
-            await waitForCondition(() => manager.hasStreamPart(streamPartId))
+            await until(() => manager.hasStreamPart(streamPartId))
         })
     })
 
@@ -61,7 +62,7 @@ describe('ContentDeliveryManager', () => {
         it('happy path', async () => {
             const streamPartId = StreamPartIDUtils.parse('stream#0')
             const proxy = createMockPeerDescriptor()
-            const userId = randomEthereumAddress()
+            const userId = randomUserId()
             await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
             expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
             await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
@@ -71,7 +72,7 @@ describe('ContentDeliveryManager', () => {
         it('empty node list', async () => {
             const streamPartId = StreamPartIDUtils.parse('stream#0')
             const proxy = createMockPeerDescriptor()
-            const userId = randomEthereumAddress()
+            const userId = randomUserId()
             await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
             expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
             await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
@@ -83,7 +84,7 @@ describe('ContentDeliveryManager', () => {
         it('connection count to 0', async () => {
             const streamPartId = StreamPartIDUtils.parse('stream#0')
             const proxy = createMockPeerDescriptor()
-            const userId = randomEthereumAddress()
+            const userId = randomUserId()
             await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId, 0)
             expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
             await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)

package/test/unit/ContentDeliveryRpcLocal.test.ts

@@ -1,10 +1,10 @@
 import { ListeningRpcCommunicator } from '@streamr/dht'
-import { randomEthereumAddress } from '@streamr/test-utils'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { ContentDeliveryRpcLocal } from '../../src/logic/ContentDeliveryRpcLocal'
-import { LeaveStreamPartNotice } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { LeaveStreamPartNotice } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 describe('ContentDeliveryRpcLocal', () => {
 
@@ -16,7 +16,7 @@ describe('ContentDeliveryRpcLocal', () => {
     const message = createStreamMessage(
         JSON.stringify({ hello: 'WORLD' }),
         StreamPartIDUtils.parse('random-graph#0'),
-        randomEthereumAddress()
+        randomUserId()
     )
 
     let mockBroadcast: jest.Mock

package/test/unit/DuplicateMessageDetector.test.ts

@@ -60,10 +60,10 @@ describe('gap handling', () => {
     })
 
     test('gap division', () => {
-        expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(18, 0)))
+        expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(18, 0))).toEqual(true)
         expect(detector.toString()).toEqual('(10|0, 15|0], (18|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
 
-        expect(detector.markAndCheck(new NumberPair(60, 0), new NumberPair(79, 5)))
+        expect(detector.markAndCheck(new NumberPair(60, 0), new NumberPair(79, 5))).toEqual(true)
         expect(detector.toString()).toEqual('(10|0, 15|0], (18|0, 20|0], (40|0, 60|0], (79|5, 80|10], (100|0, Infinity|Infinity]')
     })
 
@@ -84,10 +84,10 @@ describe('gap handling', () => {
     })
 
     test('full contraction', () => {
-        expect(detector.markAndCheck(new NumberPair(40, 0), new NumberPair(80, 10)))
+        expect(detector.markAndCheck(new NumberPair(40, 0), new NumberPair(80, 10))).toEqual(true)
         expect(detector.toString()).toEqual('(10|0, 20|0], (100|0, Infinity|Infinity]')
 
-        expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0)))
+        expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0))).toEqual(true)
         expect(detector.toString()).toEqual('(100|0, Infinity|Infinity]')
     })
 })
@@ -153,28 +153,28 @@ describe('erroneous messages that overlap gaps', () => {
     })
 
     it('completely around gap', () => {
-        expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(30, 0))).toThrowError(GapMisMatchError)
+        expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(30, 0))).toThrow(GapMisMatchError)
     })
 
     it('previousNumber below gap while number in gap', () => {
-        expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(15, 0))).toThrowError(GapMisMatchError)
+        expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(15, 0))).toThrow(GapMisMatchError)
     })
 
     it('previousNumber in gap while number over gap', () => {
-        expect(() => detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 5))).toThrowError(GapMisMatchError)
+        expect(() => detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 5))).toThrow(GapMisMatchError)
     })
 
     it('completely around multiple gaps', () => {
-        expect(() => detector.markAndCheck(new NumberPair(10, 0), new NumberPair(200, 0))).toThrowError(GapMisMatchError)
+        expect(() => detector.markAndCheck(new NumberPair(10, 0), new NumberPair(200, 0))).toThrow(GapMisMatchError)
     })
 })
 
 test('checks that number > previousNumber', () => {
     const detector = new DuplicateMessageDetector()
     expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(1, 0)))
-        .toThrowError(InvalidNumberingError)
+        .toThrow(InvalidNumberingError)
     expect(() => detector.markAndCheck(new NumberPair(5, 5), new NumberPair(5, 5)))
-        .toThrowError(InvalidNumberingError)
+        .toThrow(InvalidNumberingError)
 })
 
 test('lowest gaps get dropped when reaching maximum number of gaps', () => {

package/test/unit/ExternalNetworkRpc.test.ts

@@ -1,10 +1,10 @@
 import { Message } from '@streamr/dht'
 import { ExternalNetworkRpc, SERVICE_ID } from '../../src/logic/ExternalNetworkRpc'
-import { HandshakeRequest, HandshakeResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { HandshakeRequest, HandshakeResponse } from '../../generated/packages/dht/protos/DhtRpc'
 import { MockTransport } from '../utils/mock/MockTransport'
 import { RpcMessage } from '@streamr/proto-rpc'
-import { Any } from '../../src/proto/google/protobuf/any'
-import { HandshakeRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { Any } from '../../generated/google/protobuf/any'
+import { HandshakeRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 
 describe('ExternalNetworkRpc', () => {
 

package/test/unit/HandshakeRpcLocal.test.ts

@@ -1,8 +1,8 @@
-import { DhtAddress, NodeType, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '@streamr/dht'
+import { DhtAddress, NodeType, toNodeId, toDhtAddressRaw } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { NodeList } from '../../src/logic/NodeList'
 import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
-import { InterleaveRequest, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { InterleaveRequest, StreamPartHandshakeRequest } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { createMockContentDeliveryRpcRemote, createMockHandshakeRpcRemote, createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
@@ -19,7 +19,7 @@ describe('HandshakeRpcLocal', () => {
     let handshakeWithInterleaving: jest.Mock
 
     beforeEach(() => {
-        neighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), 10)
+        neighbors = new NodeList(toNodeId(localPeerDescriptor), 10)
         ongoingHandshakes = new Set()
         ongoingInterleaves = new Set()
         handshakeWithInterleaving = jest.fn()
@@ -86,20 +86,7 @@ describe('HandshakeRpcLocal', () => {
     it('handshakeWithInterleaving success', async () => {
         const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
-                nodeId: getRawFromDhtAddress('0x2222' as DhtAddress),
-                type: NodeType.NODEJS
-            }
-        }
-        await rpcLocal.interleaveRequest(req, {
-            incomingSourceDescriptor: createMockPeerDescriptor()
-        } as any)
-        expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
-    })
-
-    it('handshakeWithInterleaving success', async () => {
-        const req: InterleaveRequest = {
-            interleaveTargetDescriptor: {
-                nodeId: getRawFromDhtAddress('0x2222' as DhtAddress),
+                nodeId: toDhtAddressRaw('0x2222' as DhtAddress),
                 type: NodeType.NODEJS
             }
         }
@@ -115,7 +102,7 @@ describe('HandshakeRpcLocal', () => {
         neighbors.add(createMockContentDeliveryRpcRemote())
         neighbors.add(createMockContentDeliveryRpcRemote())
         const requestor = createMockPeerDescriptor()
-        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(requestor))
+        ongoingInterleaves.add(toNodeId(requestor))
         const req = StreamPartHandshakeRequest.create({
             streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
@@ -134,9 +121,9 @@ describe('HandshakeRpcLocal', () => {
         neighbors.add(createMockContentDeliveryRpcRemote(interleavingPeer2))
         neighbors.add(createMockContentDeliveryRpcRemote(interleavingPeer3))
         neighbors.add(createMockContentDeliveryRpcRemote())
-        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer1))
-        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer2))
-        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer3))
+        ongoingInterleaves.add(toNodeId(interleavingPeer1))
+        ongoingInterleaves.add(toNodeId(interleavingPeer2))
+        ongoingInterleaves.add(toNodeId(interleavingPeer3))
         const req = StreamPartHandshakeRequest.create({
             streamPartId: STREAM_PART_ID,
             requestId: 'requestId'

package/test/unit/Handshaker.test.ts

@@ -1,4 +1,4 @@
-import { ListeningRpcCommunicator, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ListeningRpcCommunicator, Simulator, SimulatorTransport, toNodeId } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { range } from 'lodash'
 import { NodeList } from '../../src/logic/NodeList'
@@ -28,7 +28,7 @@ describe('Handshaker', () => {
         await simulatorTransport.start()
         const rpcCommunicator = new ListeningRpcCommunicator(streamPartId, simulatorTransport)
 
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         neighbors = new NodeList(nodeId, 10)
         leftNodeView = new NodeList(nodeId, 20)
         rightNodeView = new NodeList(nodeId, 20)

package/test/unit/InspectSession.test.ts

@@ -1,8 +1,8 @@
 import { InspectSession, Events } from '../../src/logic/inspect/InspectSession'
-import { MessageID } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { MessageID } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { waitForEvent3 } from '../../../utils/dist/src/waitForEvent3'
 import { utf8ToBinary } from '@streamr/utils'
-import { DhtAddress, createRandomDhtAddress } from '@streamr/dht'
+import { DhtAddress, randomDhtAddress } from '@streamr/dht'
 
 describe('InspectSession', () => {
 
@@ -30,8 +30,8 @@ describe('InspectSession', () => {
     }
 
     beforeEach(() => {
-        inspectedNode = createRandomDhtAddress()
-        anotherNode = createRandomDhtAddress()
+        inspectedNode = randomDhtAddress()
+        anotherNode = randomDhtAddress()
         inspectSession = new InspectSession({
             inspectedNode
         })
@@ -52,6 +52,7 @@ describe('InspectSession', () => {
         inspectSession.markMessage(anotherNode, messageId1)
         await Promise.all([
             waitForEvent3<Events>(inspectSession, 'done', 100),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             inspectSession.markMessage(inspectedNode, messageId1)
         ])
         expect(inspectSession.getInspectedMessageCount()).toBe(1)
@@ -61,6 +62,7 @@ describe('InspectSession', () => {
         inspectSession.markMessage(inspectedNode, messageId1)
         await Promise.all([
             waitForEvent3<Events>(inspectSession, 'done', 100),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             inspectSession.markMessage(anotherNode, messageId1)
         ])
         expect(inspectSession.getInspectedMessageCount()).toBe(1)
@@ -71,6 +73,7 @@ describe('InspectSession', () => {
         await expect(async () => {
             await Promise.all([
                 waitForEvent3<Events>(inspectSession, 'done', 100),
+                // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
                 inspectSession.markMessage(anotherNode, messageId2)
             ])
         }).rejects.toThrow('waitForEvent3')

package/test/unit/Inspector.test.ts

@@ -1,4 +1,4 @@
-import { ListeningRpcCommunicator, createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ListeningRpcCommunicator, randomDhtAddress, toNodeId } from '@streamr/dht'
 import { StreamPartIDUtils, utf8ToBinary } from '@streamr/utils'
 import { Inspector } from '../../src/logic/inspect/Inspector'
 import { MockTransport } from '../utils/mock/MockTransport'
@@ -11,7 +11,7 @@ describe('Inspector', () => {
 
     const inspectedDescriptor = createMockPeerDescriptor()
 
-    const nodeId = createRandomDhtAddress()
+    const nodeId = randomDhtAddress()
     let mockConnect: jest.Mock
 
     const messageRef = {
@@ -40,12 +40,12 @@ describe('Inspector', () => {
 
     it('Opens inspection connection and runs successfully', async () => {
         setTimeout(() => {
-            inspector.markMessage(getNodeIdFromPeerDescriptor(inspectedDescriptor), messageRef)
+            inspector.markMessage(toNodeId(inspectedDescriptor), messageRef)
             inspector.markMessage(nodeId, messageRef)
         }, 250)
         await inspector.inspect(inspectedDescriptor)
-        expect(inspector.isInspected(getNodeIdFromPeerDescriptor(inspectedDescriptor))).toBe(false)
-        expect(mockConnect).toBeCalledTimes(1)
+        expect(inspector.isInspected(toNodeId(inspectedDescriptor))).toBe(false)
+        expect(mockConnect).toHaveBeenCalledTimes(1)
     })
 
 })

package/test/unit/NeighborFinder.test.ts

@@ -1,14 +1,14 @@
 import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
 import { NodeList } from '../../src/logic/NodeList'
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { range } from 'lodash'
 import { expect } from 'expect'
 import { createMockContentDeliveryRpcRemote } from '../utils/utils'
-import { DhtAddress, createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, randomDhtAddress, toNodeId } from '@streamr/dht'
 
 describe('NeighborFinder', () => {
 
-    const nodeId = createRandomDhtAddress()
+    const nodeId = randomDhtAddress()
     let neighbors: NodeList
     let nearbyNodeView: NodeList
     let neighborFinder: NeighborFinder
@@ -24,7 +24,7 @@ describe('NeighborFinder', () => {
             if (Math.random() < 0.5) {
                 neighbors.add(target!)
             } else {
-                excluded.push(getNodeIdFromPeerDescriptor(target!.getPeerDescriptor()))
+                excluded.push(toNodeId(target!.getPeerDescriptor()))
             }
             return excluded
         }
@@ -45,7 +45,7 @@ describe('NeighborFinder', () => {
 
     it('Finds target number of nodes', async () => {
         neighborFinder.start()
-        await waitForCondition(() => neighbors.size() >= minCount, 10000)
+        await until(() => neighbors.size() >= minCount, 10000)
         expect(neighborFinder.isRunning()).toEqual(false)
     })
 })

package/test/unit/NeighborUpdateRpcLocal.test.ts

@@ -1,11 +1,11 @@
-import { DhtAddress, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, ListeningRpcCommunicator, toNodeId } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { range } from 'lodash'
 import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
 import { NodeList } from '../../src/logic/NodeList'
 import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
 import { NeighborUpdateRpcLocal } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcLocal'
-import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor } from '../utils/utils'
 
@@ -35,8 +35,8 @@ describe('NeighborUpdateRpcLocal', () => {
 
     beforeEach(() => {
         rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
-        neighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), neighborTargetCount + 1)
-        nearbyNodeView = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), neighborTargetCount)
+        neighbors = new NodeList(toNodeId(localPeerDescriptor), neighborTargetCount + 1)
+        nearbyNodeView = new NodeList(toNodeId(localPeerDescriptor), neighborTargetCount)
         neighborFinder = {
             start: jest.fn()
         } as any
@@ -122,12 +122,12 @@ describe('NeighborUpdateRpcLocal', () => {
             removeMe: false
         }, { incomingSourceDescriptor: caller } as any)
         expect(res.removeMe).toEqual(true)
-        expect(neighbors.has(getNodeIdFromPeerDescriptor(caller))).toEqual(false)
+        expect(neighbors.has(toNodeId(caller))).toEqual(false)
     })
 
     it('does not ask to be removed if there is an ongoing handshake to the caller', async () => {
         const caller = createMockPeerDescriptor()
-        ongoingHandshakes.add(getNodeIdFromPeerDescriptor(caller))
+        ongoingHandshakes.add(toNodeId(caller))
         const res = await rpcLocal.neighborUpdate({
             streamPartId,
             neighborDescriptors: [localPeerDescriptor],

package/test/unit/NetworkNode.test.ts

@@ -1,14 +1,14 @@
-import { randomEthereumAddress } from '@streamr/test-utils'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { NetworkNode } from '../../src/NetworkNode'
 import { NetworkStack } from '../../src/NetworkStack'
 import { Events } from '../../src/logic/ContentDeliveryManager'
-import { StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { StreamMessage } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 const STREAM_PART = StreamPartIDUtils.parse('stream#0')
-const PUBLISHER_ID = randomEthereumAddress()
+const PUBLISHER_ID = randomUserId()
 
 const createMessage = (id: number): StreamMessage => {
     return createStreamMessage(`${id}`, STREAM_PART, PUBLISHER_ID)
@@ -33,10 +33,10 @@ describe('NetworkNode', () => {
         contentDeliveryManager.emit('newMessage', msg2)
         expect(onMessage.mock.calls[0][0]).toEqual(msg1)
         expect(onMessage.mock.calls[1][0]).toEqual(msg2)
-        expect(onMessage).toBeCalledTimes(2)
+        expect(onMessage).toHaveBeenCalledTimes(2)
 
         node.removeMessageListener(onMessage)
         contentDeliveryManager.emit('newMessage', createMessage(3))
-        expect(onMessage).toBeCalledTimes(2)
+        expect(onMessage).toHaveBeenCalledTimes(2)
     })
 })