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

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/SortedContactList.test.ts

@@ -1,153 +1,103 @@
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import type { ServiceInfo, MethodInfo } from '@protobuf-ts/runtime-rpc'
 import { PeerID } from '../../src/helpers/PeerID'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { IDhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { LeaveNotice, NodeType, PeerDescriptor, RouteMessageAck } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { FindDataRequest, FindDataResponse, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { PingRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { ClosestPeersResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { ClosestPeersRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { UnaryCall } from '@protobuf-ts/runtime-rpc'
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc'
-import { DhtPeer } from '../../src/dht/DhtPeer'
-import { IMessageType } from '@protobuf-ts/runtime'
-import { Empty } from '../../src/proto/google/protobuf/empty'
 
-/* eslint-disable class-methods-use-this */
-class MockRpcClient implements IDhtRpcServiceClient, ServiceInfo {
-    typeName = 'MockRpcClient'
-    methods: MethodInfo<any, any> [] = [
-        { name: 'getClosestPeers', O: {} as IMessageType<ClosestPeersResponse> } as MethodInfo<any, any>,
-        { name: 'ping', O: {} as IMessageType<PingResponse> } as MethodInfo<any, any>,
-        { name: 'findData', O: {} as IMessageType<RouteMessageAck> } as MethodInfo<any, any>,
-        { name: 'leaveNotice', O: {} as IMessageType<Empty> } as MethodInfo<any, any>
-    ]
-    options = {}
-    getClosestPeers(_input: ClosestPeersRequest, _options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse> {
-        return {} as UnaryCall<ClosestPeersRequest, ClosestPeersResponse>
-    }
-    ping(_input: PingRequest, _options?: RpcOptions): UnaryCall <PingRequest, PingResponse> {
-        return {} as UnaryCall<PingRequest, PingResponse>
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    findData(_input: FindDataRequest, _options?: RpcOptions): UnaryCall<FindDataRequest, FindDataResponse> {
-        return {} as UnaryCall<FindDataRequest, FindDataResponse>
-    }
-
-    leaveNotice(_input: LeaveNotice, _options?: RpcOptions): UnaryCall<LeaveNotice, Empty> {
-        return {} as UnaryCall<LeaveNotice, Empty>
-    }
-}
-
-const getId = (descriptor: PeerDescriptor): PeerID => {
-    return PeerID.fromValue(descriptor.kademliaId)
+const createItem = (kademliaId: Uint8Array): { getPeerId: () => PeerID } => {
+    return { getPeerId: () => PeerID.fromValue(kademliaId) }
 }
 
 describe('SortedContactList', () => {
-    const serviceId = 'sorted'
-    const descriptor0: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 0]), type: NodeType.NODEJS }
-    const descriptor1: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 1]), type: NodeType.NODEJS }
-    const descriptor2: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 2]), type: NodeType.NODEJS }
-    const descriptor3: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 3]), type: NodeType.NODEJS }
-    const descriptor4: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 4]), type: NodeType.NODEJS }
-    const peer1 = new DhtPeer(descriptor0, descriptor1, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer2 = new DhtPeer(descriptor0, descriptor2, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer3 = new DhtPeer(descriptor0, descriptor3, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer4 = new DhtPeer(descriptor0, descriptor4, toProtoRpcClient(new MockRpcClient()), serviceId)
+    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('compares Ids correctly', async () => {
-        const list = new SortedContactList(getId(descriptor0), 10)
-        expect(list.compareIds(getId(descriptor0), getId(descriptor0))).toBe(0)
-        expect(list.compareIds(getId(descriptor1), getId(descriptor1))).toBe(0)
-        expect(list.compareIds(getId(descriptor0), getId(descriptor1))).toBe(-1)
-        expect(list.compareIds(getId(descriptor0), getId(descriptor2))).toBe(-2)
-        expect(list.compareIds(getId(descriptor1), getId(descriptor0))).toBe(1)
-        expect(list.compareIds(getId(descriptor2), getId(descriptor0))).toBe(2)
-        expect(list.compareIds(getId(descriptor2), getId(descriptor3))).toBe(-1)
-        expect(list.compareIds(getId(descriptor1), getId(descriptor4))).toBe(-3)
+        const list = new SortedContactList(item0.getPeerId(), 10)
+        expect(list.compareIds(item0.getPeerId(), item0.getPeerId())).toBe(0)
+        expect(list.compareIds(item1.getPeerId(), item1.getPeerId())).toBe(0)
+        expect(list.compareIds(item0.getPeerId(), item1.getPeerId())).toBe(-1)
+        expect(list.compareIds(item0.getPeerId(), item2.getPeerId())).toBe(-2)
+        expect(list.compareIds(item1.getPeerId(), item0.getPeerId())).toBe(1)
+        expect(list.compareIds(item2.getPeerId(), item0.getPeerId())).toBe(2)
+        expect(list.compareIds(item2.getPeerId(), item3.getPeerId())).toBe(-1)
+        expect(list.compareIds(item1.getPeerId(), item4.getPeerId())).toBe(-3)
     })
     
     it('orders itself correctly', async () => {
-
-        const list = new SortedContactList(getId(descriptor0), 10)
-
-        list.addContact(peer3)
-        list.addContact(peer2)
-        list.addContact(peer1)
-
+        const list = new SortedContactList(item0.getPeerId(), 10)
+        list.addContact(item3)
+        list.addContact(item2)
+        list.addContact(item1)
         const contacts = list.getUncontactedContacts(3)
         expect(contacts.length).toEqual(3)
-        expect(contacts[0]).toEqual(peer1)
-        expect(contacts[1]).toEqual(peer2)
-        expect(contacts[2]).toEqual(peer3)
+        expect(contacts[0]).toEqual(item1)
+        expect(contacts[1]).toEqual(item2)
+        expect(contacts[2]).toEqual(item3)
     })
     
     it('handles contacted nodes correctly', async () => {
-        const list = new SortedContactList(getId(descriptor0), 10)
-
-        list.addContact(peer3)
-        list.addContact(peer2)
-        list.addContact(peer1)
-
-        list.setContacted(getId(descriptor2))
+        const list = new SortedContactList(item0.getPeerId(), 10)
+        list.addContact(item3)
+        list.addContact(item2)
+        list.addContact(item1)
+        list.setContacted(item2.getPeerId())
         const contacts = list.getUncontactedContacts(3)
         expect(contacts.length).toEqual(2)
-        expect(contacts[0]).toEqual(peer1)
-        expect(contacts[1]).toEqual(peer3)
+        expect(contacts[0]).toEqual(item1)
+        expect(contacts[1]).toEqual(item3)
     })
 
     it('cannot exceed maxSize', async () => {
-        const list = new SortedContactList(getId(descriptor0), 3)
+        const list = new SortedContactList(item0.getPeerId(), 3)
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
-        list.addContact(peer1)
-        list.addContact(peer4)
-        list.addContact(peer3)
-        list.addContact(peer2)
+        list.addContact(item1)
+        list.addContact(item4)
+        list.addContact(item3)
+        list.addContact(item2)
         expect(list.getSize()).toEqual(3)
-        expect(onContactRemoved).toBeCalledWith(descriptor4, [descriptor1, descriptor2, descriptor3])
-        expect(list.getContact(getId(descriptor4))).toBeFalsy()
+        expect(onContactRemoved).toBeCalledWith(item4, [item1, item2, item3])
+        expect(list.getContact(item4.getPeerId())).toBeFalsy()
     })
 
     it('removing contacts', async () => {
-        const list = new SortedContactList(getId(descriptor0), 8)
+        const list = new SortedContactList(item0.getPeerId(), 8)
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
-        list.addContact(peer4)
-        list.addContact(peer3)
-        list.addContact(peer2)
-        list.addContact(peer1)
-        list.removeContact(getId(descriptor2))
+        list.addContact(item4)
+        list.addContact(item3)
+        list.addContact(item2)
+        list.addContact(item1)
+        list.removeContact(item2.getPeerId())
         expect(list.getSize()).toEqual(3)
-        expect(list.getContact(getId(descriptor2))).toBeFalsy()
+        expect(list.getContact(item2.getPeerId())).toBeFalsy()
         expect(list.getContactIds()).toEqual(list.getContactIds().sort(list.compareIds))
-        expect(list.getAllContacts()).toEqual([peer1, peer3, peer4])
-        expect(onContactRemoved).toBeCalledWith(descriptor2, [descriptor1, descriptor3, descriptor4])
+        expect(list.getAllContacts()).toEqual([item1, item3, item4])
+        expect(onContactRemoved).toBeCalledWith(item2, [item1, item3, item4])
         const ret = list.removeContact(PeerID.fromValue(Buffer.from([0, 0, 0, 6])))
         expect(ret).toEqual(false)
     })
 
     it('get closes contacts', () => {
-        const list = new SortedContactList(getId(descriptor0), 8)
-        list.addContact(peer1)
-        list.addContact(peer3)
-        list.addContact(peer4)
-        list.addContact(peer2)
-        expect(list.getClosestContacts(2)).toEqual([peer1, peer2])
-        expect(list.getClosestContacts()).toEqual([peer1, peer2, peer3, peer4])
+        const list = new SortedContactList(item0.getPeerId(), 8)
+        list.addContact(item1)
+        list.addContact(item3)
+        list.addContact(item4)
+        list.addContact(item2)
+        expect(list.getClosestContacts(2)).toEqual([item1, item2])
+        expect(list.getClosestContacts()).toEqual([item1, item2, item3, item4])
     })
 
     it('get active contacts', () => {
-        const list = new SortedContactList(getId(descriptor0), 8)
-        list.addContact(peer1)
-        list.addContact(peer3)
-        list.addContact(peer4)
-        list.addContact(peer2)
-        list.setActive(getId(descriptor2))
-        list.setActive(getId(descriptor3))
-        list.setActive(getId(descriptor4))
-        expect(list.getActiveContacts()).toEqual([peer2, peer3, peer4])
+        const list = new SortedContactList(item0.getPeerId(), 8)
+        list.addContact(item1)
+        list.addContact(item3)
+        list.addContact(item4)
+        list.addContact(item2)
+        list.setActive(item2.getPeerId())
+        list.setActive(item3.getPeerId())
+        list.setActive(item4.getPeerId())
+        expect(list.getActiveContacts()).toEqual([item2, item3, item4])
     })
 })

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)
+        })
+    })
+})

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/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> {
 
     }