@streamr/dht 0.0.1-tatum.6 → 0.0.1-tatum.7

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -4,7 +4,7 @@ import { Simulator } from '../../src/connection/Simulator/Simulator'
 import { PeerID } from '../../src/helpers/PeerID'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { waitForCondition } from '@streamr/utils'
 
 describe('Storing data in DHT with two peers', () => {
@@ -48,13 +48,13 @@ describe('Storing data in DHT with two peers', () => {
 
         const successfulStorers1 = await otherNode.storeDataToDht(dataKey1.value, data1)
         const successfulStorers2 = await entryPoint.storeDataToDht(dataKey2.value, data2)
-        expect(successfulStorers1[0].nodeName).toEqual(entryPoint.getPeerDescriptor().nodeName)
-        expect(successfulStorers2[0].nodeName).toEqual(otherNode.getPeerDescriptor().nodeName)
+        expect(successfulStorers1[0].kademliaId).toStrictEqual(entryPoint.getPeerDescriptor().kademliaId)
+        expect(successfulStorers2[0].kademliaId).toStrictEqual(otherNode.getPeerDescriptor().kademliaId)
 
         const foundData1 = await otherNode.getDataFromDht(dataKey1.value)
         const foundData2 = await entryPoint.getDataFromDht(dataKey2.value)
-        expect(isSamePeerDescriptor(otherNode.getPeerDescriptor(), Any.unpack(foundData1.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
-        expect(isSamePeerDescriptor(entryPoint.getPeerDescriptor(), Any.unpack(foundData2.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(otherNode.getPeerDescriptor(), Any.unpack(foundData1[0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(entryPoint.getPeerDescriptor(), Any.unpack(foundData2[0]!.data!, PeerDescriptor))).toBeTrue()
     })
 
     it('Can store on one peer DHT', async () => {
@@ -63,9 +63,9 @@ describe('Storing data in DHT with two peers', () => {
         const dataKey = PeerID.fromString('data-to-store')
         const data = Any.pack(entryPoint.getPeerDescriptor(), PeerDescriptor)
         const successfulStorers = await entryPoint.storeDataToDht(dataKey.value, data)
-        expect(successfulStorers[0].nodeName).toEqual(entryPoint.getPeerDescriptor().nodeName)
+        expect(successfulStorers[0].kademliaId).toStrictEqual(entryPoint.getPeerDescriptor().kademliaId)
 
         const foundData = await entryPoint.getDataFromDht(dataKey.value)
-        expect(isSamePeerDescriptor(entryPoint.getPeerDescriptor(), Any.unpack(foundData.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(entryPoint.getPeerDescriptor(), Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
     }, 60000)
 })

package/test/integration/WebRtcConnectionManagement.test.ts

@@ -6,7 +6,19 @@ 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/exports'
+import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
+import { MetricsContext } from '@streamr/utils'
+
+const createConnectionManager = (ownPeerDescriptor: PeerDescriptor, transport: ITransport) => {
+    return new ConnectionManager({
+        createConnectorFacade: () => new DefaultConnectorFacade({
+            transport,
+            createOwnPeerDescriptor: () => ownPeerDescriptor
+        }),
+        metricsContext: new MetricsContext()
+    })
+}
 
 describe('WebRTC Connection Management', () => {
 
@@ -17,32 +29,27 @@ describe('WebRTC Connection Management', () => {
 
     const peerDescriptor1: PeerDescriptor = {
         kademliaId: PeerID.fromString('peer1').value,
-        nodeName: 'peer1',
         type: NodeType.NODEJS,
     }
 
     const peerDescriptor2: PeerDescriptor = {
         kademliaId: PeerID.fromString('peer2').value,
-        nodeName: 'peer2',
         type: NodeType.NODEJS,
     }
 
-    let connectorTransport1: ITransport
-    let connectorTransport2: ITransport
+    let connectorTransport1: SimulatorTransport
+    let connectorTransport2: SimulatorTransport
 
     beforeEach(async () => {
-
         simulator = new Simulator(LatencyType.FIXED, 500)
-
         connectorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        manager1 = new ConnectionManager({ transportLayer: connectorTransport1 })
-
+        await connectorTransport1.start()
+        manager1 = createConnectionManager(peerDescriptor1, connectorTransport1)
         connectorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        manager2 = new ConnectionManager({ transportLayer: connectorTransport2 })
-
-        await manager1.start((_msg) => peerDescriptor1)
-        await manager2.start((_msg) => peerDescriptor2)
-
+        await connectorTransport2.start()
+        manager2 = createConnectionManager(peerDescriptor2, connectorTransport2)
+        await manager1.start()
+        await manager2.start()
     })
 
     afterEach(async () => {
@@ -138,26 +145,26 @@ describe('WebRTC Connection Management', () => {
         })
 
         const connectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('connected', (_peerDescriptor: PeerDescriptor) => {
+            manager1.on('connected', () => {
                 //expect(message.messageType).toBe(MessageType.RPC)
                 resolve()
             })
         })
 
         const connectedPromise2 = new Promise<void>((resolve, _reject) => {
-            manager2.on('connected', (_peerDescriptor: PeerDescriptor) => {
+            manager2.on('connected', () => {
                 resolve()
             })
         })
 
         const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            manager1.on('disconnected', () => {
                 resolve()
             })
         })
 
         const disconnectedPromise2 = new Promise<void>((resolve, _reject) => {
-            manager2.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            manager2.on('disconnected', () => {
                 resolve()
             })
         })
@@ -186,7 +193,7 @@ describe('WebRTC Connection Management', () => {
         }
 
         const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            manager1.on('disconnected', () => {
                 resolve()
             })
         })

package/test/integration/WebRtcConnectorRpc.test.ts

@@ -11,8 +11,6 @@ import {
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { generateId } from '../utils/utils'
 import { IWebRtcConnectorService } from '../../src/proto/packages/dht/protos/DhtRpc.server'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 import { waitForCondition } from '@streamr/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
@@ -45,25 +43,25 @@ describe('WebRTC rpc messages', () => {
         rpcCommunicator1 = new RpcCommunicator()
         const serverFunctions: IWebRtcConnectorService = {
 
-            requestConnection: async (_urequest: WebRtcConnectionRequest, _context: ServerCallContext): Promise<Empty> => {
+            requestConnection: async (): Promise<Empty> => {
                 requestConnectionCounter += 1
                 const res: Empty = {}
                 return res
             },
 
-            rtcOffer: async (_urequest: RtcOffer, _context: ServerCallContext): Promise<Empty> => {
+            rtcOffer: async (): Promise<Empty> => {
                 rtcOfferCounter += 1
                 const res: Empty = {}
                 return res
             },
 
-            rtcAnswer: async (_urequest: RtcAnswer, _context: ServerCallContext): Promise<Empty> => {
+            rtcAnswer: async (): Promise<Empty> => {
                 rtcAnswerCounter += 1
                 const res: Empty = {}
                 return res
             },
 
-            iceCandidate: async (_urequest: IceCandidate, _context: ServerCallContext): Promise<Empty> => {
+            iceCandidate: async (): Promise<Empty> => {
                 iceCandidateCounter += 1
                 const res: Empty = {}
                 return res
@@ -76,11 +74,11 @@ describe('WebRTC rpc messages', () => {
         rpcCommunicator2.registerRpcNotification(IceCandidate, 'iceCandidate', serverFunctions.iceCandidate)
         rpcCommunicator2.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
         })
 
-        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator1.handleIncomingMessage(message)
         })
 

package/test/integration/WebSocket.test.ts

@@ -9,11 +9,13 @@ const logger = new Logger(module)
 
 describe('WebSocket', () => {
 
-    const webSocketServer = new WebSocketServer()
+    const webSocketServer = new WebSocketServer({
+        portRange: { min: 9999, max: 9999 }
+    })
     const clientWebSocket = new ClientWebSocket()
 
     beforeAll(async () => {
-        await webSocketServer.start({ min: 9999, max: 9999 })
+        await webSocketServer.start()
     })
 
     it('Happy path', (done) => {

package/test/integration/WebSocketConnectionManagement.test.ts

@@ -1,15 +1,26 @@
 /* eslint-disable promise/no-nesting */
 
+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 { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { SimulatorTransport } from '../../src/exports'
 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 { waitForCondition } from '@streamr/utils'
+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'>) => {
+    return {
+        createConnectorFacade: () => new DefaultConnectorFacade({
+            createOwnPeerDescriptor: () => ownPeerDescriptor,
+            ...opts
+        }),
+        metricsContext: new MetricsContext()
+    }
+}
+
 describe('WebSocket Connection Management', () => {
 
     const serviceId = 'test'
@@ -33,28 +44,30 @@ describe('WebSocket Connection Management', () => {
         type: NodeType.NODEJS,
     }
 
-    let connectorTransport1: ITransport
-    let connectorTransport2: ITransport
+    let connectorTransport1: SimulatorTransport
+    let connectorTransport2: SimulatorTransport
 
     beforeEach(async () => {
 
-        connectorTransport1 = new ConnectionManager({ ownPeerDescriptor: wsServerConnectorPeerDescriptor, simulator: simulator })
-        connectorTransport2 = new ConnectionManager({ ownPeerDescriptor: noWsServerConnectorPeerDescriptor, simulator: simulator })
+        connectorTransport1 = new SimulatorTransport(wsServerConnectorPeerDescriptor, simulator)
+        await connectorTransport1.start()
+        connectorTransport2 = new SimulatorTransport(noWsServerConnectorPeerDescriptor, simulator)
+        await connectorTransport2.start()
 
-        const config1 = {
-            transportLayer: connectorTransport1,
+        const config1 = createConfig(wsServerConnectorPeerDescriptor, {
+            transport: connectorTransport1,
             websocketHost: '127.0.0.1',
-            websocketPortRange: { min: 12223, max: 12223 },
-        }
-        const config2 = {
-            transportLayer: connectorTransport2
-        }
+            websocketPortRange: { min: 12223, max: 12223 }
+        })
+        const config2 = createConfig(noWsServerConnectorPeerDescriptor, {
+            transport: connectorTransport2
+        })
 
         wsServerManager = new ConnectionManager(config1)
         noWsServerManager = new ConnectionManager(config2)
 
-        await wsServerManager.start((_response) => wsServerConnectorPeerDescriptor)
-        await noWsServerManager.start((_response) => noWsServerConnectorPeerDescriptor)
+        await wsServerManager.start()
+        await noWsServerManager.start()
     })
 
     afterEach(async () => {

package/test/integration/WebSocketConnectorRpc.test.ts

@@ -8,7 +8,6 @@ import {
     WebSocketConnectionResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { MockWebSocketConnectorRpc } from '../utils/utils'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
 describe('WebSocketConnectorRpc', () => {
@@ -44,11 +43,11 @@ describe('WebSocketConnectorRpc', () => {
             MockWebSocketConnectorRpc.requestConnection
         )
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
         })
 
-        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator1.handleIncomingMessage(message)
         })
 

package/test/unit/DuplicateDetector.test.ts

@@ -3,25 +3,24 @@ import { DuplicateDetector } from '../../src/dht/routing/DuplicateDetector'
 describe('Duplicate Detector', () => {
     let detector: DuplicateDetector
     const maxLimit = 10
-    const senderId = 'sender'
     beforeEach(async () => {
         detector = new DuplicateDetector(maxLimit, 100)
     })
 
     it('detects duplicates', async () => {
-        detector.add('test', senderId)
+        detector.add('test')
         expect(detector.size()).toEqual(1)
         expect(detector.isMostLikelyDuplicate('test')).toEqual(true)
     })
 
     it('resets on resetLimit', () => {
         for (let i = 0; i < maxLimit; i++) {
-            detector.add(`test${i}`, senderId)
+            detector.add(`test${i}`)
         }
         for (let i = 0; i < maxLimit; i++) {
             expect(detector.isMostLikelyDuplicate(`test${i}`)).toEqual(true)
         }
-        detector.add('test10', senderId)
+        detector.add('test10')
         expect(detector.size()).toEqual(10)
         expect(detector.isMostLikelyDuplicate('test0')).toEqual(false)
         expect(detector.isMostLikelyDuplicate('test10')).toEqual(true)

package/test/unit/LocalDataStore.test.ts

@@ -1,7 +1,7 @@
 import { Any } from '../../src/proto/google/protobuf/any'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import {
-    isSamePeerDescriptor,
+    areEqualPeerDescriptors,
     keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../src/helpers/peerIdFromPeerDescriptor'
@@ -13,13 +13,11 @@ describe('LocalDataStore', () => {
     let localDataStore: LocalDataStore
     const storer1: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS,
-        nodeName: 'storer1'
+        type: NodeType.NODEJS
     }
     const storer2: PeerDescriptor = {
         kademliaId: new Uint8Array([3, 2, 1]),
-        type: NodeType.NODEJS,
-        nodeName: 'storer2'
+        type: NodeType.NODEJS
     }
     const data1 = Any.pack(storer1, PeerDescriptor)
     const data2 = Any.pack(storer2, PeerDescriptor)
@@ -39,7 +37,7 @@ describe('LocalDataStore', () => {
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(isSamePeerDescriptor(fetchedDescriptor, storer1)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
         })
     })
 
@@ -52,7 +50,7 @@ describe('LocalDataStore', () => {
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(isSamePeerDescriptor(fetchedDescriptor, storer1)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
         })
     })
 
@@ -66,7 +64,7 @@ describe('LocalDataStore', () => {
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(isSamePeerDescriptor(fetchedDescriptor, storer2)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storer2)).toBeTrue()
         })
     })
 

package/test/unit/RandomContactList.test.ts

@@ -1,5 +1,5 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
-import { PeerID } from '../../src/exports'
+import { PeerID } from '../../src/helpers/PeerID'
 
 const createItem = (kademliaId: Uint8Array): { getPeerId: () => PeerID } => {
     return { getPeerId: () => PeerID.fromValue(kademliaId) }

package/test/unit/RecursiveFinder.test.ts

@@ -13,28 +13,25 @@ import {
     createRecursiveFindRequest
 } from '../utils/utils'
 import { RecursiveFinder } from '../../src/dht/find/RecursiveFinder'
-import { DhtPeer } from '../../src/dht/DhtPeer'
+import { RemoteDhtNode } from '../../src/dht/RemoteDhtNode'
 import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import { v4 } from 'uuid'
 import { MockRouter } from '../utils/mock/Router'
 import { MockTransport } from '../utils/mock/Transport'
-import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('RecursiveFinder', () => {
 
     let recursiveFinder: RecursiveFinder
-    let connections: Map<PeerIDKey, DhtPeer>
+    let connections: Map<PeerIDKey, RemoteDhtNode>
 
-    const peerId1 = PeerID.fromString('peerid')
     const peerDescriptor1: PeerDescriptor = {
-        kademliaId: peerId1.value,
-        type: NodeType.NODEJS,
-        nodeName: 'peerid'
+        kademliaId: PeerID.fromString('peerid').value,
+        type: NodeType.NODEJS
     }
     const peerDescriptor2: PeerDescriptor = {
         kademliaId: PeerID.fromString('destination').value,
-        type: NodeType.NODEJS,
-        nodeName: 'destination'
+        type: NodeType.NODEJS
     }
     const recursiveFindRequest = createRecursiveFindRequest(FindMode.NODE)
     const message: Message = {
@@ -61,7 +58,6 @@ describe('RecursiveFinder', () => {
         connections = new Map()
         recursiveFinder = new RecursiveFinder({
             ownPeerDescriptor: peerDescriptor1,
-            ownPeerId: peerId1,
             router: new MockRouter(),
             connections,
             serviceId: 'RecursiveFinder',
@@ -84,11 +80,11 @@ describe('RecursiveFinder', () => {
 
     it('startRecursiveFind with mode Node returns self if no peers', async () => {
         const res = await recursiveFinder.startRecursiveFind(PeerID.fromString('find').value)
-        expect(isSamePeerDescriptor(res.closestNodes[0], peerDescriptor1)).toEqual(true)
+        expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
     })
 
     it('RecursiveFinder server throws if payload is not recursiveFindRequest', async () => {
-        const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1, peerDescriptor2)
+        const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
         const badMessage: Message = {
             serviceId: 'unknown',
             messageId: v4(),

package/test/unit/Router.test.ts

@@ -1,10 +1,9 @@
 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 { DhtPeer } from '../../src/dht/DhtPeer'
+import { RemoteDhtNode } from '../../src/dht/RemoteDhtNode'
 import { createWrappedClosestPeersRequest, createMockRoutingRpcCommunicator } from '../utils/utils'
 import { v4 } from 'uuid'
-import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('Router', () => {
     let router: Router
@@ -12,14 +11,13 @@ describe('Router', () => {
     const peerId = PeerID.fromString('router')
     const peerDescriptor1: PeerDescriptor = {
         kademliaId: peerId.value,
-        type: NodeType.NODEJS,
-        nodeName: 'router'
+        type: NodeType.NODEJS
     }
     const peerDescriptor2: PeerDescriptor = {
         kademliaId: PeerID.fromString('destination').value,
-        type: NodeType.NODEJS,
+        type: NodeType.NODEJS
     }
-    const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1, peerDescriptor2)
+    const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
     const message: Message = {
         serviceId: 'unknown',
         messageId: v4(),
@@ -39,18 +37,17 @@ describe('Router', () => {
         destinationPeer: peerDescriptor1,
         sourcePeer: peerDescriptor2
     }
-    let connections: Map<PeerIDKey, DhtPeer>
+    let connections: Map<PeerIDKey, RemoteDhtNode>
     const mockRpcCommunicator = createMockRoutingRpcCommunicator()
 
-    const createMockDhtPeer = (destination: PeerDescriptor): DhtPeer => {
-        return new DhtPeer(peerDescriptor1, destination, {} as any, 'router')
+    const createMockRemoteDhtNode = (destination: PeerDescriptor): RemoteDhtNode => {
+        return new RemoteDhtNode(peerDescriptor1, destination, {} as any, 'router')
     }
 
     beforeEach(() => {
         connections = new Map()
         router = new Router({
             ownPeerDescriptor: peerDescriptor1,
-            ownPeerId: peerId,
             rpcCommunicator: mockRpcCommunicator,
             addContact: (_contact) => {},
             serviceId: 'router',
@@ -75,7 +72,7 @@ describe('Router', () => {
     })
 
     it('doRouteMessage with connections', () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockDhtPeer(peerDescriptor2))
+        connections.set(PeerID.fromString('test').toKey(), createMockRemoteDhtNode(peerDescriptor2))
         const ack = router.doRouteMessage({
             message,
             destinationPeer: peerDescriptor2,
@@ -88,36 +85,36 @@ describe('Router', () => {
     })
 
     it('route server is destination without connections', async () => {
-        const ack = await router.routeMessage(routedMessage, {} as any)
+        const ack = await router.routeMessage(routedMessage)
         expect(ack.error).toEqual('')
     })
 
     it('route server with connections', async () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockDhtPeer(peerDescriptor2))
-        const ack = await router.routeMessage(routedMessage, {} as any)
+        connections.set(PeerID.fromString('test').toKey(), createMockRemoteDhtNode(peerDescriptor2))
+        const ack = await router.routeMessage(routedMessage)
         expect(ack.error).toEqual('')
     })
 
     it('route server on duplicate message', async () => {
-        router.addToDuplicateDetector(routedMessage.requestId, keyFromPeerDescriptor(peerDescriptor2))
-        const ack = await router.routeMessage(routedMessage, {} as any)
+        router.addToDuplicateDetector(routedMessage.requestId)
+        const ack = await router.routeMessage(routedMessage)
         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, {} as any)
+        const ack = await router.forwardMessage(routedMessage)
         expect(ack.error).toEqual('No routing candidates found')
     })
 
     it('forward server with connections', async () => {
-        connections.set(PeerID.fromString('test').toKey(), createMockDhtPeer(peerDescriptor2))
-        const ack = await router.forwardMessage(routedMessage, {} as any)
+        connections.set(PeerID.fromString('test').toKey(), createMockRemoteDhtNode(peerDescriptor2))
+        const ack = await router.forwardMessage(routedMessage)
         expect(ack.error).toEqual('')
     })
 
     it('forward server on duplicate message', async () => {
-        router.addToDuplicateDetector(routedMessage.requestId, keyFromPeerDescriptor(peerDescriptor2))
-        const ack = await router.forwardMessage(routedMessage, {} as any)
+        router.addToDuplicateDetector(routedMessage.requestId)
+        const ack = await router.forwardMessage(routedMessage)
         expect(ack.error).toEqual('message given to forwardMessage() service is likely a duplicate')
     })
 

package/test/unit/WebSocketConnector.test.ts

@@ -0,0 +1,64 @@
+/* eslint-disable max-len */
+import { WebSocketConnector } from '../../src/connection/WebSocket/WebSocketConnector'
+import { ConnectivityMethod, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import crypto from 'crypto'
+import { MockTransport } from '../utils/mock/Transport'
+
+const createMockPeerDescriptor = (nodeType: NodeType, websocket?: ConnectivityMethod): PeerDescriptor => {
+    return {
+        kademliaId: crypto.randomBytes(10),
+        type: nodeType,
+        websocket
+    }
+}
+
+describe('WebSocketConnector', () => {
+
+    describe('isPossibleToFormConnection', () => {
+
+        const connector = new WebSocketConnector({
+            transport: new MockTransport(),
+            canConnect: () => {}
+        } as any)
+
+        it('node without server', () => {
+            connector.setOwnPeerDescriptor(createMockPeerDescriptor(NodeType.NODEJS))
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: false }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: true }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS))).toBe(false)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.BROWSER))).toBe(false)
+        })
+
+        it('node with TLS server', () => {
+            connector.setOwnPeerDescriptor(createMockPeerDescriptor(NodeType.NODEJS, { host: '1.1.1.1', port: 11, tls: true }))
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: false }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: true }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.BROWSER))).toBe(true)
+        })
+
+        it('node with non-TLS server', () => {
+            connector.setOwnPeerDescriptor(createMockPeerDescriptor(NodeType.NODEJS, { host: '1.1.1.1', port: 11, tls: false }))
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: false }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: true }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.BROWSER))).toBe(false)
+        })
+
+        it('node with non-TLS server in local network', () => {
+            connector.setOwnPeerDescriptor(createMockPeerDescriptor(NodeType.NODEJS, { host: '192.168.11.11', port: 11, tls: false }))
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: false }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: true }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.BROWSER))).toBe(true)
+        })
+
+        it('browser', () => {
+            connector.setOwnPeerDescriptor(createMockPeerDescriptor(NodeType.BROWSER))
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: false }))).toBe(false)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: true }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS))).toBe(false)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.BROWSER))).toBe(false)
+        })
+    })
+})