@streamr/dht 102.0.0-beta.1 → 102.0.0-beta.2

package/test/integration/SimultaneousConnections.test.ts

@@ -1,316 +0,0 @@
-import { MetricsContext, until } from '@streamr/utils'
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
-import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { Message, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { getRandomRegion } from '../../src/connection/simulator/pings'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { toNodeId } from '../../src/identifiers'
-
-const BASE_MESSAGE: Message = {
-    serviceId: 'serviceId',
-    messageId: '1',
-    body: {
-        oneofKind: 'rpcMessage',
-        rpcMessage: RpcMessage.create()
-    }
-}
-
-const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeOptions, 'createLocalPeerDescriptor'>) => {
-    return new ConnectionManager({
-        createConnectorFacade: () => new DefaultConnectorFacade({
-            createLocalPeerDescriptor: async () => localPeerDescriptor,
-            ...opts
-        }),
-        metricsContext: new MetricsContext(),
-        allowIncomingPrivateConnections: false
-    })
-}
-
-describe('SimultaneousConnections', () => {
-
-    let simulator: Simulator
-    let simTransport1: SimulatorTransport
-    let simTransport2: SimulatorTransport
-    const peerDescriptor1 = createMockPeerDescriptor({ region: getRandomRegion() })
-    const peerDescriptor2 = createMockPeerDescriptor({ region: getRandomRegion() })
-
-    beforeEach(async () => {
-        simulator = new Simulator(LatencyType.REAL)
-        simTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        await simTransport1.start()
-        simTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        await simTransport2.start()
-    })
-
-    afterEach(async () => {
-        await simTransport1.stop()
-        await simTransport2.stop()
-    })
-
-    it('simultanous simulated connection', async () => {
-        const msg1: Message = {
-            ...BASE_MESSAGE,
-            targetDescriptor: peerDescriptor2
-        }
-        const msg2: Message = {
-            ...BASE_MESSAGE,
-            targetDescriptor: peerDescriptor1
-        }
-
-        const promise1 = new Promise<void>((resolve, _reject) => {
-            simTransport1.on('message', async (message: Message) => {
-                expect(message.body.oneofKind).toBe('rpcMessage')
-                resolve()
-            })
-        })
-        const promise2 = new Promise<void>((resolve, _reject) => {
-            simTransport2.on('message', async (message: Message) => {
-                expect(message.body.oneofKind).toBe('rpcMessage')
-                resolve()
-            })
-        })
-        await Promise.all([
-            promise1,
-            promise2,
-            simTransport1.send(msg1),
-            simTransport2.send(msg2)
-        ])
-        await until(() => simTransport2.hasConnection(toNodeId(peerDescriptor1)))
-        await until(() => simTransport1.hasConnection(toNodeId(peerDescriptor2)))
-    })
-
-    describe('Websocket 2 servers', () => {
-
-        let connectionManager1: ConnectionManager
-        let connectionManager2: ConnectionManager
-        
-        const wsPeerDescriptor1 = createMockPeerDescriptor({
-            websocket: {
-                host: '127.0.0.1',
-                port: 43432,
-                tls: false
-            },
-            region: getRandomRegion()
-        })
-
-        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(wsPeerDescriptor1, {
-                transport: new MockTransport(),
-                websocketPortRange,
-                entryPoints: [wsPeerDescriptor1],
-                websocketServerEnableTls: false
-            })
-            connectionManager2 = createConnectionManager(wsPeerDescriptor2, {
-                transport: new MockTransport(),
-                websocketPortRange,
-                entryPoints: [wsPeerDescriptor1],
-                websocketServerEnableTls: false
-            })
-            await connectionManager1.start()
-            await connectionManager2.start()
-        })
-
-        afterEach(async () => {
-            await connectionManager1.stop()
-            await connectionManager2.stop()
-        })
-
-        it('Simultaneous Connections', async () => {
-            const msg1: Message = {
-                ...BASE_MESSAGE,
-                targetDescriptor: wsPeerDescriptor2
-            }
-            const msg2: Message = {
-                ...BASE_MESSAGE,
-                targetDescriptor: wsPeerDescriptor1
-            }
-
-            const promise1 = new Promise<void>((resolve, _reject) => {
-                connectionManager1.on('message', async (message: Message) => {
-                    expect(message.body.oneofKind).toBe('rpcMessage')
-                    resolve()
-                })
-            })
-            const promise2 = new Promise<void>((resolve, _reject) => {
-                connectionManager2.on('message', async (message: Message) => {
-                    expect(message.body.oneofKind).toBe('rpcMessage')
-                    resolve()
-                })
-            })
-
-            await Promise.all([
-                promise1,
-                promise2,
-                connectionManager1.send(msg1),
-                connectionManager2.send(msg2)
-            ])
-
-            await until(() => connectionManager1.hasConnection(toNodeId(wsPeerDescriptor2)))
-            await until(() => connectionManager2.hasConnection(toNodeId(wsPeerDescriptor1)))
-        })
-    })
-
-    describe('Websocket 1 server (ConnectionRequests)', () => {
-    
-        let simTransport1: SimulatorTransport
-        let simTransport2: SimulatorTransport
-        let connectionManager1: ConnectionManager
-        let connectionManager2: ConnectionManager
-
-        const wsPeerDescriptor1 = createMockPeerDescriptor({
-            websocket: {
-                host: '127.0.0.1',
-                port: 43432,
-                tls: false
-            },
-            region: getRandomRegion()
-        })
-
-        const wsPeerDescriptor2 = createMockPeerDescriptor({ region: getRandomRegion() })
-
-        beforeEach(async () => {
-            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: [wsPeerDescriptor1],
-                websocketServerEnableTls: false
-            })
-            connectionManager2 = createConnectionManager(wsPeerDescriptor2, {
-                transport: simTransport2
-            })
-            await connectionManager1.start()
-            await connectionManager2.start()
-        })
-
-        afterEach(async () => {
-            await connectionManager1.stop()
-            await connectionManager2.stop()
-            await simTransport1.stop()
-            await simTransport2.stop()
-        })
-
-        it('Simultaneous Connections', async () => {
-            const msg1: Message = {
-                ...BASE_MESSAGE,
-                targetDescriptor: wsPeerDescriptor2
-            }
-            const msg2: Message = {
-                ...BASE_MESSAGE,
-                targetDescriptor: wsPeerDescriptor1
-            }
-
-            const promise1 = new Promise<void>((resolve, _reject) => {
-                connectionManager1.on('message', async (message: Message) => {
-                    expect(message.body.oneofKind).toBe('rpcMessage')
-                    resolve()
-                })
-            })
-            const promise2 = new Promise<void>((resolve, _reject) => {
-                connectionManager2.on('message', async (message: Message) => {
-                    expect(message.body.oneofKind).toBe('rpcMessage')
-                    resolve()
-                })
-            })
-
-            await Promise.all([
-                promise1,
-                promise2,
-                connectionManager1.send(msg1),
-                connectionManager2.send(msg2)
-            ])
-
-            await until(() => connectionManager1.hasConnection(toNodeId(wsPeerDescriptor2)))
-            await until(() => connectionManager2.hasConnection(toNodeId(wsPeerDescriptor1)))
-        })
-    })
-
-    describe('WebRTC', () => {
-
-        let simTransport1: SimulatorTransport
-        let simTransport2: SimulatorTransport
-        let connectionManager1: ConnectionManager
-        let connectionManager2: ConnectionManager
-
-        const wrtcPeerDescriptor1 = createMockPeerDescriptor({ region: getRandomRegion() })
-        const wrtcPeerDescriptor2 = createMockPeerDescriptor({ region: getRandomRegion() })
-
-        beforeEach(async () => {
-            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(wrtcPeerDescriptor2, {
-                transport: simTransport2,
-            })
-            await connectionManager1.start()
-            await connectionManager2.start()
-        })
-
-        afterEach(async () => {
-            await connectionManager1.stop()
-            await connectionManager2.stop()
-            await simTransport1.stop()
-            await simTransport2.stop()
-        })
-
-        it('Simultaneous Connections', async () => {
-            const msg1: Message = {
-                ...BASE_MESSAGE,
-                targetDescriptor: wrtcPeerDescriptor2
-            }
-            const msg2: Message = {
-                ...BASE_MESSAGE,
-                targetDescriptor: wrtcPeerDescriptor1
-            }
-
-            const promise1 = new Promise<void>((resolve, _reject) => {
-                connectionManager1.on('message', async (message: Message) => {
-                    expect(message.body.oneofKind).toBe('rpcMessage')
-                    resolve()
-                })
-            })
-            const promise2 = new Promise<void>((resolve, _reject) => {
-                connectionManager2.on('message', async (message: Message) => {
-                    expect(message.body.oneofKind).toBe('rpcMessage')
-                    resolve()
-                })
-            })
-
-            await Promise.all([
-                promise1,
-                promise2,
-                connectionManager1.send(msg1),
-                connectionManager2.send(msg2)
-            ])
-
-            await until(() => connectionManager1.hasConnection(toNodeId(wrtcPeerDescriptor2)))
-            await until(() => connectionManager2.hasConnection(toNodeId(wrtcPeerDescriptor1)))
-        })
-    })
-
-})

