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

package/test/unit/RecursiveFinder.test.ts

@@ -1,5 +1,4 @@
 import {
-    FindMode,
     Message,
     MessageType,
     NodeType,
@@ -10,40 +9,37 @@ import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
 import {
     createMockRoutingRpcCommunicator,
     createWrappedClosestPeersRequest,
-    createRecursiveFindRequest
+    createFindRequest
 } 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 findRequest = createFindRequest(false)
     const message: Message = {
         serviceId: 'unknown',
         messageId: v4(),
         messageType: MessageType.RPC,
         body: {
-            oneofKind: 'recursiveFindRequest',
-            recursiveFindRequest
+            oneofKind: 'findRequest',
+            findRequest
         },
         sourceDescriptor: peerDescriptor1,
         targetDescriptor: peerDescriptor2
@@ -61,7 +57,6 @@ describe('RecursiveFinder', () => {
         connections = new Map()
         recursiveFinder = new RecursiveFinder({
             ownPeerDescriptor: peerDescriptor1,
-            ownPeerId: peerId1,
             router: new MockRouter(),
             connections,
             serviceId: 'RecursiveFinder',
@@ -84,11 +79,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)
+    it('RecursiveFinder server throws if payload is not FindRequest', async () => {
+        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/WebSocketConnectorRpcLocal.test.ts

@@ -0,0 +1,64 @@
+/* eslint-disable max-len */
+import { WebSocketConnectorRpcLocal } from '../../src/connection/WebSocket/WebSocketConnectorRpcLocal'
+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('WebSocketConnectorRpcLocal', () => {
+
+    describe('isPossibleToFormConnection', () => {
+
+        const connector = new WebSocketConnectorRpcLocal({
+            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)
+        })
+    })
+})

package/test/unit/WebSocketServer.test.ts

@@ -3,19 +3,25 @@ import { WebSocketServer } from '../../src/connection/WebSocket/WebSocketServer'
 describe('WebSocketServer', () => {
 
     it('starts and stops', async () => {
-        const server = new WebSocketServer()
-        const port = await server.start({ min: 19792, max: 19792 })
+        const server = new WebSocketServer({
+            portRange: { min: 19792, max: 19792 }
+        })
+        const port = await server.start()
         expect(port).toEqual(19792)
         await server.stop()
     })
 
     it('throws if server is already in use', async () => {
-        const server1 = new WebSocketServer()
-        const port = await server1.start({ min: 19792, max: 19792 })
+        const server1 = new WebSocketServer({
+            portRange: { min: 19792, max: 19792 }
+        })
+        const port = await server1.start()
         expect(port).toEqual(19792)
 
-        const server2 = new WebSocketServer()
-        await expect(server2.start({ min: 19792, max: 19792 }))
+        const server2 = new WebSocketServer({
+            portRange: { min: 19792, max: 19792 }
+        })
+        await expect(server2.start())
             .rejects
             .toThrow()
 
@@ -24,12 +30,16 @@ describe('WebSocketServer', () => {
     })
 
     it('Starts server in next port if first one is already in use', async () => {
-        const server1 = new WebSocketServer()
-        const port1 = await server1.start({ min: 19792, max: 19793 })
+        const server1 = new WebSocketServer({
+            portRange: { min: 19792, max: 19793 }
+        })
+        const port1 = await server1.start()
         expect(port1).toEqual(19792)
 
-        const server2 = new WebSocketServer()
-        const port2 = await server2.start({ min: 19792, max: 19793 })
+        const server2 = new WebSocketServer({
+            portRange: { min: 19792, max: 19793 }
+        })
+        const port2 = await server2.start()
         expect(port2).toEqual(19793)
 
         await server1.stop()
@@ -37,9 +47,11 @@ describe('WebSocketServer', () => {
     })
 
     it('throws if too big a port number is given', async () => {
-        const server = new WebSocketServer()
+        const server = new WebSocketServer({
+            portRange: { min: 197923233, max: 197923233 }
+        })
 
-        await expect(server.start({ min: 197923233, max: 197923233 }))
+        await expect(server.start())
             .rejects
             .toThrow()
 

package/test/unit/{webrtcReplaceInternalIpWithExternalIp.ts → webrtcReplaceInternalIpWithExternalIp.test.ts}

@@ -1,4 +1,4 @@
-import { replaceInternalIpWithExternalIp } from '../../src/connection/WebRTC/WebRtcConnector'
+import { replaceInternalIpWithExternalIp } from '../../src/connection/WebRTC/WebRtcConnectorRpcLocal'
 
 describe('replaceIpIfCandidateTypeIsHost', () => {
 

package/test/utils/mock/RecursiveFinder.ts

@@ -1,5 +1,5 @@
 import { RecursiveFindResult, IRecursiveFinder } from '../../../src/dht/find/RecursiveFinder'
-import { RouteMessageAck, RouteMessageWrapper } from '../../../src/proto/packages/dht/protos/DhtRpc'
+import { RouteMessageAck } from '../../../src/proto/packages/dht/protos/DhtRpc'
 
 export class MockRecursiveFinder implements IRecursiveFinder {
 
@@ -12,7 +12,7 @@ export class MockRecursiveFinder implements IRecursiveFinder {
     }
 
     // eslint-disable-next-line class-methods-use-this
-    async findRecursively(_routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
+    async findRecursively(): Promise<RouteMessageAck> {
         return RouteMessageAck.create()
     }
 

package/test/utils/mock/Router.ts

@@ -1,37 +1,35 @@
 import { IRouter } from '../../../src/dht/routing/Router'
-import { RoutingSession, RoutingMode } from '../../../src/dht/routing/RoutingSession'
-import { PeerDescriptor, Message, RouteMessageAck, RouteMessageWrapper } from '../../../src/proto/packages/dht/protos/DhtRpc'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { RouteMessageAck } from '../../../src/proto/packages/dht/protos/DhtRpc'
 
 export class MockRouter implements IRouter {
 
     // eslint-disable-next-line class-methods-use-this
-    addRoutingSession(_session: RoutingSession): void {
+    addRoutingSession(): void {
         return
     }
 
     // eslint-disable-next-line class-methods-use-this
-    removeRoutingSession(_sessionId: string): void {
+    removeRoutingSession(): void {
         return
     }
 
     // eslint-disable-next-line class-methods-use-this
-    addToDuplicateDetector(_messageId: string, _senderId: string, _message?: Message): void {
+    addToDuplicateDetector(): void {
         return
     }
 
     // eslint-disable-next-line class-methods-use-this
-    checkDuplicate(_messageId: string): boolean {
+    isMostLikelyDuplicate(): boolean {
         return false
     }
 
     // eslint-disable-next-line class-methods-use-this
-    doRouteMessage(_routedMessage: RouteMessageWrapper, _mode: RoutingMode): RouteMessageAck {
+    doRouteMessage(): RouteMessageAck {
         return RouteMessageAck.create()
     }
 
     // eslint-disable-next-line class-methods-use-this
-    send(_msg: Message, _reachableThrough: PeerDescriptor[]): Promise<void> {
+    send(): Promise<void> {
         throw Error('Not implemented')
     }
 
@@ -41,12 +39,12 @@ export class MockRouter implements IRouter {
     }
 
     // eslint-disable-next-line class-methods-use-this
-    async routeMessage(_routedMessage: RouteMessageWrapper, _context: ServerCallContext): Promise<RouteMessageAck> {
+    async routeMessage(): Promise<RouteMessageAck> {
         return RouteMessageAck.create()
     }
 
     // eslint-disable-next-line class-methods-use-this
-    async forwardMessage(_forwardMessage: RouteMessageWrapper, _context: ServerCallContext): Promise<RouteMessageAck> {
+    async forwardMessage(): Promise<RouteMessageAck> {
         return RouteMessageAck.create()
     }
 

package/test/utils/mock/Transport.ts

@@ -1,11 +1,11 @@
 import { ITransport, TransportEvents } from '../../../src/transport/ITransport'
 import { EventEmitter } from 'eventemitter3'
-import { Message, PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
 
 export class MockTransport extends EventEmitter<TransportEvents> implements ITransport {
 
     // eslint-disable-next-line class-methods-use-this
-    async send(_msg: Message, _doNotConnect?: boolean): Promise<void> {
+    async send(): Promise<void> {
 
     }