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

package/test/unit/WebsocketClientConnector.test.ts

@@ -1,101 +0,0 @@
-/* eslint-disable max-len */
-import { WebsocketClientConnector } from '../../src/connection/websocket/WebsocketClientConnector'
-import { NodeType } from '../../generated/packages/dht/protos/DhtRpc'
-import { MockConnection } from '../utils/mock/MockConnection'
-import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('WebsocketClientConnector', () => {
-
-    let connector: WebsocketClientConnector
-
-    beforeEach(() => {
-        connector = new WebsocketClientConnector({
-            rpcCommunicator: new MockRpcCommunicator(),
-            canConnect: () => {}
-        } as any)
-    })
-
-    afterEach(() => {
-        connector.destroy()
-    })
-
-    describe('isPossibleToFormConnection', () => {
-
-        it('node without server', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
-        })
-
-        it('node with TLS server', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: true } }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
-        })
-
-        it('node with non-TLS server', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: false } }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
-        })
-
-        it('node with non-TLS server in local network', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '192.168.11.11', port: 11, tls: false } }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
-        })
-
-        it('browser', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.BROWSER }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
-        })
-    })
-
-    describe('Connect', () => {
-
-        it('Returns existing connecting connection', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor())
-            const remotePeerDescriptor = createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: false } })
-            const firstConnection = connector.connect(remotePeerDescriptor)
-            const secondConnection = connector.connect(remotePeerDescriptor)
-            expect(firstConnection).toEqual(secondConnection)
-            firstConnection.close(false)
-        })
-
-        it('Disconnected event removes connecting connection', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor())
-            const remotePeerDescriptor = createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: false } })
-            const firstConnection = connector.connect(remotePeerDescriptor)
-            firstConnection.emit('disconnected', false)
-            const secondConnection = connector.connect(remotePeerDescriptor)
-            expect(firstConnection).not.toEqual(secondConnection)
-            firstConnection.close(false)
-            secondConnection.close(false)
-        })
-
-        it('Connected event removes connecting connection', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor())
-            const remotePeerDescriptor = createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: false } })
-            const firstConnection = connector.connect(remotePeerDescriptor)
-            firstConnection.onHandshakeCompleted(new MockConnection())
-            const secondConnection = connector.connect(remotePeerDescriptor)
-            expect(firstConnection).not.toEqual(secondConnection)
-            firstConnection.close(false)
-            secondConnection.close(false)
-        })
-
-    })
-
-})

package/test/unit/WebsocketServer.test.ts

@@ -1,66 +0,0 @@
-import { WebsocketServer } from '../../src/connection/websocket/WebsocketServer'
-
-describe('WebsocketServer', () => {
-
-    it('starts and stops', async () => {
-        const server = new WebsocketServer({
-            portRange: { min: 19792, max: 19792 },
-            enableTls: false
-        })
-        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({
-            portRange: { min: 19792, max: 19792 },
-            enableTls: false
-        })
-        const port = await server1.start()
-        expect(port).toEqual(19792)
-
-        const server2 = new WebsocketServer({
-            portRange: { min: 19792, max: 19792 },
-            enableTls: false
-        })
-        await expect(server2.start())
-            .rejects
-            .toThrow()
-
-        await server1.stop()
-        await server2.stop()
-    })
-
-    it('Starts server in next port if first one is already in use', async () => {
-        const server1 = new WebsocketServer({
-            portRange: { min: 19792, max: 19793 },
-            enableTls: false
-        })
-        const port1 = await server1.start()
-        expect(port1).toEqual(19792)
-
-        const server2 = new WebsocketServer({
-            portRange: { min: 19792, max: 19793 },
-            enableTls: false
-        })
-        const port2 = await server2.start()
-        expect(port2).toEqual(19793)
-
-        await server1.stop()
-        await server2.stop()
-    })
-
-    it('throws if too big a port number is given', async () => {
-        const server = new WebsocketServer({
-            portRange: { min: 197923233, max: 197923233 },
-            enableTls: false
-        })
-
-        await expect(server.start())
-            .rejects
-            .toThrow()
-
-        await server.stop()
-    })
-})

