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

package/test/types/global.d.ts

@@ -1 +0,0 @@
-import 'jest-extended'

package/test/unit/AddressTools.test.ts

@@ -1,44 +0,0 @@
-import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../src/helpers/AddressTools'
-
-describe('getAddressFromIceCandidate', () => {
-    it('extract IPv4 address from ICE host candidate', () => {
-        expect(getAddressFromIceCandidate('candidate:1 1 udp 2122262783 203.0.113.180 4444 typ host'))
-            .toEqual('203.0.113.180')
-    })
-
-    it('extract IPv4 address from ICE server reflexive candidate', () => {
-        expect(getAddressFromIceCandidate('candidate:1 1 udp 2122262783 198.51.100.130 4445 typ srflx raddr 0.0.0.0 rport 0'))
-            .toEqual('198.51.100.130')
-    })
-
-    it('extract IPv6 address from ICE candidate', () => {
-        expect(getAddressFromIceCandidate('candidate:1 1 udp 3756231458 2001:db8::4125:918c:4402:cc54 6666 typ host'))
-            .toEqual('2001:db8::4125:918c:4402:cc54')
-    })
-
-    it('fail on mDNS ICE candidate', () => {
-        expect(getAddressFromIceCandidate('candidate:1 1 udp 2122296321 9b36eaac-bb2e-49bb-bb78-21c41c499900.local 7000 typ host')).toBeUndefined()
-    })
-})
-
-describe('isPrivateIPv4', () => {
-    it('return true for range 10.0.0.0/8', () => {
-        expect(isPrivateIPv4('10.11.12.13')).toBe(true)
-    })
-
-    it('return true for range 172.16.0.0/12', () => {
-        expect(isPrivateIPv4('172.16.130.131')).toBe(true)
-    })
-
-    it('return true for range 192.168.0.0/16', () => {
-        expect(isPrivateIPv4('192.168.1.1')).toBe(true)
-    })
-
-    it('return false for a public address', () => {
-        expect(isPrivateIPv4('203.0.113.181')).toBe(false)
-    })
-
-    it('return true for localhost IP address', () => {
-        expect(isPrivateIPv4('127.0.0.1')).toBe(true)
-    })
-})

package/test/unit/AutoCertifierClientFacade.test.ts

@@ -1,58 +0,0 @@
-import EventEmitter from 'eventemitter3'
-import { AutoCertifierClientFacade, IAutoCertifierClient } from '../../src/connection/websocket/AutoCertifierClientFacade'
-import { MockTransport } from '../utils/mock/MockTransport'
-
-class MockAutoCertifierClient extends EventEmitter {
-    start = async () => {
-        this.emit('updatedCertificate', {})
-    }
-    // eslint-disable-next-line class-methods-use-this
-    stop = () => {}
-    emitUpdateSubdomain = () => {
-        this.emit('updatedCertificate', {})
-    }
-}
-
-describe('AutoCertifierClientFacade', () => {
-
-    let client: AutoCertifierClientFacade
-    let mockClient: IAutoCertifierClient
-    let setHost: jest.Mock
-    let updateCertificate: jest.Mock
-
-    beforeEach(() => {
-        mockClient = new MockAutoCertifierClient()
-        const mockClientFactory = (): IAutoCertifierClient => mockClient
-        setHost = jest.fn()
-        updateCertificate = jest.fn()
-        client = new AutoCertifierClientFacade({
-            url: '',
-            configFile: '',
-            transport: new MockTransport(),
-            wsServerPort: 0,
-            setHost,
-            updateCertificate,
-            createClientFactory: mockClientFactory
-        })
-    }) 
-
-    afterEach(() => {
-        client.stop()
-    })
-
-    it('start', async () => {
-        await client.start()
-        expect(setHost).toHaveBeenCalled()
-        expect(updateCertificate).toHaveBeenCalled()
-    })
-
-    it('updated events are processed', async () => {
-        await client.start()
-        expect(setHost).toHaveBeenCalledTimes(1)
-        expect(updateCertificate).toHaveBeenCalledTimes(1);
-        (mockClient as MockAutoCertifierClient).emitUpdateSubdomain()
-        expect(setHost).toHaveBeenCalledTimes(2)
-        expect(updateCertificate).toHaveBeenCalledTimes(2)
-    })
-
-})

