@streamr/dht 100.0.0-testnet-one.4 → 100.0.0-testnet-two.0

package/test/end-to-end/Layer1-Scale-Webrtc.test.ts

@@ -1,24 +1,17 @@
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID } from '../../src/helpers/PeerID'
+import { createMockPeerDescriptor } from '../utils/utils'
 
+const STREAM_ID = 'stream'
+const NUM_OF_NODES = 16
 const NUM_OF_NODES_PER_KBUCKET = 8
 
 describe('Layer1 Scale', () => {
-    const epPeerDescriptor: PeerDescriptor = {
-        nodeId: PeerID.fromString('0').value,
-        type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 43228, tls: false }
-    }
-
-    const STREAM_ID = 'stream'
-
-    const NUM_OF_NODES = 16
 
+    const epPeerDescriptor = createMockPeerDescriptor({
+        websocket: { host: '127.0.0.1', port: 43228, tls: false }
+    })
     let layer0Nodes: DhtNode[]
-
     let layer1Nodes: DhtNode[]
-
     let epLayer0Node: DhtNode
     let epLayer1Node: DhtNode
 

package/test/end-to-end/WebsocketConnectionRequest.test.ts

@@ -1,16 +1,15 @@
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { PeerID } from '../../src/helpers/PeerID'
 import { waitForCondition } from '@streamr/utils'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('Websocket IConnection Requests', () => {
-    const epPeerDescriptor: PeerDescriptor = {
-        nodeId: PeerID.fromString('3').value,
-        type: NodeType.NODEJS,
+
+    const epPeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 10021, tls: false }
-    }
+    })
     let epDhtNode: DhtNode
     let node1: DhtNode
     let node2: DhtNode

package/test/end-to-end/memory-leak.test.ts

@@ -1,30 +1,28 @@
 import LeakDetector from 'jest-leak-detector'
 import { binaryToHex, waitForCondition } from '@streamr/utils'
