@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-rc.1

package/test/integration/WebsocketConnectorRpc.test.ts

@@ -1,36 +1,28 @@
 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'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
 describe('WebsocketConnectorRpc', () => {
-    let rpcCommunicator1: RpcCommunicator
-    let rpcCommunicator2: RpcCommunicator
+
+    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
+    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
     let client1: ProtoRpcClient<WebsocketConnectorRpcClient>
     let client2: ProtoRpcClient<WebsocketConnectorRpcClient>
-
-    const peerDescriptor1: PeerDescriptor = {
-        kademliaId: generateId('peer1'),
-        type: NodeType.NODEJS
-    }
-
-    const peerDescriptor2: PeerDescriptor = {
-        kademliaId: 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 +30,7 @@ describe('WebsocketConnectorRpc', () => {
         rpcCommunicator2 = new RpcCommunicator()
         rpcCommunicator2.registerRpcMethod(
             WebsocketConnectionRequest,
-            WebsocketConnectionResponse,
+            Empty,
             'requestConnection',
             mockWebsocketConnectorRpc.requestConnection
         )
@@ -67,16 +59,14 @@ describe('WebsocketConnectorRpc', () => {
         },
         { targetDescriptor: peerDescriptor2 },
         )
-        const res1 = await response1
-        expect(res1.accepted).toEqual(true)
-
+        await response1
+        
         const response2 = client2.requestConnection({
             ip: '127.0.0.1',
             port: 9111
         },
         { targetDescriptor: peerDescriptor1 },
         )
-        const res2 = await response2
-        expect(res2.accepted).toEqual(true)
+        await response2
     })
 })

package/test/integration/{RpcErrors.test.ts → rpc-connections-over-webrpc.test.ts}

@@ -1,6 +1,5 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { PeerID } from '../../src/helpers/PeerID'
 import { ITransport } from '../../src/transport/ITransport'
 import { v4 } from 'uuid'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
@@ -8,9 +7,12 @@ import { DhtRpcOptions } from '../../src/rpc-protocol/DhtRpcOptions'
 import { ListeningRpcCommunicator } from '../../src/transport/ListeningRpcCommunicator'
 import { ProtoRpcClient, toProtoRpcClient } from '@streamr/proto-rpc'
 import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { NodeType, PeerDescriptor, PingRequest, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor, PingRequest, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { MetricsContext } from '@streamr/utils'
+import { createMockPeerDescriptor } from '../utils/utils'
+
+const SERVICE_ID = 'test'
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
@@ -22,47 +24,32 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
     })
 }
 
