@streamr/dht 100.2.4-beta.0 → 100.2.5-beta.0

package/test/end-to-end/Layer0Webrtc-Layer1.test.ts

@@ -50,41 +50,47 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
             entryPoints: [entrypointDescriptor]
         })
 
+        await layer0EntryPoint.start()
+        await layer0Node1.start()
+        await layer0Node2.start()
+        await layer0Node3.start()
+        await layer0Node4.start()
+
         layer1EntryPoint = new DhtNode({
             nodeId: getNodeIdFromPeerDescriptor(entrypointDescriptor),
             transport: layer0EntryPoint,
+            connectionsView: layer0EntryPoint.getConnectionsView(),
             serviceId: 'layer1'
         })
 
         layer1Node1 = new DhtNode({
             nodeId: layer0Node1Id,
             transport: layer0Node1,
+            connectionsView: layer0Node1.getConnectionsView(),
             serviceId: 'layer1'
         })
 
         layer1Node2 = new DhtNode({
             nodeId: layer0Node2Id,
             transport: layer0Node2,
+            connectionsView: layer0Node2.getConnectionsView(),
             serviceId: 'layer1'
         })
 
         layer1Node3 = new DhtNode({
             nodeId: layer0Node3Id,
             transport: layer0Node3,
+            connectionsView: layer0Node3.getConnectionsView(),
             serviceId: 'layer1'
         })
 
         layer1Node4 = new DhtNode({
             nodeId: layer0Node4Id,
             transport: layer0Node4,
+            connectionsView: layer0Node4.getConnectionsView(),
             serviceId: 'layer1'
         })
 
-        await layer0EntryPoint.start()
-        await layer0Node1.start()
-        await layer0Node2.start()
-        await layer0Node3.start()
-        await layer0Node4.start()
         await layer1EntryPoint.start()
         await layer1Node1.start()
         await layer1Node2.start()

package/test/end-to-end/Layer1-Scale-WebSocket.test.ts