package/test/unit/WebsocketServerConnector.test.ts

@@ -1,102 +0,0 @@
-/* eslint-disable max-len */
-import { WebsocketServerConnector } from '../../src/connection/websocket/WebsocketServerConnector'
-import { NodeType } from '../../generated/packages/dht/protos/DhtRpc'
-import { MockConnection } from '../utils/mock/MockConnection'
-import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('WebsocketServerConnector', () => {
-
-    let connector: WebsocketServerConnector
-
-    beforeEach(() => {
-        connector = new WebsocketServerConnector({
-            rpcCommunicator: new MockRpcCommunicator(),
-            canConnect: () => {}
-        } as any)
-    })
-
-    afterEach(() => {
-        connector.destroy()
-    })
-
-    describe('isPossibleToFormConnection', () => {
-
-        it('node without server', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
-        })
-
-        it('node with TLS server', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: true } }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(true)
-        })
-
-        it('node with non-TLS server', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: false } }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
-        })
-
-        it('node with non-TLS server in local network', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '192.168.11.11', port: 11, tls: false } }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(true)
-        })
-
-        it('browser', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.BROWSER }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
-        })
-
-    })
-
-    describe('Connect', () => {
-
-        it('Returns existing connecting connection', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: false } }))
-            const remotePeerDescriptor = createMockPeerDescriptor()
-            const firstConnection = connector.connect(remotePeerDescriptor)
-            const secondConnection = connector.connect(remotePeerDescriptor)
-            expect(firstConnection).toEqual(secondConnection)
-            firstConnection.close(false)
-        })
-
-        it('Disconnected event removes connecting connection', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: false } }))
-            const remotePeerDescriptor = createMockPeerDescriptor()
-            const firstConnection = connector.connect(remotePeerDescriptor)
-            firstConnection.emit('disconnected', false)
-            const secondConnection = connector.connect(remotePeerDescriptor)
-            expect(firstConnection).not.toEqual(secondConnection)
-            firstConnection.close(false)
-            secondConnection.close(false)
-        })
-
-        it('Connected event removes connecting connection', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: false } }))
-            const remotePeerDescriptor = createMockPeerDescriptor()
-            const firstConnection = connector.connect(remotePeerDescriptor)
-            firstConnection.onHandshakeCompleted(new MockConnection())
-            const secondConnection = connector.connect(remotePeerDescriptor)
-            expect(firstConnection).not.toEqual(secondConnection)
-            firstConnection.close(false)
-            secondConnection.close(false)
-        })
-
-    })
-
-})

package/test/unit/connectivityRequestHandler.test.ts

