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

package/test/integration/SimultaneousConnections.test.ts

@@ -1,11 +1,23 @@
 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 { Message, 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 { MockTransport } from '../utils/mock/Transport'
+import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+
+const BASE_MESSAGE: Message = {
+    serviceId: 'serviceId',
+    messageId: '1',
+    body: {
+        oneofKind: 'rpcMessage',
+        rpcMessage: RpcMessage.create()
+    }
+}
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
     return new ConnectionManager({
@@ -20,111 +32,92 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit
 describe('SimultaneousConnections', () => {
 
     let simulator: Simulator
-    let simulatorTransport1: SimulatorTransport
-    let simulatorTransport2: SimulatorTransport
-
-    const peerDescriptor1 = {
-        kademliaId: PeerID.fromString('mock1').value,
-        type: NodeType.NODEJS
-    }
-
-    const peerDescriptor2 = {
-        kademliaId: PeerID.fromString('mock2').value,
-        type: NodeType.NODEJS
-    }
-
-    const baseMsg: Message = {
-        serviceId: 'serviceId',
-        messageType: MessageType.RPC,
-        messageId: '1',
-        body: {
-            oneofKind: 'rpcMessage',
-            rpcMessage: RpcMessage.create()
-        }
-    }
+    let simTransport1: SimulatorTransport
+    let simTransport2: SimulatorTransport
+    const peerDescriptor1 = createMockPeerDescriptor({ region: getRandomRegion() })
+    const peerDescriptor2 = createMockPeerDescriptor({ region: getRandomRegion() })
 
     beforeEach(async () => {
-        simulator = new Simulator()
-        simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        await simulatorTransport1.start()
-        simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        await simulatorTransport2.start()
+        simulator = new Simulator(LatencyType.REAL)
+        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 () => {
         const msg1: Message = {
-            ...baseMsg,
+            ...BASE_MESSAGE,
             targetDescriptor: peerDescriptor2
         }
         const msg2: Message = {
-            ...baseMsg,
+            ...BASE_MESSAGE,
             targetDescriptor: peerDescriptor1
         }
 
         const promise1 = new Promise<void>((resolve, _reject) => {
-            simulatorTransport1.on('message', async (message: Message) => {
-                expect(message.messageType).toBe(MessageType.RPC)
+            simTransport1.on('message', async (message: Message) => {
+                expect(message.body.oneofKind).toBe('rpcMessage')
                 resolve()
             })
         })
         const promise2 = new Promise<void>((resolve, _reject) => {
-            simulatorTransport2.on('message', async (message: Message) => {
-                expect(message.messageType).toBe(MessageType.RPC)
+            simTransport2.on('message', async (message: Message) => {
+                expect(message.body.oneofKind).toBe('rpcMessage')
                 resolve()
             })
         })
         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(getNodeIdFromPeerDescriptor(peerDescriptor1)))
+        await waitForCondition(() => simTransport1.hasConnection(getNodeIdFromPeerDescriptor(peerDescriptor2)))
     })
 
     describe('Websocket 2 servers', () => {
 
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
-
-        const wsPeer1: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock1').value,
-            type: NodeType.NODEJS,
+        
+        const wsPeerDescriptor1 = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 43432,
                 tls: false
-            }
-        }
+            },
+            region: getRandomRegion()
+        })
 
-        const wsPeer2: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock2').value,
-            type: NodeType.NODEJS,
+        const wsPeerDescriptor2 = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 43433,
                 tls: false
-            }
-        }
+            },
+            region: getRandomRegion()
+        })
 
         beforeEach(async () => {
+
             const websocketPortRange = { min: 43432, max: 43433 }
-            connectionManager1 = createConnectionManager(wsPeer1, {
-                transport: simulatorTransport1,
+            connectionManager1 = createConnectionManager(wsPeerDescriptor1, {
+                transport: new MockTransport(),
                 websocketPortRange,
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
-            connectionManager2 = createConnectionManager(wsPeer2, {
-                transport: simulatorTransport2,
+            connectionManager2 = createConnectionManager(wsPeerDescriptor2, {
+                transport: new MockTransport(),
                 websocketPortRange,
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
             await connectionManager1.start()
@@ -138,23 +131,23 @@ describe('SimultaneousConnections', () => {
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
-                ...baseMsg,
-                targetDescriptor: wsPeer2
+                ...BASE_MESSAGE,
+                targetDescriptor: wsPeerDescriptor2
             }
             const msg2: Message = {
-                ...baseMsg,
-                targetDescriptor: wsPeer1
+                ...BASE_MESSAGE,
+                targetDescriptor: wsPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
                 connectionManager1.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
             const promise2 = new Promise<void>((resolve, _reject) => {
                 connectionManager2.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
@@ -166,40 +159,44 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wsPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wsPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(getNodeIdFromPeerDescriptor(wsPeerDescriptor2)))
+            await waitForCondition(() => connectionManager2.hasConnection(getNodeIdFromPeerDescriptor(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,
-            type: NodeType.NODEJS,
+        const wsPeerDescriptor1 = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 43432,
                 tls: false
-            }
-        }
+            },
+            region: getRandomRegion()
+        })
 
-        const wsPeer2: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock2').value,
-            type: NodeType.NODEJS
-        }
+        const wsPeerDescriptor2 = createMockPeerDescriptor({ region: getRandomRegion() })
 
         beforeEach(async () => {
-            connectionManager1 = createConnectionManager(wsPeer1, {
-                transport: simulatorTransport1,
+            simulator = new Simulator(LatencyType.REAL)
+            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,27 +205,29 @@ 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
+                ...BASE_MESSAGE,
+                targetDescriptor: wsPeerDescriptor2
             }
             const msg2: Message = {
-                ...baseMsg,
-                targetDescriptor: wsPeer1
+                ...BASE_MESSAGE,
+                targetDescriptor: wsPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
                 connectionManager1.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
             const promise2 = new Promise<void>((resolve, _reject) => {
                 connectionManager2.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
@@ -240,32 +239,32 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wsPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wsPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(getNodeIdFromPeerDescriptor(wsPeerDescriptor2)))
+            await waitForCondition(() => connectionManager2.hasConnection(getNodeIdFromPeerDescriptor(wsPeerDescriptor1)))
         })
     })
 
     describe('WebRTC', () => {
 
+        let simTransport1: SimulatorTransport
+        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
 
-        const wrtcPeer1: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock1').value,
-            type: NodeType.NODEJS
-        }
-
-        const wrtcPeer2: PeerDescriptor = {
-            kademliaId: PeerID.fromString('mock2').value,
-            type: NodeType.NODEJS
-        }
+        const wrtcPeerDescriptor1 = createMockPeerDescriptor({ region: getRandomRegion() })
+        const wrtcPeerDescriptor2 = createMockPeerDescriptor({ region: getRandomRegion() })
 
         beforeEach(async () => {
-            connectionManager1 = createConnectionManager(wrtcPeer1, {
-                transport: simulatorTransport1,
+            simulator = new Simulator(LatencyType.REAL)
+            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,27 +273,29 @@ 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
+                ...BASE_MESSAGE,
+                targetDescriptor: wrtcPeerDescriptor2
             }
             const msg2: Message = {
-                ...baseMsg,
-                targetDescriptor: wrtcPeer1
+                ...BASE_MESSAGE,
+                targetDescriptor: wrtcPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
                 connectionManager1.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
             const promise2 = new Promise<void>((resolve, _reject) => {
                 connectionManager2.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
@@ -306,8 +307,8 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wrtcPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wrtcPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(getNodeIdFromPeerDescriptor(wrtcPeerDescriptor2)))
+            await waitForCondition(() => connectionManager2.hasConnection(getNodeIdFromPeerDescriptor(wrtcPeerDescriptor1)))
         })
     })
 

package/test/integration/Store.test.ts

@@ -1,20 +1,20 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
+import { getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
-import { PeerID } from '../../src/helpers/PeerID'
-import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { Any } from '../../src/proto/google/protobuf/any'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
+import { createMockConnectionDhtNode, createMockPeerDescriptor, waitConnectionManagersReadyForTesting } from '../utils/utils'
+
+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 +22,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])))
@@ -42,28 +38,48 @@ describe('Storing data in DHT', () => {
 
     afterEach(async () => {
         await Promise.all(nodes.map((node) => node.stop()))
-    })
+    }, 15000)
 
     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 entry = createMockDataEntry()
+        const successfulStorers = await nodes[storingNodeIndex].storeDataToDht(
+            getDhtAddressFromRaw(entry.key),
+            entry.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 entry = createMockDataEntry()
+        const successfulStorers = await storingNode.storeDataToDht(
+            getDhtAddressFromRaw(entry.key),
+            entry.data!
+        )
         expect(successfulStorers.length).toBeGreaterThan(4)
+        const fetchingNode = getRandomNode()
+        const results = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
+        results.forEach((result) => {
+            expectEqualData(result, entry)
+        })
+    }, 30000)
 
+    it('storing with explicit creator', async () => {
+        const storingNode = getRandomNode()
+        const entry = createMockDataEntry()
+        const requestor = createMockPeerDescriptor()
+        const successfulStorers = await storingNode.storeDataToDht(
+            getDhtAddressFromRaw(entry.key),
+            entry.data!,
+            getDhtAddressFromRaw(requestor.nodeId)
+        )
+        expect(successfulStorers.length).toBeGreaterThan(4)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(dataKey.value)
-        results.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+        const results = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
+        results.forEach((result) => {
+            expectEqualData(result, entry)
+            expect(getDhtAddressFromRaw(result.creator)).toEqual(getNodeIdFromPeerDescriptor(requestor))
         })
-    }, 90000)
+    }, 30000)
 })

package/test/integration/StoreAndDelete.test.ts

@@ -1,20 +1,19 @@
 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 { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { Any } from '../../src/proto/google/protobuf/any'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
+import { createRandomDhtAddress } from '../../src/identifiers'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { wait } from '@streamr/utils'
+
+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 +21,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,
+            createRandomDhtAddress(), 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,45 +39,40 @@ 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 entry = createMockDataEntry()
+        const successfulStorers = await storingNode.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
         expect(successfulStorers.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(dataKey.value)
-
+        await storingNode.deleteDataFromDht(getDhtAddressFromRaw(entry.key), true)
+        // Wait for the delete operation to propagate
+        await wait(500)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(dataKey.value)
-        results.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(entry.deleted).toBeTrue()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+        const results = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(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 = PeerID.fromString('3232323e12r31r3')
-        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
-        const successfulStorers1 = await storingNode.storeDataToDht(dataKey.value, data)
+        const entry = createMockDataEntry()
+        const successfulStorers1 = await storingNode.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
         expect(successfulStorers1.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(dataKey.value)
-
+        await storingNode.deleteDataFromDht(getDhtAddressFromRaw(entry.key), true)
+        // Wait for the delete operation to propagate
+        await wait(500)
         const fetchingNode = getRandomNode()
-        const results1 = await fetchingNode.getDataFromDht(dataKey.value)
-        results1.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(entry.deleted).toBeTrue()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+        const results1 = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
+        results1.forEach((result) => {
+            expect(result.deleted).toBeTrue()
+            expectEqualData(result, entry)
         })
-
-        const successfulStorers2 = await storingNode.storeDataToDht(dataKey.value, data)
+        const successfulStorers2 = await storingNode.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
         expect(successfulStorers2.length).toBeGreaterThan(4)
-
-        const results2 = await fetchingNode.getDataFromDht(dataKey.value)
-        results2.forEach((entry) => {
-            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(entry.deleted).toBeFalse()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+        const results2 = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
+        results2.forEach((result) => {
+            expect(result.deleted).toBeFalse()
+            expectEqualData(result, entry)
         })
     }, 90000)
 })