package/test/unit/ConnectionManager.test.ts

@@ -1,65 +0,0 @@
-import { MetricsContext } from '@streamr/utils'
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { toNodeId, PendingConnection } from '../../src/exports'
-import { FakeConnectorFacade } from '../utils/FakeConnectorFacade'
-import { MockConnection } from '../utils/mock/MockConnection'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { getOfferer } from '../../src/helpers/offering'
-
-describe('ConnetionManager', () => {
-
-    let connectionManager: ConnectionManager
-    let fakeConnectorFacade: FakeConnectorFacade
-    const localPeerDescriptor = createMockPeerDescriptor()
-
-    beforeEach(async () => {
-        connectionManager = new ConnectionManager({
-            metricsContext: new MetricsContext(),
-            allowIncomingPrivateConnections: false,
-            createConnectorFacade: () => { 
-                fakeConnectorFacade = new FakeConnectorFacade(localPeerDescriptor)
-                return fakeConnectorFacade
-            }
-        })
-        await connectionManager.start()
-    })
-
-    afterEach(async () => {
-        await connectionManager.stop()
-    })
-
-    it('should replace a duplicate connecting connection', () => {
-        const remotePeerDescriptor = createMockPeerDescriptor()
-        const pendingConnection1 = new PendingConnection(remotePeerDescriptor)
-        const offerer = getOfferer(toNodeId(localPeerDescriptor), toNodeId(remotePeerDescriptor))
-        const accepted1 = fakeConnectorFacade.callOnNewConnection(pendingConnection1)
-        expect(accepted1).toBeTrue()
-        const pendingConnection2 = new PendingConnection(remotePeerDescriptor)
-        const accepted2 = fakeConnectorFacade.callOnNewConnection(pendingConnection2)
-
-        expect(accepted2).toBe(offerer === 'remote')
-
-        pendingConnection1.close(true)
-        pendingConnection2.close(true)
-    })
-
-    it('should replace a duplicate connected connection', () => {
-        const remotePeerDescriptor = createMockPeerDescriptor()
-        const pendingConnection1 = new PendingConnection(remotePeerDescriptor)
-        const offerer = getOfferer(toNodeId(localPeerDescriptor), toNodeId(remotePeerDescriptor))
-        const accepted1 = fakeConnectorFacade.callOnNewConnection(pendingConnection1)
-        expect(accepted1).toBeTrue()
-        pendingConnection1.onHandshakeCompleted(new MockConnection())
-        const pendingConnection2 = new PendingConnection(remotePeerDescriptor)
-        const accepted2 = fakeConnectorFacade.callOnNewConnection(pendingConnection2)
-        if (accepted2) {
-            pendingConnection1.onHandshakeCompleted(new MockConnection())
-        }
-        expect(accepted2).toBe(offerer === 'remote')
-
-        pendingConnection1.close(true)
-        pendingConnection2.close(true)
-    })
-
-})
-

package/test/unit/ConnectivityHelpers.test.ts