-describe('RPC errors', () => {
+describe('RPC connections over WebRTC', () => {
 
     let manager1: ConnectionManager
     let manager2: ConnectionManager
-
     let rpcCommunicator1: ListeningRpcCommunicator
     let rpcCommunicator2: ListeningRpcCommunicator
-
     let client1: ProtoRpcClient<DhtNodeRpcClient>
-    //let client2: ProtoRpcClient<DhtNodeRpcClient>
-
     let simulator: Simulator
-
-    const peerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peer1').value,
-        type: NodeType.NODEJS,
-    }
-
-    const peerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peer2').value,
-        type: NodeType.NODEJS,
-    }
-
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
     let connectorTransport1: SimulatorTransport
     let connectorTransport2: SimulatorTransport
 
-    const serviceId = 'test'
-
     beforeEach(async () => {
 
         simulator = new Simulator(LatencyType.FIXED, 50)
         connectorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
         await connectorTransport1.start()
         manager1 = createConnectionManager(peerDescriptor1, connectorTransport1)
-        rpcCommunicator1 = new ListeningRpcCommunicator(serviceId, manager1)
+        rpcCommunicator1 = new ListeningRpcCommunicator(SERVICE_ID, manager1)
         client1 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator1.getRpcClientTransport()))
 
         connectorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
         await connectorTransport2.start()
         manager2 = createConnectionManager(peerDescriptor2, connectorTransport2)
-        rpcCommunicator2 = new ListeningRpcCommunicator(serviceId, manager2)
+        rpcCommunicator2 = new ListeningRpcCommunicator(SERVICE_ID, manager2)
         //client2 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator2.getRpcClientTransport()))
 
         await manager1.start()
@@ -71,10 +58,10 @@ describe('RPC errors', () => {
     })
 
     afterEach(async () => {
-        await connectorTransport1.stop()
-        await connectorTransport2.stop()
         await manager1.stop()
         await manager2.stop()
+        await connectorTransport1.stop()
+        await connectorTransport2.stop()
         simulator.stop()
     })
 
@@ -117,6 +104,9 @@ describe('RPC errors', () => {
     }, 60000)
 
     /*
+    
+    TODO enable these tests (NET-1177)
+
     it.only('Throws a client-side exception if WebRTC connection fails', async () => {
 
         const request: PingRequest = {
@@ -143,14 +133,13 @@ describe('RPC errors', () => {
 
         const msg: Message = {
             serviceId,
-            messageType: MessageType.RPC,
             messageId: '1',
             body: RpcMessage.toBinary(rpcMessage)
         }
 
         const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
             manager1.on('disconnected', () => {
-                //expect(message.messageType).toBe(MessageType.RPC)
+                //expect(message.body.oneofKind).toBe('rpcMessage')
                 resolve()
             })
         })

package/test/unit/AddressTools.test.ts

@@ -37,4 +37,8 @@ describe('isPrivateIPv4', () => {
     it('return false for a public address', () => {
         expect(isPrivateIPv4('203.0.113.181')).toBe(false)
     })
+
+    it('return true for localhost IP address', () => {
+        expect(isPrivateIPv4('127.0.0.1')).toBe(true)
+    })
 })

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 = {
-        kademliaId: new Uint8Array(1),
-        type: NodeType.NODEJS,
+    const tlsServerPeerDescriptor = createMockPeerDescriptor({
         websocket: {
             host: 'mock',
             port: 1234,
             tls: true
         }
-    }
-
-    const noTlsServerPeerDescriptor = {
-        kademliaId: new Uint8Array(1),
-        type: NodeType.NODEJS,
+    })
+    const noTlsServerPeerDescriptor = createMockPeerDescriptor({
         websocket: {
             host: 'mock',
             port: 1234,
             tls: false
         }
-    }
-
-    const browserPeerDescriptor = {
-        kademliaId: new Uint8Array(2),
+    })
+    const browserPeerDescriptor = createMockPeerDescriptor({
         type: NodeType.BROWSER
-    }
-
-    const noServerPeerDescriptor = {
-        kademliaId: 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)
     })
 
     it('detects duplicates', async () => {
@@ -13,11 +16,11 @@ describe('Duplicate Detector', () => {
         expect(detector.isMostLikelyDuplicate('test')).toEqual(true)
     })
 
-    it('resets on resetLimit', () => {
-        for (let i = 0; i < maxLimit; i++) {
+    it('removes from tail when full', () => {
+        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,15 @@
-import { Any } from '../../src/proto/google/protobuf/any'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import {
-    areEqualPeerDescriptors,
-    keyFromPeerDescriptor,
-    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 { LocalDataStore } from '../../src/dht/store/LocalDataStore'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { createMockDataEntry } from '../utils/mock/mockDataEntry'
+import { createRandomDhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 describe('LocalDataStore', () => {
+
     let localDataStore: LocalDataStore
-    const storer1: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS
-    }
-    const storer2: PeerDescriptor = {
-        kademliaId: new Uint8Array([3, 2, 1]),
-        type: NodeType.NODEJS
-    }
-    const data1 = Any.pack(storer1, PeerDescriptor)
-    const data2 = Any.pack(storer2, PeerDescriptor)
 
     beforeEach(() => {
-        localDataStore = new LocalDataStore()
+        localDataStore = new LocalDataStore(30 * 1000)
     })
 
     afterEach(() => {
@@ -31,75 +17,92 @@ describe('LocalDataStore', () => {
     })
 
     it('can store', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1, 
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        const fetchedData = localDataStore.getEntry(dataKey)
-        fetchedData.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
-        })
+        const storedEntry = createMockDataEntry()
+        localDataStore.storeEntry(storedEntry)
+        const fetchedEntries = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+        expect(fetchedEntries).toIncludeSameMembers([storedEntry])
     })
 
     it('multiple storers behind one key', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, 
-            data: data1, ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        const fetchedData = localDataStore.getEntry(dataKey)
-        fetchedData.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
-        })
+        const creator1 = createRandomDhtAddress()
+        const creator2 = createRandomDhtAddress()
+        const key = createRandomDhtAddress()
+        const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
+        const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
+        localDataStore.storeEntry(storedEntry1)
+        localDataStore.storeEntry(storedEntry2)
+        const fetchedEntries = Array.from(localDataStore.values(key))
+        expect(fetchedEntries).toIncludeSameMembers([storedEntry1, storedEntry2])
     })
 
     it('can remove data entries', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, data: data2,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.deleteEntry(dataKey, storer1)
-        const fetchedData = localDataStore.getEntry(dataKey)
-        fetchedData.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storer2)).toBeTrue()
-        })
+        const creator1 = createRandomDhtAddress()
+        const creator2 = createRandomDhtAddress()
+        const key = createRandomDhtAddress()
+        const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
+        const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
+        localDataStore.storeEntry(storedEntry1)
+        localDataStore.storeEntry(storedEntry2)
+        localDataStore.deleteEntry(key, creator1)
+        const fetchedEntries = Array.from(localDataStore.values(key))
+        expect(fetchedEntries).toIncludeSameMembers([storedEntry2])
     })
 
     it('can remove all data entries', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, data: data2,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.deleteEntry(dataKey, storer1)
-        localDataStore.deleteEntry(dataKey, storer2)
-        const fetchedData = localDataStore.getEntry(dataKey)
-        expect(fetchedData.size).toBe(0)
+        const creator1 = createRandomDhtAddress()
+        const creator2 = createRandomDhtAddress()
+        const key = createRandomDhtAddress()
+        const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
+        const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
+        localDataStore.storeEntry(storedEntry1)
+        localDataStore.storeEntry(storedEntry2)
+        localDataStore.deleteEntry(key, creator1)
+        localDataStore.deleteEntry(key, creator2)
+        expect(Array.from(localDataStore.values(key))).toHaveLength(0)
     })
 
     it('data is deleted after TTL', async () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 1000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        const intitialStore = localDataStore.getEntry(dataKey)
-        expect(intitialStore.size).toBe(1)
+        const storedEntry = createMockDataEntry({ ttl: 1000 })
+        localDataStore.storeEntry(storedEntry)
+        expect(Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))).toHaveLength(1)
         await wait(1100)
-        const fetchedData = localDataStore.getEntry(dataKey)
-        expect(fetchedData.size).toBe(0)
+        expect(Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))).toHaveLength(0)
     })
 
-    it('can mark data as deleted', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        const notDeletedData = localDataStore.getEntry(dataKey)
-        expect(notDeletedData.get(keyFromPeerDescriptor(storer1))!.deleted).toBeFalse()
-        localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(storer1))
-        const deletedData = localDataStore.getEntry(dataKey)
-        expect(deletedData.get(keyFromPeerDescriptor(storer1))!.deleted).toBeTrue()
-    })
+    describe('mark data as deleted', () => {
 
+        it('happy path', () => {
+            const creator1 = createRandomDhtAddress()
+            const storedEntry = createMockDataEntry({ creator: creator1 })
+            localDataStore.storeEntry(storedEntry)
+            const notDeletedData = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+            expect(notDeletedData[0].deleted).toBeFalse()
+            const returnValue = localDataStore.markAsDeleted(
+                getDhtAddressFromRaw(storedEntry.key),
+                creator1
+            )
+            expect(returnValue).toBe(true)
+            const deletedData = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+            expect(deletedData[0].deleted).toBeTrue()
+        })
+
+        it('data not stored', () => {
+            const key = createRandomDhtAddress()
+            const returnValue = localDataStore.markAsDeleted(
+                key,
+                getNodeIdFromPeerDescriptor(createMockPeerDescriptor())
+            )
+            expect(returnValue).toBe(false)
+        })
+
+        it('data not stored by the given creator', () => {
+            const storedEntry = createMockDataEntry()
+            localDataStore.storeEntry(storedEntry)
+            const returnValue = localDataStore.markAsDeleted(
+                getDhtAddressFromRaw(storedEntry.key),
+                getNodeIdFromPeerDescriptor(createMockPeerDescriptor())
+            )
+            expect(returnValue).toBe(false)
+        })
+    })
 })

package/test/unit/PeerManager.test.ts

@@ -0,0 +1,33 @@
+import { PeerManager, getDistance } from '../../src/dht/PeerManager'
+import { DhtAddress, createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
+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'
+import { createMockPeerDescriptor } from '../utils/utils'
+
+describe('PeerManager', () => {
+
+    it('getClosestContactsTo', () => {
+        const nodeIds = range(10).map(() => createRandomDhtAddress())
+        const peerDescriptor = createMockPeerDescriptor()
+        const manager = new PeerManager({
+            localNodeId: getNodeIdFromPeerDescriptor(peerDescriptor),
+            localPeerDescriptor: peerDescriptor,
+            createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => {
+                return new DhtNodeRpcRemote(undefined as any, peerDescriptor, undefined as any, new MockRpcCommunicator())
+            }
+        } as any)
+        manager.addContact(nodeIds.map((n) => ({ nodeId: getRawFromDhtAddress(n), type: NodeType.NODEJS })))
+
+        const referenceId = createRandomDhtAddress()
+        const excluded = new Set<DhtAddress>(sampleSize(nodeIds, 2))
+        const actual = manager.getClosestContactsTo(referenceId, 5, excluded)
+
+        const expected = sortBy(
+            without(nodeIds, ...Array.from(excluded.values())),
+            (n: DhtAddress) => getDistance(getRawFromDhtAddress(n), getRawFromDhtAddress(referenceId))
+        ).slice(0, 5)
+        expect(actual.map((n) => n.getNodeId())).toEqual(expected)
+    })
+})

package/test/unit/RandomContactList.test.ts

@@ -1,11 +1,14 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
-import { PeerID } from '../../src/helpers/PeerID'
+import { DhtAddress, DhtAddressRaw, 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('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 +16,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 +30,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]
         )