package/test/integration/Store.test.ts

@@ -1,85 +0,0 @@
-import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { toDhtAddress, toNodeId } from '../../src/identifiers'
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { createMockConnectionDhtNode, createMockPeerDescriptor, waitForStableTopology } 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 getRandomNode = () => {
-        return nodes[Math.floor(Math.random() * nodes.length)]
-    }
-
-    beforeEach(async () => {
-        nodes = []
-        entryPoint = await createMockConnectionDhtNode(simulator,
-            undefined, K, MAX_CONNECTIONS)
-        nodes.push(entryPoint)
-        entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
-        nodes.push(entryPoint)
-        for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator,
-                undefined, K, MAX_CONNECTIONS, 60000)
-            nodes.push(node)
-        }
-        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
-        await waitForStableTopology(nodes, MAX_CONNECTIONS)
-    }, 90000)
-
-    afterEach(async () => {
-        await Promise.all(nodes.map((node) => node.stop()))
-    }, 15000)
-
-    it('Storing data works', async () => {
-        const storingNodeIndex = 34
-        const entry = createMockDataEntry()
-        const successfulStorers = await nodes[storingNodeIndex].storeDataToDht(
-            toDhtAddress(entry.key),
-            entry.data!
-        )
-        expect(successfulStorers.length).toBeGreaterThan(4)
-    }, 30000)
-
-    it('Storing and getting data works', async () => {
-        const storingNode = getRandomNode()
-        const entry = createMockDataEntry()
-        const successfulStorers = await storingNode.storeDataToDht(
-            toDhtAddress(entry.key),
-            entry.data!
-        )
-        expect(successfulStorers.length).toBeGreaterThan(4)
-        const fetchingNode = getRandomNode()
-        const results = await fetchingNode.fetchDataFromDht(toDhtAddress(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(
-            toDhtAddress(entry.key),
-            entry.data!,
-            toDhtAddress(requestor.nodeId)
-        )
-        expect(successfulStorers.length).toBeGreaterThan(4)
-        const fetchingNode = getRandomNode()
-        const results = await fetchingNode.fetchDataFromDht(toDhtAddress(entry.key))
-        results.forEach((result) => {
-            expectEqualData(result, entry)
-            expect(toDhtAddress(result.creator)).toEqual(toNodeId(requestor))
-        })
-    }, 30000)
-})