-import { randomBytes } from 'crypto'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { Message, MessageType, NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message, MessageType } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 const MESSAGE_ID = 'mock-message-id'
 
 describe('memory leak', () => {
 
     it('send message', async () => {
-        const entryPointDescriptor = {
-            nodeId: randomBytes(10),
-            type: NodeType.NODEJS,
+        const entryPointDescriptor = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 11224,
                 tls: false
             }
-        }
+        })
         let entryPoint: DhtNode | undefined = new DhtNode({
             peerId: binaryToHex(entryPointDescriptor.nodeId),
             websocketHost: entryPointDescriptor.websocket!.host,
             websocketPortRange: {
-                min: entryPointDescriptor.websocket.port,
-                max: entryPointDescriptor.websocket.port
+                min: entryPointDescriptor.websocket!.port,
+                max: entryPointDescriptor.websocket!.port
             },
             entryPoints: [entryPointDescriptor],
             websocketServerEnableTls: false

package/test/integration/ConnectionLocking.test.ts

@@ -4,9 +4,9 @@ import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { ITransport } from '../../src/exports'
-import { PeerID } from '../../src/helpers/PeerID'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { getRandomRegion } from '../../dist/src/connection/simulator/pings'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
@@ -20,23 +20,16 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
 
 describe('Connection Locking', () => {
 
-    const mockPeerDescriptor1: PeerDescriptor = {
-        nodeId: PeerID.fromString('mock1').value,
-        type: NodeType.NODEJS,
+    const mockPeerDescriptor1 = createMockPeerDescriptor({
         region: getRandomRegion()
-    }
-    const mockPeerDescriptor2: PeerDescriptor = {
-        nodeId: PeerID.fromString('mock2').value,
-        type: NodeType.NODEJS,
+    })
+    const mockPeerDescriptor2 = createMockPeerDescriptor({
         region: getRandomRegion()
-    }
-
+    })
     let mockConnectorTransport1: ConnectionManager
     let mockConnectorTransport2: ConnectionManager
-
     let connectionManager1: ConnectionManager
     let connectionManager2: ConnectionManager
-
     let simulator: Simulator
 
     beforeEach(async () => {

package/test/integration/ConnectionManager.test.ts

@@ -1,6 +1,5 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { ConnectivityResponse, Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID } from '../../src/helpers/PeerID'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { createPeerDescriptor } from '../../src/dht/DhtNode'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
@@ -8,38 +7,25 @@ import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
 import { SimulatorTransport } from '../../src/exports'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
 import { MarkOptional } from 'ts-essentials'
-import { createRandomNodeId } from '../../src/helpers/nodeId'
 import { TransportEvents } from '../../src/transport/ITransport'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
+
+const SERVICE_ID = 'demo'
 
 const logger = new Logger(module)
 
 // TODO: refactor this test file to use beforeEach and AfterEach for proper teardown
 describe('ConnectionManager', () => {
-    const serviceId = 'demo'
-
-    const mockPeerDescriptor1: PeerDescriptor = {
-        nodeId: PeerID.fromString('tester1').value,
-        type: NodeType.NODEJS
-    }
-    const mockPeerDescriptor2: PeerDescriptor = {
-        nodeId: PeerID.fromString('tester2').value,
-        type: NodeType.NODEJS
-    }
 
-    const mockPeerDescriptor3: PeerDescriptor = {
-        nodeId: PeerID.fromString('tester3').value,
-        type: NodeType.NODEJS
-    }
-    const mockPeerDescriptor4: PeerDescriptor = {
-        nodeId: PeerID.fromString('tester4').value,
-        type: NodeType.NODEJS
-    }
+    const mockPeerDescriptor1 = createMockPeerDescriptor()
+    const mockPeerDescriptor2 = createMockPeerDescriptor()
+    const mockPeerDescriptor3 = createMockPeerDescriptor()
+    const mockPeerDescriptor4 = createMockPeerDescriptor()
     const simulator = new Simulator()
-
     const mockTransport = new SimulatorTransport(mockPeerDescriptor1, simulator)
     const mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
     const mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)
-
     let createLocalPeerDescriptor: jest.Mock<PeerDescriptor, [ConnectivityResponse]>
 
     const createConnectionManager = (opts: MarkOptional<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
@@ -85,12 +71,13 @@ describe('ConnectionManager', () => {
 
     it('Throws an async exception if fails to connect to entrypoints', async () => {
 
+        const entryPoint = createMockPeerDescriptor({
+            websocket: { host: '127.0.0.1', port: 12345, tls: false }
+        })
         const connectionManager = createConnectionManager({
             transport: mockTransport,
             websocketPortRange: { min: 9992, max: 9992 },
-            entryPoints: [
-                { nodeId: Uint8Array.from([1, 2, 3]), type: NodeType.NODEJS, websocket: { host: '127.0.0.1', port: 12345, tls: false } }
-            ]
+            entryPoints: [entryPoint]
         })
 
         await expect(connectionManager.start()).rejects.toThrow('Failed to connect to the entrypoints')
@@ -108,12 +95,13 @@ describe('ConnectionManager', () => {
         await connectionManager1.start()
         expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
 
+        const entryPoint = createMockPeerDescriptor({
+            websocket: { host: '127.0.0.1', port: 9993, tls: false } 
+        })
         const connectionManager2 = createConnectionManager({
             transport: mockConnectorTransport2,
             websocketPortRange: { min: 9994, max: 9994 },
-            entryPoints: [
-                { nodeId: Uint8Array.from([1, 2, 3]), type: NodeType.NODEJS, websocket: { host: '127.0.0.1', port: 9993, tls: false } }
-            ]
+            entryPoints: [entryPoint]
         })
 
         await connectionManager2.start()
@@ -145,7 +133,7 @@ describe('ConnectionManager', () => {
         expect(createLocalPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
 
         const msg: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             messageType: MessageType.RPC,
             messageId: '1',
             body: {
@@ -204,7 +192,7 @@ describe('ConnectionManager', () => {
         await connectionManager2.start()
 
         const msg: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             messageType: MessageType.RPC,
             messageId: '1',
             body: {
@@ -255,7 +243,7 @@ describe('ConnectionManager', () => {
         await connectionManager4.start()
 
         const msg: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             messageType: MessageType.RPC,
             messageId: '1',
             body: {
@@ -319,7 +307,7 @@ describe('ConnectionManager', () => {
         const peerDescriptor = connectionManager1.getLocalPeerDescriptor()
         peerDescriptor.nodeId = new Uint8Array([12, 12, 12, 12])
         const msg: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             messageType: MessageType.RPC,
             messageId: '1',
             targetDescriptor: peerDescriptor,
@@ -337,25 +325,20 @@ describe('ConnectionManager', () => {
 
     it('Cannot send to a WebSocketServer if nodeIds do not match', async () => {
 
-        const peerDescriptor1 = {
-            nodeId: createRandomNodeId(),
-            type: NodeType.NODEJS,
+        const peerDescriptor1 = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 10002,
                 tls: false
             }
-        }
-
-        const peerDescriptor2 = {
-            nodeId: createRandomNodeId(),
-            type: NodeType.NODEJS,
+        })
+        const peerDescriptor2 = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 10003,
                 tls: false
             }
-        }
+        })
         const connectionManager1 = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
@@ -375,12 +358,12 @@ describe('ConnectionManager', () => {
         await connectionManager2.start()
 
         const msg: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             messageType: MessageType.RPC,
             messageId: '1',
             targetDescriptor: {
                 // This is not the correct nodeId of peerDescriptor2
-                nodeId: new Uint8Array([1, 2, 3, 4]),
+                nodeId: createRandomNodeId(),
                 type: NodeType.NODEJS,
                 websocket: peerDescriptor2.websocket
             },

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -1,24 +1,19 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createMockConnectionDhtNode } from '../utils/utils'
+import { createMockConnectionDhtNode, createMockPeerDescriptor } from '../utils/utils'
 
 const NUM_OF_NODES_PER_KBUCKET = 8
 
 const runTest = async (latencyType: LatencyType) => {
     const simulator = new Simulator(latencyType)
-    const entryPointId = '0'
-    const entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, NUM_OF_NODES_PER_KBUCKET)
-    const entrypointDescriptor = {
-        nodeId: entryPoint.getNodeId().value,
-        type: NodeType.NODEJS,
+    const entrypointDescriptor = createMockPeerDescriptor({
         region: getRandomRegion()
-    }
+    })
+    const entryPoint = await createMockConnectionDhtNode(simulator, entrypointDescriptor.nodeId, NUM_OF_NODES_PER_KBUCKET)
     const nodes: DhtNode[] = []
     for (let i = 1; i < 100; i++) {
-        const nodeId = `${i}`
-        const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, NUM_OF_NODES_PER_KBUCKET)
+        const node = await createMockConnectionDhtNode(simulator, undefined, NUM_OF_NODES_PER_KBUCKET)
         nodes.push(node)
     }
 

package/test/integration/DhtNodeExternalAPI.test.ts

@@ -1,10 +1,9 @@
-import { DhtNode } from '../../src/dht/DhtNode'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { createMockConnectionDhtNode, createMockPeerDescriptor } from '../utils/utils'
-import { Any } from '../../src/proto/google/protobuf/any'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { createRandomNodeId } from '../../src/helpers/nodeId'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { createRandomNodeId, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
+import { createMockConnectionDhtNode } from '../utils/utils'
 
 describe('DhtNodeExternalApi', () => {
 
@@ -14,8 +13,8 @@ describe('DhtNodeExternalApi', () => {
 
     beforeEach(async () => {
         simulator = new Simulator(LatencyType.NONE)
-        dhtNode1 = await createMockConnectionDhtNode('node1', simulator)
-        remote = await createMockConnectionDhtNode('remote', simulator)
+        dhtNode1 = await createMockConnectionDhtNode(simulator)
+        remote = await createMockConnectionDhtNode(simulator)
         await dhtNode1.joinDht([dhtNode1.getLocalPeerDescriptor()])
     })
 
@@ -28,12 +27,10 @@ describe('DhtNodeExternalApi', () => {
     })
 
     it('findData happy path', async () => {
-        const data = Any.pack(dhtNode1.getLocalPeerDescriptor(), PeerDescriptor)
-        const key = createRandomNodeId()
-        await dhtNode1.storeDataToDht(key, data)
-
-        const foundData = await remote.findDataViaPeer(key, dhtNode1.getLocalPeerDescriptor())
-        expect(Any.unpack(foundData[0].data!, PeerDescriptor)).toEqual(dhtNode1.getLocalPeerDescriptor())
+        const entry = createMockDataEntry()
+        await dhtNode1.storeDataToDht(entry.key, entry.data!)
+        const foundData = await remote.findDataViaPeer(entry.key, dhtNode1.getLocalPeerDescriptor())
+        expectEqualData(foundData[0], entry)
     })
     
     it('findData returns empty array if no data found', async () => {
@@ -42,14 +39,11 @@ describe('DhtNodeExternalApi', () => {
     })
 
     it('external store data happy path', async () => {
-        const storedPeerDescriptor = createMockPeerDescriptor()
-        const data = Any.pack(storedPeerDescriptor, PeerDescriptor)
-        const key = createRandomNodeId()
-
-        await remote.storeDataViaPeer(key, data, dhtNode1.getLocalPeerDescriptor())
-        const foundData = await remote.findDataViaPeer(key, dhtNode1.getLocalPeerDescriptor())
-        expect(areEqualPeerDescriptors(Any.unpack(foundData[0].data!, PeerDescriptor), storedPeerDescriptor)).toEqual(true)
-        expect(areEqualPeerDescriptors(foundData[0].creator!, remote.getLocalPeerDescriptor())).toEqual(true)
+        const entry = createMockDataEntry()
+        await remote.storeDataViaPeer(entry.key, entry.data!, dhtNode1.getLocalPeerDescriptor())
+        const foundData = await remote.findDataViaPeer(entry.key, dhtNode1.getLocalPeerDescriptor())
+        expectEqualData(foundData[0], entry)
+        expect(getNodeIdFromBinary(foundData[0].creator)).toEqual(getNodeIdFromPeerDescriptor(remote.getLocalPeerDescriptor()))
     })
   
 })

package/test/integration/DhtNodeRpcRemote.test.ts

@@ -1,46 +1,37 @@
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
-import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { getMockPeers, MockDhtRpc } from '../utils/utils'
+import { RpcCommunicator } from '@streamr/proto-rpc'
+import { createMockDhtRpc, createMockPeerDescriptor, createMockPeers } from '../utils/utils'
 import {
     ClosestPeersRequest,
     ClosestPeersResponse,
-    NodeType,
-    PeerDescriptor,
     PingRequest,
     PingResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { generateId } from '../utils/utils'
+
+const SERVICE_ID = 'test'
 
 describe('DhtNodeRpcRemote', () => {
 
     let rpcRemote: DhtNodeRpcRemote
     let clientRpcCommunicator: RpcCommunicator
     let serverRpcCommunicator: RpcCommunicator
-    const serviceId = 'test'
-    const clientPeerDescriptor: PeerDescriptor = {
-        nodeId: generateId('client'),
-        type: NodeType.NODEJS
-    }
-    const serverPeerDescriptor: PeerDescriptor = {
-        nodeId: generateId('server'),
-        type: NodeType.NODEJS
-    }
+    const clientPeerDescriptor = createMockPeerDescriptor()
+    const serverPeerDescriptor = createMockPeerDescriptor()
+    const mockDhtRpc = createMockDhtRpc(createMockPeers())
 
     beforeEach(() => {
         clientRpcCommunicator = new RpcCommunicator()
         serverRpcCommunicator = new RpcCommunicator()
-        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
-        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', MockDhtRpc.ping)
+        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
+        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', mockDhtRpc.ping)
         clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             serverRpcCommunicator.handleIncomingMessage(message)
         })
         serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        const client = toProtoRpcClient(new DhtNodeRpcClient(clientRpcCommunicator.getRpcClientTransport()))
-        rpcRemote = new DhtNodeRpcRemote(clientPeerDescriptor, serverPeerDescriptor, client, serviceId)
+        rpcRemote = new DhtNodeRpcRemote(clientPeerDescriptor, serverPeerDescriptor, SERVICE_ID, clientRpcCommunicator)
     })
 
     afterEach(() => {
@@ -55,17 +46,17 @@ describe('DhtNodeRpcRemote', () => {
 
     it('getClosestPeers happy path', async () => {
         const neighbors = await rpcRemote.getClosestPeers(clientPeerDescriptor.nodeId)
-        expect(neighbors.length).toEqual(getMockPeers().length)
+        expect(neighbors.length).toEqual(createMockPeers().length)
     })
 
     it('ping error path', async () => {
-        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', MockDhtRpc.throwPingError)
+        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', mockDhtRpc.throwPingError)
         const active = await rpcRemote.ping()
         expect(active).toEqual(false)
     })
 
     it('getClosestPeers error path', async () => {
-        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.throwGetClosestPeersError)
+        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.throwGetClosestPeersError)
         await expect(rpcRemote.getClosestPeers(clientPeerDescriptor.nodeId))
             .rejects.toThrow('Closest peers error')
     })

package/test/integration/DhtRpc.test.ts

@@ -1,26 +1,21 @@
-import { getMockPeers, MockDhtRpc } from '../utils/utils'
+import { createMockDhtRpc, createMockPeerDescriptor, createMockPeers } from '../utils/utils'
 import { ProtoRpcClient, RpcCommunicator, RpcError, toProtoRpcClient } from '@streamr/proto-rpc'
 import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { generateId } from '../utils/utils'
-import { ClosestPeersRequest, ClosestPeersResponse, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { ClosestPeersRequest, ClosestPeersResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { wait } from '@streamr/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('DhtRpc', () => {
+
     let rpcCommunicator1: RpcCommunicator
     let rpcCommunicator2: RpcCommunicator
     let client1: ProtoRpcClient<DhtNodeRpcClient>
     let client2: ProtoRpcClient<DhtNodeRpcClient>
-
-    const peerDescriptor1: PeerDescriptor = {
-        nodeId: generateId('peer1'),
-        type: NodeType.NODEJS
-    }
-
-    const peerDescriptor2: PeerDescriptor = {
-        nodeId: generateId('peer2'),
-        type: NodeType.NODEJS
-    }
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
+    const neighbors = createMockPeers()
+    const mockDhtRpc = createMockDhtRpc(neighbors)
 
     const outgoingListener2 = (message: RpcMessage) => {
         rpcCommunicator1.handleIncomingMessage(message)
@@ -28,10 +23,10 @@ describe('DhtRpc', () => {
 
     beforeEach(() => {
         rpcCommunicator1 = new RpcCommunicator()
-        rpcCommunicator1.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
+        rpcCommunicator1.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
 
         rpcCommunicator2 = new RpcCommunicator()
-        rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
+        rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
 
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
@@ -57,7 +52,7 @@ describe('DhtRpc', () => {
             }
         )
         const res1 = await response1
-        expect(res1.peers).toEqual(getMockPeers())
+        expect(res1.peers.map((p) => getNodeIdFromPeerDescriptor(p))).toEqual(neighbors.map((n) => getNodeIdFromPeerDescriptor(n)))
 
         const response2 = client2.getClosestPeers(
             { nodeId: peerDescriptor2.nodeId, requestId: '1' },
@@ -67,7 +62,7 @@ describe('DhtRpc', () => {
             }
         )
         const res2 = await response2
-        expect(res2.peers).toEqual(getMockPeers())
+        expect(res2.peers.map((p) => getNodeIdFromPeerDescriptor(p))).toEqual(neighbors.map((n) => getNodeIdFromPeerDescriptor(n)))
     })
 
     it('Default RPC timeout, client side', async () => {
@@ -91,7 +86,7 @@ describe('DhtRpc', () => {
         let timeout: NodeJS.Timeout
 
         async function respondGetClosestPeersWithTimeout(): Promise<ClosestPeersResponse> {
-            const neighbors = getMockPeers()
+            const neighbors = createMockPeers()
             const response: ClosestPeersResponse = {
                 peers: neighbors,
                 requestId: 'why am i still here'

package/test/integration/Find.test.ts

@@ -1,9 +1,13 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor, RecursiveOperation } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
 import { PeerID } from '../../src/helpers/PeerID'
 import { peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { hexToBinary } from '@streamr/utils'
+
+const NUM_NODES = 100
+const K = 2
 
 describe('Find correctness', () => {
 
@@ -11,18 +15,14 @@ describe('Find correctness', () => {
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator(LatencyType.REAL)
-    const NUM_NODES = 100
-    const K = 2
 
     beforeEach(async () => {
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, K)
+        entryPoint = await createMockConnectionDhtNode(simulator, undefined, K)
         nodes.push(entryPoint)
         entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, K, 20, 60000)
+            const node = await createMockConnectionDhtNode(simulator, undefined, K, 20, 60000)
             nodes.push(node)
         }
         await entryPoint.joinDht([entrypointDescriptor])
@@ -38,10 +38,10 @@ describe('Find correctness', () => {
     })
 
     it('Entrypoint can find a node from the network (exact match)', async () => {
-        const nodeIdToFind = nodes[45].getNodeId().value
-        const results = await entryPoint.startFind(nodeIdToFind)
+        const targetId = hexToBinary(nodes[45].getNodeId())
+        const results = await entryPoint.executeRecursiveOperation(targetId, RecursiveOperation.FIND_NODE)
         expect(results.closestNodes.length).toBeGreaterThanOrEqual(5)
-        expect(PeerID.fromValue(nodeIdToFind).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
+        expect(PeerID.fromValue(targetId).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
     }, 30000)
 
 })