@@ -1,61 +0,0 @@
-import { NodeType } from '../../generated/packages/dht/protos/DhtRpc'
-import { expectedConnectionType } from '../../src/helpers/Connectivity'
-import { ConnectionType } from '../../src/connection/IConnection'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('Connectivity helpers', () => {
-
-    const tlsServerPeerDescriptor = createMockPeerDescriptor({
-        websocket: {
-            host: 'mock',
-            port: 1234,
-            tls: true
-        }
-    })
-    const noTlsServerPeerDescriptor = createMockPeerDescriptor({
-        websocket: {
-            host: 'mock',
-            port: 1234,
-            tls: false
-        }
-    })
-    const browserPeerDescriptor = createMockPeerDescriptor({
-        type: NodeType.BROWSER
-    })
-    const noServerPeerDescriptor = createMockPeerDescriptor({
-        type: NodeType.NODEJS
-    })
-
-    it('two server peers', () => {
-        expect(expectedConnectionType(tlsServerPeerDescriptor, tlsServerPeerDescriptor)).toBe(ConnectionType.WEBSOCKET_CLIENT)
-    })
-
-    it('server to noServer', () => {
-        expect(expectedConnectionType(tlsServerPeerDescriptor, noServerPeerDescriptor)).toBe(ConnectionType.WEBSOCKET_SERVER)
-    })
-
-    it('no server to server', () => {
-        expect(expectedConnectionType(noServerPeerDescriptor, tlsServerPeerDescriptor)).toBe(ConnectionType.WEBSOCKET_CLIENT)
-    })
-
-    it('no server to no server', () => {
-        expect(expectedConnectionType(noServerPeerDescriptor, noServerPeerDescriptor)).toBe(ConnectionType.WEBRTC)
-    })
-
-    it('browser to tls server', () => {
-        expect(expectedConnectionType(browserPeerDescriptor, tlsServerPeerDescriptor)).toBe(ConnectionType.WEBSOCKET_CLIENT)
-    })
-
-    it('tls server to browser', () => {
-        expect(expectedConnectionType(tlsServerPeerDescriptor, browserPeerDescriptor)).toBe(ConnectionType.WEBSOCKET_SERVER)
-    })
-
-    it('browser to no tls server', () => {
-        expect(expectedConnectionType(browserPeerDescriptor, noTlsServerPeerDescriptor)).toBe(ConnectionType.WEBRTC)
-    })
-
-    it('no tls server to browser', () => {
-        expect(expectedConnectionType(noTlsServerPeerDescriptor, browserPeerDescriptor)).toBe(ConnectionType.WEBRTC)
-    })
-
-})

package/test/unit/DiscoverySession.test.ts

