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

package/test/unit/ManagedConnection.test.ts

@@ -1,58 +0,0 @@
-import { wait } from '@streamr/utils'
-import { ManagedConnection } from '../../src/exports'
-import { MockConnection } from '../utils/mock/MockConnection'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('ManagedConnection', () => {
-
-    let managedConnection: ManagedConnection
-    let connection: MockConnection
-    beforeEach(() => {
-        connection = new MockConnection()
-        managedConnection = new ManagedConnection(createMockPeerDescriptor(), connection)
-    })
-
-    afterEach(() => {
-        managedConnection.close(false)
-    })
-
-    it('emits disconnected after close', (done) => {
-        managedConnection.once('disconnected', (graceful) => {
-            expect(graceful).toBe(true)
-            done()
-        })
-        managedConnection.close(true)
-    })
-
-    it('sends data', () => {
-        const data = new Uint8Array([1, 2, 3])
-        managedConnection.send(data)
-        expect(connection.sentData[0]).toEqual(data)
-    })
-
-    it('emits data', (done) => {
-        const data = new Uint8Array([1, 2, 3])
-        managedConnection.on('managedData', (data) => {
-            expect(data).toEqual(data)
-            done()
-        })
-        connection.emitData(data)
-    })
-
-    it('sets lastUsedTimestamp on send', async () => {
-        const createdTimestamp = managedConnection.getLastUsedTimestamp()
-        await wait(5)
-        managedConnection.send(new Uint8Array([1, 2, 3]))
-        expect(managedConnection.getLastUsedTimestamp()).toBeGreaterThan(createdTimestamp)
-    })
-
-    it('replace as duplicate', async () => {
-        managedConnection.once('disconnected', () => {
-            throw new Error('disconnected')
-        })
-        managedConnection.replaceAsDuplicate()
-        managedConnection.close(true)
-        await wait(50)
-    })
-
-})

package/test/unit/PeerManager.test.ts

