@streamr/dht 100.0.0-pretestnet.2 → 100.0.0-pretestnet.3

package/test/integration/{WebRtcConnectionManagement.test.ts → WebrtcConnectionManagement.test.ts}

@@ -1,20 +1,20 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { PeerID } from '../../src/helpers/PeerID'
 import { ConnectionType } from '../../src/connection/IConnection'
 import { ITransport } from '../../src/transport/ITransport'
 import * as Err from '../../src/helpers/errors'
-import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { MetricsContext } from '@streamr/utils'
 
-const createConnectionManager = (ownPeerDescriptor: PeerDescriptor, transport: ITransport) => {
+const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
         createConnectorFacade: () => new DefaultConnectorFacade({
             transport,
-            createOwnPeerDescriptor: () => ownPeerDescriptor
+            createLocalPeerDescriptor: () => localPeerDescriptor
         }),
         metricsContext: new MetricsContext()
     })

package/test/integration/{WebRtcConnectorRpc.test.ts → WebrtcConnectorRpc.test.ts}

@@ -1,23 +1,23 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebRtcConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { WebrtcConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import {
     IceCandidate,
     NodeType,
     PeerDescriptor,
     RtcAnswer,
     RtcOffer,
-    WebRtcConnectionRequest
+    WebrtcConnectionRequest
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { generateId } from '../utils/utils'
-import { IWebRtcConnectorRpc } from '../../src/proto/packages/dht/protos/DhtRpc.server'
+import { IWebrtcConnectorRpc } from '../../src/proto/packages/dht/protos/DhtRpc.server'
 import { waitForCondition } from '@streamr/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
 describe('WebRTC rpc messages', () => {
     let rpcCommunicator1: RpcCommunicator
     let rpcCommunicator2: RpcCommunicator
-    let client: ProtoRpcClient<WebRtcConnectorRpcClient>
+    let client: ProtoRpcClient<WebrtcConnectorRpcClient>
 
     let requestConnectionCounter: number
     let rtcOfferCounter: number
@@ -36,7 +36,7 @@ describe('WebRTC rpc messages', () => {
         iceCandidateCounter = 0
 
         rpcCommunicator1 = new RpcCommunicator()
-        const serverFunctions: IWebRtcConnectorRpc = {
+        const serverFunctions: IWebrtcConnectorRpc = {
 
             requestConnection: async (): Promise<Empty> => {
                 requestConnectionCounter += 1
@@ -67,7 +67,7 @@ describe('WebRTC rpc messages', () => {
         rpcCommunicator2.registerRpcNotification(RtcOffer, 'rtcOffer', serverFunctions.rtcOffer)
         rpcCommunicator2.registerRpcNotification(RtcAnswer, 'rtcAnswer', serverFunctions.rtcAnswer)
         rpcCommunicator2.registerRpcNotification(IceCandidate, 'iceCandidate', serverFunctions.iceCandidate)
-        rpcCommunicator2.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
+        rpcCommunicator2.registerRpcNotification(WebrtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
 
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
@@ -77,7 +77,7 @@ describe('WebRTC rpc messages', () => {
             rpcCommunicator1.handleIncomingMessage(message)
         })
 
-        client = toProtoRpcClient(new WebRtcConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
+        client = toProtoRpcClient(new WebrtcConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
     })
 
     afterEach(async () => {
@@ -87,7 +87,6 @@ describe('WebRTC rpc messages', () => {
 
     it('send connectionRequest', async () => {
         client.requestConnection({
-            connectionId: 'connectionRequest'
         },
         { targetDescriptor, notification: true }
         )

package/test/integration/{WebSocket.test.ts → Websocket.test.ts}

@@ -1,26 +1,27 @@
 /* eslint-disable no-console */
 
-import { WebSocketServer } from '../../src/connection/WebSocket/WebSocketServer'
+import { WebsocketServer } from '../../src/connection/websocket/WebsocketServer'
 import { IConnection } from '../../src/connection/IConnection'
-import { ClientWebSocket } from '../../src/connection/WebSocket/ClientWebSocket'
+import { ClientWebsocket } from '../../src/connection/websocket/ClientWebsocket'
 import { Logger } from '@streamr/utils'
 
 const logger = new Logger(module)
 
-describe('WebSocket', () => {
+describe('Websocket', () => {
 
-    const webSocketServer = new WebSocketServer({
-        portRange: { min: 9999, max: 9999 }
+    const websocketServer = new WebsocketServer({
+        portRange: { min: 9977, max: 9977 },
+        enableTls: false
     })
-    const clientWebSocket = new ClientWebSocket()
+    const clientWebsocket = new ClientWebsocket()
 
     beforeAll(async () => {
-        await webSocketServer.start()
+        await websocketServer.start()
     })
 
     it('Happy path', (done) => {
             
-        webSocketServer.on('connected', (serverConnection: IConnection) => {
+        websocketServer.on('connected', (serverConnection: IConnection) => {
             const time = Date.now()
             logger.info('server side sendind msg at ' + time)
             serverConnection.send(Uint8Array.from([1, 2, 3, 4]))
@@ -40,11 +41,11 @@ describe('WebSocket', () => {
             })
         })
         
-        clientWebSocket.on('connected', () => {
+        clientWebsocket.on('connected', () => {
             const time = Date.now()
             logger.info('client side setting listeners at ' + time)
             
-            clientWebSocket.on('data', (bytes: Uint8Array) => {
+            clientWebsocket.on('data', (bytes: Uint8Array) => {
                 const time = Date.now()
                 logger.info('client side receiving message at ' + time)
 
@@ -53,14 +54,14 @@ describe('WebSocket', () => {
                 
                 const time2 = Date.now()
                 logger.info('client side sendind msg at ' + time2)
-                clientWebSocket.send(Uint8Array.from([1, 2, 3, 4]))
+                clientWebsocket.send(Uint8Array.from([1, 2, 3, 4]))
             })
         })
 
-        clientWebSocket.connect('ws://127.0.0.1:9999')
+        clientWebsocket.connect('ws://127.0.0.1:9977')
     })
 
     afterAll(async () => {
-        await webSocketServer.stop()
+        await websocketServer.stop()
     })
 })

package/test/integration/{WebSocketConnectionManagement.test.ts → WebsocketConnectionManagement.test.ts}

@@ -4,24 +4,24 @@ import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
 import { ConnectionType } from '../../src/connection/IConnection'
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/exports'
 import { PeerID } from '../../src/helpers/PeerID'
 import * as Err from '../../src/helpers/errors'
 import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
-const createConfig = (ownPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createOwnPeerDescriptor'>) => {
+const createConfig = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
     return {
         createConnectorFacade: () => new DefaultConnectorFacade({
-            createOwnPeerDescriptor: () => ownPeerDescriptor,
+            createLocalPeerDescriptor: () => localPeerDescriptor,
             ...opts
         }),
         metricsContext: new MetricsContext()
     }
 }
 
-describe('WebSocket Connection Management', () => {
+describe('Websocket Connection Management', () => {
 
     const serviceId = 'test'
     let wsServerManager: ConnectionManager

package/test/integration/{WebSocketConnectorRpc.test.ts → WebsocketConnectorRpc.test.ts}

@@ -1,20 +1,20 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebSocketConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { WebsocketConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { generateId } from '../utils/utils'
 import {
     NodeType,
     PeerDescriptor,
-    WebSocketConnectionRequest,
-    WebSocketConnectionResponse
+    WebsocketConnectionRequest,
+    WebsocketConnectionResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { mockWebSocketConnectorRpc } from '../utils/utils'
+import { mockWebsocketConnectorRpc } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
-describe('WebSocketConnectorRpc', () => {
+describe('WebsocketConnectorRpc', () => {
     let rpcCommunicator1: RpcCommunicator
     let rpcCommunicator2: RpcCommunicator
-    let client1: ProtoRpcClient<WebSocketConnectorRpcClient>
-    let client2: ProtoRpcClient<WebSocketConnectorRpcClient>
+    let client1: ProtoRpcClient<WebsocketConnectorRpcClient>
+    let client2: ProtoRpcClient<WebsocketConnectorRpcClient>
 
     const peerDescriptor1: PeerDescriptor = {
         kademliaId: generateId('peer1'),
@@ -29,18 +29,18 @@ describe('WebSocketConnectorRpc', () => {
     beforeEach(() => {
         rpcCommunicator1 = new RpcCommunicator()
         rpcCommunicator1.registerRpcMethod(
-            WebSocketConnectionRequest,
-            WebSocketConnectionResponse,
+            WebsocketConnectionRequest,
+            WebsocketConnectionResponse,
             'requestConnection',
-            mockWebSocketConnectorRpc.requestConnection
+            mockWebsocketConnectorRpc.requestConnection
         )
 
         rpcCommunicator2 = new RpcCommunicator()
         rpcCommunicator2.registerRpcMethod(
-            WebSocketConnectionRequest,
-            WebSocketConnectionResponse,
+            WebsocketConnectionRequest,
+            WebsocketConnectionResponse,
             'requestConnection',
-            mockWebSocketConnectorRpc.requestConnection
+            mockWebsocketConnectorRpc.requestConnection
         )
 
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
@@ -51,8 +51,8 @@ describe('WebSocketConnectorRpc', () => {
             rpcCommunicator1.handleIncomingMessage(message)
         })
 
-        client1 = toProtoRpcClient(new WebSocketConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
-        client2 = toProtoRpcClient(new WebSocketConnectorRpcClient(rpcCommunicator2.getRpcClientTransport()))
+        client1 = toProtoRpcClient(new WebsocketConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
+        client2 = toProtoRpcClient(new WebsocketConnectorRpcClient(rpcCommunicator2.getRpcClientTransport()))
     })
 
     afterEach(async () => {

package/test/unit/AutoCertifierClientFacade.test.ts

@@ -0,0 +1,58 @@
+import EventEmitter from 'eventemitter3'
+import { AutoCertifierClientFacade, IAutoCertifierClient } from '../../src/connection/websocket/AutoCertifierClientFacade'
+import { MockTransport } from '../utils/mock/Transport'
+
+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).toBeCalled()
+        expect(updateCertificate).toBeCalled()
+    })
+
+    it('updated events are processed', async () => {
+        await client.start()
+        expect(setHost).toBeCalledTimes(1)
+        expect(updateCertificate).toBeCalledTimes(1);
+        (mockClient as MockAutoCertifierClient).emitUpdateSubdomain()
+        expect(setHost).toBeCalledTimes(2)
+        expect(updateCertificate).toBeCalledTimes(2)
+    })
+
+})

package/test/unit/ConnectivityHelpers.test.ts

@@ -0,0 +1,69 @@
+import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { expectedConnectionType } from '../../src/helpers/Connectivity'
+import { ConnectionType } from '../../src/connection/IConnection'
+
+describe('Connectivity helpers', () => {
+
+    const tlsServerPeerDescriptor = {
+        kademliaId: new Uint8Array(1),
+        type: NodeType.NODEJS,
+        websocket: {
+            host: 'mock',
+            port: 1234,
+            tls: true
+        }
+    }
+
+    const noTlsServerPeerDescriptor = {
+        kademliaId: new Uint8Array(1),
+        type: NodeType.NODEJS,
+        websocket: {
+            host: 'mock',
+            port: 1234,
+            tls: false
+        }
+    }
+
+    const browserPeerDescriptor = {
+        kademliaId: new Uint8Array(2),
+        type: NodeType.BROWSER
+    }
+
+    const noServerPeerDescriptor = {
+        kademliaId: new Uint8Array(3),
+        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/{RecursiveFinder.test.ts → Finder.test.ts}

@@ -3,26 +3,27 @@ import {
     MessageType,
     NodeType,
     PeerDescriptor,
+    RouteMessageAck,
     RouteMessageWrapper
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
 import {
-    createMockRoutingRpcCommunicator,
     createWrappedClosestPeersRequest,
     createFindRequest
 } from '../utils/utils'
-import { RecursiveFinder } from '../../src/dht/find/RecursiveFinder'
-import { RemoteDhtNode } from '../../src/dht/RemoteDhtNode'
+import { Finder } from '../../src/dht/find/Finder'
+import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import { v4 } from 'uuid'
 import { MockRouter } from '../utils/mock/Router'
 import { MockTransport } from '../utils/mock/Transport'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
 
-describe('RecursiveFinder', () => {
+describe('Finder', () => {
 
-    let recursiveFinder: RecursiveFinder
-    let connections: Map<PeerIDKey, RemoteDhtNode>
+    let finder: Finder
+    let connections: Map<PeerIDKey, DhtNodeRpcRemote>
 
     const peerDescriptor1: PeerDescriptor = {
         kademliaId: PeerID.fromString('peerid').value,
@@ -52,37 +53,38 @@ describe('RecursiveFinder', () => {
         destinationPeer: peerDescriptor1,
         sourcePeer: peerDescriptor2
     }
+    const rpcCommunicator = new FakeRpcCommunicator()
 
     beforeEach(() => {
         connections = new Map()
-        recursiveFinder = new RecursiveFinder({
-            ownPeerDescriptor: peerDescriptor1,
+        finder = new Finder({
+            localPeerDescriptor: peerDescriptor1,
             router: new MockRouter(),
             connections,
-            serviceId: 'RecursiveFinder',
+            serviceId: 'Finder',
             localDataStore: new LocalDataStore(),
             sessionTransport: new MockTransport(),
             addContact: (_contact, _setActive) => {},
             isPeerCloserToIdThanSelf: (_peer1, _compareToId) => true,
-            rpcCommunicator: createMockRoutingRpcCommunicator()
+            rpcCommunicator: rpcCommunicator as any
         })
     })
 
     afterEach(() => {
-        recursiveFinder.stop()
+        finder.stop()
     })
 
-    it('RecursiveFinder server', async () => {
-        const res = await recursiveFinder.findRecursively(routedMessage)
+    it('Finder server', async () => {
+        const res = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage) as RouteMessageAck
         expect(res.error).toEqual('')
     })
 
-    it('startRecursiveFind with mode Node returns self if no peers', async () => {
-        const res = await recursiveFinder.startRecursiveFind(PeerID.fromString('find').value)
+    it('startFind with mode Node returns self if no peers', async () => {
+        const res = await finder.startFind(PeerID.fromString('find').value)
         expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
     })
 
-    it('RecursiveFinder server throws if payload is not FindRequest', async () => {
+    it('Finder server throws if payload is not FindRequest', async () => {
         const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
         const badMessage: Message = {
             serviceId: 'unknown',
@@ -95,7 +97,7 @@ describe('RecursiveFinder', () => {
             sourceDescriptor: peerDescriptor1,
             targetDescriptor: peerDescriptor2
         }
-        await expect(recursiveFinder.findRecursively({
+        await expect(() => rpcCommunicator.callRpcMethod('routeFindRequest', {
             message: badMessage,
             requestId: 'REQ',
             routingPath: [],

package/test/unit/Router.test.ts

@@ -1,9 +1,10 @@
+import { v4 } from 'uuid'
+import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { Router } from '../../src/dht/routing/Router'
-import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
-import { RemoteDhtNode } from '../../src/dht/RemoteDhtNode'
-import { createWrappedClosestPeersRequest, createMockRoutingRpcCommunicator } from '../utils/utils'
-import { v4 } from 'uuid'
+import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createWrappedClosestPeersRequest } from '../utils/utils'
+import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
 
 describe('Router', () => {
     let router: Router
@@ -37,18 +38,18 @@ describe('Router', () => {
         destinationPeer: peerDescriptor1,
         sourcePeer: peerDescriptor2
     }
-    let connections: Map<PeerIDKey, RemoteDhtNode>
-    const mockRpcCommunicator = createMockRoutingRpcCommunicator()
+    let connections: Map<PeerIDKey, DhtNodeRpcRemote>
+    const rpcCommunicator = new FakeRpcCommunicator()
 
-    const createMockRemoteDhtNode = (destination: PeerDescriptor): RemoteDhtNode => {
-        return new RemoteDhtNode(peerDescriptor1, destination, {} as any, 'router')
+    const createMockDhtNodeRpcRemote = (destination: PeerDescriptor): DhtNodeRpcRemote => {
+        return new DhtNodeRpcRemote(peerDescriptor1, destination, {} as any, 'router')
     }
 
     beforeEach(() => {
         connections = new Map()
         router = new Router({
-            ownPeerDescriptor: peerDescriptor1,
-            rpcCommunicator: mockRpcCommunicator,
+            localPeerDescriptor: peerDescriptor1,
+            rpcCommunicator: rpcCommunicator as any,
             addContact: (_contact) => {},
             serviceId: 'router',
             connections
@@ -59,63 +60,62 @@ describe('Router', () => {
         router.stop()
     })
 
-    it('doRouteMessage without connections', () => {
-        const ack = router.doRouteMessage({
+    it('doRouteMessage without connections', async () => {
+        const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
             message,
             destinationPeer: peerDescriptor2,
             requestId: v4(),
             sourcePeer: peerDescriptor1,
             reachableThrough: [],
             routingPath: []
-        })
+        }) as RouteMessageAck
         expect(ack.error).toEqual('No routing candidates found')
     })
 
-    it('doRouteMessage with connections', () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockRemoteDhtNode(peerDescriptor2))
-        const ack = router.doRouteMessage({
+    it('doRouteMessage with connections', async () => {
+        connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
             message,
             destinationPeer: peerDescriptor2,
             requestId: v4(),
             sourcePeer: peerDescriptor1,
             reachableThrough: [],
             routingPath: []
-        })
+        }) as RouteMessageAck
         expect(ack.error).toEqual('')
     })
 
     it('route server is destination without connections', async () => {
-        const ack = await router.routeMessage(routedMessage)
+        const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toEqual('')
     })
 
     it('route server with connections', async () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockRemoteDhtNode(peerDescriptor2))
-        const ack = await router.routeMessage(routedMessage)
+        connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toEqual('')
     })
 
     it('route server on duplicate message', async () => {
         router.addToDuplicateDetector(routedMessage.requestId)
-        const ack = await router.routeMessage(routedMessage)
+        const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toEqual('message given to routeMessage() service is likely a duplicate')
     })
 
     it('forward server no connections', async () => {
-        const ack = await router.forwardMessage(routedMessage)
+        const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toEqual('No routing candidates found')
     })
 
     it('forward server with connections', async () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockRemoteDhtNode(peerDescriptor2))
-        const ack = await router.forwardMessage(routedMessage)
+        connections.set(PeerID.fromString('test').toKey(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toEqual('')
     })
 
     it('forward server on duplicate message', async () => {
         router.addToDuplicateDetector(routedMessage.requestId)
-        const ack = await router.forwardMessage(routedMessage)
+        const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toEqual('message given to forwardMessage() service is likely a duplicate')
     })
-
 })

package/test/unit/UUID.test.ts

@@ -32,7 +32,7 @@ describe('UUID', () => {
     })
 
     it('Throws if incorrect string is given as uuid string parameter', () => {
-        expect(()=> {new UUID('äå%')}).toThrow(TypeError)
+        expect(() => {new UUID('äå%')}).toThrow(TypeError)
     })
 
     it('Uses passed UUID as id', () => {