@@ -24,7 +24,12 @@ describe('Layer1 Scale', () => {
         await epLayer0Node.start()
         await epLayer0Node.joinDht([epPeerDescriptor])
 
-        epLayer1Node = new DhtNode({ transport: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID })
+        epLayer1Node = new DhtNode({ 
+            transport: epLayer0Node,
+            connectionsView: epLayer0Node.getConnectionsView(),
+            peerDescriptor: epPeerDescriptor,
+            serviceId: STREAM_ID
+        })
         await epLayer1Node.start()
         await epLayer1Node.joinDht([epPeerDescriptor])
 
@@ -42,6 +47,7 @@ describe('Layer1 Scale', () => {
             layer0Nodes.push(node)
             const layer1 = new DhtNode({
                 transport: node,
+                connectionsView: node.getConnectionsView(),
                 entryPoints: [epPeerDescriptor],
                 peerDescriptor: node.getLocalPeerDescriptor(),
                 serviceId: STREAM_ID,

package/test/end-to-end/Layer1-Scale-Webrtc.test.ts

@@ -16,11 +16,19 @@ describe('Layer1 Scale', () => {
     let epLayer1Node: DhtNode
 
     beforeEach(async () => {
-        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor, websocketServerEnableTls: false })
+        epLayer0Node = new DhtNode({
+            peerDescriptor: epPeerDescriptor,
+            websocketServerEnableTls: false
+        })
         await epLayer0Node.start()
         await epLayer0Node.joinDht([epPeerDescriptor])
 
-        epLayer1Node = new DhtNode({ transport: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID })
+        epLayer1Node = new DhtNode({
+            transport: epLayer0Node,
+            connectionsView: epLayer0Node.getConnectionsView(),
+            peerDescriptor: epPeerDescriptor,
+            serviceId: STREAM_ID
+        })
         await epLayer1Node.start()
         await epLayer1Node.joinDht([epPeerDescriptor])
 
@@ -36,6 +44,7 @@ describe('Layer1 Scale', () => {
             layer0Nodes.push(node)
             const layer1 = new DhtNode({
                 transport: node,
+                connectionsView: node.getConnectionsView(),
                 entryPoints: [epPeerDescriptor],
                 peerDescriptor: node.getLocalPeerDescriptor(),
                 serviceId: STREAM_ID,

package/test/integration/ConnectionLocking.test.ts

@@ -13,7 +13,7 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
     return new ConnectionManager({
         createConnectorFacade: () => new DefaultConnectorFacade({
             transport,
-            createLocalPeerDescriptor: () => localPeerDescriptor
+            createLocalPeerDescriptor: async () => localPeerDescriptor
         }),
         metricsContext: new MetricsContext()
     })

package/test/integration/ConnectionManager.test.ts

@@ -33,7 +33,7 @@ describe('ConnectionManager', () => {
     const createConnectionManager = (opts: MarkOptional<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
         return new ConnectionManager({
             createConnectorFacade: () => new DefaultConnectorFacade({
-                createLocalPeerDescriptor,
+                createLocalPeerDescriptor: async (response) => createLocalPeerDescriptor(response),
                 websocketServerEnableTls: false,
                 ...opts
             }),
@@ -363,7 +363,7 @@ describe('ConnectionManager', () => {
             transport: mockTransport,
             websocketHost: '127.0.0.1',
             websocketPortRange: { min: 10002, max: 10002 },
-            createLocalPeerDescriptor: () => peerDescriptor1 
+            createLocalPeerDescriptor: async () => peerDescriptor1 
         })
 
         await connectionManager1.start()
@@ -372,7 +372,7 @@ describe('ConnectionManager', () => {
             transport: mockTransport,
             websocketHost: '127.0.0.1',
             websocketPortRange: { min: 10003, max: 10003 },
-            createLocalPeerDescriptor: () => peerDescriptor2
+            createLocalPeerDescriptor: async () => peerDescriptor2
         })
 
         await connectionManager2.start()

package/test/integration/ConnectivityChecking.test.ts

@@ -1,7 +1,7 @@
 import { MetricsContext } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { sendConnectivityRequest } from '../../src/connection/connectivityChecker'
 import { LOCAL_PROTOCOL_VERSION } from '../../src/helpers/version'
@@ -15,7 +15,7 @@ describe('ConnectivityChecking', () => {
     beforeEach(async () => {
         server = new ConnectionManager({
             createConnectorFacade: () => new DefaultConnectorFacade({
-                createLocalPeerDescriptor: () => {
+                createLocalPeerDescriptor: async () => {
                     return {
                         ...createMockPeerDescriptor(),
                         websocket: {
@@ -44,7 +44,7 @@ describe('ConnectivityChecking', () => {
             host: HOST,
             port: PORT,
             tls: false,
-            selfSigned: false
+            allowSelfSignedCertificate: false
         }
         const response = await sendConnectivityRequest(request, server.getLocalPeerDescriptor())
         expect(response.version).toEqual(LOCAL_PROTOCOL_VERSION)

package/test/integration/DhtNode.test.ts

@@ -1,9 +1,7 @@
 import { waitForCondition } from '@streamr/utils'
 import { range, without } from 'lodash'
 import { DhtNodeRpcLocal } from '../../src/dht/DhtNodeRpcLocal'
-import { Contact } from '../../src/dht/contact/Contact'
-import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import { DhtAddress, DhtNode, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '../../src/exports'
+import { DhtNode, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '../../src/exports'
 import { ClosestPeersRequest, ClosestPeersResponse, PeerDescriptor, PingRequest, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { FakeEnvironment } from '../utils/FakeTransport'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -11,21 +9,6 @@ import { createMockPeerDescriptor } from '../utils/utils'
 const OTHER_NODE_COUNT = 3
 const SERVICE_ID_LAYER0 = 'layer0'
 
-const getClosestNodes = (
-    referenceId: DhtAddress,
-    nodes: PeerDescriptor[],
-    maxCount: number,
-    allowToContainReferenceId: boolean
-): PeerDescriptor[] => {
-    const list = new SortedContactList<Contact>({
-        referenceId,
-        allowToContainReferenceId,
-        maxSize: maxCount
-    })
-    list.addContacts(nodes.map((n) => new Contact(n)))
-    return list.getClosestContacts().map((c) => c.getPeerDescriptor())
-}
-
 describe('DhtNode', () => {
 
     let localPeerDescriptor: PeerDescriptor
@@ -36,7 +19,7 @@ describe('DhtNode', () => {
         const epRpcCommunicator = new ListeningRpcCommunicator(SERVICE_ID_LAYER0, environment.createTransport(peerDescriptor))
         const dhtNodeRpcLocal = new DhtNodeRpcLocal({
             peerDiscoveryQueryBatchSize: undefined as any,
-            getClosestNeighborsTo: (nodeId: DhtAddress, maxCount: number) => getClosestNodes(nodeId, getAllPeerDescriptors(), maxCount, true),
+            getNeighbors: () => without(getAllPeerDescriptors(), peerDescriptor),
             getClosestRingContactsTo: undefined as any,
             addContact: () => {},
             removeContact: undefined as any,
@@ -64,9 +47,11 @@ describe('DhtNode', () => {
             startRemoteNode(other, environment)
         }
 
+        const transport = environment.createTransport(localPeerDescriptor)
         const localNode = new DhtNode({
             peerDescriptor: localPeerDescriptor,
-            transport: environment.createTransport(localPeerDescriptor),
+            transport,
+            connectionsView: transport,
             entryPoints: [entryPointPeerDescriptor]
         })
         await localNode.start()

package/test/integration/GeoIpConnectivityChecking.test.ts

@@ -0,0 +1,71 @@
+import { MetricsContext } from '@streamr/utils'
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
+import { MockTransport } from '../utils/mock/MockTransport'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { sendConnectivityRequest } from '../../src/connection/connectivityChecker'
+import { LOCAL_PROTOCOL_VERSION } from '../../src/helpers/version'
+import { WebsocketServerConnection } from '../../src/connection/websocket/WebsocketServerConnection'
+import fs from 'fs'
+
+// www.gov.za
+const testIp = '164.151.129.20'
+
+// Pretoria, South Africa
+const testLatitude = -25.7599
+const testLongitude = 28.2604
+
+const dbPath = '/tmp/geoipdatabasesintegration'
+
+describe('ConnectivityChecking', () => {
+
+    let server: ConnectionManager
+    const PORT = 15002
+    const HOST = '127.0.0.1'
+    let mock: jest.SpyInstance<string, [], any> 
+
+    beforeEach(async () => {
+        server = new ConnectionManager({
+            createConnectorFacade: () => new DefaultConnectorFacade({
+                createLocalPeerDescriptor: async () => {
+                    return {
+                        ...createMockPeerDescriptor(),
+                        websocket: {
+                            host: HOST,
+                            port: PORT,
+                            tls: false
+                        }
+                    }
+                },
+                websocketHost: HOST,
+                websocketPortRange: { min: PORT, max: PORT },
+                websocketServerEnableTls: false,
+                transport: new MockTransport(),
+                geoIpDatabaseFolder: dbPath
+            }),
+            metricsContext: new MetricsContext()
+        })
+        await server.start()
+        mock = jest.spyOn(WebsocketServerConnection.prototype, 'getRemoteIpAddress').mockImplementation(() => testIp)
+    })
+
+    afterEach(async () => {
+        await server.stop()
+        fs.unlinkSync(dbPath + '/GeoLite2-City.mmdb')
+        fs.rmSync(dbPath, { recursive: true })
+        mock.mockRestore()
+    })
+
+    it('connectivityCheck replies with correct latitude and longitude', async () => {
+        const request = {
+            host: HOST,
+            port: PORT,
+            tls: false,
+            allowSelfSignedCertificate: false
+        }
+        const response = await sendConnectivityRequest(request, server.getLocalPeerDescriptor())
+        expect(response.version).toEqual(LOCAL_PROTOCOL_VERSION)
+        expect(response.latitude).toEqual(testLatitude)
+        expect(response.longitude).toEqual(testLongitude)
+    })
+})

package/test/integration/Layer1-scale.test.ts

@@ -63,9 +63,9 @@ describe('Layer1', () => {
             const layer0Node = nodes[i]
             const layer1Node = layer1Nodes[i]
             expect(layer1Node.getNodeId()).toEqual(layer0Node.getNodeId())
-            expect(layer1Node.getConnectionCount()).toEqual(layer0Node.getConnectionCount())
+            expect(layer1Node.getConnectionsView().getConnectionCount()).toEqual(layer0Node.getConnectionsView().getConnectionCount())
             expect(layer1Node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
-            expect(layer1Node.getConnections()).toEqual(layer0Node.getConnections())
+            expect(layer1Node.getConnectionsView().getConnections()).toEqual(layer0Node.getConnectionsView().getConnections())
         }
     }, 120000)
 
@@ -119,10 +119,10 @@ describe('Layer1', () => {
             const stream3Node = stream3[i]
             const stream4Node = stream4[i]
 
-            expect(layer0Node.getConnectionCount()).toEqual(stream1Node.getConnectionCount())
-            expect(layer0Node.getConnectionCount()).toEqual(stream2Node.getConnectionCount())
-            expect(layer0Node.getConnectionCount()).toEqual(stream3Node.getConnectionCount())
-            expect(layer0Node.getConnectionCount()).toEqual(stream4Node.getConnectionCount())
+            expect(layer0Node.getConnectionsView().getConnectionCount()).toEqual(stream1Node.getConnectionsView().getConnectionCount())
+            expect(layer0Node.getConnectionsView().getConnectionCount()).toEqual(stream2Node.getConnectionsView().getConnectionCount())
+            expect(layer0Node.getConnectionsView().getConnectionCount()).toEqual(stream3Node.getConnectionsView().getConnectionCount())
+            expect(layer0Node.getConnectionsView().getConnectionCount()).toEqual(stream4Node.getConnectionsView().getConnectionCount())
 
         }
     }, 120000)

package/test/integration/RouteMessage.test.ts

@@ -73,6 +73,7 @@ describe('Route Message With Mock Connections', () => {
         }
 
         await runAndWaitForEvents3<DhtNodeEvents>([() => {
+            // @ts-expect-error private
             sourceNode.router!.doRouteMessage({
                 message,
                 target: destinationNode.getLocalPeerDescriptor().nodeId,
@@ -104,6 +105,7 @@ describe('Route Message With Mock Connections', () => {
                 sourceDescriptor: sourceNode.getLocalPeerDescriptor(),
                 targetDescriptor: destinationNode.getLocalPeerDescriptor()
             }
+            // @ts-expect-error private
             sourceNode.router!.doRouteMessage({
                 message,
                 target: destinationNode.getLocalPeerDescriptor().nodeId,
@@ -141,6 +143,7 @@ describe('Route Message With Mock Connections', () => {
                             sourceDescriptor: node.getLocalPeerDescriptor(),
                             targetDescriptor: destinationNode.getLocalPeerDescriptor()
                         }
+                        // @ts-expect-error private
                         node.router!.doRouteMessage({
                             message,
                             target: receiver.getLocalPeerDescriptor().nodeId,
@@ -217,6 +220,7 @@ describe('Route Message With Mock Connections', () => {
         }
 
         await runAndWaitForEvents3<DhtNodeEvents>([() => {
+            // @ts-expect-error private
             sourceNode.router!.doRouteMessage(forwardedMessage, RoutingMode.FORWARD)
         }], [[destinationNode, 'message']])
 

package/test/integration/ScaleDownDht.test.ts

@@ -57,7 +57,7 @@ describe('Scaling down a Dht network', () => {
             stoppedNodes.add(getNodeIdFromPeerDescriptor(stoppingPeerDescriptor))
             await nodeToStop.stop()
             const nodeIsCleaned = nodes.filter((node) => !stoppedNodes.has(node.getNodeId())).every((node) =>
-                node.getConnections().every((peer) => {
+                node.getConnectionsView().getConnections().every((peer) => {
                     if (areEqualPeerDescriptors(peer, stoppingPeerDescriptor)) {
                         logger.error(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + ', ' 
                             + getNodeIdFromPeerDescriptor(stoppingPeerDescriptor) + ' cleaning up failed')

package/test/integration/SimultaneousConnections.test.ts

@@ -7,7 +7,7 @@ import { Message, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dht
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockTransport } from '../utils/mock/MockTransport'
 import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const BASE_MESSAGE: Message = {
@@ -22,7 +22,7 @@ const BASE_MESSAGE: Message = {
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
     return new ConnectionManager({
         createConnectorFacade: () => new DefaultConnectorFacade({
-            createLocalPeerDescriptor: () => localPeerDescriptor,
+            createLocalPeerDescriptor: async () => localPeerDescriptor,
             ...opts
         }),
         metricsContext: new MetricsContext()

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -15,7 +15,7 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
     return new ConnectionManager({
         createConnectorFacade: () => new DefaultConnectorFacade({
             transport,
-            createLocalPeerDescriptor: () => localPeerDescriptor
+            createLocalPeerDescriptor: async () => localPeerDescriptor
         }),
         metricsContext: new MetricsContext()
     })

package/test/integration/Websocket.test.ts

@@ -58,7 +58,7 @@ describe('Websocket', () => {
             })
         })
 
-        clientWebsocket.connect('ws://127.0.0.1:9977')
+        clientWebsocket.connect('ws://127.0.0.1:9977', false)
     })
 
     afterAll(async () => {

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -17,7 +17,7 @@ const SERVICE_ID = 'test'
 const createConfig = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
     return {
         createConnectorFacade: () => new DefaultConnectorFacade({
-            createLocalPeerDescriptor: () => localPeerDescriptor,
+            createLocalPeerDescriptor: async () => localPeerDescriptor,
             ...opts
         }),
         metricsContext: new MetricsContext()

package/test/integration/rpc-connections-over-webrpc.test.ts

@@ -18,7 +18,7 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
     return new ConnectionManager({
         createConnectorFacade: () => new DefaultConnectorFacade({
             transport,
-            createLocalPeerDescriptor: () => localPeerDescriptor
+            createLocalPeerDescriptor: async () => localPeerDescriptor
         }),
         metricsContext: new MetricsContext()
     })

package/test/unit/AutoCertifierClientFacade.test.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'eventemitter3'
 import { AutoCertifierClientFacade, IAutoCertifierClient } from '../../src/connection/websocket/AutoCertifierClientFacade'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockTransport } from '../utils/mock/MockTransport'
 
 class MockAutoCertifierClient extends EventEmitter {
     start = async () => {

package/test/unit/DiscoverySession.test.ts

@@ -6,6 +6,7 @@ import { DiscoverySession } from '../../src/dht/discovery/DiscoverySession'
 import { DhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createTestTopology } from '../utils/topology'
+import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
 
 const NODE_COUNT = 40
 const MIN_NEIGHBOR_COUNT = 2  // nodes can get more neighbors when we merge network partitions
@@ -53,7 +54,7 @@ describe('DiscoverySession', () => {
                 queriedNodes.push(nodeId)
                 await wait(10)
                 const peerManager = createPeerManager(nodeId)
-                return peerManager.getClosestNeighborsTo(referenceId, QUERY_BATCH_SIZE).map((remote) => remote.getPeerDescriptor())
+                return getClosestNodes(referenceId, peerManager.getNeighbors().map((n) => n.getPeerDescriptor()), { maxCount: QUERY_BATCH_SIZE })
             },
             ping: async () => true
         }
@@ -70,7 +71,8 @@ describe('DiscoverySession', () => {
             noProgressLimit: NO_PROGRESS_LIMIT,
             peerManager,
             contactedPeers,
-            abortSignal: new AbortController().signal
+            abortSignal: new AbortController().signal,
+            createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => createMockRpcRemote(peerDescriptor) as any
         })
         await session.findClosestNodes(1000)
         expect(queriedNodes.length).toBeGreaterThanOrEqual(1)

package/test/unit/PeerManager.test.ts

@@ -1,14 +1,27 @@
 import { waitForCondition } from '@streamr/utils'
-import { range, sample, sampleSize, sortBy, without } from 'lodash'
+import { range, sample, sampleSize } from 'lodash'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
-import { PeerManager, getDistance } from '../../src/dht/PeerManager'
-import { Contact } from '../../src/dht/contact/Contact'
-import { SortedContactList } from '../../src/dht/contact/SortedContactList'
+import { PeerManager } from '../../src/dht/PeerManager'
+import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
 import { DhtAddress, createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 import { createMockPeerDescriptor } from '../utils/utils'
 
+const createDhtNodeRpcRemote = (
+    peerDescriptor: PeerDescriptor,
+    localPeerDescriptor: PeerDescriptor,
+    pingFailures: Set<DhtAddress>
+) => {
+    const remote = new class extends DhtNodeRpcRemote {
+        // eslint-disable-next-line class-methods-use-this
+        async ping(): Promise<boolean> {
+            return !pingFailures.has(getNodeIdFromPeerDescriptor(peerDescriptor))
+        }
+    }(localPeerDescriptor, peerDescriptor, undefined as any, new MockRpcCommunicator())
+    return remote
+}
+
 const createPeerManager = (
     nodeIds: DhtAddress[], 
     localPeerDescriptor = createMockPeerDescriptor(),
@@ -18,15 +31,7 @@ const createPeerManager = (
         localNodeId: getNodeIdFromPeerDescriptor(localPeerDescriptor),
         localPeerDescriptor: localPeerDescriptor,
         isLayer0: true,
-        createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => {
-            const remote = new class extends DhtNodeRpcRemote {
-                // eslint-disable-next-line class-methods-use-this
-                async ping(): Promise<boolean> {
-                    return !pingFailures.has(getNodeIdFromPeerDescriptor(peerDescriptor))
-                }
-            }(localPeerDescriptor, peerDescriptor, undefined as any, new MockRpcCommunicator())
-            return remote
-        },
+        createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => createDhtNodeRpcRemote(peerDescriptor, localPeerDescriptor, pingFailures),
         hasConnection: () => false
     } as any)
     const contacts = nodeIds.map((n) => ({ nodeId: getRawFromDhtAddress(n), type: NodeType.NODEJS }))
@@ -36,45 +41,14 @@ const createPeerManager = (
     return manager
 }
 
-const getClosestContact = (contacts: PeerDescriptor[], referenceId: DhtAddress): PeerDescriptor | undefined => {
-    const list = new SortedContactList({
-        referenceId,
-        allowToContainReferenceId: false
-    })
-    for (const contact of contacts) {
-        list.addContact(new Contact(contact))
-    }
-    const id = list.getClosestContactId()
-    if (id !== undefined) {
-        return contacts.find((c) => getNodeIdFromPeerDescriptor(c) === id)
-    } else {
-        return undefined
-    }
-}
-
 describe('PeerManager', () => {
 
-    it('getClosestNeighborsTo', () => {
-        const nodeIds = range(10).map(() => createRandomDhtAddress())
-        const manager = createPeerManager(nodeIds)
-        const referenceId = createRandomDhtAddress()
-        const excluded = new Set<DhtAddress>(sampleSize(nodeIds, 2))
-
-        const actual = manager.getClosestNeighborsTo(referenceId, 5, excluded)
-
-        const expected = sortBy(
-            without(manager.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n)), ...Array.from(excluded.values())),
-            (n: DhtAddress) => getDistance(getRawFromDhtAddress(n), getRawFromDhtAddress(referenceId))
-        ).slice(0, 5)
-        expect(actual.map((n) => n.getNodeId())).toEqual(expected)
-    })
-
-    it('getContactCount', () => {
+    it('getNearbyContactCount', () => {
         const nodeIds = range(10).map(() => createRandomDhtAddress())
         const manager = createPeerManager(nodeIds)
-        expect(manager.getContactCount()).toBe(10)
-        expect(manager.getContactCount(new Set(sampleSize(nodeIds, 2)))).toBe(8)
-        expect(manager.getContactCount(new Set([sample(nodeIds)!, createRandomDhtAddress()]))).toBe(9)
+        expect(manager.getNearbyContactCount()).toBe(10)
+        expect(manager.getNearbyContactCount(new Set(sampleSize(nodeIds, 2)))).toBe(8)
+        expect(manager.getNearbyContactCount(new Set([sample(nodeIds)!, createRandomDhtAddress()]))).toBe(9)
     })
 
     it('addContact: ping fails', async () => {
@@ -89,11 +63,31 @@ describe('PeerManager', () => {
         }
         expect(manager.getNeighborCount()).toBe(0)
         manager.addContact(failureContact)
-        const closesSuccessContact = getClosestContact(successContacts, getNodeIdFromPeerDescriptor(localPeerDescriptor))!
+        const closesSuccessContact = getClosestNodes(getNodeIdFromPeerDescriptor(localPeerDescriptor), successContacts)[0]
         await waitForCondition(() => {
-            const neighborNodeIds = manager.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+            const neighborNodeIds = manager.getNeighbors().map((n) => n.getNodeId())
             return neighborNodeIds.includes(getNodeIdFromPeerDescriptor(closesSuccessContact))
         })
-        expect(manager.getNeighbors()).toEqual([closesSuccessContact])
+        expect(manager.getNeighborCount()).toBe(1)
+        expect(manager.getNeighbors()[0].getPeerDescriptor()).toEqualPeerDescriptor(closesSuccessContact)
     })
+
+    it('pruneOfflineNodes removes offline nodes', async () => {
+        const localPeerDescriptor = createMockPeerDescriptor()
+        const successContacts = range(5).map(() => createMockPeerDescriptor())
+        const failureContact = createMockPeerDescriptor()
+        const failureSet: Set<DhtAddress> = new Set()
+        const manager = createPeerManager([], localPeerDescriptor, failureSet)
+        for (const successContact of successContacts) {
+            manager.addContact(successContact)
+        }
+        manager.addContact(failureContact)
+        expect(manager.getNeighborCount()).toBe(6)
+        failureSet.add(getNodeIdFromPeerDescriptor(failureContact))
+        await manager.pruneOfflineNodes(
+            manager.getNeighbors().map((node) => createDhtNodeRpcRemote(node.getPeerDescriptor(), localPeerDescriptor, failureSet))
+        )
+        expect(manager.getNeighborCount()).toBe(5)
+    })
+
 })

package/test/unit/RandomContactList.test.ts

@@ -45,4 +45,14 @@ describe('RandomContactList', () => {
         expect(list.getSize()).toEqual(3)
     })
 
+    it('get contacts', () => {
+        const list = new RandomContactList(item0.getNodeId(), 5, 1)
+        list.addContact(item1)
+        list.addContact(item2)
+        list.addContact(item3)
+        list.addContact(item4)
+        expect(list.getContacts()).toHaveLength(4)
+        expect(list.getContacts(3)).toHaveLength(3)
+        expect(list.getContacts(-2)).toHaveLength(0)
+    })
 })

package/test/unit/RecursiveOperationManager.test.ts

@@ -13,12 +13,13 @@ import {
 import { RecursiveOperationManager } from '../../src/dht/recursive-operation/RecursiveOperationManager'
 import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import { v4 } from 'uuid'
-import { MockRouter } from '../utils/mock/Router'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockRouter } from '../utils/mock/MockRouter'
+import { MockTransport } from '../utils/mock/MockTransport'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
 import { Router } from '../../src/dht/routing/Router'
 import { ITransport } from '../../src/transport/ITransport'
 import { areEqualPeerDescriptors, createRandomDhtAddress } from '../../src/identifiers'
+import { MockConnectionsView } from '../utils/mock/MockConnectionsView'
 
 const createMockRouter = (error?: RouteMessageError): Partial<Router> => {
     return {
@@ -77,6 +78,7 @@ describe('RecursiveOperationManager', () => {
             serviceId: 'RecursiveOperationManager',
             localDataStore: new LocalDataStore(30 * 100),
             sessionTransport: transport,
+            connectionsView: new MockConnectionsView(),
             addContact: () => {},
             rpcCommunicator: rpcCommunicator as any,
             createDhtNodeRpcRemote: () => undefined as any