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

package/test/integration/RpcErrors.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({
@@ -26,43 +28,28 @@ describe('RPC errors', () => {
 
     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 = {
-        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
 
-    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()

package/test/integration/ScaleDownDht.test.ts

@@ -3,36 +3,37 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { Logger } from '@streamr/utils'
+import { Logger, hexToBinary } from '@streamr/utils'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
 
 const logger = new Logger(module)
 
+const NUM_NODES = 80
+const MAX_CONNECTIONS = 15
+const K = 2
+
 describe('Scaling down a Dht network', () => {
+
     let entryPoint: DhtNode
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator(LatencyType.REAL)
-    const NUM_NODES = 80
-    const MAX_CONNECTIONS = 15
-    const K = 2
 
     beforeEach(async () => {
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
-            undefined, K, MAX_CONNECTIONS)
+        entryPoint = await createMockConnectionDhtNode(simulator,
+            createRandomNodeId(), K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
 
         entrypointDescriptor = {
-            nodeId: entryPoint.getNodeId().value,
+            nodeId: hexToBinary(entryPoint.getNodeId()),
             type: NodeType.NODEJS,
             region: getRandomRegion()
         }
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, K, MAX_CONNECTIONS)
+            const node = await createMockConnectionDhtNode(simulator, undefined, K, MAX_CONNECTIONS)
             nodes.push(node)
         }
         await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))

package/test/integration/SimultaneousConnections.test.ts

@@ -1,11 +1,24 @@
 import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
-import { Simulator } from '../../src/connection/simulator/Simulator'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { PeerID } from '../../src/helpers/PeerID'
 import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { getRandomRegion } from '../../src/connection/simulator/pings'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
+import { MockTransport } from '../utils/mock/Transport'
+
+const BASE_MESSAGE: Message = {
+    serviceId: 'serviceId',
+    messageType: MessageType.RPC,
+    messageId: '1',
+    body: {
+        oneofKind: 'rpcMessage',
+        rpcMessage: RpcMessage.create()
+    }
+}
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
     return new ConnectionManager({
@@ -22,29 +35,11 @@ describe('SimultaneousConnections', () => {
     let simulator: Simulator
     let simTransport1: SimulatorTransport
     let simTransport2: SimulatorTransport
-
-    const peerDescriptor1 = {
-        nodeId: PeerID.fromString('mock1').value,
-        type: NodeType.NODEJS
-    }
-
-    const peerDescriptor2 = {
-        nodeId: PeerID.fromString('mock2').value,
-        type: NodeType.NODEJS
-    }
-
-    const baseMsg: Message = {
-        serviceId: 'serviceId',
-        messageType: MessageType.RPC,
-        messageId: '1',
-        body: {
-            oneofKind: 'rpcMessage',
-            rpcMessage: RpcMessage.create()
-        }
-    }
+    const peerDescriptor1 = createMockPeerDescriptor({ region: getRandomRegion() })
+    const peerDescriptor2 = createMockPeerDescriptor({ region: getRandomRegion() })
 
     beforeEach(async () => {
-        simulator = new Simulator()
+        simulator = new Simulator(LatencyType.REAL)
         simTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
         await simTransport1.start()
         simTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
@@ -58,11 +53,11 @@ describe('SimultaneousConnections', () => {
 
     it('simultanous simulated connection', async () => {
         const msg1: Message = {
-            ...baseMsg,
+            ...BASE_MESSAGE,
             targetDescriptor: peerDescriptor2
         }
         const msg2: Message = {
-            ...baseMsg,
+            ...BASE_MESSAGE,
             targetDescriptor: peerDescriptor1
         }
 
@@ -90,50 +85,42 @@ describe('SimultaneousConnections', () => {
 
     describe('Websocket 2 servers', () => {
 
-        let simTransport1: SimulatorTransport
-        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
         
         const wsPeerDescriptor1: PeerDescriptor = {
-            nodeId: PeerID.fromString('mock1').value,
+            nodeId: createRandomNodeId(),
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
                 port: 43432,
                 tls: false
-            }
+            },
+            region: getRandomRegion()
         }
 
         const wsPeerDescriptor2: PeerDescriptor = {
-            nodeId: PeerID.fromString('mock2').value,
+            nodeId: createRandomNodeId(),
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
                 port: 43433,
                 tls: false
-            }
+            },
+            region: getRandomRegion()
         }
 
         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(wsPeerDescriptor1, {
-                transport: simTransport1,
+                transport: new MockTransport(),
                 websocketPortRange,
                 entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
             connectionManager2 = createConnectionManager(wsPeerDescriptor2, {
-                transport: simTransport2,
+                transport: new MockTransport(),
                 websocketPortRange,
                 entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
@@ -145,17 +132,15 @@ describe('SimultaneousConnections', () => {
         afterEach(async () => {
             await connectionManager1.stop()
             await connectionManager2.stop()
-            await simTransport1.stop()
-            await simTransport2.stop()
         })
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
-                ...baseMsg,
+                ...BASE_MESSAGE,
                 targetDescriptor: wsPeerDescriptor2
             }
             const msg2: Message = {
-                ...baseMsg,
+                ...BASE_MESSAGE,
                 targetDescriptor: wsPeerDescriptor1
             }
 
@@ -192,22 +177,20 @@ describe('SimultaneousConnections', () => {
         let connectionManager2: ConnectionManager
 
         const wsPeerDescriptor1: PeerDescriptor = {
-            nodeId: PeerID.fromString('mock1').value,
+            nodeId: createRandomNodeId(),
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
                 port: 43432,
                 tls: false
-            }
+            },
+            region: getRandomRegion()
         }
 
-        const wsPeerDescriptor2: PeerDescriptor = {
-            nodeId: PeerID.fromString('mock2').value,
-            type: NodeType.NODEJS
-        }
+        const wsPeerDescriptor2 = createMockPeerDescriptor({ region: getRandomRegion() })
 
         beforeEach(async () => {
-            simulator = new Simulator()
+            simulator = new Simulator(LatencyType.REAL)
             simTransport1 = new SimulatorTransport(wsPeerDescriptor1, simulator)
             await simTransport1.start()
             simTransport2 = new SimulatorTransport(wsPeerDescriptor2, simulator)
@@ -235,11 +218,11 @@ describe('SimultaneousConnections', () => {
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
-                ...baseMsg,
+                ...BASE_MESSAGE,
                 targetDescriptor: wsPeerDescriptor2
             }
             const msg2: Message = {
-                ...baseMsg,
+                ...BASE_MESSAGE,
                 targetDescriptor: wsPeerDescriptor1
             }
 
@@ -275,18 +258,11 @@ describe('SimultaneousConnections', () => {
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
 
-        const wrtcPeerDescriptor1: PeerDescriptor = {
-            nodeId: PeerID.fromString('mock1').value,
-            type: NodeType.NODEJS
-        }
-
-        const wrtcPeerDescriptor2: PeerDescriptor = {
-            nodeId: PeerID.fromString('mock2').value,
-            type: NodeType.NODEJS
-        }
+        const wrtcPeerDescriptor1 = createMockPeerDescriptor({ region: getRandomRegion() })
+        const wrtcPeerDescriptor2 = createMockPeerDescriptor({ region: getRandomRegion() })
 
         beforeEach(async () => {
-            simulator = new Simulator()
+            simulator = new Simulator(LatencyType.REAL)
             simTransport1 = new SimulatorTransport(wrtcPeerDescriptor1, simulator)
             await simTransport1.start()
             simTransport2 = new SimulatorTransport(wrtcPeerDescriptor2, simulator)
@@ -310,11 +286,11 @@ describe('SimultaneousConnections', () => {
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
-                ...baseMsg,
+                ...BASE_MESSAGE,
                 targetDescriptor: wrtcPeerDescriptor2
             }
             const msg2: Message = {
-                ...baseMsg,
+                ...BASE_MESSAGE,
                 targetDescriptor: wrtcPeerDescriptor1
             }
 

package/test/integration/Store.test.ts

@@ -1,20 +1,21 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
+import { getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
 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'
+
+const NUM_NODES = 100
+const MAX_CONNECTIONS = 20
+const K = 4
 
 describe('Storing data in DHT', () => {
+
     let entryPoint: DhtNode
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator(LatencyType.REAL)
-    const NUM_NODES = 100
-    const MAX_CONNECTIONS = 20
-    const K = 4
-    const nodeIndicesById: Record<string, number> = {}
 
     const getRandomNode = () => {
         return nodes[Math.floor(Math.random() * nodes.length)]
@@ -22,18 +23,14 @@ describe('Storing data in DHT', () => {
 
     beforeEach(async () => {
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
+        entryPoint = await createMockConnectionDhtNode(simulator,
             undefined, K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
-        nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
         entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
         nodes.push(entryPoint)
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator, 
+            const node = await createMockConnectionDhtNode(simulator,
                 undefined, K, MAX_CONNECTIONS, 60000)
-            nodeIndicesById[node.getNodeId().toKey()] = i
             nodes.push(node)
         }
         await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
@@ -46,44 +43,34 @@ describe('Storing data in DHT', () => {
 
     it('Storing data works', async () => {
         const storingNodeIndex = 34
-        const dataKey = createRandomNodeId()
-        const storedData = createMockPeerDescriptor()
-        const data = Any.pack(storedData, PeerDescriptor)
-        const successfulStorers = await nodes[storingNodeIndex].storeDataToDht(dataKey, data)
+        const entry = createMockDataEntry()
+        const successfulStorers = await nodes[storingNodeIndex].storeDataToDht(entry.key, entry.data!)
         expect(successfulStorers.length).toBeGreaterThan(4)
     }, 30000)
 
     it('Storing and getting data works', async () => {
         const storingNode = getRandomNode()
-        const dataKey = createRandomNodeId()
-        const storedData = createMockPeerDescriptor()
-        const data = Any.pack(storedData, PeerDescriptor)
-        const successfulStorers = await storingNode.storeDataToDht(dataKey, data)
+        const entry = createMockDataEntry()
+        const successfulStorers = await storingNode.storeDataToDht(entry.key, entry.data!)
         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()
+        const results = await fetchingNode.getDataFromDht(entry.key)
+        results.forEach((result) => {
+            expectEqualData(result, entry)
         })
     }, 30000)
 
     it('storing with explicit creator', async () => {
         const storingNode = getRandomNode()
-        const dataKey = createRandomNodeId()
-        const storedData = createMockPeerDescriptor()
-        const data = Any.pack(storedData, PeerDescriptor)
+        const entry = createMockDataEntry()
         const requestor = createMockPeerDescriptor()
-        const successfulStorers = await storingNode.storeDataToDht(dataKey, data, requestor)
+        const successfulStorers = await storingNode.storeDataToDht(entry.key, entry.data!, getNodeIdFromBinary(requestor.nodeId))
         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()
+        const results = await fetchingNode.getDataFromDht(entry.key)
+        results.forEach((result) => {
+            expectEqualData(result, entry)
+            expect(getNodeIdFromBinary(result.creator)).toEqual(getNodeIdFromPeerDescriptor(requestor))
         })
     }, 30000)
 })

package/test/integration/StoreAndDelete.test.ts

@@ -1,20 +1,17 @@
 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, createMockPeerDescriptor, waitConnectionManagersReadyForTesting } from '../utils/utils'
-import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { Any } from '../../src/proto/google/protobuf/any'
+import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
 import { createRandomNodeId } from '../../src/helpers/nodeId'
 
+const NUM_NODES = 5
+const MAX_CONNECTIONS = 5
+const K = 4
+
 describe('Storing data in DHT', () => {
-    let entryPoint: DhtNode
+
     let nodes: DhtNode[]
-    let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator(LatencyType.REAL)
-    const NUM_NODES = 5
-    const MAX_CONNECTIONS = 5
-    const K = 4
-    const nodeIndicesById: Record<string, number> = {}
 
     const getRandomNode = () => {
         return nodes[Math.floor(Math.random() * nodes.length)]
@@ -22,21 +19,15 @@ describe('Storing data in DHT', () => {
 
     beforeEach(async () => {
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
-            undefined, K, MAX_CONNECTIONS)
-        nodes.push(entryPoint)
-        nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
-        entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
+        const entryPoint = await createMockConnectionDhtNode(simulator,
+            createRandomNodeId(), K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator, 
+            const node = await createMockConnectionDhtNode(simulator, 
                 undefined, K, MAX_CONNECTIONS, 60000)
-            nodeIndicesById[node.getNodeId().toKey()] = i
             nodes.push(node)
         }
-        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
+        await Promise.all(nodes.map((node) => node.joinDht([entryPoint.getLocalPeerDescriptor()])))
         await waitConnectionManagersReadyForTesting(nodes.map((node) => node.connectionManager!), MAX_CONNECTIONS)
     }, 90000)
 
@@ -46,47 +37,36 @@ describe('Storing data in DHT', () => {
 
     it('Data can be deleted', async () => {
         const storingNode = getRandomNode()
-        const dataKey = createRandomNodeId()
-        const storedData = createMockPeerDescriptor()
-        const data = Any.pack(storedData, PeerDescriptor)
-        const successfulStorers = await storingNode.storeDataToDht(dataKey, data)
+        const entry = createMockDataEntry()
+        const successfulStorers = await storingNode.storeDataToDht(entry.key, entry.data!)
         expect(successfulStorers.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(dataKey, true)
-
+        await storingNode.deleteDataFromDht(entry.key, true)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(dataKey)
-        results.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(entry.deleted).toBeTrue()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storedData)).toBeTrue()
+        const results = await fetchingNode.getDataFromDht(entry.key)
+        results.forEach((result) => {
+            expect(result.deleted).toBeTrue()
+            expectEqualData(result, entry)
         })
     }, 90000)
 
     it('Data can be deleted and re-stored', async () => {
         const storingNode = getRandomNode()
-        const dataKey = createRandomNodeId()
-        const storedData = createMockPeerDescriptor()
-        const data = Any.pack(storedData, PeerDescriptor)
-        const successfulStorers1 = await storingNode.storeDataToDht(dataKey, data)
+        const entry = createMockDataEntry()
+        const successfulStorers1 = await storingNode.storeDataToDht(entry.key, entry.data!)
         expect(successfulStorers1.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(dataKey, true)
-
+        await storingNode.deleteDataFromDht(entry.key, true)
         const fetchingNode = getRandomNode()
-        const results1 = await fetchingNode.getDataFromDht(dataKey)
-        results1.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(entry.deleted).toBeTrue()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storedData)).toBeTrue()
+        const results1 = await fetchingNode.getDataFromDht(entry.key)
+        results1.forEach((result) => {
+            expect(result.deleted).toBeTrue()
+            expectEqualData(result, entry)
         })
-
-        const successfulStorers2 = await storingNode.storeDataToDht(dataKey, data)
+        const successfulStorers2 = await storingNode.storeDataToDht(entry.key, entry.data!)
         expect(successfulStorers2.length).toBeGreaterThan(4)
-
-        const results2 = await fetchingNode.getDataFromDht(dataKey)
-        results2.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(entry.deleted).toBeFalse()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storedData)).toBeTrue()
+        const results2 = await fetchingNode.getDataFromDht(entry.key)
+        results2.forEach((result) => {
+            expect(result.deleted).toBeFalse()
+            expectEqualData(result, entry)
         })
     }, 90000)
 })

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -1,31 +1,19 @@
-import { createMockConnectionDhtNode, createMockPeerDescriptor } from '../utils/utils'
+import { createMockConnectionDhtNode } from '../utils/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { Simulator } from '../../src/connection/simulator/Simulator'
-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'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
 
 describe('Storing data in DHT with two peers', () => {
 
     let entryPoint: DhtNode
     let otherNode: DhtNode
-
     let simulator: Simulator | undefined
 
     beforeEach(async () => {
         simulator = new Simulator()
-        const entryPointId = 'node0'
-        const otherNodeId = 'other-node'
-        entryPoint = await createMockConnectionDhtNode(
-            entryPointId,
-            simulator,
-        )
-        otherNode = await createMockConnectionDhtNode(
-            otherNodeId,
-            simulator
-        )
+        entryPoint = await createMockConnectionDhtNode(simulator)
+        otherNode = await createMockConnectionDhtNode(simulator)
 
         await entryPoint.start()
         await otherNode.start()
@@ -41,31 +29,22 @@ describe('Storing data in DHT with two peers', () => {
     })
 
     it('Node can store on two peer DHT', async () => {
-        const storedData1 = createMockPeerDescriptor()
-        const storedData2 = createMockPeerDescriptor()
-        const dataKey1 = createRandomNodeId()
-        const dataKey2 = createRandomNodeId()
-        const data1 = Any.pack(storedData1, PeerDescriptor)
-        const data2 = Any.pack(storedData2, PeerDescriptor)
-
-        await otherNode.storeDataToDht(dataKey1, data1)
-        await entryPoint.storeDataToDht(dataKey2, data2)
-
-        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()
+        const storedData1 = createMockDataEntry()
+        const storedData2 = createMockDataEntry()
+        await otherNode.storeDataToDht(storedData1.key, storedData1.data!)
+        await entryPoint.storeDataToDht(storedData2.key, storedData2.data!)
+        const foundData1 = await otherNode.getDataFromDht(storedData1.key)
+        const foundData2 = await entryPoint.getDataFromDht(storedData2.key)
+        expectEqualData(foundData1[0], storedData1)
+        expectEqualData(foundData2[0], storedData2)
     })
 
     it('Can store on one peer DHT', async () => {
         await otherNode.stop()
         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)
-        expect(areEqualPeerDescriptors(storedData, Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
+        const storedData = createMockDataEntry()
+        await entryPoint.storeDataToDht(storedData.key, storedData.data!)
+        const foundData = await entryPoint.getDataFromDht(storedData.key)
+        expectEqualData(foundData[0], storedData)
     }, 60000)
 })