package/test/integration/StoreAndDelete.test.ts

@@ -1,77 +0,0 @@
-import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { createMockConnectionDhtNode, waitForStableTopology } from '../utils/utils'
-import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { randomDhtAddress, toDhtAddress } 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 nodes: DhtNode[]
-    const simulator = new Simulator(LatencyType.REAL)
-
-    const getRandomNode = () => {
-        return nodes[Math.floor(Math.random() * nodes.length)]
-    }
-
-    beforeEach(async () => {
-        nodes = []
-        const entryPoint = await createMockConnectionDhtNode(simulator,
-            randomDhtAddress(), K, MAX_CONNECTIONS)
-        nodes.push(entryPoint)
-        for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator, 
-                undefined, K, MAX_CONNECTIONS, 60000)
-            nodes.push(node)
-        }
-        await Promise.all(nodes.map((node) => node.joinDht([entryPoint.getLocalPeerDescriptor()])))
-        await waitForStableTopology(nodes, MAX_CONNECTIONS)
-    }, 90000)
-
-    afterEach(async () => {
-        await Promise.all(nodes.map((node) => node.stop()))
-    })
-
-    it('Data can be deleted', async () => {
-        const storingNode = getRandomNode()
-        const entry = createMockDataEntry()
-        const successfulStorers = await storingNode.storeDataToDht(toDhtAddress(entry.key), entry.data!)
-        expect(successfulStorers.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(toDhtAddress(entry.key), true)
-        // Wait for the delete operation to propagate
-        await wait(500)
-        const fetchingNode = getRandomNode()
-        const results = await fetchingNode.fetchDataFromDht(toDhtAddress(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 entry = createMockDataEntry()
-        const successfulStorers1 = await storingNode.storeDataToDht(toDhtAddress(entry.key), entry.data!)
-        expect(successfulStorers1.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(toDhtAddress(entry.key), true)
-        // Wait for the delete operation to propagate
-        await wait(500)
-        const fetchingNode = getRandomNode()
-        const results1 = await fetchingNode.fetchDataFromDht(toDhtAddress(entry.key))
-        results1.forEach((result) => {
-            expect(result.deleted).toBeTrue()
-            expectEqualData(result, entry)
-        })
-        const successfulStorers2 = await storingNode.storeDataToDht(toDhtAddress(entry.key), entry.data!)
-        expect(successfulStorers2.length).toBeGreaterThan(4)
-        const results2 = await fetchingNode.fetchDataFromDht(toDhtAddress(entry.key))
-        results2.forEach((result) => {
-            expect(result.deleted).toBeFalse()
-            expectEqualData(result, entry)
-        })
-    }, 90000)
-})

package/test/integration/StoreOnDhtWithThreeNodes.test.ts

@@ -1,59 +0,0 @@
-import { createMockConnectionDhtNode } from '../utils/utils'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { Simulator } from '../../src/connection/simulator/Simulator'
-import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { toDhtAddress } from '../../src/identifiers'
-
-describe('Storing data in DHT with two peers', () => {
-
-    let entryPoint: DhtNode
-    let node1: DhtNode
-    let node2: DhtNode
-    let simulator: Simulator | undefined
-
-    beforeEach(async () => {
-        simulator = new Simulator()
-        entryPoint = await createMockConnectionDhtNode(simulator)
-        node1 = await createMockConnectionDhtNode(simulator)
-        node2 = await createMockConnectionDhtNode(simulator)
-
-        await entryPoint.start()
-        await node1.start()
-        await node2.start()
-
-        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
-        node1.joinDht([entryPoint.getLocalPeerDescriptor()]).catch(() => {})
-        node2.joinDht([entryPoint.getLocalPeerDescriptor()]).catch(() => {})
-        await Promise.all([
-            node1.waitForNetworkConnectivity(),
-            node2.waitForNetworkConnectivity()
-        ])
-    })
-
-    afterEach(async () => {
-        await entryPoint.stop()
-        await node1.stop()
-        await node2.stop()
-        simulator!.stop()
-    })
-
-    it('Node can store on three peer DHT', async () => {
-        const storedData1 = createMockDataEntry()
-        const storedData2 = createMockDataEntry()
-        // Here we effectively test that fetching "null" data doesn't take too long. A test timeout here indicates an issue. 
-        await node1.fetchDataFromDht(toDhtAddress(storedData1.key))
-        await node2.fetchDataFromDht(toDhtAddress(storedData1.key))
-        
-        await node1.storeDataToDht(toDhtAddress(storedData1.key), storedData1.data!)
-        await node2.storeDataToDht(toDhtAddress(storedData1.key), storedData1.data!)
-        await entryPoint.storeDataToDht(toDhtAddress(storedData2.key), storedData2.data!)
-        const foundData1 = await node1.fetchDataFromDht(toDhtAddress(storedData1.key))
-        const foundData2 = await node2.fetchDataFromDht(toDhtAddress(storedData1.key))
-        const foundData3 = await entryPoint.fetchDataFromDht(toDhtAddress(storedData2.key))
-        expectEqualData(foundData1[0], storedData1)
-        expectEqualData(foundData1[1], storedData1)
-        expectEqualData(foundData2[0], storedData1)
-        expectEqualData(foundData2[1], storedData1)
-        expectEqualData(foundData3[0], storedData2)
-    }, 30000)
-})

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -1,51 +0,0 @@
-import { createMockConnectionDhtNode } from '../utils/utils'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { Simulator } from '../../src/connection/simulator/Simulator'
-import { until } from '@streamr/utils'
-import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { toDhtAddress } from '../../src/identifiers'
-
-describe('Storing data in DHT with two peers', () => {
-
-    let entryPoint: DhtNode
-    let otherNode: DhtNode
-    let simulator: Simulator | undefined
-
-    beforeEach(async () => {
-        simulator = new Simulator()
-        entryPoint = await createMockConnectionDhtNode(simulator)
-        otherNode = await createMockConnectionDhtNode(simulator)
-
-        await entryPoint.start()
-        await otherNode.start()
-
-        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
-        await otherNode.joinDht([entryPoint.getLocalPeerDescriptor()])
-    })
-
-    afterEach(async () => {
-        await entryPoint.stop()
-        await otherNode.stop()
-        simulator!.stop()
-    })
-
-    it('Node can store on two peer DHT', async () => {
-        const storedData1 = createMockDataEntry()
-        const storedData2 = createMockDataEntry()
-        await otherNode.storeDataToDht(toDhtAddress(storedData1.key), storedData1.data!)
-        await entryPoint.storeDataToDht(toDhtAddress(storedData2.key), storedData2.data!)
-        const foundData1 = await otherNode.fetchDataFromDht(toDhtAddress(storedData1.key))
-        const foundData2 = await entryPoint.fetchDataFromDht(toDhtAddress(storedData2.key))
-        expectEqualData(foundData1[0], storedData1)
-        expectEqualData(foundData2[0], storedData2)
-    })
-
-    it('Can store on one peer DHT', async () => {
-        await otherNode.stop()
-        await until(() => entryPoint.getNeighborCount() === 0)
-        const storedData = createMockDataEntry()
-        await entryPoint.storeDataToDht(toDhtAddress(storedData.key), storedData.data!)
-        const foundData = await entryPoint.fetchDataFromDht(toDhtAddress(storedData.key))
-        expectEqualData(foundData[0], storedData)
-    }, 60000)
-})

package/test/integration/StoreRpcRemote.test.ts

@@ -1,54 +0,0 @@
-import { RpcCommunicator } from '@streamr/proto-rpc'
-import {
-    StoreDataRequest,
-    StoreDataResponse
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { createMockPeerDescriptor, mockStoreRpc } from '../utils/utils'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { StoreRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
-import { StoreRpcRemote } from '../../src/dht/store/StoreRpcRemote'
-import { createMockDataEntry } from '../utils/mock/mockDataEntry'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
-import { randomDhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
-
-describe('StoreRpcRemote', () => {
-
-    let rpcRemote: StoreRpcRemote
-    let clientRpcCommunicator: RpcCommunicator<DhtCallContext>
-    let serverRpcCommunicator: RpcCommunicator<DhtCallContext>
-    const clientPeerDescriptor = createMockPeerDescriptor()
-    const serverPeerDescriptor = createMockPeerDescriptor()
-    const data = createMockDataEntry()
-    const request: StoreDataRequest = {
-        key: data.key,
-        data: data.data,
-        creator: toDhtAddressRaw(randomDhtAddress()),
-        ttl: 10
-    }
-
-    beforeEach(() => {
-        clientRpcCommunicator = new RpcCommunicator()
-        serverRpcCommunicator = new RpcCommunicator()
-        serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.storeData)
-        clientRpcCommunicator.setOutgoingMessageListener(async (message: RpcMessage) => {
-            serverRpcCommunicator.handleIncomingMessage(message, new DhtCallContext())
-        })
-        serverRpcCommunicator.setOutgoingMessageListener(async (message: RpcMessage) => {
-            clientRpcCommunicator.handleIncomingMessage(message, new DhtCallContext())
-        })
-        rpcRemote = new StoreRpcRemote(clientPeerDescriptor, serverPeerDescriptor, clientRpcCommunicator, StoreRpcClient)
-    })
-
-    it('storeData happy path', async () => {
-        await expect(rpcRemote.storeData(request)).toResolve()
-    })
-
-    it('storeData rejects', async () => {
-        serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.throwStoreDataError)
-        await expect(rpcRemote.storeData(request)).rejects.toThrow(
-            'Could not store data to'
-            + ` ${toNodeId(serverPeerDescriptor)} from ${toNodeId(clientPeerDescriptor)}`
-            + ' Error: Mock'
-        )
-    })
-})