@@ -1,87 +0,0 @@
-import { Multimap, wait } from '@streamr/utils'
-import { sampleSize } from 'lodash'
-import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
-import { PeerManager, getDistance } from '../../src/dht/PeerManager'
-import { DiscoverySession } from '../../src/dht/discovery/DiscoverySession'
-import { DhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
-import { NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { createTestTopology } from '../utils/topology'
-import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
-
-const NODE_COUNT = 40
-const MIN_NEIGHBOR_COUNT = 2  // nodes can get more neighbors when we merge network partitions
-const PARALLELISM = 1
-const NO_PROGRESS_LIMIT = 1
-const QUERY_BATCH_SIZE = 5  // the default value in DhtNode's options, not relevant in this test
-
-const createPeerDescriptor = (nodeId: DhtAddress): PeerDescriptor => {
-    return {
-        nodeId: toDhtAddressRaw(nodeId),
-        type: NodeType.NODEJS
-    }
-}
-
-describe('DiscoverySession', () => {
-
-    let topology: Multimap<DhtAddress, DhtAddress>
-    const queriedNodes: DhtAddress[] = []
-
-    beforeAll(() => {
-        topology = createTestTopology(NODE_COUNT, MIN_NEIGHBOR_COUNT)
-    })
-
-    const createPeerManager = (localNodeId: DhtAddress): PeerManager => {
-        const peerManager = new PeerManager({
-            localNodeId,
-            localPeerDescriptor: createPeerDescriptor(localNodeId),
-            isLayer0: true,
-            createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => createMockRpcRemote(peerDescriptor) as any,
-            hasConnection: () => true
-        } as any)
-        for (const neighbor of topology.get(localNodeId)) {
-            peerManager.addContact(createPeerDescriptor(neighbor))
-        }
-        return peerManager
-    }
-
-    const createMockRpcRemote = (peerDescriptor: PeerDescriptor): Partial<DhtNodeRpcRemote> => {
-        const nodeId = toNodeId(peerDescriptor)
-        return {
-            id: toDhtAddressRaw(nodeId),
-            getPeerDescriptor: () => peerDescriptor,
-            getNodeId: () => nodeId,
-            getClosestPeers: async (referenceId: DhtAddress) => {
-                queriedNodes.push(nodeId)
-                await wait(10)
-                const peerManager = createPeerManager(nodeId)
-                return getClosestNodes(referenceId, peerManager.getNeighbors().map((n) => n.getPeerDescriptor()), { maxCount: QUERY_BATCH_SIZE })
-            },
-            ping: async () => true
-        }
-    }
-
-    it('happy path', async () => {
-        const nodeIds = [...topology.keys()]
-        const [localNodeId, targetId] = sampleSize(nodeIds, 2)
-        const contactedPeers = new Set<DhtAddress>()
-        const peerManager = createPeerManager(localNodeId)
-        const session = new DiscoverySession({
-            targetId,
-            parallelism: PARALLELISM,
-            noProgressLimit: NO_PROGRESS_LIMIT,
-            peerManager,
-            contactedPeers,
-            abortSignal: new AbortController().signal,
-            createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => createMockRpcRemote(peerDescriptor) as any
-        })
-        await session.findClosestNodes(1000)
-        expect(queriedNodes.length).toBeGreaterThanOrEqual(1)
-        // Each queried node should closer to the target than the previous queried node, because we
-        // use parallelism=1 and noProgressLimit=1
-        const distancesToTarget = queriedNodes
-            .map((nodeId) => getDistance(toDhtAddressRaw(nodeId), toDhtAddressRaw(targetId)))
-        for (let i = 1; i < distancesToTarget.length ; i++) {
-            expect(distancesToTarget[i]).toBeLessThan(distancesToTarget[i - 1])
-        }
-    })
-})

package/test/unit/DuplicateDetector.test.ts

@@ -1,31 +0,0 @@
-import { DuplicateDetector } from '../../src/dht/routing/DuplicateDetector'
-
-const MAX_VALUE_COUNT = 10
-
-describe('Duplicate Detector', () => {
-
-    let detector: DuplicateDetector
-
-    beforeEach(async () => {
-        detector = new DuplicateDetector(MAX_VALUE_COUNT)
-    })
-
-    it('detects duplicates', async () => {
-        detector.add('test')
-        expect(detector.size()).toEqual(1)
-        expect(detector.isMostLikelyDuplicate('test')).toEqual(true)
-    })
-
-    it('removes from tail when full', () => {
-        for (let i = 0; i < MAX_VALUE_COUNT; i++) {
-            detector.add(`test${i}`)
-        }
-        for (let i = 0; i < MAX_VALUE_COUNT; i++) {
-            expect(detector.isMostLikelyDuplicate(`test${i}`)).toEqual(true)
-        }
-        detector.add('test10')
-        expect(detector.size()).toEqual(10)
-        expect(detector.isMostLikelyDuplicate('test0')).toEqual(false)
-        expect(detector.isMostLikelyDuplicate('test10')).toEqual(true)
-    })
-})

package/test/unit/Handshaker.test.ts

@@ -1,169 +0,0 @@
-import EventEmitter from 'eventemitter3'
-import { 
-    acceptHandshake,
-    createHandshakeRequest,
-    createHandshakeResponse,
-    createIncomingHandshaker,
-    createOutgoingHandshaker,
-    Handshaker,
-    rejectHandshake
-} from '../../src/connection/Handshaker'
-import { ConnectionEvents, IConnection } from '../../src/connection/IConnection'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { HandshakeError, Message } from '../../generated/packages/dht/protos/DhtRpc'
-import { PendingConnection } from '../../src/connection/PendingConnection'
-
-describe('Handshaker', () => {
-
-    let handshaker: Handshaker
-    let pendingConnection: PendingConnection
-    let connection: IConnection
-
-    let mockOnHandshakeCompleted: () => void
-    let mockSend: () => void
-    let mockConnectionClose: () => void
-    let mockPendingConnectionClose: () => void
-    let mockPendingConnectionDestroy: () => void
-    let mockConnectionDestroy: () => void
-
-    beforeEach(() => {
-        mockOnHandshakeCompleted = jest.fn()
-        mockPendingConnectionClose = jest.fn()
-        mockPendingConnectionDestroy = jest.fn()
-        mockConnectionDestroy = jest.fn()
-        pendingConnection = new class extends EventEmitter {
-            // eslint-disable-next-line class-methods-use-this
-            attachConnection() { 
-                mockOnHandshakeCompleted()
-            }
-            // eslint-disable-next-line class-methods-use-this
-            close() {
-                mockPendingConnectionClose()
-            }
-
-            // eslint-disable-next-line class-methods-use-this
-            destroy() {
-                mockPendingConnectionDestroy()
-            }
-
-            // eslint-disable-next-line class-methods-use-this
-            onHandshakeCompleted(_connection: IConnection) {
-                mockOnHandshakeCompleted()
-            }
-        } as any
-
-        mockSend = jest.fn()
-        mockConnectionClose = jest.fn()
-        connection = new class extends EventEmitter<ConnectionEvents> {
-            // eslint-disable-next-line class-methods-use-this
-            send(_message: any) {
-                mockSend()
-            }
-            // eslint-disable-next-line class-methods-use-this
-            close() {
-                mockConnectionClose()
-            }
-
-            // eslint-disable-next-line class-methods-use-this
-            destroy() {
-                mockConnectionDestroy()
-            }
-        } as any    
-    })
-
-    describe('Outgoing', () => {
-
-        beforeEach(() => {
-            handshaker = createOutgoingHandshaker(
-                createMockPeerDescriptor(),
-                pendingConnection,
-                connection,
-                createMockPeerDescriptor()
-            )
-        })
-
-        afterEach(() => {
-            handshaker.stop()
-        })
-
-        it('sends request after connected', () => {
-            (connection as any).emit('connected')
-            expect(mockSend).toHaveBeenCalledTimes(1)
-        })
-
-        it('onHandshakeCompleted', () => {
-            const message = createHandshakeResponse(createMockPeerDescriptor());
-            (connection as any).emit('data', Message.toBinary(message))
-            handshaker.emit('handshakeCompleted', createMockPeerDescriptor())
-            expect(mockOnHandshakeCompleted).toHaveBeenCalledTimes(1)
-        })
-
-        it('onHandshakeFailed invalid PeerDescriptor', () => {
-            handshaker.emit('handshakeFailed', HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
-            expect(mockOnHandshakeCompleted).not.toHaveBeenCalled()
-        })
-
-        it('onHandshakeFailed unsupported version', () => {
-            handshaker.emit('handshakeFailed', HandshakeError.UNSUPPORTED_PROTOCOL_VERSION)
-            expect(mockOnHandshakeCompleted).not.toHaveBeenCalled()
-            expect(mockPendingConnectionClose).toHaveBeenCalledTimes(1)
-        })
-
-        it('onHandShakeFailed ', () => {
-            handshaker.emit('handshakeFailed', HandshakeError.DUPLICATE_CONNECTION)
-            expect(mockPendingConnectionDestroy).not.toHaveBeenCalled()
-            expect(mockOnHandshakeCompleted).not.toHaveBeenCalled()
-        })
-
-        it('calls pending connection close if connection closes', () => {
-            (connection as any).emit('disconnected')
-            expect(mockPendingConnectionClose).toHaveBeenCalledTimes(1)
-        })
-
-        it('closes connection if managed connection closes', () => {
-            (pendingConnection as any).emit('disconnected')
-            expect(mockConnectionClose).toHaveBeenCalledTimes(1)
-        })
-
-    })
-
-    describe('Incoming', () => {
-
-        beforeEach(() => {
-            handshaker = createIncomingHandshaker(createMockPeerDescriptor(), pendingConnection, connection)
-        })
-
-        afterEach(() => {
-            handshaker.stop()
-        })
-
-        it('onHandshakeRequest', () => {
-            const message = createHandshakeRequest(createMockPeerDescriptor(), createMockPeerDescriptor());
-            (connection as any).emit('data', Message.toBinary(message))
-            handshaker.emit('handshakeRequest', createMockPeerDescriptor(), '1.0')
-        })
-
-        it('calls pending connection onDisconnected if connection closes', () => {
-            (connection as any).emit('disconnected')
-            expect(mockPendingConnectionClose).toHaveBeenCalledTimes(1)
-        })
-
-        it('closes connection if managed connection closes', () => {
-            (pendingConnection as any).emit('disconnected')
-            expect(mockConnectionClose).toHaveBeenCalledTimes(1)
-        })
-
-        it('destroys connection if handshake is rejected', () => {
-            rejectHandshake(pendingConnection, connection, handshaker, HandshakeError.DUPLICATE_CONNECTION)
-            expect(mockPendingConnectionDestroy).toHaveBeenCalled()
-            expect(mockConnectionDestroy).toHaveBeenCalled()
-        })
-
-        it('calls onHandshakeCompleted if handshake is accepted', () => {
-            acceptHandshake(handshaker, pendingConnection, connection)
-            expect(mockOnHandshakeCompleted).toHaveBeenCalled()
-        })
-
-    })
-
-})

package/test/unit/ListeningRpcCommunicator.test.ts

@@ -1,52 +0,0 @@
-import { until } from '@streamr/utils'
-import { ListeningRpcCommunicator } from '../../src/transport/ListeningRpcCommunicator'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { RpcMessage } from '@streamr/proto-rpc'
-import { Deferred, RpcMetadata, RpcStatus } from '@protobuf-ts/runtime-rpc'
-
-const createDeferredPromises = () => {
-
-    const defHeader = new Deferred<RpcMetadata>()
-    const defMessage = new Deferred<any>()
-    const defStatus = new Deferred<RpcStatus>()
-    const defTrailer = new Deferred<RpcMetadata>()
-    
-    const deferredParser = () => {}
-    return {
-        message: defMessage,
-        header: defHeader,
-        trailer: defTrailer,
-        status: defStatus,
-        messageParser: deferredParser as any
-    }
-}
-
-describe('ListeningRpcCommunicator', () => {
-    const SERVICE_ID = 'test'
-    let rpcCommunicator: ListeningRpcCommunicator
-    let transport: MockTransport
-
-    beforeEach(() => {
-        transport = new MockTransport()
-        rpcCommunicator = new ListeningRpcCommunicator(SERVICE_ID, transport)
-    })
-
-    afterEach(() => {
-        rpcCommunicator.destroy()
-        transport.stop()
-    })
-
-    it('rejects requests on disconnect event to the target', async () => {
-        const peerDescriptor = createMockPeerDescriptor()
-        rpcCommunicator.getRpcClientTransport().emit(
-            'rpcRequest',
-            RpcMessage.create(),
-            { targetDescriptor: peerDescriptor }, createDeferredPromises()
-        )
-        await until(() => rpcCommunicator.getRequestIds(() => true).length > 0)
-        transport.emit('disconnected', peerDescriptor, false)
-        await until(() => rpcCommunicator.getRequestIds(() => true).length === 0)
-    }, 10000)
-
-})

package/test/unit/LocalDataStore.test.ts

@@ -1,108 +0,0 @@
-import { wait } from '@streamr/utils'
-import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { createMockDataEntry } from '../utils/mock/mockDataEntry'
-import { randomDhtAddress, toDhtAddress, toNodeId } from '../../src/identifiers'
-
-describe('LocalDataStore', () => {
-
-    let localDataStore: LocalDataStore
-
-    beforeEach(() => {
-        localDataStore = new LocalDataStore(30 * 1000)
-    })
-
-    afterEach(() => {
-        localDataStore.clear()
-    })
-
-    it('can store', () => {
-        const storedEntry = createMockDataEntry()
-        localDataStore.storeEntry(storedEntry)
-        const fetchedEntries = Array.from(localDataStore.values(toDhtAddress(storedEntry.key)))
-        expect(fetchedEntries).toIncludeSameMembers([storedEntry])
-    })
-
-    it('multiple storers behind one key', () => {
-        const creator1 = randomDhtAddress()
-        const creator2 = randomDhtAddress()
-        const key = randomDhtAddress()
-        const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
-        const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
-        localDataStore.storeEntry(storedEntry1)
-        localDataStore.storeEntry(storedEntry2)
-        const fetchedEntries = Array.from(localDataStore.values(key))
-        expect(fetchedEntries).toIncludeSameMembers([storedEntry1, storedEntry2])
-    })
-
-    it('can remove data entries', () => {
-        const creator1 = randomDhtAddress()
-        const creator2 = randomDhtAddress()
-        const key = randomDhtAddress()
-        const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
-        const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
-        localDataStore.storeEntry(storedEntry1)
-        localDataStore.storeEntry(storedEntry2)
-        localDataStore.deleteEntry(key, creator1)
-        const fetchedEntries = Array.from(localDataStore.values(key))
-        expect(fetchedEntries).toIncludeSameMembers([storedEntry2])
-    })
-
-    it('can remove all data entries', () => {
-        const creator1 = randomDhtAddress()
-        const creator2 = randomDhtAddress()
-        const key = randomDhtAddress()
-        const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
-        const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
-        localDataStore.storeEntry(storedEntry1)
-        localDataStore.storeEntry(storedEntry2)
-        localDataStore.deleteEntry(key, creator1)
-        localDataStore.deleteEntry(key, creator2)
-        expect(Array.from(localDataStore.values(key))).toHaveLength(0)
-    })
-
-    it('data is deleted after TTL', async () => {
-        const storedEntry = createMockDataEntry({ ttl: 1000 })
-        localDataStore.storeEntry(storedEntry)
-        expect(Array.from(localDataStore.values(toDhtAddress(storedEntry.key)))).toHaveLength(1)
-        await wait(1100)
-        expect(Array.from(localDataStore.values(toDhtAddress(storedEntry.key)))).toHaveLength(0)
-    })
-
-    describe('mark data as deleted', () => {
-
-        it('happy path', () => {
-            const creator1 = randomDhtAddress()
-            const storedEntry = createMockDataEntry({ creator: creator1 })
-            localDataStore.storeEntry(storedEntry)
-            const notDeletedData = Array.from(localDataStore.values(toDhtAddress(storedEntry.key)))
-            expect(notDeletedData[0].deleted).toBeFalse()
-            const returnValue = localDataStore.markAsDeleted(
-                toDhtAddress(storedEntry.key),
-                creator1
-            )
-            expect(returnValue).toBe(true)
-            const deletedData = Array.from(localDataStore.values(toDhtAddress(storedEntry.key)))
-            expect(deletedData[0].deleted).toBeTrue()
-        })
-
-        it('data not stored', () => {
-            const key = randomDhtAddress()
-            const returnValue = localDataStore.markAsDeleted(
-                key,
-                toNodeId(createMockPeerDescriptor())
-            )
-            expect(returnValue).toBe(false)
-        })
-
-        it('data not stored by the given creator', () => {
-            const storedEntry = createMockDataEntry()
-            localDataStore.storeEntry(storedEntry)
-            const returnValue = localDataStore.markAsDeleted(
-                toDhtAddress(storedEntry.key),
-                toNodeId(createMockPeerDescriptor())
-            )
-            expect(returnValue).toBe(false)
-        })
-    })
-})