@@ -1,104 +0,0 @@
-import { ipv4ToNumber, until } from '@streamr/utils'
-import { EventEmitter } from 'eventemitter3'
-import { once } from 'events'
-import { Server as HttpServer, createServer as createHttpServer } from 'http'
-import { server as WsServer } from 'websocket'
-import { CONNECTIVITY_CHECKER_SERVICE_ID } from '../../src/connection/connectivityChecker'
-import { attachConnectivityRequestHandler } from '../../src/connection/connectivityRequestHandler'
-import { Message } from '../../generated/packages/dht/protos/DhtRpc'
-import { LOCAL_PROTOCOL_VERSION } from '../../src/helpers/version'
-
-const HOST = '127.0.0.1'
-const PORT = 15001
-
-describe('connectivityRequestHandler', () => {
-
-    let httpServer: HttpServer
-    let wsServer: WsServer
-    let connection: any
-
-    beforeEach(async () => {
-        httpServer = createHttpServer()
-        wsServer = new WsServer({
-            httpServer,
-            autoAcceptConnections: true
-        })
-        httpServer.listen(PORT)
-        await once(httpServer, 'listening')
-        connection = new EventEmitter()
-        connection.send = jest.fn()
-        connection.getRemoteIpAddress = () => HOST
-    })
-
-    afterEach(async () => {
-        wsServer.shutDown()
-        httpServer.close()
-        await once(httpServer, 'close')
-    })
-
-    it('happy path', async () => {
-        attachConnectivityRequestHandler(connection)
-        const request: Message = {
-            serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
-            messageId: 'mock-message-id',
-            body: {
-                oneofKind: 'connectivityRequest',
-                connectivityRequest: { port: PORT, host: HOST, tls: false, allowSelfSignedCertificate: false }
-            }
-        }
-        connection.emit('data', Message.toBinary(request))
-
-        await until(() => connection.send.mock.calls.length > 0)
-
-        const receivedMessage = Message.fromBinary(connection.send.mock.calls[0][0])
-        expect(receivedMessage).toEqual({
-            body: {
-                connectivityResponse: {
-                    host: HOST,
-                    natType: 'open_internet',
-                    websocket: {
-                        host: HOST,
-                        port: PORT,
-                        tls: false
-                    },
-                    ipAddress: ipv4ToNumber(HOST),
-                    protocolVersion: LOCAL_PROTOCOL_VERSION
-                },
-                oneofKind: 'connectivityResponse'
-            },
-            messageId: expect.any(String),
-            serviceId: 'system/connectivity-checker'
-        })
-    })
-
-    it('disabled connectivity probing', async () => {
-        attachConnectivityRequestHandler(connection)
-        const request: Message = {
-            serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
-            messageId: 'mock-message-id',
-            body: {
-                oneofKind: 'connectivityRequest',
-                connectivityRequest: { port: 0, host: HOST, tls: false, allowSelfSignedCertificate: false }
-            }
-        }
-        connection.emit('data', Message.toBinary(request))
-
-        await until(() => connection.send.mock.calls.length > 0)
-
-        const receivedMessage = Message.fromBinary(connection.send.mock.calls[0][0])
-        expect(receivedMessage).toEqual({
-            body: {
-                connectivityResponse: {
-                    host: HOST,
-                    natType: 'unknown',
-                    ipAddress: ipv4ToNumber(HOST),
-                    protocolVersion: LOCAL_PROTOCOL_VERSION
-                },
-                oneofKind: 'connectivityResponse'
-            },
-            messageId: expect.any(String),
-            serviceId: 'system/connectivity-checker'
-        })
-    })
-
-})

package/test/unit/createPeerDescriptor.test.ts

