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

package/test/unit/{Finder.test.ts → RecursiveOperationManager.test.ts}

@@ -1,9 +1,7 @@
 import {
-    FindAction,
+    RecursiveOperation,
     Message,
     MessageType,
-    NodeType,
-    PeerDescriptor,
     RouteMessageAck,
     RouteMessageError,
     RouteMessageWrapper
@@ -11,19 +9,20 @@ import {
 import { PeerID } from '../../src/helpers/PeerID'
 import {
     createWrappedClosestPeersRequest,
-    createFindRequest
+    createFindRequest,
+    createMockPeerDescriptor
 } from '../utils/utils'
-import { Finder } from '../../src/dht/find/Finder'
+import { RecursiveOperationManager } from '../../src/dht/recursive-operation/RecursiveOperationManager'
 import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import { v4 } from 'uuid'
 import { MockRouter } from '../utils/mock/Router'
 import { MockTransport } from '../utils/mock/Transport'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
-import { IRouter } from '../../src/dht/routing/Router'
+import { Router } from '../../src/dht/routing/Router'
 import { ITransport } from '../../src/exports'
 
-const createMockRouter = (error?: RouteMessageError): Partial<IRouter> => {
+const createMockRouter = (error?: RouteMessageError): Partial<Router> => {
     return {
         doRouteMessage: (routedMessage: RouteMessageWrapper) => {
             return {
@@ -35,24 +34,18 @@ const createMockRouter = (error?: RouteMessageError): Partial<IRouter> => {
         addToDuplicateDetector: () => {}
     }
 }
-describe('Finder', () => {
+describe('RecursiveOperationManager', () => {
 
-    const peerDescriptor1: PeerDescriptor = {
-        nodeId: PeerID.fromString('peerid').value,
-        type: NodeType.NODEJS
-    }
-    const peerDescriptor2: PeerDescriptor = {
-        nodeId: PeerID.fromString('destination').value,
-        type: NodeType.NODEJS
-    }
-    const findRequest = createFindRequest(FindAction.NODE)
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
+    const recursiveOperationRequest = createFindRequest()
     const message: Message = {
         serviceId: 'unknown',
         messageId: v4(),
         messageType: MessageType.RPC,
         body: {
-            oneofKind: 'findRequest',
-            findRequest
+            oneofKind: 'recursiveOperationRequest',
+            recursiveOperationRequest
         },
         sourceDescriptor: peerDescriptor1,
         targetDescriptor: peerDescriptor2
@@ -63,40 +56,42 @@ describe('Finder', () => {
         routingPath: [],
         reachableThrough: [],
         sourcePeer: peerDescriptor1,
-        destinationPeer: peerDescriptor2
+        target: peerDescriptor2.nodeId
     }
     const rpcCommunicator = new FakeRpcCommunicator()
 
-    const createFinder = (router: IRouter = new MockRouter(), transport: ITransport = new MockTransport()): Finder => {
-        return new Finder({
+    const createRecursiveOperationManager = (
+        router: Router = new MockRouter() as any,
+        transport: ITransport = new MockTransport()
+    ): RecursiveOperationManager => {
+        return new RecursiveOperationManager({
             localPeerDescriptor: peerDescriptor1,
             router,
             connections: new Map(),
-            serviceId: 'Finder',
-            localDataStore: new LocalDataStore(),
+            serviceId: 'RecursiveOperationManager',
+            localDataStore: new LocalDataStore(30 * 100),
             sessionTransport: transport,
             addContact: () => {},
-            isPeerCloserToIdThanSelf: (_peer1, _compareToId) => true,
             rpcCommunicator: rpcCommunicator as any
         })
     }
 
-    it('Finder server', async () => {
-        const finder = createFinder()
-        const res = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage) as RouteMessageAck
+    it('RecursiveOperationManager server', async () => {
+        const recursiveOperationManager = createRecursiveOperationManager()
+        const res = await rpcCommunicator.callRpcMethod('routeRequest', routedMessage) as RouteMessageAck
         expect(res.error).toBeUndefined()
-        finder.stop()
+        recursiveOperationManager.stop()
     })
 
     it('startFind with mode Node returns self if no peers', async () => {
-        const finder = createFinder()
-        const res = await finder.startFind(PeerID.fromString('find').value)
+        const recursiveOperationManager = createRecursiveOperationManager()
+        const res = await recursiveOperationManager.execute(PeerID.fromString('find').value, RecursiveOperation.FIND_NODE)
         expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
-        finder.stop()
+        recursiveOperationManager.stop()
     })
 
-    it('Finder server throws if payload is not FindRequest', async () => {
-        const finder = createFinder(new MockRouter())
+    it('RecursiveOperationManager server throws if payload is not RecursiveOperationRequest', async () => {
+        const manager = createRecursiveOperationManager(new MockRouter() as any)
         const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
         const badMessage: Message = {
             serviceId: 'unknown',
@@ -109,15 +104,15 @@ describe('Finder', () => {
             sourceDescriptor: peerDescriptor1,
             targetDescriptor: peerDescriptor2
         }
-        await expect(() => rpcCommunicator.callRpcMethod('routeFindRequest', {
+        await expect(() => rpcCommunicator.callRpcMethod('routeRequest', {
             message: badMessage,
             requestId: 'REQ',
             routingPath: [],
             reachableThrough: [],
-            destinationPeer: peerDescriptor1,
+            target: peerDescriptor1.nodeId,
             sourcePeer: peerDescriptor2
         })).rejects.toThrow()
-        finder.stop()
+        manager.stop()
     })
 
     it('no targets', async () => {
@@ -128,14 +123,14 @@ describe('Finder', () => {
             on: () => {},
             off: () => {}
         }
-        const finder = createFinder(router as any, transport as any)
-        const ack = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage)
+        const recursiveOperationManager = createRecursiveOperationManager(router as any, transport as any)
+        const ack = await rpcCommunicator.callRpcMethod('routeRequest', routedMessage)
         expect(ack).toEqual({
             requestId: routedMessage.requestId,
             error: RouteMessageError.NO_TARGETS
         })
         expect(send).toHaveBeenCalledTimes(1)
-        finder.stop()
+        recursiveOperationManager.stop()
     })
 
     it('error', async () => {
@@ -144,13 +139,13 @@ describe('Finder', () => {
         const transport = { 
             send
         }
-        const finder = createFinder(router as any, transport as any)
-        const ack = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage)
+        const recursiveOperationManager = createRecursiveOperationManager(router as any, transport as any)
+        const ack = await rpcCommunicator.callRpcMethod('routeRequest', routedMessage)
         expect(ack).toEqual({
             requestId: routedMessage.requestId,
             error: RouteMessageError.DUPLICATE
         })
         expect(send).not.toHaveBeenCalled()
-        finder.stop()
+        recursiveOperationManager.stop()
     })
 })

package/test/unit/RecursiveOperationSession.test.ts

@@ -0,0 +1,68 @@
+import { waitForCondition } 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/exports'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
+import { Message, PeerDescriptor, RecursiveOperation } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { RecursiveOperationSessionRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
+import { FakeEnvironment } from '../utils/FakeTransport'
+import { createMockPeerDescriptor } from '../utils/utils'
+
+describe('RecursiveOperationSession', () => {
+
+    let environment: FakeEnvironment
+    let localPeerDescriptor: PeerDescriptor
+
+    const createRpcRemote = (serviceId: ServiceID) => {
+        const transport = environment.createTransport()
+        const send = (msg: Message) => transport.send(msg)
+        return new RecursiveOperationSessionRpcRemote(
+            createMockPeerDescriptor(),
+            localPeerDescriptor,
+            serviceId,
+            new RoutingRpcCommunicator(serviceId, send),
+            RecursiveOperationSessionRpcClient
+        )
+    }
+
+    beforeEach(() => {
+        environment = new FakeEnvironment()
+        localPeerDescriptor = createMockPeerDescriptor()
+    })
+
+    it('happy path', async () => {
+        const doRouteRequest = jest.fn()
+        const session = new RecursiveOperationSession({
+            transport: environment.createTransport(),
+            targetId: createRandomNodeId(),
+            localPeerDescriptor,
+            waitedRoutingPathCompletions: 3,
+            operation: RecursiveOperation.FIND_NODE,
+            doRouteRequest
+        })
+        const onCompleted = jest.fn()
+        session.on('completed', onCompleted)
+
+        session.start('')
+        expect(doRouteRequest).toHaveBeenCalled()
+        range(3).forEach(() => {
+            const remote = createRpcRemote(session.getId())
+            remote.sendResponse(
+                [createMockPeerDescriptor(), createMockPeerDescriptor()],
+                [createMockPeerDescriptor(), createMockPeerDescriptor()],
+                [],
+                true
+            )
+        })
+
+        // 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)
+        const result = session.getResults()
+        // TODO assert peer descriptors
+        expect(result.closestNodes).toHaveLength(6)
+        expect(result.dataEntries).toEqual([])
+    })
+})

package/test/unit/Router.test.ts

@@ -1,31 +1,25 @@
 import { v4 } from 'uuid'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { Router } from '../../src/dht/routing/Router'
-import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
+import { PeerID } from '../../src/helpers/PeerID'
 import { 
     Message,
     MessageType,
-    NodeType,
     PeerDescriptor,
     RouteMessageAck,
     RouteMessageError,
     RouteMessageWrapper
 } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createWrappedClosestPeersRequest } from '../utils/utils'
+import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../utils/utils'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
+import { NodeID } from '../../src/helpers/nodeId'
+import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 
 describe('Router', () => {
-    let router: Router
 
-    const peerId = PeerID.fromString('router')
-    const peerDescriptor1: PeerDescriptor = {
-        nodeId: peerId.value,
-        type: NodeType.NODEJS
-    }
-    const peerDescriptor2: PeerDescriptor = {
-        nodeId: PeerID.fromString('destination').value,
-        type: NodeType.NODEJS
-    }
+    let router: Router
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
     const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
     const message: Message = {
         serviceId: 'unknown',
@@ -43,14 +37,14 @@ describe('Router', () => {
         requestId: 'REQ',
         routingPath: [],
         reachableThrough: [],
-        destinationPeer: peerDescriptor1,
+        target: peerDescriptor1.nodeId,
         sourcePeer: peerDescriptor2
     }
-    let connections: Map<PeerIDKey, DhtNodeRpcRemote>
+    let connections: Map<NodeID, DhtNodeRpcRemote>
     const rpcCommunicator = new FakeRpcCommunicator()
 
     const createMockDhtNodeRpcRemote = (destination: PeerDescriptor): DhtNodeRpcRemote => {
-        return new DhtNodeRpcRemote(peerDescriptor1, destination, {} as any, 'router')
+        return new DhtNodeRpcRemote(peerDescriptor1, destination, undefined as any, new MockRpcCommunicator())
     }
 
     beforeEach(() => {
@@ -59,7 +53,6 @@ describe('Router', () => {
             localPeerDescriptor: peerDescriptor1,
             rpcCommunicator: rpcCommunicator as any,
             addContact: (_contact) => {},
-            serviceId: 'router',
             connections
         })
     })
@@ -71,7 +64,7 @@ describe('Router', () => {
     it('doRouteMessage without connections', async () => {
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
             message,
-            destinationPeer: peerDescriptor2,
+            target: peerDescriptor2.nodeId,
             requestId: v4(),
             sourcePeer: peerDescriptor1,
             reachableThrough: [],
@@ -81,10 +74,10 @@ describe('Router', () => {
     })
 
     it('doRouteMessage with connections', async () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(PeerID.fromString('test').toNodeId(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
             message,
-            destinationPeer: peerDescriptor2,
+            target: peerDescriptor2.nodeId,
             requestId: v4(),
             sourcePeer: peerDescriptor1,
             reachableThrough: [],
@@ -99,7 +92,7 @@ describe('Router', () => {
     })
 
     it('route server with connections', async () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(PeerID.fromString('test').toNodeId(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toBeUndefined()
     })
@@ -116,7 +109,7 @@ describe('Router', () => {
     })
 
     it('forward server with connections', async () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(PeerID.fromString('test').toNodeId(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toBeUndefined()
     })

package/test/unit/RoutingSession.test.ts

@@ -1,29 +1,20 @@
 import { v4 } from 'uuid'
-import { RoutingSession } from '../../src/dht/routing/RoutingSession'
-import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createWrappedClosestPeersRequest } from '../utils/utils'
-import { hexToBinary } from '@streamr/utils'
-import { PeerIDKey } from '../../src/helpers/PeerID'
+import { RoutingMode, RoutingSession } from '../../src/dht/routing/RoutingSession'
+import { Message, MessageType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../utils/utils'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
-import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { NodeID } from '../../src/helpers/nodeId'
+import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 
 describe('RoutingSession', () => {
 
     let session: RoutingSession
-    let connections: Map<PeerIDKey, DhtNodeRpcRemote>
+    let connections: Map<NodeID, DhtNodeRpcRemote>
     let rpcCommunicator: RoutingRpcCommunicator
-
-    const mockPeerDescriptor1: PeerDescriptor = {
-        nodeId: hexToBinary('eee1'),
-        type: NodeType.NODEJS
-    }
-
-    const mockPeerDescriptor2 = {
-        nodeId: hexToBinary('eee2'),
-        type: NodeType.NODEJS
-    }
-
+    const mockPeerDescriptor1 = createMockPeerDescriptor()
+    const mockPeerDescriptor2 = createMockPeerDescriptor()
     const rpcWrapper = createWrappedClosestPeersRequest(mockPeerDescriptor1)
     const message: Message = {
         serviceId: 'unknown',
@@ -41,18 +32,25 @@ describe('RoutingSession', () => {
         requestId: 'REQ',
         routingPath: [],
         reachableThrough: [],
-        destinationPeer: mockPeerDescriptor1,
+        target: mockPeerDescriptor1.nodeId,
         sourcePeer: mockPeerDescriptor2
     }
 
     const createMockDhtNodeRpcRemote = (destination: PeerDescriptor): DhtNodeRpcRemote => {
-        return new DhtNodeRpcRemote(mockPeerDescriptor1, destination, {} as any, 'router')
+        return new DhtNodeRpcRemote(mockPeerDescriptor1, destination, undefined as any, rpcCommunicator)
     }
 
     beforeEach(() => {
-        rpcCommunicator = new RoutingRpcCommunicator('mock', async () => {})
+        rpcCommunicator = new MockRpcCommunicator()
         connections = new Map()
-        session = new RoutingSession(rpcCommunicator, mockPeerDescriptor1, routedMessage, connections, 2)
+        session = new RoutingSession({
+            rpcCommunicator: rpcCommunicator,
+            localPeerDescriptor: mockPeerDescriptor1,
+            routedMessage,
+            connections, 
+            parallelism: 2,
+            mode: RoutingMode.ROUTE
+        })
     })
 
     afterEach(() => {
@@ -61,15 +59,15 @@ describe('RoutingSession', () => {
     })
 
     it('findMoreContacts', () => {
-        connections.set(keyFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
+        connections.set(getNodeIdFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
         const contacts = session.updateAndGetRoutablePeers()
         expect(contacts.length).toBe(1)
     })
 
     it('findMoreContacts peer disconnects', () => {
-        connections.set(keyFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
+        connections.set(getNodeIdFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
         expect(session.updateAndGetRoutablePeers().length).toBe(1)
-        connections.delete(keyFromPeerDescriptor(mockPeerDescriptor2))
+        connections.delete(getNodeIdFromPeerDescriptor(mockPeerDescriptor2))
         expect(session.updateAndGetRoutablePeers().length).toBe(0)
     })
 

package/test/unit/SortedContactList.test.ts

@@ -1,11 +1,16 @@
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import { PeerID } from '../../src/helpers/PeerID'
+import { NodeID, createRandomNodeId, getNodeIdFromBinary } from '../../src/helpers/nodeId'
 
-const createItem = (nodeId: Uint8Array): { getPeerId: () => PeerID } => {
-    return { getPeerId: () => PeerID.fromValue(nodeId) }
+const createItem = (nodeId: Uint8Array): { getNodeId: () => NodeID, getPeerId: () => PeerID } => {
+    return { 
+        getNodeId: () => getNodeIdFromBinary(nodeId),
+        getPeerId: () => PeerID.fromValue(nodeId)
+    }
 }
 
 describe('SortedContactList', () => {
+
     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]))
@@ -13,19 +18,19 @@ describe('SortedContactList', () => {
     const item4 = createItem(new Uint8Array([0, 0, 0, 4]))
 
     it('compares Ids correctly', async () => {
-        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 10, allowToContainReferenceId: true, emitEvents: false })
-        expect(list.compareIds(item0.getPeerId(), item0.getPeerId())).toBe(0)
-        expect(list.compareIds(item1.getPeerId(), item1.getPeerId())).toBe(0)
-        expect(list.compareIds(item0.getPeerId(), item1.getPeerId())).toBe(-1)
-        expect(list.compareIds(item0.getPeerId(), item2.getPeerId())).toBe(-2)
-        expect(list.compareIds(item1.getPeerId(), item0.getPeerId())).toBe(1)
-        expect(list.compareIds(item2.getPeerId(), item0.getPeerId())).toBe(2)
-        expect(list.compareIds(item2.getPeerId(), item3.getPeerId())).toBe(-1)
-        expect(list.compareIds(item1.getPeerId(), item4.getPeerId())).toBe(-3)
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 10, allowToContainReferenceId: true, emitEvents: false })
+        expect(list.compareIds(item0.getNodeId(), item0.getNodeId())).toBe(0)
+        expect(list.compareIds(item1.getNodeId(), item1.getNodeId())).toBe(0)
+        expect(list.compareIds(item0.getNodeId(), item1.getNodeId())).toBe(-1)
+        expect(list.compareIds(item0.getNodeId(), item2.getNodeId())).toBe(-2)
+        expect(list.compareIds(item1.getNodeId(), item0.getNodeId())).toBe(1)
+        expect(list.compareIds(item2.getNodeId(), item0.getNodeId())).toBe(2)
+        expect(list.compareIds(item2.getNodeId(), item3.getNodeId())).toBe(-1)
+        expect(list.compareIds(item1.getNodeId(), item4.getNodeId())).toBe(-3)
     })
 
     it('orders itself correctly', async () => {
-        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 10, allowToContainReferenceId: true, emitEvents: false })
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 10, allowToContainReferenceId: true, emitEvents: false })
         list.addContact(item3)
         list.addContact(item2)
         list.addContact(item1)
@@ -37,11 +42,11 @@ describe('SortedContactList', () => {
     })
 
     it('handles contacted nodes correctly', async () => {
-        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 10, allowToContainReferenceId: false, emitEvents: false })
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 10, allowToContainReferenceId: false, emitEvents: false })
         list.addContact(item3)
         list.addContact(item2)
         list.addContact(item1)
-        list.setContacted(item2.getPeerId())
+        list.setContacted(item2.getNodeId())
         const contacts = list.getUncontactedContacts(3)
         expect(contacts.length).toEqual(2)
         expect(contacts[0]).toEqual(item1)
@@ -49,7 +54,7 @@ describe('SortedContactList', () => {
     })
 
     it('cannot exceed maxSize', async () => {
-        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 3, allowToContainReferenceId: false, emitEvents: true })
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 3, allowToContainReferenceId: false, emitEvents: true })
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
         list.addContact(item1)
@@ -57,31 +62,41 @@ describe('SortedContactList', () => {
         list.addContact(item3)
         list.addContact(item2)
         expect(list.getSize()).toEqual(3)
+        expect(list.getAllContacts()).toEqual([item1, item2, item3])
+        expect(list.getContactIds()).toEqual([item1.getNodeId(), item2.getNodeId(), item3.getNodeId()])
         expect(onContactRemoved).toBeCalledWith(item4, [item1, item2, item3])
-        expect(list.getContact(item4.getPeerId())).toBeFalsy()
+        expect(list.getContact(item4.getNodeId())).toBeFalsy()
     })
 
     it('removing contacts', async () => {
-        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 8, allowToContainReferenceId: false, emitEvents: true })
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 8, allowToContainReferenceId: false, emitEvents: true })
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
+        list.removeContact(getNodeIdFromBinary(createRandomNodeId()))
+        list.addContact(item3)
+        list.removeContact(item3.getNodeId())
         list.addContact(item4)
         list.addContact(item3)
         list.addContact(item2)
         list.addContact(item1)
-        list.removeContact(item2.getPeerId())
+        list.removeContact(item2.getNodeId())
         expect(list.getSize()).toEqual(3)
-        expect(list.getContact(item2.getPeerId())).toBeFalsy()
+        expect(list.getContact(item2.getNodeId())).toBeFalsy()
         expect(list.getContactIds()).toEqual(list.getContactIds().sort(list.compareIds))
         expect(list.getAllContacts()).toEqual([item1, item3, item4])
-        expect(onContactRemoved).toBeCalledWith(item2, [item1, item3, item4])
-        const ret = list.removeContact(PeerID.fromValue(Buffer.from([0, 0, 0, 6])))
+        const ret = list.removeContact(getNodeIdFromBinary(Buffer.from([0, 0, 0, 6])))
         expect(ret).toEqual(false)
+        list.removeContact(item3.getNodeId())
+        list.removeContact(getNodeIdFromBinary(createRandomNodeId()))
+        expect(list.getAllContacts()).toEqual([item1, item4])
+        expect(onContactRemoved).toHaveBeenNthCalledWith(1, item3, [])
+        expect(onContactRemoved).toHaveBeenNthCalledWith(2, item2, [item1, item3, item4])
+        expect(onContactRemoved).toHaveBeenNthCalledWith(3, item3, [item1, item4])
     })
 
     it('get closest contacts', () => {
         const list = new SortedContactList({
-            referenceId: item0.getPeerId(), 
+            referenceId: item0.getNodeId(), 
             maxSize: 8, 
             allowToContainReferenceId: false, 
             emitEvents: false 
@@ -95,14 +110,14 @@ describe('SortedContactList', () => {
     })
 
     it('get active contacts', () => {
-        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 8, allowToContainReferenceId: false, emitEvents: false })
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 8, allowToContainReferenceId: false, emitEvents: false })
         list.addContact(item1)
         list.addContact(item3)
         list.addContact(item4)
         list.addContact(item2)
-        list.setActive(item2.getPeerId())
-        list.setActive(item3.getPeerId())
-        list.setActive(item4.getPeerId())
+        list.setActive(item2.getNodeId())
+        list.setActive(item3.getNodeId())
+        list.setActive(item4.getNodeId())
         expect(list.getActiveContacts()).toEqual([item2, item3, item4])
     })
 })