@@ -1,93 +0,0 @@
-import { waitForCondition } from '@streamr/utils'
-import { range, sample, sampleSize } from 'lodash'
-import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
-import { PeerManager } from '../../src/dht/PeerManager'
-import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
-import { DhtAddress, randomDhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
-import { NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const createDhtNodeRpcRemote = (
-    peerDescriptor: PeerDescriptor,
-    localPeerDescriptor: PeerDescriptor,
-    pingFailures: Set<DhtAddress>
-) => {
-    const remote = new class extends DhtNodeRpcRemote {
-        // eslint-disable-next-line class-methods-use-this
-        async ping(): Promise<boolean> {
-            return !pingFailures.has(toNodeId(peerDescriptor))
-        }
-    }(localPeerDescriptor, peerDescriptor, undefined as any, new MockRpcCommunicator())
-    return remote
-}
-
-const createPeerManager = (
-    nodeIds: DhtAddress[], 
-    localPeerDescriptor = createMockPeerDescriptor(),
-    pingFailures: Set<DhtAddress> = new Set()
-) => {
-    const manager = new PeerManager({
-        localNodeId: toNodeId(localPeerDescriptor),
-        localPeerDescriptor: localPeerDescriptor,
-        isLayer0: true,
-        createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => createDhtNodeRpcRemote(peerDescriptor, localPeerDescriptor, pingFailures),
-        hasConnection: () => false
-    } as any)
-    const contacts = nodeIds.map((n) => ({ nodeId: toDhtAddressRaw(n), type: NodeType.NODEJS }))
-    for (const contact of contacts) {
-        manager.addContact(contact)
-    }
-    return manager
-}
-
-describe('PeerManager', () => {
-
-    it('getNearbyContactCount', () => {
-        const nodeIds = range(10).map(() => randomDhtAddress())
-        const manager = createPeerManager(nodeIds)
-        expect(manager.getNearbyContactCount()).toBe(10)
-        expect(manager.getNearbyContactCount(new Set(sampleSize(nodeIds, 2)))).toBe(8)
-        expect(manager.getNearbyContactCount(new Set([sample(nodeIds)!, randomDhtAddress()]))).toBe(9)
-    })
-
-    it('addContact: ping fails', async () => {
-        const localPeerDescriptor = createMockPeerDescriptor()
-        const successContacts = range(5).map(() => createMockPeerDescriptor())
-        const failureContact = createMockPeerDescriptor()
-        const manager = createPeerManager([], localPeerDescriptor, new Set([toNodeId(failureContact)]))
-        for (const successContact of successContacts) {
-            manager.addContact(successContact)
-            manager.setContactActive(toNodeId(successContact))
-            manager.removeNeighbor(toNodeId(successContact))
-        }
-        expect(manager.getNeighborCount()).toBe(0)
-        manager.addContact(failureContact)
-        const closesSuccessContact = getClosestNodes(toNodeId(localPeerDescriptor), successContacts)[0]
-        await waitForCondition(() => {
-            const neighborNodeIds = manager.getNeighbors().map((n) => n.getNodeId())
-            return neighborNodeIds.includes(toNodeId(closesSuccessContact))
-        })
-        expect(manager.getNeighborCount()).toBe(1)
-        expect(manager.getNeighbors()[0].getPeerDescriptor()).toEqualPeerDescriptor(closesSuccessContact)
-    })
-
-    it('pruneOfflineNodes removes offline nodes', async () => {
-        const localPeerDescriptor = createMockPeerDescriptor()
-        const successContacts = range(5).map(() => createMockPeerDescriptor())
-        const failureContact = createMockPeerDescriptor()
-        const failureSet: Set<DhtAddress> = new Set()
-        const manager = createPeerManager([], localPeerDescriptor, failureSet)
-        for (const successContact of successContacts) {
-            manager.addContact(successContact)
-        }
-        manager.addContact(failureContact)
-        expect(manager.getNeighborCount()).toBe(6)
-        failureSet.add(toNodeId(failureContact))
-        await manager.pruneOfflineNodes(
-            manager.getNeighbors().map((node) => createDhtNodeRpcRemote(node.getPeerDescriptor(), localPeerDescriptor, failureSet))
-        )
-        expect(manager.getNeighborCount()).toBe(5)
-    })
-
-})

package/test/unit/PendingConnection.test.ts

@@ -1,57 +0,0 @@
-import { wait, waitForEvent3 } from '@streamr/utils'
-import { PendingConnection } from '../../src/exports'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { PendingConnectionEvents } from '../../src/connection/PendingConnection'
-import { MockConnection } from '../utils/mock/MockConnection'
-
-describe('PendingConnection', () => {
-
-    let pendingConnection: PendingConnection
-    
-    beforeEach(() => {
-        pendingConnection = new PendingConnection(createMockPeerDescriptor(), 500)
-    })
-
-    afterEach(() => {
-        pendingConnection.close(false)
-    })
-
-    it('does not emit disconnected after replacedAsDuplicate', async () => {
-        pendingConnection.once('disconnected', () => {
-            throw new Error('disconnected')
-        })
-        pendingConnection.replaceAsDuplicate()
-        pendingConnection.close(false)
-        await wait(50)
-    })
-
-    it('emits disconnected after timed out', async () => {
-        await waitForEvent3<PendingConnectionEvents>(pendingConnection, 'disconnected')  
-    })
-
-    it('does not emit disconnected if destroyed', async () => {
-        pendingConnection.once('disconnected', () => {
-            throw new Error('disconnected')
-        })
-        pendingConnection.destroy()
-        await wait(50)
-    })
-
-    it('emites connected', (done) => {
-        const mockConnection = new MockConnection()
-        pendingConnection.once('connected', (_peerDescriptor, connection) => {
-            expect(mockConnection).toEqual(connection)
-            done()
-        })
-        pendingConnection.onHandshakeCompleted(mockConnection)
-    }) 
-
-    it('does not emit connected if replaced', async () => {
-        pendingConnection.once('connected', () => {
-            throw new Error('connected')
-        })
-        pendingConnection.replaceAsDuplicate()
-        await wait(50)
-    })
-
-})

package/test/unit/ProtobufMessage.test.ts

@@ -1,21 +0,0 @@
-/*
-import { ProtobufMessage } from '../../src/protobufclasses/ProtobufMessage'
-import { Message, RpcMessage } from '../../generated/DhtRpc'
-import { v4 } from 'uuid'
-import { MessageType } from '@protobuf-ts/runtime'
-*/
-
-describe('ProtobufMessage', () => {
-
-    it('can parse and print a Message', async () => {
-        
-        /*
-        const message: Message = {
-            messageId: v4(),
-            messageType: 
-        }
-        const data = Message.toBinary(message)
-        ProtobufMessage.fromBinary(data)
-        */
-    })
-})

package/test/unit/RandomContactList.test.ts

@@ -1,58 +0,0 @@
-import { RandomContactList } from '../../src/dht/contact/RandomContactList'
-import { DhtAddress, DhtAddressRaw, toDhtAddress } from '../../src/identifiers'
-
-const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress } => {
-    return { 
-        getNodeId: () => toDhtAddress(nodeId)
-    }
-}
-
-describe('RandomContactList', () => {
-
-    const item0 = createItem(new Uint8Array([0, 0, 0, 0]))
-    const item1 = createItem(new Uint8Array([0, 0, 0, 1]))
-    const item2 = createItem(new Uint8Array([0, 0, 0, 2]))
-    const item3 = createItem(new Uint8Array([0, 0, 0, 3]))
-    const item4 = createItem(new Uint8Array([0, 0, 0, 4]))
-
-    it('adds contacts correctly', () => {
-        const list = new RandomContactList(item0.getNodeId(), 5, 1)
-        list.addContact(item1)
-        list.addContact(item2)
-        list.addContact(item3)
-        list.addContact(item3)
-        list.addContact(item4)
-        list.addContact(item4)
-        expect(list.getSize()).toEqual(4)
-        expect(list.getContacts()).toEqual(
-            [item1, item2, item3, item4]
-        )
-    })
-
-    it('removes contacts correctly', () => {
-        const list = new RandomContactList(item0.getNodeId(), 5, 1)
-        list.addContact(item1)
-        list.addContact(item2)
-        list.addContact(item3)
-        list.addContact(item4)
-        list.removeContact(item2.getNodeId())
-        expect(list.getContact(item1.getNodeId())).toBeTruthy()
-        expect(list.getContact(item3.getNodeId())).toBeTruthy()
-        expect(list.getContact(item4.getNodeId())).toBeTruthy()
-        expect(list.getContacts()).toEqual(
-            [item1, item3, item4]
-        )
-        expect(list.getSize()).toEqual(3)
-    })
-
-    it('get contacts', () => {
-        const list = new RandomContactList(item0.getNodeId(), 5, 1)
-        list.addContact(item1)
-        list.addContact(item2)
-        list.addContact(item3)
-        list.addContact(item4)
-        expect(list.getContacts()).toHaveLength(4)
-        expect(list.getContacts(3)).toHaveLength(3)
-        expect(list.getContacts(-2)).toHaveLength(0)
-    })
-})

package/test/unit/RecursiveOperationManager.test.ts

@@ -1,161 +0,0 @@
-import {
-    RecursiveOperation,
-    Message,
-    RouteMessageAck,
-    RouteMessageError,
-    RouteMessageWrapper,
-    RecursiveOperationRequest
-} from '../../generated/packages/dht/protos/DhtRpc'
-import {
-    createWrappedClosestPeersRequest,
-    createMockPeerDescriptor
-} from '../utils/utils'
-import { RecursiveOperationManager } from '../../src/dht/recursive-operation/RecursiveOperationManager'
-import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
-import { v4 } from 'uuid'
-import { MockRouter } from '../utils/mock/MockRouter'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
-import { Router } from '../../src/dht/routing/Router'
-import { ITransport } from '../../src/transport/ITransport'
-import { areEqualPeerDescriptors, randomDhtAddress } from '../../src/identifiers'
-import { MockConnectionsView } from '../utils/mock/MockConnectionsView'
-
-const createMockRouter = (error?: RouteMessageError): Partial<Router> => {
-    return {
-        doRouteMessage: (routedMessage: RouteMessageWrapper) => {
-            return {
-                requestId: routedMessage.requestId,
-                error
-            }
-        },
-        isMostLikelyDuplicate: () => false,
-        addToDuplicateDetector: () => {}
-    }
-}
-
-const createRequest = (): RecursiveOperationRequest => {
-    const request: RecursiveOperationRequest = {
-        operation: RecursiveOperation.FIND_CLOSEST_NODES,
-        sessionId: v4()
-    }
-    return request
-}
-
-describe('RecursiveOperationManager', () => {
-
-    const peerDescriptor1 = createMockPeerDescriptor()
-    const peerDescriptor2 = createMockPeerDescriptor()
-    const recursiveOperationRequest = createRequest()
-    const message: Message = {
-        serviceId: 'unknown',
-        messageId: v4(),
-        body: {
-            oneofKind: 'recursiveOperationRequest',
-            recursiveOperationRequest
-        },
-        sourceDescriptor: peerDescriptor1,
-        targetDescriptor: peerDescriptor2
-    }
-    const routedMessage: RouteMessageWrapper = {
-        message,
-        requestId: 'REQ',
-        routingPath: [],
-        reachableThrough: [],
-        sourcePeer: peerDescriptor1,
-        target: peerDescriptor2.nodeId,
-        parallelRootNodeIds: []
-    }
-    const rpcCommunicator = new FakeRpcCommunicator()
-
-    const createRecursiveOperationManager = (
-        router: Router = new MockRouter() as any,
-        transport: ITransport = new MockTransport()
-    ): RecursiveOperationManager => {
-        return new RecursiveOperationManager({
-            localPeerDescriptor: peerDescriptor1,
-            router,
-            serviceId: 'RecursiveOperationManager',
-            localDataStore: new LocalDataStore(30 * 100),
-            sessionTransport: transport,
-            connectionsView: new MockConnectionsView(),
-            addContact: () => {},
-            rpcCommunicator: rpcCommunicator as any,
-            createDhtNodeRpcRemote: () => undefined as any
-        })
-    }
-
-    it('RecursiveOperationManager server', async () => {
-        const recursiveOperationManager = createRecursiveOperationManager()
-        const res = await rpcCommunicator.callRpcMethod('routeRequest', routedMessage) as RouteMessageAck
-        expect(res.error).toBeUndefined()
-        recursiveOperationManager.stop()
-    })
-
-    it('find closest nodes returns self if no peers', async () => {
-        const recursiveOperationManager = createRecursiveOperationManager()
-        const res = await recursiveOperationManager.execute(randomDhtAddress(), RecursiveOperation.FIND_CLOSEST_NODES)
-        expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
-        recursiveOperationManager.stop()
-    })
-
-    it('RecursiveOperationManager server throws if payload is not RecursiveOperationRequest', async () => {
-        const manager = createRecursiveOperationManager(new MockRouter() as any)
-        const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
-        const badMessage: Message = {
-            serviceId: 'unknown',
-            messageId: v4(),
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: rpcWrapper
-            },
-            sourceDescriptor: peerDescriptor1,
-            targetDescriptor: peerDescriptor2
-        }
-        await expect(() => rpcCommunicator.callRpcMethod('routeRequest', {
-            message: badMessage,
-            requestId: 'REQ',
-            routingPath: [],
-            reachableThrough: [],
-            target: peerDescriptor1.nodeId,
-            sourcePeer: peerDescriptor2
-        })).rejects.toThrow()
-        manager.stop()
-    })
-
-    it('no targets', async () => {
-        const router = createMockRouter(RouteMessageError.NO_TARGETS)
-        const send = jest.fn()
-        const transport = { 
-            send,
-            getConnections: () => [],
-            on: () => {},
-            off: () => {}
-        }
-        const recursiveOperationManager = createRecursiveOperationManager(router as any, transport as any)
-        const ack = await rpcCommunicator.callRpcMethod('routeRequest', routedMessage)
-        expect(ack).toEqual({
-            requestId: routedMessage.requestId,
-            error: RouteMessageError.NO_TARGETS
-        })
-        expect(send).toHaveBeenCalledTimes(1)
-        recursiveOperationManager.stop()
-    })
-
-    it('error', async () => {
-        const router = createMockRouter(RouteMessageError.DUPLICATE)
-        const send = jest.fn()
-        const transport = { 
-            send,
-            getConnections: () => []
-        }
-        const recursiveOperationManager = createRecursiveOperationManager(router as any, transport as any)
-        const ack = await rpcCommunicator.callRpcMethod('routeRequest', routedMessage)
-        expect(ack).toEqual({
-            requestId: routedMessage.requestId,
-            error: RouteMessageError.DUPLICATE
-        })
-        expect(send).not.toHaveBeenCalled()
-        recursiveOperationManager.stop()
-    })
-})

