@streamr/dht 0.0.1-tatum.5 → 0.0.1-tatum.7

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -4,7 +4,7 @@ import { Simulator } from '../../src/connection/Simulator/Simulator'
 import { PeerID } from '../../src/helpers/PeerID'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { waitForCondition } from '@streamr/utils'
 
 describe('Storing data in DHT with two peers', () => {
@@ -48,13 +48,13 @@ describe('Storing data in DHT with two peers', () => {
 
         const successfulStorers1 = await otherNode.storeDataToDht(dataKey1.value, data1)
         const successfulStorers2 = await entryPoint.storeDataToDht(dataKey2.value, data2)
-        expect(successfulStorers1[0].nodeName).toEqual(entryPoint.getPeerDescriptor().nodeName)
-        expect(successfulStorers2[0].nodeName).toEqual(otherNode.getPeerDescriptor().nodeName)
+        expect(successfulStorers1[0].kademliaId).toStrictEqual(entryPoint.getPeerDescriptor().kademliaId)
+        expect(successfulStorers2[0].kademliaId).toStrictEqual(otherNode.getPeerDescriptor().kademliaId)
 
         const foundData1 = await otherNode.getDataFromDht(dataKey1.value)
         const foundData2 = await entryPoint.getDataFromDht(dataKey2.value)
-        expect(isSamePeerDescriptor(otherNode.getPeerDescriptor(), Any.unpack(foundData1.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
-        expect(isSamePeerDescriptor(entryPoint.getPeerDescriptor(), Any.unpack(foundData2.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(otherNode.getPeerDescriptor(), Any.unpack(foundData1[0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(entryPoint.getPeerDescriptor(), Any.unpack(foundData2[0]!.data!, PeerDescriptor))).toBeTrue()
     })
 
     it('Can store on one peer DHT', async () => {
@@ -63,9 +63,9 @@ describe('Storing data in DHT with two peers', () => {
         const dataKey = PeerID.fromString('data-to-store')
         const data = Any.pack(entryPoint.getPeerDescriptor(), PeerDescriptor)
         const successfulStorers = await entryPoint.storeDataToDht(dataKey.value, data)
-        expect(successfulStorers[0].nodeName).toEqual(entryPoint.getPeerDescriptor().nodeName)
+        expect(successfulStorers[0].kademliaId).toStrictEqual(entryPoint.getPeerDescriptor().kademliaId)
 
         const foundData = await entryPoint.getDataFromDht(dataKey.value)
-        expect(isSamePeerDescriptor(entryPoint.getPeerDescriptor(), Any.unpack(foundData.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(entryPoint.getPeerDescriptor(), Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
     }, 60000)
 })

package/test/integration/WebRtcConnectionManagement.test.ts

@@ -6,7 +6,19 @@ import { PeerID } from '../../src/helpers/PeerID'
 import { ConnectionType } from '../../src/connection/IConnection'
 import { ITransport } from '../../src/transport/ITransport'
 import * as Err from '../../src/helpers/errors'
-import { SimulatorTransport } from '../../src/exports'
+import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
+import { MetricsContext } from '@streamr/utils'
+
+const createConnectionManager = (ownPeerDescriptor: PeerDescriptor, transport: ITransport) => {
+    return new ConnectionManager({
+        createConnectorFacade: () => new DefaultConnectorFacade({
+            transport,
+            createOwnPeerDescriptor: () => ownPeerDescriptor
+        }),
+        metricsContext: new MetricsContext()
+    })
+}
 
 describe('WebRTC Connection Management', () => {
 
@@ -17,32 +29,27 @@ describe('WebRTC Connection Management', () => {
 
     const peerDescriptor1: PeerDescriptor = {
         kademliaId: PeerID.fromString('peer1').value,
-        nodeName: 'peer1',
         type: NodeType.NODEJS,
     }
 
     const peerDescriptor2: PeerDescriptor = {
         kademliaId: PeerID.fromString('peer2').value,
-        nodeName: 'peer2',
         type: NodeType.NODEJS,
     }
 
-    let connectorTransport1: ITransport
-    let connectorTransport2: ITransport
+    let connectorTransport1: SimulatorTransport
+    let connectorTransport2: SimulatorTransport
 
     beforeEach(async () => {
-
         simulator = new Simulator(LatencyType.FIXED, 500)
-
         connectorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        manager1 = new ConnectionManager({ transportLayer: connectorTransport1 })
-
+        await connectorTransport1.start()
+        manager1 = createConnectionManager(peerDescriptor1, connectorTransport1)
         connectorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        manager2 = new ConnectionManager({ transportLayer: connectorTransport2 })
-
-        await manager1.start((_msg) => peerDescriptor1)
-        await manager2.start((_msg) => peerDescriptor2)
-
+        await connectorTransport2.start()
+        manager2 = createConnectionManager(peerDescriptor2, connectorTransport2)
+        await manager1.start()
+        await manager2.start()
     })
 
     afterEach(async () => {
@@ -138,26 +145,26 @@ describe('WebRTC Connection Management', () => {
         })
 
         const connectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('connected', (_peerDescriptor: PeerDescriptor) => {
+            manager1.on('connected', () => {
                 //expect(message.messageType).toBe(MessageType.RPC)
                 resolve()
             })
         })
 
         const connectedPromise2 = new Promise<void>((resolve, _reject) => {
-            manager2.on('connected', (_peerDescriptor: PeerDescriptor) => {
+            manager2.on('connected', () => {
                 resolve()
             })
         })
 
         const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            manager1.on('disconnected', () => {
                 resolve()
             })
         })
 
         const disconnectedPromise2 = new Promise<void>((resolve, _reject) => {
-            manager2.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            manager2.on('disconnected', () => {
                 resolve()
             })
         })
@@ -186,7 +193,7 @@ describe('WebRTC Connection Management', () => {
         }
 
         const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            manager1.on('disconnected', () => {
                 resolve()
             })
         })

package/test/integration/WebRtcConnectorRpc.test.ts

@@ -11,8 +11,6 @@ import {
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { generateId } from '../utils/utils'
 import { IWebRtcConnectorService } from '../../src/proto/packages/dht/protos/DhtRpc.server'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 import { waitForCondition } from '@streamr/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
@@ -45,25 +43,25 @@ describe('WebRTC rpc messages', () => {
         rpcCommunicator1 = new RpcCommunicator()
         const serverFunctions: IWebRtcConnectorService = {
 
-            requestConnection: async (_urequest: WebRtcConnectionRequest, _context: ServerCallContext): Promise<Empty> => {
+            requestConnection: async (): Promise<Empty> => {
                 requestConnectionCounter += 1
                 const res: Empty = {}
                 return res
             },
 
-            rtcOffer: async (_urequest: RtcOffer, _context: ServerCallContext): Promise<Empty> => {
+            rtcOffer: async (): Promise<Empty> => {
                 rtcOfferCounter += 1
                 const res: Empty = {}
                 return res
             },
 
-            rtcAnswer: async (_urequest: RtcAnswer, _context: ServerCallContext): Promise<Empty> => {
+            rtcAnswer: async (): Promise<Empty> => {
                 rtcAnswerCounter += 1
                 const res: Empty = {}
                 return res
             },
 
-            iceCandidate: async (_urequest: IceCandidate, _context: ServerCallContext): Promise<Empty> => {
+            iceCandidate: async (): Promise<Empty> => {
                 iceCandidateCounter += 1
                 const res: Empty = {}
                 return res
@@ -76,11 +74,11 @@ describe('WebRTC rpc messages', () => {
         rpcCommunicator2.registerRpcNotification(IceCandidate, 'iceCandidate', serverFunctions.iceCandidate)
         rpcCommunicator2.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
         })
 
-        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator1.handleIncomingMessage(message)
         })
 

package/test/integration/WebSocket.test.ts

@@ -9,11 +9,13 @@ const logger = new Logger(module)
 
 describe('WebSocket', () => {
 
-    const webSocketServer = new WebSocketServer()
+    const webSocketServer = new WebSocketServer({
+        portRange: { min: 9999, max: 9999 }
+    })
     const clientWebSocket = new ClientWebSocket()
 
     beforeAll(async () => {
-        await webSocketServer.start({ min: 9999, max: 9999 })
+        await webSocketServer.start()
     })
 
     it('Happy path', (done) => {

package/test/integration/WebSocketConnectionManagement.test.ts

@@ -1,15 +1,26 @@
 /* eslint-disable promise/no-nesting */
 
+import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
+import { ConnectionType } from '../../src/connection/IConnection'
 import { Simulator } from '../../src/connection/Simulator/Simulator'
-import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { SimulatorTransport } from '../../src/exports'
 import { PeerID } from '../../src/helpers/PeerID'
-import { ConnectionType } from '../../src/connection/IConnection'
-import { ITransport } from '../../src/transport/ITransport'
 import * as Err from '../../src/helpers/errors'
-import { waitForCondition } from '@streamr/utils'
+import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
+const createConfig = (ownPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createOwnPeerDescriptor'>) => {
+    return {
+        createConnectorFacade: () => new DefaultConnectorFacade({
+            createOwnPeerDescriptor: () => ownPeerDescriptor,
+            ...opts
+        }),
+        metricsContext: new MetricsContext()
+    }
+}
+
 describe('WebSocket Connection Management', () => {
 
     const serviceId = 'test'
@@ -33,28 +44,30 @@ describe('WebSocket Connection Management', () => {
         type: NodeType.NODEJS,
     }
 
-    let connectorTransport1: ITransport
-    let connectorTransport2: ITransport
+    let connectorTransport1: SimulatorTransport
+    let connectorTransport2: SimulatorTransport
 
     beforeEach(async () => {
 
-        connectorTransport1 = new ConnectionManager({ ownPeerDescriptor: wsServerConnectorPeerDescriptor, simulator: simulator })
-        connectorTransport2 = new ConnectionManager({ ownPeerDescriptor: noWsServerConnectorPeerDescriptor, simulator: simulator })
+        connectorTransport1 = new SimulatorTransport(wsServerConnectorPeerDescriptor, simulator)
+        await connectorTransport1.start()
+        connectorTransport2 = new SimulatorTransport(noWsServerConnectorPeerDescriptor, simulator)
+        await connectorTransport2.start()
 
-        const config1 = {
-            transportLayer: connectorTransport1,
+        const config1 = createConfig(wsServerConnectorPeerDescriptor, {
+            transport: connectorTransport1,
             websocketHost: '127.0.0.1',
-            websocketPortRange: { min: 12223, max: 12223 },
-        }
-        const config2 = {
-            transportLayer: connectorTransport2
-        }
+            websocketPortRange: { min: 12223, max: 12223 }
+        })
+        const config2 = createConfig(noWsServerConnectorPeerDescriptor, {
+            transport: connectorTransport2
+        })
 
         wsServerManager = new ConnectionManager(config1)
         noWsServerManager = new ConnectionManager(config2)
 
-        await wsServerManager.start((_response) => wsServerConnectorPeerDescriptor)
-        await noWsServerManager.start((_response) => noWsServerConnectorPeerDescriptor)
+        await wsServerManager.start()
+        await noWsServerManager.start()
     })
 
     afterEach(async () => {

package/test/integration/WebSocketConnectorRpc.test.ts

@@ -8,7 +8,6 @@ import {
     WebSocketConnectionResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { MockWebSocketConnectorRpc } from '../utils/utils'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
 describe('WebSocketConnectorRpc', () => {
@@ -44,11 +43,11 @@ describe('WebSocketConnectorRpc', () => {
             MockWebSocketConnectorRpc.requestConnection
         )
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
         })
 
-        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator1.handleIncomingMessage(message)
         })
 

package/test/unit/DuplicateDetector.test.ts

@@ -3,25 +3,24 @@ import { DuplicateDetector } from '../../src/dht/routing/DuplicateDetector'
 describe('Duplicate Detector', () => {
     let detector: DuplicateDetector
     const maxLimit = 10
-    const senderId = 'sender'
     beforeEach(async () => {
         detector = new DuplicateDetector(maxLimit, 100)
     })
 
     it('detects duplicates', async () => {
-        detector.add('test', senderId)
+        detector.add('test')
         expect(detector.size()).toEqual(1)
         expect(detector.isMostLikelyDuplicate('test')).toEqual(true)
     })
 
     it('resets on resetLimit', () => {
         for (let i = 0; i < maxLimit; i++) {
-            detector.add(`test${i}`, senderId)
+            detector.add(`test${i}`)
         }
         for (let i = 0; i < maxLimit; i++) {
             expect(detector.isMostLikelyDuplicate(`test${i}`)).toEqual(true)
         }
-        detector.add('test10', senderId)
+        detector.add('test10')
         expect(detector.size()).toEqual(10)
         expect(detector.isMostLikelyDuplicate('test0')).toEqual(false)
         expect(detector.isMostLikelyDuplicate('test10')).toEqual(true)

package/test/unit/LocalDataStore.test.ts

@@ -1,7 +1,7 @@
 import { Any } from '../../src/proto/google/protobuf/any'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import {
-    isSamePeerDescriptor,
+    areEqualPeerDescriptors,
     keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../src/helpers/peerIdFromPeerDescriptor'
@@ -13,13 +13,11 @@ describe('LocalDataStore', () => {
     let localDataStore: LocalDataStore
     const storer1: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS,
-        nodeName: 'storer1'
+        type: NodeType.NODEJS
     }
     const storer2: PeerDescriptor = {
         kademliaId: new Uint8Array([3, 2, 1]),
-        type: NodeType.NODEJS,
-        nodeName: 'storer2'
+        type: NodeType.NODEJS
     }
     const data1 = Any.pack(storer1, PeerDescriptor)
     const data2 = Any.pack(storer2, PeerDescriptor)
@@ -39,7 +37,7 @@ describe('LocalDataStore', () => {
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(isSamePeerDescriptor(fetchedDescriptor, storer1)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
         })
     })
 
@@ -52,7 +50,7 @@ describe('LocalDataStore', () => {
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(isSamePeerDescriptor(fetchedDescriptor, storer1)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
         })
     })
 
@@ -66,7 +64,7 @@ describe('LocalDataStore', () => {
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(isSamePeerDescriptor(fetchedDescriptor, storer2)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storer2)).toBeTrue()
         })
     })
 

package/test/unit/RandomContactList.test.ts

@@ -1,92 +1,43 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
-import type { ServiceInfo, MethodInfo } from '@protobuf-ts/runtime-rpc'
 import { PeerID } from '../../src/helpers/PeerID'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { IDhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { LeaveNotice, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { FindDataRequest, FindDataResponse, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { PingRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { ClosestPeersResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { ClosestPeersRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { UnaryCall } from '@protobuf-ts/runtime-rpc'
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc'
-import { DhtPeer } from '../../src/dht/DhtPeer'
-import { IMessageType } from '@protobuf-ts/runtime'
-import { Empty } from '../../src/proto/google/protobuf/empty'
 
-class MockRpcClient implements IDhtRpcServiceClient, ServiceInfo {
-    typeName = 'MockRpcClient'
-    methods: MethodInfo<any, any> [] = [
-        { name: 'getClosestPeers', O: {} as IMessageType<ClosestPeersResponse> } as MethodInfo<any, any>,
-        { name: 'ping', O: {} as IMessageType<PingResponse> } as MethodInfo<any, any>,
-        { name: 'findData', O: {} as IMessageType<FindDataRequest> } as MethodInfo<any, any>,
-        { name: 'leaveNotice', O: {} as IMessageType<Empty> } as MethodInfo<any, any>
-    ]
-    options = {}
-
-    // eslint-disable-next-line class-methods-use-this
-    getClosestPeers(_input: ClosestPeersRequest, _options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse> {
-        return {} as UnaryCall<ClosestPeersRequest, ClosestPeersResponse>
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    ping(_input: PingRequest, _options?: RpcOptions): UnaryCall <PingRequest, PingResponse> {
-        return {} as UnaryCall<PingRequest, PingResponse>
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    findData(_input: FindDataRequest, _options?: RpcOptions): UnaryCall<FindDataRequest, FindDataResponse> {
-        return {} as UnaryCall<FindDataRequest, FindDataResponse>
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    leaveNotice(_input: LeaveNotice, _options?: RpcOptions): UnaryCall<LeaveNotice, Empty> {
-        return {} as UnaryCall<LeaveNotice, Empty>
-    }
-}
-
-const getId = (descriptor: PeerDescriptor): PeerID => {
-    return PeerID.fromValue(descriptor.kademliaId)
+const createItem = (kademliaId: Uint8Array): { getPeerId: () => PeerID } => {
+    return { getPeerId: () => PeerID.fromValue(kademliaId) }
 }
 
 describe('RandomContactList', () => {
-    const serviceId = 'random'
-    const descriptor0: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 0]), type: NodeType.NODEJS }
-    const descriptor1: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 1]), type: NodeType.NODEJS }
-    const descriptor2: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 2]), type: NodeType.NODEJS }
-    const descriptor3: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 3]), type: NodeType.NODEJS }
-    const descriptor4: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 4]), type: NodeType.NODEJS }
-    const peer1 = new DhtPeer(descriptor0, descriptor1, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer2 = new DhtPeer(descriptor0, descriptor2, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer3 = new DhtPeer(descriptor0, descriptor3, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer4 = new DhtPeer(descriptor0, descriptor4, toProtoRpcClient(new MockRpcClient()), serviceId)
+    const item0 = createItem(new Uint8Array([0, 0, 0, 0]))
+    const item1 = createItem(new Uint8Array([0, 0, 0, 1]))
+    const item2 = createItem(new Uint8Array([0, 0, 0, 2]))
+    const item3 = createItem(new Uint8Array([0, 0, 0, 3]))
+    const item4 = createItem(new Uint8Array([0, 0, 0, 4]))
 
     it('adds contacts correctly', () => {
-        const list = new RandomContactList(getId(descriptor0), 5, 1)
-        list.addContact(peer1)
-        list.addContact(peer2)
-        list.addContact(peer3)
-        list.addContact(peer3)
-        list.addContact(peer4)
-        list.addContact(peer4)
+        const list = new RandomContactList(item0.getPeerId(), 5, 1)
+        list.addContact(item1)
+        list.addContact(item2)
+        list.addContact(item3)
+        list.addContact(item3)
+        list.addContact(item4)
+        list.addContact(item4)
         expect(list.getSize()).toEqual(4)
         expect(list.getContacts()).toEqual(
-            [peer1, peer2, peer3, peer4]
+            [item1, item2, item3, item4]
         )
     })
 
     it('removes contacts correctly', () => {
-        const list = new RandomContactList(getId(descriptor0), 5, 1)
-        list.addContact(peer1)
-        list.addContact(peer2)
-        list.addContact(peer3)
-        list.addContact(peer4)
-        list.removeContact(getId(descriptor2))
-        expect(list.getContact(getId(descriptor1))).toBeTruthy()
-        expect(list.getContact(getId(descriptor3))).toBeTruthy()
-        expect(list.getContact(getId(descriptor4))).toBeTruthy()
+        const list = new RandomContactList(item0.getPeerId(), 5, 1)
+        list.addContact(item1)
+        list.addContact(item2)
+        list.addContact(item3)
+        list.addContact(item4)
+        list.removeContact(item2.getPeerId())
+        expect(list.getContact(item1.getPeerId())).toBeTruthy()
+        expect(list.getContact(item3.getPeerId())).toBeTruthy()
+        expect(list.getContact(item4.getPeerId())).toBeTruthy()
         expect(list.getContacts()).toEqual(
-            [peer1, peer3, peer4]
+            [item1, item3, item4]
         )
         expect(list.getSize()).toEqual(3)
     })

package/test/unit/RecursiveFinder.test.ts

@@ -13,28 +13,25 @@ import {
     createRecursiveFindRequest
 } from '../utils/utils'
 import { RecursiveFinder } from '../../src/dht/find/RecursiveFinder'
-import { DhtPeer } from '../../src/dht/DhtPeer'
+import { RemoteDhtNode } from '../../src/dht/RemoteDhtNode'
 import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import { v4 } from 'uuid'
 import { MockRouter } from '../utils/mock/Router'
 import { MockTransport } from '../utils/mock/Transport'
-import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('RecursiveFinder', () => {
 
     let recursiveFinder: RecursiveFinder
-    let connections: Map<PeerIDKey, DhtPeer>
+    let connections: Map<PeerIDKey, RemoteDhtNode>
 
-    const peerId1 = PeerID.fromString('peerid')
     const peerDescriptor1: PeerDescriptor = {
-        kademliaId: peerId1.value,
-        type: NodeType.NODEJS,
-        nodeName: 'peerid'
+        kademliaId: PeerID.fromString('peerid').value,
+        type: NodeType.NODEJS
     }
     const peerDescriptor2: PeerDescriptor = {
         kademliaId: PeerID.fromString('destination').value,
-        type: NodeType.NODEJS,
-        nodeName: 'destination'
+        type: NodeType.NODEJS
     }
     const recursiveFindRequest = createRecursiveFindRequest(FindMode.NODE)
     const message: Message = {
@@ -61,7 +58,6 @@ describe('RecursiveFinder', () => {
         connections = new Map()
         recursiveFinder = new RecursiveFinder({
             ownPeerDescriptor: peerDescriptor1,
-            ownPeerId: peerId1,
             router: new MockRouter(),
             connections,
             serviceId: 'RecursiveFinder',
@@ -84,11 +80,11 @@ describe('RecursiveFinder', () => {
 
     it('startRecursiveFind with mode Node returns self if no peers', async () => {
         const res = await recursiveFinder.startRecursiveFind(PeerID.fromString('find').value)
-        expect(isSamePeerDescriptor(res.closestNodes[0], peerDescriptor1)).toEqual(true)
+        expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
     })
 
     it('RecursiveFinder server throws if payload is not recursiveFindRequest', async () => {
-        const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1, peerDescriptor2)
+        const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
         const badMessage: Message = {
             serviceId: 'unknown',
             messageId: v4(),