@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-testnet-one.1

package/test/integration/SimultaneousConnections.test.ts

@@ -20,16 +20,16 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit
 describe('SimultaneousConnections', () => {
 
     let simulator: Simulator
-    let simulatorTransport1: SimulatorTransport
-    let simulatorTransport2: SimulatorTransport
+    let simTransport1: SimulatorTransport
+    let simTransport2: SimulatorTransport
 
     const peerDescriptor1 = {
-        kademliaId: PeerID.fromString('mock1').value,
+        nodeId: PeerID.fromString('mock1').value,
         type: NodeType.NODEJS
     }
 
     const peerDescriptor2 = {
-        kademliaId: PeerID.fromString('mock2').value,
+        nodeId: PeerID.fromString('mock2').value,
         type: NodeType.NODEJS
     }
 
@@ -45,15 +45,15 @@ describe('SimultaneousConnections', () => {
 
     beforeEach(async () => {
         simulator = new Simulator()
-        simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        await simulatorTransport1.start()
-        simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        await simulatorTransport2.start()
+        simTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        await simTransport1.start()
+        simTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        await simTransport2.start()
     })
 
     afterEach(async () => {
-        await simulatorTransport1.stop()
-        await simulatorTransport2.stop()
+        await simTransport1.stop()
+        await simTransport2.stop()
     })
 
     it('simultanous simulated connection', async () => {
@@ -67,13 +67,13 @@ describe('SimultaneousConnections', () => {
         }
 
         const promise1 = new Promise<void>((resolve, _reject) => {
-            simulatorTransport1.on('message', async (message: Message) => {
+            simTransport1.on('message', async (message: Message) => {
                 expect(message.messageType).toBe(MessageType.RPC)
                 resolve()
             })
         })
         const promise2 = new Promise<void>((resolve, _reject) => {
-            simulatorTransport2.on('message', async (message: Message) => {
+            simTransport2.on('message', async (message: Message) => {
                 expect(message.messageType).toBe(MessageType.RPC)
                 resolve()
             })
@@ -81,20 +81,22 @@ describe('SimultaneousConnections', () => {
         await Promise.all([
             promise1,
             promise2,
-            simulatorTransport1.send(msg1),
-            simulatorTransport2.send(msg2)
+            simTransport1.send(msg1),
+            simTransport2.send(msg2)
         ])
-        await waitForCondition(() => simulatorTransport2.hasConnection(peerDescriptor1))
-        await waitForCondition(() => simulatorTransport1.hasConnection(peerDescriptor2))
+        await waitForCondition(() => simTransport2.hasConnection(peerDescriptor1))
+        await waitForCondition(() => simTransport1.hasConnection(peerDescriptor2))
     })
 
     describe('Websocket 2 servers', () => {
 
+        let simTransport1: SimulatorTransport
+        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
-
-        const wsPeer1: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock1').value,
+        
+        const wsPeerDescriptor1: PeerDescriptor = {
+            nodeId: PeerID.fromString('mock1').value,
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
@@ -103,8 +105,8 @@ describe('SimultaneousConnections', () => {
             }
         }
 
-        const wsPeer2: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock2').value,
+        const wsPeerDescriptor2: PeerDescriptor = {
+            nodeId: PeerID.fromString('mock2').value,
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
@@ -114,17 +116,26 @@ describe('SimultaneousConnections', () => {
         }
 
         beforeEach(async () => {
+            
+            // SimulatorTransport needs to have exatly same peerDescriptor as ConnectionManager
+            // that is why we need to create new SimulatorTransports here
+            simulator = new Simulator()
+            simTransport1 = new SimulatorTransport(wsPeerDescriptor1, simulator)
+            await simTransport1.start()
+            simTransport2 = new SimulatorTransport(wsPeerDescriptor2, simulator)
+            await simTransport2.start()
+            
             const websocketPortRange = { min: 43432, max: 43433 }
-            connectionManager1 = createConnectionManager(wsPeer1, {
-                transport: simulatorTransport1,
+            connectionManager1 = createConnectionManager(wsPeerDescriptor1, {
+                transport: simTransport1,
                 websocketPortRange,
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
-            connectionManager2 = createConnectionManager(wsPeer2, {
-                transport: simulatorTransport2,
+            connectionManager2 = createConnectionManager(wsPeerDescriptor2, {
+                transport: simTransport2,
                 websocketPortRange,
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
             await connectionManager1.start()
@@ -134,16 +145,18 @@ describe('SimultaneousConnections', () => {
         afterEach(async () => {
             await connectionManager1.stop()
             await connectionManager2.stop()
+            await simTransport1.stop()
+            await simTransport2.stop()
         })
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer2
+                targetDescriptor: wsPeerDescriptor2
             }
             const msg2: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer1
+                targetDescriptor: wsPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
@@ -166,18 +179,20 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wsPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wsPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(wsPeerDescriptor2))
+            await waitForCondition(() => connectionManager2.hasConnection(wsPeerDescriptor1))
         })
     })
 
     describe('Websocket 1 server (ConnectionRequests)', () => {
-
+    
+        let simTransport1: SimulatorTransport
+        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
 
-        const wsPeer1: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock1').value,
+        const wsPeerDescriptor1: PeerDescriptor = {
+            nodeId: PeerID.fromString('mock1').value,
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
@@ -186,20 +201,26 @@ describe('SimultaneousConnections', () => {
             }
         }
 
-        const wsPeer2: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock2').value,
+        const wsPeerDescriptor2: PeerDescriptor = {
+            nodeId: PeerID.fromString('mock2').value,
             type: NodeType.NODEJS
         }
 
         beforeEach(async () => {
-            connectionManager1 = createConnectionManager(wsPeer1, {
-                transport: simulatorTransport1,
+            simulator = new Simulator()
+            simTransport1 = new SimulatorTransport(wsPeerDescriptor1, simulator)
+            await simTransport1.start()
+            simTransport2 = new SimulatorTransport(wsPeerDescriptor2, simulator)
+            await simTransport2.start()
+
+            connectionManager1 = createConnectionManager(wsPeerDescriptor1, {
+                transport: simTransport1,
                 websocketPortRange: { min: 43432, max: 43432 },
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
-            connectionManager2 = createConnectionManager(wsPeer2, {
-                transport: simulatorTransport2
+            connectionManager2 = createConnectionManager(wsPeerDescriptor2, {
+                transport: simTransport2
             })
             await connectionManager1.start()
             await connectionManager2.start()
@@ -208,16 +229,18 @@ describe('SimultaneousConnections', () => {
         afterEach(async () => {
             await connectionManager1.stop()
             await connectionManager2.stop()
+            await simTransport1.stop()
+            await simTransport2.stop()
         })
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer2
+                targetDescriptor: wsPeerDescriptor2
             }
             const msg2: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer1
+                targetDescriptor: wsPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
@@ -240,32 +263,39 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wsPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wsPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(wsPeerDescriptor2))
+            await waitForCondition(() => connectionManager2.hasConnection(wsPeerDescriptor1))
         })
     })
 
     describe('WebRTC', () => {
 
+        let simTransport1: SimulatorTransport
+        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
 
-        const wrtcPeer1: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock1').value,
+        const wrtcPeerDescriptor1: PeerDescriptor = {
+            nodeId: PeerID.fromString('mock1').value,
             type: NodeType.NODEJS
         }
 
-        const wrtcPeer2: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock2').value,
+        const wrtcPeerDescriptor2: PeerDescriptor = {
+            nodeId: PeerID.fromString('mock2').value,
             type: NodeType.NODEJS
         }
 
         beforeEach(async () => {
-            connectionManager1 = createConnectionManager(wrtcPeer1, {
-                transport: simulatorTransport1,
+            simulator = new Simulator()
+            simTransport1 = new SimulatorTransport(wrtcPeerDescriptor1, simulator)
+            await simTransport1.start()
+            simTransport2 = new SimulatorTransport(wrtcPeerDescriptor2, simulator)
+            await simTransport2.start()
+            connectionManager1 = createConnectionManager(wrtcPeerDescriptor1, {
+                transport: simTransport1,
             })
-            connectionManager2 = createConnectionManager(wrtcPeer2, {
-                transport: simulatorTransport2,
+            connectionManager2 = createConnectionManager(wrtcPeerDescriptor2, {
+                transport: simTransport2,
             })
             await connectionManager1.start()
             await connectionManager2.start()
@@ -274,16 +304,18 @@ describe('SimultaneousConnections', () => {
         afterEach(async () => {
             await connectionManager1.stop()
             await connectionManager2.stop()
+            await simTransport1.stop()
+            await simTransport2.stop()
         })
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
                 ...baseMsg,
-                targetDescriptor: wrtcPeer2
+                targetDescriptor: wrtcPeerDescriptor2
             }
             const msg2: Message = {
                 ...baseMsg,
-                targetDescriptor: wrtcPeer1
+                targetDescriptor: wrtcPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
@@ -306,8 +338,8 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wrtcPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wrtcPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(wrtcPeerDescriptor2))
+            await waitForCondition(() => connectionManager2.hasConnection(wrtcPeerDescriptor1))
         })
     })
 

package/test/integration/Store.test.ts

@@ -1,10 +1,10 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
-import { PeerID } from '../../src/helpers/PeerID'
+import { createMockConnectionDhtNode, createMockPeerDescriptor, waitConnectionManagersReadyForTesting } from '../utils/utils'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Any } from '../../src/proto/google/protobuf/any'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
 
 describe('Storing data in DHT', () => {
     let entryPoint: DhtNode
@@ -46,24 +46,44 @@ describe('Storing data in DHT', () => {
 
     it('Storing data works', async () => {
         const storingNodeIndex = 34
-        const dataKey = PeerID.fromString('3232323e12r31r3')
-        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
-        const successfulStorers = await nodes[storingNodeIndex].storeDataToDht(dataKey.value, data)
+        const dataKey = createRandomNodeId()
+        const storedData = createMockPeerDescriptor()
+        const data = Any.pack(storedData, PeerDescriptor)
+        const successfulStorers = await nodes[storingNodeIndex].storeDataToDht(dataKey, data)
         expect(successfulStorers.length).toBeGreaterThan(4)
-    }, 90000)
+    }, 30000)
 
     it('Storing and getting data works', async () => {
         const storingNode = getRandomNode()
-        const dataKey = PeerID.fromString('3232323e12r31r3')
-        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
-        const successfulStorers = await storingNode.storeDataToDht(dataKey.value, data)
+        const dataKey = createRandomNodeId()
+        const storedData = createMockPeerDescriptor()
+        const data = Any.pack(storedData, PeerDescriptor)
+        const successfulStorers = await storingNode.storeDataToDht(dataKey, data)
         expect(successfulStorers.length).toBeGreaterThan(4)
 
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(dataKey.value)
+        const results = await fetchingNode.getDataFromDht(dataKey)
         results.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            const foundData = Any.unpack(entry.data!, PeerDescriptor)
+            expect(areEqualPeerDescriptors(foundData, storedData)).toBeTrue()
         })
-    }, 90000)
+    }, 30000)
+
+    it('storing with explicit creator', async () => {
+        const storingNode = getRandomNode()
+        const dataKey = createRandomNodeId()
+        const storedData = createMockPeerDescriptor()
+        const data = Any.pack(storedData, PeerDescriptor)
+        const requestor = createMockPeerDescriptor()
+        const successfulStorers = await storingNode.storeDataToDht(dataKey, data, requestor)
+        expect(successfulStorers.length).toBeGreaterThan(4)
+
+        const fetchingNode = getRandomNode()
+        const results = await fetchingNode.getDataFromDht(dataKey)
+        results.forEach((entry) => {
+            const foundData = Any.unpack(entry.data!, PeerDescriptor)
+            expect(areEqualPeerDescriptors(foundData, storedData)).toBeTrue()
+            expect(areEqualPeerDescriptors(entry.creator!, requestor)).toBeTrue()
+        })
+    }, 30000)
 })

package/test/integration/StoreAndDelete.test.ts

@@ -1,10 +1,10 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
-import { PeerID } from '../../src/helpers/PeerID'
+import { createMockConnectionDhtNode, createMockPeerDescriptor, waitConnectionManagersReadyForTesting } from '../utils/utils'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Any } from '../../src/proto/google/protobuf/any'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
 
 describe('Storing data in DHT', () => {
     let entryPoint: DhtNode
@@ -46,45 +46,47 @@ describe('Storing data in DHT', () => {
 
     it('Data can be deleted', async () => {
         const storingNode = getRandomNode()
-        const dataKey = PeerID.fromString('3232323e12r31r3')
-        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
-        const successfulStorers = await storingNode.storeDataToDht(dataKey.value, data)
+        const dataKey = createRandomNodeId()
+        const storedData = createMockPeerDescriptor()
+        const data = Any.pack(storedData, PeerDescriptor)
+        const successfulStorers = await storingNode.storeDataToDht(dataKey, data)
         expect(successfulStorers.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(dataKey.value)
+        await storingNode.deleteDataFromDht(dataKey, true)
 
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(dataKey.value)
+        const results = await fetchingNode.getDataFromDht(dataKey)
         results.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
             expect(entry.deleted).toBeTrue()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storedData)).toBeTrue()
         })
     }, 90000)
 
     it('Data can be deleted and re-stored', async () => {
         const storingNode = getRandomNode()
-        const dataKey = PeerID.fromString('3232323e12r31r3')
-        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
-        const successfulStorers1 = await storingNode.storeDataToDht(dataKey.value, data)
+        const dataKey = createRandomNodeId()
+        const storedData = createMockPeerDescriptor()
+        const data = Any.pack(storedData, PeerDescriptor)
+        const successfulStorers1 = await storingNode.storeDataToDht(dataKey, data)
         expect(successfulStorers1.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(dataKey.value)
+        await storingNode.deleteDataFromDht(dataKey, true)
 
         const fetchingNode = getRandomNode()
-        const results1 = await fetchingNode.getDataFromDht(dataKey.value)
+        const results1 = await fetchingNode.getDataFromDht(dataKey)
         results1.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
             expect(entry.deleted).toBeTrue()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storedData)).toBeTrue()
         })
 
-        const successfulStorers2 = await storingNode.storeDataToDht(dataKey.value, data)
+        const successfulStorers2 = await storingNode.storeDataToDht(dataKey, data)
         expect(successfulStorers2.length).toBeGreaterThan(4)
 
-        const results2 = await fetchingNode.getDataFromDht(dataKey.value)
+        const results2 = await fetchingNode.getDataFromDht(dataKey)
         results2.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
             expect(entry.deleted).toBeFalse()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storedData)).toBeTrue()
         })
     }, 90000)
 })

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -1,11 +1,11 @@
-import { createMockConnectionDhtNode } from '../utils/utils'
+import { createMockConnectionDhtNode, createMockPeerDescriptor } from '../utils/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { Simulator } from '../../src/connection/simulator/Simulator'
-import { PeerID } from '../../src/helpers/PeerID'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { waitForCondition } from '@streamr/utils'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
 
 describe('Storing data in DHT with two peers', () => {
 
@@ -41,31 +41,31 @@ describe('Storing data in DHT with two peers', () => {
     })
 
     it('Node can store on two peer DHT', async () => {
-        const dataKey1 = PeerID.fromString('node0-stored-data')
-        const data1 = Any.pack(otherNode.getLocalPeerDescriptor(), PeerDescriptor)
-        const dataKey2 = PeerID.fromString('other-node-stored-data')
-        const data2 = Any.pack(entryPoint.getLocalPeerDescriptor(), PeerDescriptor)
+        const storedData1 = createMockPeerDescriptor()
+        const storedData2 = createMockPeerDescriptor()
+        const dataKey1 = createRandomNodeId()
+        const dataKey2 = createRandomNodeId()
+        const data1 = Any.pack(storedData1, PeerDescriptor)
+        const data2 = Any.pack(storedData2, PeerDescriptor)
 
-        const successfulStorers1 = await otherNode.storeDataToDht(dataKey1.value, data1)
-        const successfulStorers2 = await entryPoint.storeDataToDht(dataKey2.value, data2)
-        expect(successfulStorers1[0].kademliaId).toStrictEqual(entryPoint.getLocalPeerDescriptor().kademliaId)
-        expect(successfulStorers2[0].kademliaId).toStrictEqual(otherNode.getLocalPeerDescriptor().kademliaId)
+        await otherNode.storeDataToDht(dataKey1, data1)
+        await entryPoint.storeDataToDht(dataKey2, data2)
 
-        const foundData1 = await otherNode.getDataFromDht(dataKey1.value)
-        const foundData2 = await entryPoint.getDataFromDht(dataKey2.value)
-        expect(areEqualPeerDescriptors(otherNode.getLocalPeerDescriptor(), Any.unpack(foundData1[0]!.data!, PeerDescriptor))).toBeTrue()
-        expect(areEqualPeerDescriptors(entryPoint.getLocalPeerDescriptor(), Any.unpack(foundData2[0]!.data!, PeerDescriptor))).toBeTrue()
+        const foundData1 = await otherNode.getDataFromDht(dataKey1)
+        const foundData2 = await entryPoint.getDataFromDht(dataKey2)
+        expect(areEqualPeerDescriptors(storedData1, Any.unpack(foundData1[0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(storedData2, Any.unpack(foundData2[0]!.data!, PeerDescriptor))).toBeTrue()
     })
 
     it('Can store on one peer DHT', async () => {
         await otherNode.stop()
-        await waitForCondition(() => entryPoint.getBucketSize() === 0)
-        const dataKey = PeerID.fromString('data-to-store')
-        const data = Any.pack(entryPoint.getLocalPeerDescriptor(), PeerDescriptor)
-        const successfulStorers = await entryPoint.storeDataToDht(dataKey.value, data)
-        expect(successfulStorers[0].kademliaId).toStrictEqual(entryPoint.getLocalPeerDescriptor().kademliaId)
+        await waitForCondition(() => entryPoint.getNumberOfNeighbors() === 0)
+        const dataKey = createRandomNodeId()
+        const storedData = createMockPeerDescriptor()
+        const data = Any.pack(storedData, PeerDescriptor)
+        await entryPoint.storeDataToDht(dataKey, data)
 
-        const foundData = await entryPoint.getDataFromDht(dataKey.value)
-        expect(areEqualPeerDescriptors(entryPoint.getLocalPeerDescriptor(), Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
+        const foundData = await entryPoint.getDataFromDht(dataKey)
+        expect(areEqualPeerDescriptors(storedData, Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
     }, 60000)
 })

package/test/integration/StoreRpcRemote.test.ts

@@ -18,16 +18,16 @@ describe('StoreRpcRemote', () => {
     let serverRpcCommunicator: RpcCommunicator
     const serviceId = 'test'
     const clientPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('client'),
+        nodeId: generateId('client'),
         type: NodeType.NODEJS
     }
     const serverPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('server'),
+        nodeId: generateId('server'),
         type: NodeType.NODEJS
     }
     const data = Any.pack(clientPeerDescriptor, PeerDescriptor)
     const request: StoreDataRequest = {
-        kademliaId: clientPeerDescriptor.kademliaId,
+        key: clientPeerDescriptor.nodeId,
         data,
         ttl: 10
     }

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -28,12 +28,12 @@ describe('WebRTC Connection Management', () => {
     let simulator: Simulator
 
     const peerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peer1').value,
+        nodeId: PeerID.fromString('peer1').value,
         type: NodeType.NODEJS,
     }
 
     const peerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peer2').value,
+        nodeId: PeerID.fromString('peer2').value,
         type: NodeType.NODEJS,
     }
 

package/test/integration/WebrtcConnectorRpc.test.ts

@@ -25,7 +25,7 @@ describe('WebRTC rpc messages', () => {
     let iceCandidateCounter: number
 
     const targetDescriptor: PeerDescriptor = {
-        kademliaId: generateId('peer'),
+        nodeId: generateId('peer'),
         type: NodeType.NODEJS
     }