@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/test/unit/RecursiveOperationManager.test.ts

@@ -0,0 +1,157 @@
+import {
+    RecursiveOperation,
+    Message,
+    RouteMessageAck,
+    RouteMessageError,
+    RouteMessageWrapper,
+    RecursiveOperationRequest
+} from '../../src/proto/packages/dht/protos/DhtRpc'
+import {
+    createWrappedClosestPeersRequest,
+    createMockPeerDescriptor
+} from '../utils/utils'
+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 { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
+import { Router } from '../../src/dht/routing/Router'
+import { ITransport } from '../../src/transport/ITransport'
+import { areEqualPeerDescriptors, createRandomDhtAddress } from '../../src/identifiers'
+
+const createMockRouter = (error?: RouteMessageError): Partial<Router> => {
+    return {
+        doRouteMessage: (routedMessage: RouteMessageWrapper) => {
+            return {
+                requestId: routedMessage.requestId,
+                error
+            }
+        },
+        isMostLikelyDuplicate: () => false,
+        addToDuplicateDetector: () => {}
+    }
+}
+
+const createRequest = (): RecursiveOperationRequest => {
+    const request: RecursiveOperationRequest = {
+        operation: RecursiveOperation.FIND_CLOSEST_NODES,
+        sessionId: v4()
+    }
+    return request
+}
+
+describe('RecursiveOperationManager', () => {
+
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
+    const recursiveOperationRequest = createRequest()
+    const message: Message = {
+        serviceId: 'unknown',
+        messageId: v4(),
+        body: {
+            oneofKind: 'recursiveOperationRequest',
+            recursiveOperationRequest
+        },
+        sourceDescriptor: peerDescriptor1,
+        targetDescriptor: peerDescriptor2
+    }
+    const routedMessage: RouteMessageWrapper = {
+        message,
+        requestId: 'REQ',
+        routingPath: [],
+        reachableThrough: [],
+        sourcePeer: peerDescriptor1,
+        target: peerDescriptor2.nodeId,
+        parallelRootNodeIds: []
+    }
+    const rpcCommunicator = new FakeRpcCommunicator()
+
+    const createRecursiveOperationManager = (
+        router: Router = new MockRouter() as any,
+        transport: ITransport = new MockTransport()
+    ): RecursiveOperationManager => {
+        return new RecursiveOperationManager({
+            localPeerDescriptor: peerDescriptor1,
+            router,
+            connections: new Map(),
+            serviceId: 'RecursiveOperationManager',
+            localDataStore: new LocalDataStore(30 * 100),
+            sessionTransport: transport,
+            addContact: () => {},
+            rpcCommunicator: rpcCommunicator as any
+        })
+    }
+
+    it('RecursiveOperationManager server', async () => {
+        const recursiveOperationManager = createRecursiveOperationManager()
+        const res = await rpcCommunicator.callRpcMethod('routeRequest', routedMessage) as RouteMessageAck
+        expect(res.error).toBeUndefined()
+        recursiveOperationManager.stop()
+    })
+
+    it('find closest nodes returns self if no peers', async () => {
+        const recursiveOperationManager = createRecursiveOperationManager()
+        const res = await recursiveOperationManager.execute(createRandomDhtAddress(), RecursiveOperation.FIND_CLOSEST_NODES)
+        expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
+        recursiveOperationManager.stop()
+    })
+
+    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',
+            messageId: v4(),
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: rpcWrapper
+            },
+            sourceDescriptor: peerDescriptor1,
+            targetDescriptor: peerDescriptor2
+        }
+        await expect(() => rpcCommunicator.callRpcMethod('routeRequest', {
+            message: badMessage,
+            requestId: 'REQ',
+            routingPath: [],
+            reachableThrough: [],
+            target: peerDescriptor1.nodeId,
+            sourcePeer: peerDescriptor2
+        })).rejects.toThrow()
+        manager.stop()
+    })
+
+    it('no targets', async () => {
+        const router = createMockRouter(RouteMessageError.NO_TARGETS)
+        const send = jest.fn()
+        const transport = { 
+            send,
+            on: () => {},
+            off: () => {}
+        }
+        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)
+        recursiveOperationManager.stop()
+    })
+
+    it('error', async () => {
+        const router = createMockRouter(RouteMessageError.DUPLICATE)
+        const send = jest.fn()
+        const transport = { 
+            send
+        }
+        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()
+        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/types/ServiceID'
+import { createRandomDhtAddress } from '../../src/identifiers'
+import { Message, PeerDescriptor, RecursiveOperation } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { RecursiveOperationSessionRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { 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 mockPeerDescriptor = createMockPeerDescriptor()
+        const transport = environment.createTransport(mockPeerDescriptor)
+        const send = (msg: Message) => transport.send(msg)
+        return new RecursiveOperationSessionRpcRemote(
+            mockPeerDescriptor,
+            localPeerDescriptor,
+            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(localPeerDescriptor),
+            targetId: createRandomDhtAddress(),
+            localPeerDescriptor,
+            waitedRoutingPathCompletions: 3,
+            operation: RecursiveOperation.FIND_CLOSEST_NODES,
+            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,28 +1,27 @@
 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 { Message, MessageType, NodeType, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createWrappedClosestPeersRequest } from '../utils/utils'
+import { 
+    Message,
+    PeerDescriptor,
+    RouteMessageAck,
+    RouteMessageError,
+    RouteMessageWrapper
+} from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../utils/utils'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
+import { DhtAddress, getNodeIdFromPeerDescriptor, createRandomDhtAddress } from '../../src/identifiers'
+import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 
 describe('Router', () => {
-    let router: Router
 
-    const peerId = PeerID.fromString('router')
-    const peerDescriptor1: PeerDescriptor = {
-        kademliaId: peerId.value,
-        type: NodeType.NODEJS
-    }
-    const peerDescriptor2: PeerDescriptor = {
-        kademliaId: 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',
         messageId: v4(),
-        messageType: MessageType.RPC,
         body: {
             oneofKind: 'rpcMessage',
             rpcMessage: rpcWrapper
@@ -35,14 +34,15 @@ describe('Router', () => {
         requestId: 'REQ',
         routingPath: [],
         reachableThrough: [],
-        destinationPeer: peerDescriptor1,
-        sourcePeer: peerDescriptor2
+        target: peerDescriptor1.nodeId,
+        sourcePeer: peerDescriptor2,
+        parallelRootNodeIds: []
     }
-    let connections: Map<PeerIDKey, DhtNodeRpcRemote>
+    let connections: Map<DhtAddress, 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(() => {
@@ -51,8 +51,8 @@ describe('Router', () => {
             localPeerDescriptor: peerDescriptor1,
             rpcCommunicator: rpcCommunicator as any,
             addContact: (_contact) => {},
-            serviceId: 'router',
-            connections
+            connections,
+            handleMessage: () => {}
         })
     })
 
@@ -63,59 +63,76 @@ describe('Router', () => {
     it('doRouteMessage without connections', async () => {
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
             message,
-            destinationPeer: peerDescriptor2,
+            target: peerDescriptor2.nodeId,
             requestId: v4(),
             sourcePeer: peerDescriptor1,
             reachableThrough: [],
-            routingPath: []
+            routingPath: [],
+            parallelRootNodeIds: []
         }) as RouteMessageAck
-        expect(ack.error).toEqual('No routing candidates found')
+        expect(ack.error).toEqual(RouteMessageError.NO_TARGETS)
     })
 
     it('doRouteMessage with connections', async () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(createRandomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
+            message,
+            target: peerDescriptor2.nodeId,
+            requestId: v4(),
+            sourcePeer: peerDescriptor1,
+            reachableThrough: [],
+            routingPath: [],
+            parallelRootNodeIds: []
+        }) as RouteMessageAck
+        expect(ack.error).toBeUndefined()
+    })
+
+    it('doRouteMessage with parallelRootNodeIds', async () => {
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor2)
+        connections.set(nodeId, createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
             message,
-            destinationPeer: peerDescriptor2,
+            target: peerDescriptor2.nodeId,
             requestId: v4(),
             sourcePeer: peerDescriptor1,
             reachableThrough: [],
-            routingPath: []
+            routingPath: [],
+            parallelRootNodeIds: [nodeId]
         }) as RouteMessageAck
-        expect(ack.error).toEqual('')
+        expect(ack.error).toEqual(RouteMessageError.NO_TARGETS)
     })
 
     it('route server is destination without connections', async () => {
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('')
+        expect(ack.error).toBeUndefined()
     })
 
     it('route server with connections', async () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(createRandomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('')
+        expect(ack.error).toBeUndefined()
     })
 
     it('route server on duplicate message', async () => {
         router.addToDuplicateDetector(routedMessage.requestId)
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('message given to routeMessage() service is likely a duplicate')
+        expect(ack.error).toEqual(RouteMessageError.DUPLICATE)
     })
 
     it('forward server no connections', async () => {
         const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('No routing candidates found')
+        expect(ack.error).toEqual(RouteMessageError.NO_TARGETS)
     })
 
     it('forward server with connections', async () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(createRandomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('')
+        expect(ack.error).toBeUndefined()
     })
 
     it('forward server on duplicate message', async () => {
         router.addToDuplicateDetector(routedMessage.requestId)
         const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual('message given to forwardMessage() service is likely a duplicate')
+        expect(ack.error).toEqual(RouteMessageError.DUPLICATE)
     })
 })

package/test/unit/RoutingSession.test.ts

@@ -0,0 +1,79 @@
+import { v4 } from 'uuid'
+import { RoutingMode, RoutingSession } from '../../src/dht/routing/RoutingSession'
+import { Message, 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 { DhtAddress, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
+import { RoutingTablesCache } from '../../src/dht/routing/RoutingTablesCache'
+
+describe('RoutingSession', () => {
+
+    let session: RoutingSession
+    let connections: Map<DhtAddress, DhtNodeRpcRemote>
+    let rpcCommunicator: RoutingRpcCommunicator
+    let routingTablesCache: RoutingTablesCache
+    const mockPeerDescriptor1 = createMockPeerDescriptor()
+    const mockPeerDescriptor2 = createMockPeerDescriptor()
+    const rpcWrapper = createWrappedClosestPeersRequest(mockPeerDescriptor1)
+    const message: Message = {
+        serviceId: 'unknown',
+        messageId: v4(),
+        body: {
+            oneofKind: 'rpcMessage',
+            rpcMessage: rpcWrapper
+        },
+        sourceDescriptor: mockPeerDescriptor1,
+        targetDescriptor: mockPeerDescriptor2
+    }
+    const routedMessage: RouteMessageWrapper = {
+        message,
+        requestId: 'REQ',
+        routingPath: [],
+        reachableThrough: [],
+        target: mockPeerDescriptor1.nodeId,
+        sourcePeer: mockPeerDescriptor2,
+        parallelRootNodeIds: []
+    }
+
+    const createMockDhtNodeRpcRemote = (destination: PeerDescriptor): DhtNodeRpcRemote => {
+        return new DhtNodeRpcRemote(mockPeerDescriptor1, destination, undefined as any, rpcCommunicator)
+    }
+
+    beforeEach(() => {
+        rpcCommunicator = new MockRpcCommunicator()
+        connections = new Map()
+        routingTablesCache = new RoutingTablesCache()
+        session = new RoutingSession({
+            rpcCommunicator: rpcCommunicator,
+            localPeerDescriptor: mockPeerDescriptor1,
+            routedMessage,
+            connections, 
+            parallelism: 2,
+            mode: RoutingMode.ROUTE,
+            excludedNodeIds: new Set(),
+            routingTablesCache
+        })
+    })
+
+    afterEach(() => {
+        rpcCommunicator.stop()
+        session.stop()
+    })
+
+    it('findMoreContacts', () => {
+        connections.set(getNodeIdFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
+        const contacts = session.updateAndGetRoutablePeers()
+        expect(contacts.length).toBe(1)
+    })
+
+    it('findMoreContacts peer disconnects', () => {
+        connections.set(getNodeIdFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
+        expect(session.updateAndGetRoutablePeers().length).toBe(1)
+        connections.delete(getNodeIdFromPeerDescriptor(mockPeerDescriptor2))
+        routingTablesCache.onNodeDisconnected(getNodeIdFromPeerDescriptor(mockPeerDescriptor2))
+        expect(session.updateAndGetRoutablePeers().length).toBe(0)
+    })
+
+})

package/test/unit/SortedContactList.test.ts

@@ -1,11 +1,14 @@
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import { PeerID } from '../../src/helpers/PeerID'
+import { DhtAddress, DhtAddressRaw, createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
 
-const createItem = (kademliaId: Uint8Array): { getPeerId: () => PeerID } => {
-    return { getPeerId: () => PeerID.fromValue(kademliaId) }
+const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress } => {
+    return { 
+        getNodeId: () => getDhtAddressFromRaw(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 +16,19 @@ describe('SortedContactList', () => {
     const item4 = createItem(new Uint8Array([0, 0, 0, 4]))
 
     it('compares Ids correctly', async () => {
-        const list = new SortedContactList(item0.getPeerId(), 10)
-        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(item0.getPeerId(), 10)
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 10, allowToContainReferenceId: true, emitEvents: false })
         list.addContact(item3)
         list.addContact(item2)
         list.addContact(item1)
@@ -35,13 +38,13 @@ describe('SortedContactList', () => {
         expect(contacts[1]).toEqual(item2)
         expect(contacts[2]).toEqual(item3)
     })
-    
+
     it('handles contacted nodes correctly', async () => {
-        const list = new SortedContactList(item0.getPeerId(), 10)
+        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 +52,7 @@ describe('SortedContactList', () => {
     })
 
     it('cannot exceed maxSize', async () => {
-        const list = new SortedContactList(item0.getPeerId(), 3)
+        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,30 +60,45 @@ 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(item0.getPeerId(), 8)
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 8, allowToContainReferenceId: false, emitEvents: true })
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
+        list.removeContact(createRandomDhtAddress())
+        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(getDhtAddressFromRaw(Buffer.from([0, 0, 0, 6])))
         expect(ret).toEqual(false)
+        list.removeContact(item3.getNodeId())
+        list.removeContact(createRandomDhtAddress())
+        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 closes contacts', () => {
-        const list = new SortedContactList(item0.getPeerId(), 8)
+    it('get closest contacts', () => {
+        const list = new SortedContactList({
+            referenceId: item0.getNodeId(), 
+            maxSize: 8, 
+            allowToContainReferenceId: false, 
+            emitEvents: false 
+        })
         list.addContact(item1)
         list.addContact(item3)
         list.addContact(item4)
@@ -90,14 +108,27 @@ describe('SortedContactList', () => {
     })
 
     it('get active contacts', () => {
-        const list = new SortedContactList(item0.getPeerId(), 8)
+        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])
     })
+
+    it('does not emit contactAdded if contact did not fit the structure', () => {
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 2, allowToContainReferenceId: false, emitEvents: true })
+        const onContactAdded = jest.fn()
+        list.on('contactAdded', onContactAdded)
+        list.addContact(item1)
+        list.addContact(item2)
+        expect(onContactAdded).toBeCalledTimes(2)
+        list.addContact(item3)
+        expect(onContactAdded).toBeCalledTimes(2)
+        expect(list.getAllContacts().length).toEqual(2)
+    })
+
 })