@@ -1,69 +0,0 @@
-import { ipv4ToNumber } from '@streamr/utils'
-import { createPeerDescriptor } from '../../src/helpers/createPeerDescriptor'
-import { isBrowserEnvironment } from '../../src/helpers/browser/isBrowserEnvironment'
-import { NodeType } from '../../generated/packages/dht/protos/DhtRpc'
-import { randomDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
-import { getRandomRegion } from '../../dist/src/connection/simulator/pings'
-
-const IP_ADDRESS = '1.2.3.4'
-
-describe('createPeerDescriptor', () => {
-
-    const region = getRandomRegion()
-
-    it('without websocket', () => {
-        const connectivityResponse = {
-            ipAddress: ipv4ToNumber(IP_ADDRESS)
-        } as any
-        const peerDescriptor = createPeerDescriptor(connectivityResponse, region)
-        expect(peerDescriptor).toEqual({
-            nodeId: expect.any(Uint8Array),
-            type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
-            ipAddress: ipv4ToNumber(IP_ADDRESS),
-            publicKey: expect.any(Uint8Array),
-            signature: expect.any(Uint8Array),
-            region
-        })
-    })
-
-    it('with websocket', () => {
-        const connectivityResponse = {
-            ipAddress: ipv4ToNumber(IP_ADDRESS),
-            websocket: {
-                host: 'bar.com',
-                port: 123,
-                tls: true
-            }
-        } as any
-        const peerDescriptor = createPeerDescriptor(connectivityResponse, region)
-        expect(peerDescriptor).toEqual({
-            nodeId: expect.any(Uint8Array),
-            type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
-            ipAddress: ipv4ToNumber(IP_ADDRESS),
-            publicKey: expect.any(Uint8Array),
-            signature: expect.any(Uint8Array),
-            websocket: {
-                host: 'bar.com',
-                port: 123,
-                tls: true
-            },
-            region
-        })
-    })
-
-    it('explicit nodeId', () => {
-        const nodeId = randomDhtAddress()
-        const connectivityResponse = {
-            ipAddress: ipv4ToNumber(IP_ADDRESS)
-        } as any
-        const peerDescriptor = createPeerDescriptor(connectivityResponse, region, nodeId)
-        expect(peerDescriptor).toEqual({
-            nodeId: toDhtAddressRaw(nodeId),
-            type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
-            ipAddress: ipv4ToNumber(IP_ADDRESS),
-            publicKey: expect.any(Uint8Array),
-            signature: expect.any(Uint8Array),
-            region
-        })
-    })
-})

package/test/unit/customMatchers.test.ts

@@ -1,34 +0,0 @@
-import { cloneDeep } from 'lodash'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('custom matchers', () => {
-
-    it('happy path', () => {
-        const peerDescriptor = createMockPeerDescriptor({
-            websocket: { port: 1, host: 'x', tls: true }
-        })
-        expect(peerDescriptor).toEqualPeerDescriptor(cloneDeep(peerDescriptor))
-    })
-
-    it('no match', () => {
-        expect(createMockPeerDescriptor()).not.toEqualPeerDescriptor(createMockPeerDescriptor())
-    })
-
-    describe('error message', () => {
-
-        it('normal', () => {
-            const actual = createMockPeerDescriptor()
-            const expected = createMockPeerDescriptor()
-            expect(() => {
-                expect(actual).toEqualPeerDescriptor(expected)
-            }).toThrow('PeerDescriptor nodeId values don\'t match')
-        })
-
-        it('inverse', () => {
-            const peerDescriptor = createMockPeerDescriptor()
-            expect(() => {
-                expect(peerDescriptor).not.toEqualPeerDescriptor(peerDescriptor)
-            }).toThrow('PeerDescriptors are equal')
-        })
-    })
-})

package/test/unit/getClosestNodes.test.ts

@@ -1,30 +0,0 @@
-import { range, sampleSize, sortBy } from 'lodash'
-import { getDistance } from '../../src/dht/PeerManager'
-import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
-import { DhtAddress, randomDhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { PeerDescriptor } from '../../src/exports'
-
-describe('getClosestNodes', () => {
-
-    it('happy path', () => {
-        const peerDescriptors = range(10).map(() => createMockPeerDescriptor())
-        const referenceId = randomDhtAddress()
-        const excluded = new Set<DhtAddress>(sampleSize(peerDescriptors.map((n) => toNodeId(n)), 2))
-
-        const actual = getClosestNodes(
-            referenceId,
-            peerDescriptors,
-            {
-                maxCount: 5,
-                excludedNodeIds: excluded
-            }
-        )
-
-        const expected = sortBy(
-            peerDescriptors.filter((n) => !excluded.has(toNodeId(n))),
-            (peerDescriptor: PeerDescriptor) => getDistance(peerDescriptor.nodeId, toDhtAddressRaw(referenceId))
-        ).slice(0, 5)
-        expect(actual).toEqual(expected)
-    })
-})

package/test/unit/version.test.ts

@@ -1,18 +0,0 @@
-import { isMaybeSupportedProtocolVersion } from '../../src/helpers/version'
-
-describe('version', () => {
-
-    it('supported', () => {
-        expect(isMaybeSupportedProtocolVersion('1.0')).toBe(true)
-        expect(isMaybeSupportedProtocolVersion('1.1')).toBe(true)
-        expect(isMaybeSupportedProtocolVersion('2.0')).toBe(true)
-        expect(isMaybeSupportedProtocolVersion('3.5')).toBe(true)
-    })
-
-    it('not supported', () => {
-        expect(isMaybeSupportedProtocolVersion('')).toBe(false)
-        expect(isMaybeSupportedProtocolVersion('100.0.0-testnet-three.3')).toBe(false)
-        expect(isMaybeSupportedProtocolVersion('0.0')).toBe(false)
-        expect(isMaybeSupportedProtocolVersion('0.1')).toBe(false)
-    })
-})

package/test/unit/webrtcReplaceInternalIpWithExternalIp.test.ts

@@ -1,18 +0,0 @@
-import { replaceInternalIpWithExternalIp } from '../../src/connection/webrtc/WebrtcConnector'
-
-describe('replaceIpIfCandidateTypeIsHost', () => {
-
-    const hostCandidate = 'candidate:1 1 UDP 2013266431 127.0.0.1 30000 typ host'
-    const srflxCandidate = 'candidate:1 1 UDP 2013266431 127.0.0.1 30000 typ srflx'
-    
-    it('replaces ip if candidate type is host', () => {
-        const replaced = replaceInternalIpWithExternalIp(hostCandidate, '0.0.0.0')
-        expect(replaced).toEqual('candidate:1 1 UDP 2013266431 0.0.0.0 30000 typ host')
-    })
-
-    it('does not replace candidate if type is not host', () => {
-        const replaced = replaceInternalIpWithExternalIp(srflxCandidate, '0.0.0.0')
-        expect(replaced).toEqual(srflxCandidate)
-    })
-
-})

package/test/utils/FakeConnectorFacade.ts

@@ -1,41 +0,0 @@
-import { PendingConnection } from '../../src/connection/PendingConnection'
-import { DhtAddress } from '../../src/identifiers'
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { ITransport } from '../../src/transport/ITransport'
-
-export class FakeConnectorFacade {
-
-    private readonly localPeerDescriptor: PeerDescriptor
-    private onNewConnection?: (connection: PendingConnection) => boolean
-
-    constructor(localPeerDescriptor: PeerDescriptor) {
-        this.localPeerDescriptor = localPeerDescriptor
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    createConnection(peerDescriptor: PeerDescriptor): PendingConnection {
-        return new PendingConnection(peerDescriptor)
-    } 
-    
-    getLocalPeerDescriptor(): PeerDescriptor | undefined {
-        return this.localPeerDescriptor
-    }
-
-    callOnNewConnection(connection: PendingConnection): boolean {
-        return this.onNewConnection!(connection)
-    }
-
-    async start(
-        onNewConnection: (connection: PendingConnection) => boolean,
-        _hasConnection: (nodeId: DhtAddress) => boolean,
-        _autoCertifierTransport: ITransport
-    ): Promise<void> {
-        this.onNewConnection = onNewConnection
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async stop(): Promise<void> {
-        
-    }
-}
-

package/test/utils/FakeRpcCommunicator.ts

@@ -1,23 +0,0 @@
-export class FakeRpcCommunicator {
-
-    private readonly listeners: Map<string, (...args: any[]) => Promise<unknown>> = new Map()
-
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    registerRpcMethod(_requestClass: any, _returnClass: any, methodName: string, callback: (...args: any[]) => Promise<unknown>): void {
-        this.listeners.set(methodName, callback)
-    }
-    
-    async callRpcMethod(methodName: string, ...args: any[]): Promise<unknown> {
-        const listener = this.listeners.get(methodName)
-        if (listener !== undefined) {
-            return listener(...args)
-        } else {
-            throw new Error(`no registered callbacks for ${methodName}`)
-        }
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getRpcClientTransport(): any {
-        return {}
-    }
-}