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

package/test/integration/StoreRpcRemote.test.ts

@@ -1,34 +1,30 @@
-import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
+import { RpcCommunicator } from '@streamr/proto-rpc'
 import {
-    NodeType,
-    PeerDescriptor,
     StoreDataRequest,
     StoreDataResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { generateId, mockStoreRpc } from '../utils/utils'
+import { createMockPeerDescriptor, mockStoreRpc } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { StoreRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { StoreRpcRemote } from '../../src/dht/store/StoreRpcRemote'
-import { Any } from '../../src/proto/google/protobuf/any'
+import { createMockDataEntry } from '../utils/mock/mockDataEntry'
+import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
+
+const SERVICE_ID = 'test'
 
 describe('StoreRpcRemote', () => {
 
     let rpcRemote: StoreRpcRemote
     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 data = Any.pack(clientPeerDescriptor, PeerDescriptor)
+    const clientPeerDescriptor = createMockPeerDescriptor()
+    const serverPeerDescriptor = createMockPeerDescriptor()
+    const data = createMockDataEntry()
     const request: StoreDataRequest = {
-        key: clientPeerDescriptor.nodeId,
-        data,
+        key: data.key,
+        data: data.data,
+        creator: createRandomNodeId(),
         ttl: 10
     }
 
@@ -42,25 +38,19 @@ describe('StoreRpcRemote', () => {
         serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        const client = toProtoRpcClient(new StoreRpcClient(clientRpcCommunicator.getRpcClientTransport()))
-        rpcRemote = new StoreRpcRemote(clientPeerDescriptor, serverPeerDescriptor, serviceId, client)
+        rpcRemote = new StoreRpcRemote(clientPeerDescriptor, serverPeerDescriptor, SERVICE_ID, clientRpcCommunicator, StoreRpcClient)
     })
 
     it('storeData happy path', async () => {
-        const response = await rpcRemote.storeData(request)
-        expect(response.error).toBeEmpty()
+        await expect(rpcRemote.storeData(request)).toResolve()
     })
 
     it('storeData rejects', async () => {
         serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.throwStoreDataError)
-        await expect(rpcRemote.storeData(request))
-            .rejects.toThrowError('Could not store data to 736572766572 from 636c69656e74 Error: Mock')
+        await expect(rpcRemote.storeData(request)).rejects.toThrowError(
+            'Could not store data to'
+            + ` ${getNodeIdFromPeerDescriptor(serverPeerDescriptor)} from ${getNodeIdFromPeerDescriptor(clientPeerDescriptor)}`
+            + ' Error: Mock'
+        )
     })
-
-    it('storeData response error', async () => {
-        serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.storeDataErrorString)
-        const response = await rpcRemote.storeData(request)
-        expect(response.error).toEqual('Mock')
-    })
-
 })

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -2,13 +2,13 @@ import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-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/connection/simulator/SimulatorTransport'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { MetricsContext } from '@streamr/utils'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
@@ -24,19 +24,9 @@ describe('WebRTC Connection Management', () => {
 
     let manager1: ConnectionManager
     let manager2: ConnectionManager
-
     let simulator: Simulator
-
-    const peerDescriptor1: PeerDescriptor = {
-        nodeId: PeerID.fromString('peer1').value,
-        type: NodeType.NODEJS,
-    }
-
-    const peerDescriptor2: PeerDescriptor = {
-        nodeId: PeerID.fromString('peer2').value,
-        type: NodeType.NODEJS,
-    }
-
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
     let connectorTransport1: SimulatorTransport
     let connectorTransport2: SimulatorTransport
 

package/test/integration/WebrtcConnectorRpc.test.ts

@@ -2,32 +2,26 @@ import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/prot
 import { WebrtcConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import {
     IceCandidate,
-    NodeType,
-    PeerDescriptor,
     RtcAnswer,
     RtcOffer,
     WebrtcConnectionRequest
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
-import { generateId } from '../utils/utils'
+import { createMockPeerDescriptor } from '../utils/utils'
 import { IWebrtcConnectorRpc } from '../../src/proto/packages/dht/protos/DhtRpc.server'
 import { waitForCondition } from '@streamr/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
 describe('WebRTC rpc messages', () => {
+
     let rpcCommunicator1: RpcCommunicator
     let rpcCommunicator2: RpcCommunicator
     let client: ProtoRpcClient<WebrtcConnectorRpcClient>
-
     let requestConnectionCounter: number
     let rtcOfferCounter: number
     let rtcAnswerCounter: number
     let iceCandidateCounter: number
-
-    const targetDescriptor: PeerDescriptor = {
-        nodeId: generateId('peer'),
-        type: NodeType.NODEJS
-    }
+    const targetDescriptor = createMockPeerDescriptor()
 
     beforeEach(() => {
         requestConnectionCounter = 0

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -12,6 +12,8 @@ import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { TransportEvents } from '../../src/transport/ITransport'
 
+const SERVICE_ID = 'test'
+
 const createConfig = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
     return {
         createConnectorFacade: () => new DefaultConnectorFacade({
@@ -24,13 +26,10 @@ const createConfig = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultCon
 
 describe('Websocket Connection Management', () => {
 
-    const serviceId = 'test'
     let wsServerManager: ConnectionManager
     let noWsServerManager: ConnectionManager
     let biggerNoWsServerManager: ConnectionManager
-
     const simulator = new Simulator()
-
     const wsServerConnectorPeerDescriptor: PeerDescriptor = {
         nodeId: PeerID.fromString('2').value,
         type: NodeType.NODEJS,
@@ -40,12 +39,10 @@ describe('Websocket Connection Management', () => {
             tls: false
         }
     }
-
     const noWsServerConnectorPeerDescriptor: PeerDescriptor = {
         nodeId: PeerID.fromString('1').value,
         type: NodeType.NODEJS,
     }
-
     const biggerNoWsServerConnectorPeerDescriptor: PeerDescriptor = {
         nodeId: PeerID.fromString('3').value,
         type: NodeType.NODEJS,
@@ -96,7 +93,7 @@ describe('Websocket Connection Management', () => {
 
     it('Can open connections to serverless peer with smaller peerId', (done) => {
         const dummyMessage: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()
@@ -118,7 +115,7 @@ describe('Websocket Connection Management', () => {
 
     it('Can open connections to serverless peer with bigger peerId', (done) => {
         const dummyMessage: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()
@@ -140,7 +137,7 @@ describe('Websocket Connection Management', () => {
 
     it('Failed connection requests are cleaned up', async () => {
         const dummyMessage: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()
@@ -162,7 +159,7 @@ describe('Websocket Connection Management', () => {
     
     it('Can open connections to peer with server', async () => {
         const dummyMessage: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()
@@ -185,7 +182,7 @@ describe('Websocket Connection Management', () => {
 
     it('Connecting to self throws', async () => {
         const dummyMessage: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()

package/test/integration/WebsocketConnectorRpc.test.ts

@@ -1,36 +1,27 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
 import { WebsocketConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { generateId } from '../utils/utils'
+import { createMockPeerDescriptor } from '../utils/utils'
 import {
-    NodeType,
-    PeerDescriptor,
-    WebsocketConnectionRequest,
-    WebsocketConnectionResponse
+    WebsocketConnectionRequest
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { mockWebsocketConnectorRpc } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { Empty } from '../../src/proto/google/protobuf/empty'
 
 describe('WebsocketConnectorRpc', () => {
+
     let rpcCommunicator1: RpcCommunicator
     let rpcCommunicator2: RpcCommunicator
     let client1: ProtoRpcClient<WebsocketConnectorRpcClient>
     let client2: ProtoRpcClient<WebsocketConnectorRpcClient>
-
-    const peerDescriptor1: PeerDescriptor = {
-        nodeId: generateId('peer1'),
-        type: NodeType.NODEJS
-    }
-
-    const peerDescriptor2: PeerDescriptor = {
-        nodeId: generateId('peer2'),
-        type: NodeType.NODEJS
-    }
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
 
     beforeEach(() => {
         rpcCommunicator1 = new RpcCommunicator()
         rpcCommunicator1.registerRpcMethod(
             WebsocketConnectionRequest,
-            WebsocketConnectionResponse,
+            Empty,
             'requestConnection',
             mockWebsocketConnectorRpc.requestConnection
         )
@@ -38,7 +29,7 @@ describe('WebsocketConnectorRpc', () => {
         rpcCommunicator2 = new RpcCommunicator()
         rpcCommunicator2.registerRpcMethod(
             WebsocketConnectionRequest,
-            WebsocketConnectionResponse,
+            Empty,
             'requestConnection',
             mockWebsocketConnectorRpc.requestConnection
         )

package/test/unit/ConnectivityHelpers.test.ts

@@ -1,38 +1,30 @@
 import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { expectedConnectionType } from '../../src/helpers/Connectivity'
 import { ConnectionType } from '../../src/connection/IConnection'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('Connectivity helpers', () => {
 
-    const tlsServerPeerDescriptor = {
-        nodeId: new Uint8Array(1),
-        type: NodeType.NODEJS,
+    const tlsServerPeerDescriptor = createMockPeerDescriptor({
         websocket: {
             host: 'mock',
             port: 1234,
             tls: true
         }
-    }
-
-    const noTlsServerPeerDescriptor = {
-        nodeId: new Uint8Array(1),
-        type: NodeType.NODEJS,
+    })
+    const noTlsServerPeerDescriptor = createMockPeerDescriptor({
         websocket: {
             host: 'mock',
             port: 1234,
             tls: false
         }
-    }
-
-    const browserPeerDescriptor = {
-        nodeId: new Uint8Array(2),
+    })
+    const browserPeerDescriptor = createMockPeerDescriptor({
         type: NodeType.BROWSER
-    }
-
-    const noServerPeerDescriptor = {
-        nodeId: new Uint8Array(3),
+    })
+    const noServerPeerDescriptor = createMockPeerDescriptor({
         type: NodeType.NODEJS
-    }
+    })
 
     it('two server peers', () => {
         expect(expectedConnectionType(tlsServerPeerDescriptor, tlsServerPeerDescriptor)).toBe(ConnectionType.WEBSOCKET_CLIENT)

package/test/unit/DuplicateDetector.test.ts

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

package/test/unit/LocalDataStore.test.ts

@@ -1,29 +1,23 @@
-import { Any } from '../../src/proto/google/protobuf/any'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { wait } from '@streamr/utils'
+import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import {
-    areEqualPeerDescriptors,
-    keyFromPeerDescriptor,
+    getNodeIdFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
-import { wait } from '@streamr/utils'
-import { Timestamp } from '../../src/proto/google/protobuf/timestamp'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
+import { createRandomNodeId, getNodeIdFromBinary } from '../../src/helpers/nodeId'
 
 describe('LocalDataStore', () => {
+
     let localDataStore: LocalDataStore
-    const creator1: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS
-    }
-    const creator2: PeerDescriptor = {
-        nodeId: new Uint8Array([3, 2, 1]),
-        type: NodeType.NODEJS
-    }
-    const data1 = Any.pack(creator1, PeerDescriptor)
-    const data2 = Any.pack(creator2, PeerDescriptor)
 
+    const getEntryArray = (key: Uint8Array) => {
+        return Array.from(localDataStore.getEntries(key).values())
+    }
+    
     beforeEach(() => {
-        localDataStore = new LocalDataStore()
+        localDataStore = new LocalDataStore(30 * 1000)
     })
 
     afterEach(() => {
@@ -31,91 +25,86 @@ describe('LocalDataStore', () => {
     })
 
     it('can store', () => {
-        const dataKey = peerIdFromPeerDescriptor(creator1)
-        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1, 
-            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
-        const fetchedData = localDataStore.getEntry(dataKey)
-        fetchedData.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, creator1)).toBeTrue()
-        })
+        const storedEntry = createMockDataEntry()
+        localDataStore.storeEntry(storedEntry)
+        const fetchedEntries = getEntryArray(storedEntry.key)
+        expect(fetchedEntries).toHaveLength(1)
+        expectEqualData(fetchedEntries[0], storedEntry)
     })
 
     it('multiple storers behind one key', () => {
-        const dataKey = peerIdFromPeerDescriptor(creator1)
-        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
-        localDataStore.storeEntry({ creator: creator2, key: dataKey.value, 
-            data: data1, ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
-        const fetchedData = localDataStore.getEntry(dataKey)
-        fetchedData.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, creator1)).toBeTrue()
-        })
+        const creator1 = createRandomNodeId()
+        const creator2 = createRandomNodeId()
+        const key = createRandomNodeId()
+        const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
+        const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
+        localDataStore.storeEntry(storedEntry1)
+        localDataStore.storeEntry(storedEntry2)
+        const fetchedEntries = localDataStore.getEntries(key)
+        expect(fetchedEntries.size).toBe(2)
+        expectEqualData(fetchedEntries.get(getNodeIdFromBinary(creator1))!, storedEntry1)
+        expectEqualData(fetchedEntries.get(getNodeIdFromBinary(creator2))!, storedEntry2)
     })
 
     it('can remove data entries', () => {
-        const dataKey = peerIdFromPeerDescriptor(creator1)
-        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
-        localDataStore.storeEntry({ creator: creator2, key: dataKey.value, data: data2,
-            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
-        localDataStore.deleteEntry(dataKey, creator1)
-        const fetchedData = localDataStore.getEntry(dataKey)
-        fetchedData.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, creator2)).toBeTrue()
-        })
+        const creator1 = createRandomNodeId()
+        const creator2 = createRandomNodeId()
+        const key = createRandomNodeId()
+        const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
+        const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
+        localDataStore.storeEntry(storedEntry1)
+        localDataStore.storeEntry(storedEntry2)
+        localDataStore.deleteEntry(key, getNodeIdFromBinary(creator1))
+        const fetchedEntries = getEntryArray(key)
+        expect(fetchedEntries).toHaveLength(1)
+        expectEqualData(fetchedEntries[0], storedEntry2)
     })
 
     it('can remove all data entries', () => {
-        const dataKey = peerIdFromPeerDescriptor(creator1)
-        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
-        localDataStore.storeEntry({ creator: creator2, key: dataKey.value, data: data2,
-            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
-        localDataStore.deleteEntry(dataKey, creator1)
-        localDataStore.deleteEntry(dataKey, creator2)
-        const fetchedData = localDataStore.getEntry(dataKey)
-        expect(fetchedData.size).toBe(0)
+        const creator1 = createRandomNodeId()
+        const creator2 = createRandomNodeId()
+        const key = createRandomNodeId()
+        const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
+        const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
+        localDataStore.storeEntry(storedEntry1)
+        localDataStore.storeEntry(storedEntry2)
+        localDataStore.deleteEntry(key, getNodeIdFromBinary(creator1))
+        localDataStore.deleteEntry(key, getNodeIdFromBinary(creator2))
+        expect(getEntryArray(key)).toHaveLength(0)
     })
 
     it('data is deleted after TTL', async () => {
-        const dataKey = peerIdFromPeerDescriptor(creator1)
-        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
-            ttl: 1000, stale: false, deleted: false, createdAt: Timestamp.now() })
-        const intitialStore = localDataStore.getEntry(dataKey)
-        expect(intitialStore.size).toBe(1)
+        const storedEntry = createMockDataEntry({ ttl: 1000 })
+        localDataStore.storeEntry(storedEntry)
+        expect(getEntryArray(storedEntry.key)).toHaveLength(1)
         await wait(1100)
-        const fetchedData = localDataStore.getEntry(dataKey)
-        expect(fetchedData.size).toBe(0)
+        expect(getEntryArray(storedEntry.key)).toHaveLength(0)
     })
 
     describe('mark data as deleted', () => {
 
         it('happy path', () => {
-            const dataKey = peerIdFromPeerDescriptor(creator1)
-            localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
-                ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
-            const notDeletedData = localDataStore.getEntry(dataKey)
-            expect(notDeletedData.get(keyFromPeerDescriptor(creator1))!.deleted).toBeFalse()
-            const returnValue = localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(creator1))
+            const creator1 = createRandomNodeId()
+            const storedEntry = createMockDataEntry({ creator: creator1 })
+            localDataStore.storeEntry(storedEntry)
+            const notDeletedData = localDataStore.getEntries(storedEntry.key)
+            expect(notDeletedData.get(getNodeIdFromBinary(creator1))!.deleted).toBeFalse()
+            const returnValue = localDataStore.markAsDeleted(storedEntry.key, getNodeIdFromBinary(creator1))
             expect(returnValue).toBe(true)
-            const deletedData = localDataStore.getEntry(dataKey)
-            expect(deletedData.get(keyFromPeerDescriptor(creator1))!.deleted).toBeTrue()
+            const deletedData = localDataStore.getEntries(storedEntry.key)
+            expect(deletedData.get(getNodeIdFromBinary(creator1))!.deleted).toBeTrue()
         })
 
         it('data not stored', () => {
-            const dataKey = peerIdFromPeerDescriptor(creator1)
-            const returnValue = localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(creator2))
+            const dataKey = peerIdFromPeerDescriptor(createMockPeerDescriptor())
+            const returnValue = localDataStore.markAsDeleted(dataKey.value, getNodeIdFromPeerDescriptor(createMockPeerDescriptor()))
             expect(returnValue).toBe(false)
         })
 
         it('data not stored by the given creator', () => {
-            const dataKey = peerIdFromPeerDescriptor(creator1)
-            localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
-                ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
-            const returnValue = localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(creator2))
+            const storedEntry = createMockDataEntry()
+            localDataStore.storeEntry(storedEntry)
+            const returnValue = localDataStore.markAsDeleted(storedEntry.key, getNodeIdFromPeerDescriptor(createMockPeerDescriptor()))
             expect(returnValue).toBe(false)
         })
     })

package/test/unit/PeerManager.test.ts

@@ -0,0 +1,31 @@
+import { hexToBinary } from '@streamr/utils'
+import { PeerManager, getDistance } from '../../src/dht/PeerManager'
+import { NodeID, createRandomNodeId, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { range, sampleSize, sortBy, without } from 'lodash'
+import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
+import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
+
+describe('PeerManager', () => {
+
+    it('getClosestContactsTo', () => {
+        const nodeIds = range(10).map(() => getNodeIdFromBinary(createRandomNodeId()))
+        const manager = new PeerManager({
+            localNodeId: getNodeIdFromBinary(createRandomNodeId()),
+            createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => {
+                return new DhtNodeRpcRemote(undefined as any, peerDescriptor, undefined as any, new MockRpcCommunicator())
+            }
+        } as any)
+        manager.handleNewPeers(nodeIds.map((n) => ({ nodeId: hexToBinary(n), type: NodeType.NODEJS })))
+
+        const referenceId = getNodeIdFromBinary(createRandomNodeId())
+        const excluded = new Set<NodeID>(sampleSize(nodeIds, 2)!)
+        const actual = manager.getClosestContactsTo(referenceId, 5, excluded)
+
+        const expected = sortBy(
+            without(nodeIds, ...Array.from(excluded.values())),
+            (n: NodeID) => getDistance(n, referenceId)
+        ).slice(0, 5)
+        expect(actual.map((n) => n.getNodeId())).toEqual(expected)
+    })
+})

package/test/unit/RandomContactList.test.ts

@@ -1,11 +1,16 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
 import { PeerID } from '../../src/helpers/PeerID'
+import { NodeID, 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('RandomContactList', () => {
+
     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,7 +18,7 @@ describe('RandomContactList', () => {
     const item4 = createItem(new Uint8Array([0, 0, 0, 4]))
 
     it('adds contacts correctly', () => {
-        const list = new RandomContactList(item0.getPeerId(), 5, 1)
+        const list = new RandomContactList(item0.getNodeId(), 5, 1)
         list.addContact(item1)
         list.addContact(item2)
         list.addContact(item3)
@@ -27,15 +32,15 @@ describe('RandomContactList', () => {
     })
 
     it('removes contacts correctly', () => {
-        const list = new RandomContactList(item0.getPeerId(), 5, 1)
+        const list = new RandomContactList(item0.getNodeId(), 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()
+        list.removeContact(item2.getNodeId())
+        expect(list.getContact(item1.getNodeId())).toBeTruthy()
+        expect(list.getContact(item3.getNodeId())).toBeTruthy()
+        expect(list.getContact(item4.getNodeId())).toBeTruthy()
         expect(list.getContacts()).toEqual(
             [item1, item3, item4]
         )