package/test/unit/RecursiveOperationSession.test.ts

@@ -1,68 +0,0 @@
-import { waitForCondition } from '@streamr/utils'
-import { range } from 'lodash'
-import { RecursiveOperationSession } from '../../src/dht/recursive-operation/RecursiveOperationSession'
-import { RecursiveOperationSessionRpcRemote } from '../../src/dht/recursive-operation/RecursiveOperationSessionRpcRemote'
-import { ServiceID } from '../../src/types/ServiceID'
-import { randomDhtAddress } from '../../src/identifiers'
-import { Message, PeerDescriptor, RecursiveOperation } from '../../generated/packages/dht/protos/DhtRpc'
-import { RecursiveOperationSessionRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
-import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
-import { FakeEnvironment } from '../utils/FakeTransport'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('RecursiveOperationSession', () => {
-
-    let environment: FakeEnvironment
-    let localPeerDescriptor: PeerDescriptor
-
-    const createRpcRemote = (serviceId: ServiceID) => {
-        const mockPeerDescriptor = createMockPeerDescriptor()
-        const transport = environment.createTransport(mockPeerDescriptor)
-        const send = (msg: Message) => transport.send(msg)
-        return new RecursiveOperationSessionRpcRemote(
-            mockPeerDescriptor,
-            localPeerDescriptor,
-            new RoutingRpcCommunicator(serviceId, send),
-            RecursiveOperationSessionRpcClient
-        )
-    }
-
-    beforeEach(() => {
-        environment = new FakeEnvironment()
-        localPeerDescriptor = createMockPeerDescriptor()
-    })
-
-    it('happy path', async () => {
-        const doRouteRequest = jest.fn()
-        const session = new RecursiveOperationSession({
-            transport: environment.createTransport(localPeerDescriptor),
-            targetId: randomDhtAddress(),
-            localPeerDescriptor,
-            waitedRoutingPathCompletions: 3,
-            operation: RecursiveOperation.FIND_CLOSEST_NODES,
-            doRouteRequest
-        })
-        const onCompleted = jest.fn()
-        session.on('completed', onCompleted)
-
-        session.start('')
-        expect(doRouteRequest).toHaveBeenCalled()
-        range(3).forEach(() => {
-            const remote = createRpcRemote(session.getId())
-            remote.sendResponse(
-                [createMockPeerDescriptor(), createMockPeerDescriptor()],
-                [createMockPeerDescriptor(), createMockPeerDescriptor()],
-                [],
-                true
-            )
-        })
-
-        // TODO now waits for the 4s timeout, could setup test so that it completes by receiving
-        // all data it wants
-        await waitForCondition(() => onCompleted.mock.calls.length > 0)
-        const result = session.getResults()
-        // TODO assert peer descriptors
-        expect(result.closestNodes).toHaveLength(6)
-        expect(result.dataEntries).toEqual([])
-    })
-})

package/test/unit/Router.test.ts

@@ -1,137 +0,0 @@
-import { v4 } from 'uuid'
-import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
-import { Router } from '../../src/dht/routing/Router'
-import { 
-    Message,
-    PeerDescriptor,
-    RouteMessageAck,
-    RouteMessageError,
-    RouteMessageWrapper
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../utils/utils'
-import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
-import { DhtAddress, toNodeId, randomDhtAddress } from '../../src/identifiers'
-import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
-
-describe('Router', () => {
-
-    let router: Router
-    const peerDescriptor1 = createMockPeerDescriptor()
-    const peerDescriptor2 = createMockPeerDescriptor()
-    const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
-    const message: Message = {
-        serviceId: 'unknown',
-        messageId: v4(),
-        body: {
-            oneofKind: 'rpcMessage',
-            rpcMessage: rpcWrapper
-        },
-        sourceDescriptor: peerDescriptor1,
-        targetDescriptor: peerDescriptor2
-    }
-    const routedMessage: RouteMessageWrapper = {
-        message,
-        requestId: 'REQ',
-        routingPath: [],
-        reachableThrough: [],
-        target: peerDescriptor1.nodeId,
-        sourcePeer: peerDescriptor2,
-        parallelRootNodeIds: []
-    }
-    let connections: Map<DhtAddress, DhtNodeRpcRemote>
-    const rpcCommunicator = new FakeRpcCommunicator()
-
-    const createMockDhtNodeRpcRemote = (destination: PeerDescriptor): DhtNodeRpcRemote => {
-        return new DhtNodeRpcRemote(peerDescriptor1, destination, undefined as any, new MockRpcCommunicator())
-    }
-
-    beforeEach(() => {
-        connections = new Map()
-        router = new Router({
-            localPeerDescriptor: peerDescriptor1,
-            rpcCommunicator: rpcCommunicator as any,
-            handleMessage: () => {},
-            getConnections: () => [...connections.values()].map((c) => c.getPeerDescriptor())
-        })
-    })
-
-    afterEach(() => {
-        router.stop()
-    })
-
-    it('doRouteMessage without connections', async () => {
-        const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
-            message,
-            target: peerDescriptor2.nodeId,
-            requestId: v4(),
-            sourcePeer: peerDescriptor1,
-            reachableThrough: [],
-            routingPath: [],
-            parallelRootNodeIds: []
-        }) as RouteMessageAck
-        expect(ack.error).toEqual(RouteMessageError.NO_TARGETS)
-    })
-
-    it('doRouteMessage with connections', async () => {
-        connections.set(randomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
-        const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
-            message,
-            target: peerDescriptor2.nodeId,
-            requestId: v4(),
-            sourcePeer: peerDescriptor1,
-            reachableThrough: [],
-            routingPath: [],
-            parallelRootNodeIds: []
-        }) as RouteMessageAck
-        expect(ack.error).toBeUndefined()
-    })
-
-    it('doRouteMessage with parallelRootNodeIds', async () => {
-        const nodeId = toNodeId(peerDescriptor2)
-        connections.set(nodeId, createMockDhtNodeRpcRemote(peerDescriptor2))
-        const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
-            message,
-            target: peerDescriptor2.nodeId,
-            requestId: v4(),
-            sourcePeer: peerDescriptor1,
-            reachableThrough: [],
-            routingPath: [],
-            parallelRootNodeIds: [nodeId]
-        }) as RouteMessageAck
-        expect(ack.error).toEqual(RouteMessageError.NO_TARGETS)
-    })
-
-    it('route server is destination without connections', async () => {
-        const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toBeUndefined()
-    })
-
-    it('route server with connections', async () => {
-        connections.set(randomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
-        const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toBeUndefined()
-    })
-
-    it('route server on duplicate message', async () => {
-        router.addToDuplicateDetector(routedMessage.requestId)
-        const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual(RouteMessageError.DUPLICATE)
-    })
-
-    it('forward server no connections', async () => {
-        const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual(RouteMessageError.NO_TARGETS)
-    })
-
-    it('forward server with connections', async () => {
-        connections.set(randomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
-        const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toBeUndefined()
-    })
-
-    it('forward server on duplicate message', async () => {
-        router.addToDuplicateDetector(routedMessage.requestId)
-        const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
-        expect(ack.error).toEqual(RouteMessageError.DUPLICATE)
-    })
-})