@streamr/dht 100.2.4-beta.0 → 100.2.4

package/test/unit/StoreManager.test.ts

@@ -1,44 +1,46 @@
 import { wait, waitForCondition } from '@streamr/utils'
-import { range, sortBy } from 'lodash'
-import { getDistance } from '../../src/dht/PeerManager'
+import { range, without } from 'lodash'
+import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
 import { StoreManager } from '../../src/dht/store/StoreManager'
 import {
     DhtAddress,
     createRandomDhtAddress,
     getDhtAddressFromRaw,
-    getRawFromDhtAddress,
+    getRawFromDhtAddress
 } from '../../src/identifiers'
-import { NodeType, ReplicateDataRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor, ReplicateDataRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockPeerDescriptor } from '../utils/utils'
+
+const NODE_COUNT = 10
 
 const DATA_ENTRY = {
     key: getRawFromDhtAddress(createRandomDhtAddress()),
     creator: getRawFromDhtAddress(createRandomDhtAddress())
 }
-const NODES_CLOSEST_TO_DATA = sortBy(
-    range(5).map(() => createRandomDhtAddress()),
-    (id: DhtAddress) => getDistance(getRawFromDhtAddress(id), DATA_ENTRY.key)
-)
+const ALL_NODES = range(NODE_COUNT).map(() => createMockPeerDescriptor())
+
+const getNodeCloseToData = (distanceIndex: number) => {
+    const dataKey = getDhtAddressFromRaw(DATA_ENTRY.key)
+    return getClosestNodes(dataKey, ALL_NODES)[distanceIndex]
+}
 
 describe('StoreManager', () => {
 
     describe('new contact', () => {
 
         const createStoreManager = (
-            localNodeId: DhtAddress,
-            closestNeighbors: DhtAddress[],
+            localPeerDescriptor: PeerDescriptor,
+            redundancyFactor: number,
             replicateData: (request: ReplicateDataRequest) => unknown,
             setAllEntriesAsStale: (key: DhtAddress) => unknown
         ): StoreManager => {
-            const getClosestNeighborsTo = () => {
-                return closestNeighbors.map((nodeId) => ({ nodeId: getRawFromDhtAddress(nodeId), type: NodeType.NODEJS }))
-            }
             return new StoreManager({
                 rpcCommunicator: {
                     registerRpcMethod: () => {},
                     registerRpcNotification: () => {}
                 } as any,
                 recursiveOperationManager: undefined as any,
-                localPeerDescriptor: { nodeId: getRawFromDhtAddress(localNodeId), type: NodeType.NODEJS },
+                localPeerDescriptor,
                 localDataStore: { 
                     keys: () => [getDhtAddressFromRaw(DATA_ENTRY.key)],
                     values: () => [DATA_ENTRY],
@@ -46,24 +48,25 @@ describe('StoreManager', () => {
                 } as any,
                 serviceId: undefined as any,
                 highestTtl: undefined as any,
-                redundancyFactor: 3,
-                getClosestNeighborsTo,
+                redundancyFactor,
+                getNeighbors: () => without(ALL_NODES, localPeerDescriptor),
                 createRpcRemote: () => ({ replicateData } as any)
             })
         }
 
-        describe('this node is primary storer', () => {
+        describe('this node was primary storer', () => {
 
             it('new node is within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
                 const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+                const localNode = getNodeCloseToData(0)
                 const manager = createStoreManager(
-                    NODES_CLOSEST_TO_DATA[0],
-                    [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[3], NODES_CLOSEST_TO_DATA[4]],
+                    localNode,
+                    3,
                     replicateData,
                     setAllEntriesAsStale
                 )
-                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[2]), type: NodeType.NODEJS })
+                manager.onContactAdded(getNodeCloseToData(2))
                 await waitForCondition(() => replicateData.mock.calls.length === 1)
                 expect(replicateData).toHaveBeenCalledWith({
                     entry: DATA_ENTRY
@@ -74,61 +77,66 @@ describe('StoreManager', () => {
             it('new node is not within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
                 const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+                const localNode = getNodeCloseToData(0)
                 const manager = createStoreManager(
-                    NODES_CLOSEST_TO_DATA[0],
-                    [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
+                    localNode,
+                    3,
                     replicateData,
                     setAllEntriesAsStale
                 )
-                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded(getNodeCloseToData(4))
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
                 expect(setAllEntriesAsStale).not.toHaveBeenCalled()
             })
         })
 
-        describe('this node is not primary storer', () => {
+        describe('this node was not primary storer', () => {
 
             it('this node is within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
                 const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+                const localNode = getNodeCloseToData(1)
                 const manager = createStoreManager(
-                    NODES_CLOSEST_TO_DATA[1],
-                    [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
+                    localNode,
+                    3,
                     replicateData,
                     setAllEntriesAsStale
                 )
-                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded(getNodeCloseToData(4))
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
+                expect(setAllEntriesAsStale).toHaveBeenCalledTimes(0)
             })
 
             it('this node is not within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
                 const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+                const localNode = getNodeCloseToData(3)
                 const manager = createStoreManager(
-                    NODES_CLOSEST_TO_DATA[3],
-                    [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2]],
+                    localNode,
+                    3,
                     replicateData,
                     setAllEntriesAsStale
                 )
-                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded(getNodeCloseToData(4))
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
                 expect(setAllEntriesAsStale).toHaveBeenCalledTimes(1)
                 expect(setAllEntriesAsStale).toHaveBeenCalledWith(getDhtAddressFromRaw(DATA_ENTRY.key))
             })
 
-            it('this node has less than redundancyFactor neighbors', async () => {
+            it('this node is within redundancy factor, the node has less than redundancyFactor neighbors', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
                 const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+                const localNode = getNodeCloseToData(3)
                 const manager = createStoreManager(
-                    NODES_CLOSEST_TO_DATA[3],
-                    [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1]],
+                    localNode,
+                    100,
                     replicateData,
                     setAllEntriesAsStale
                 )
-                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded(getNodeCloseToData(4))
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
                 expect(setAllEntriesAsStale).toHaveBeenCalledTimes(0)

package/test/unit/StoreRpcLocal.test.ts

@@ -0,0 +1,167 @@
+import { range } from 'lodash'
+import { StoreRpcLocal } from '../../src/dht/store/StoreRpcLocal'
+import { areEqualPeerDescriptors, createRandomDhtAddress, DhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../src/identifiers'
+import { DataEntry, PeerDescriptor, StoreDataRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
+import { wait } from '@streamr/utils'
+
+describe('StoreRpcLocal', () => {
+
+    const NODE_COUNT = 5
+    const DATA_ENTRY = {
+        key: getRawFromDhtAddress(createRandomDhtAddress()),
+        creator: getRawFromDhtAddress(createRandomDhtAddress())
+    }
+
+    const ALL_NODES = range(NODE_COUNT).map(() => createMockPeerDescriptor())
+
+    const getNodeCloseToData = (distanceIndex: number) => {
+        const dataKey = getDhtAddressFromRaw(DATA_ENTRY.key)
+        return getClosestNodes(dataKey, ALL_NODES)[distanceIndex]
+    }
+
+    let storeRpcLocal: StoreRpcLocal
+    let setAllEntriesAsStale: jest.Mock<undefined, [DhtAddress]>
+    let replicateDataToContact: jest.Mock<Promise<void>, [DataEntry, PeerDescriptor]>
+
+    beforeEach(() => {
+        setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+        replicateDataToContact = jest.fn<Promise<void>, [DataEntry, PeerDescriptor]>()
+    })
+
+    describe('local node is primary storer', () => {
+
+        beforeEach(() => {
+            const localPeerDescriptor = getNodeCloseToData(0)
+            storeRpcLocal = new StoreRpcLocal({
+                localDataStore: { 
+                    storeEntry: () => true,
+                    setAllEntriesAsStale
+                } as any,
+                localPeerDescriptor,
+                replicateDataToContact,
+                getStorers: () => getClosestNodes(getDhtAddressFromRaw(DATA_ENTRY.key), ALL_NODES)
+            })
+        })
+
+        it('storeData', async () => {
+            const request = StoreDataRequest.create({
+                key: DATA_ENTRY.key,
+            })
+            await storeRpcLocal.storeData(request)
+            expect(setAllEntriesAsStale).not.toHaveBeenCalled()
+        })
+
+        it('replicateData', async () => {
+            const request = {
+                entry: DATA_ENTRY
+            }
+            await storeRpcLocal.replicateData(request as any, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
+            expect(setAllEntriesAsStale).not.toHaveBeenCalled()
+            // Wait for setImmediate
+            await wait(50)
+            expect(replicateDataToContact).toHaveBeenCalledTimes(NODE_COUNT - 1)
+        })
+        
+    })
+
+    describe('local node is storer', () => {
+        beforeEach(() => {
+            const localPeerDescriptor = getNodeCloseToData(1)
+            storeRpcLocal = new StoreRpcLocal({
+                localDataStore: { 
+                    storeEntry: () => true,
+                    setAllEntriesAsStale
+                } as any,
+                localPeerDescriptor,
+                replicateDataToContact,
+                getStorers: () => getClosestNodes(getDhtAddressFromRaw(DATA_ENTRY.key), ALL_NODES)
+            })
+        })
+
+        it('storeData', async () => {
+            const request = StoreDataRequest.create({
+                key: DATA_ENTRY.key
+            })
+            await storeRpcLocal.storeData(request)
+            expect(setAllEntriesAsStale).not.toHaveBeenCalled()
+        })
+
+        it('replicateData', async () => {
+            const request = {
+                entry: DATA_ENTRY
+            }
+            await storeRpcLocal.replicateData(request as any, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
+            expect(setAllEntriesAsStale).not.toHaveBeenCalled()
+            // Wait for setImmediate
+            await wait(50)
+            expect(replicateDataToContact).toHaveBeenCalledTimes(1)
+        })
+    })
+
+    describe('local node is not storer', () => {
+        beforeEach(() => {
+            const localPeerDescriptor = getNodeCloseToData(NODE_COUNT - 1)
+            storeRpcLocal = new StoreRpcLocal({
+                localDataStore: { 
+                    storeEntry: () => true,
+                    setAllEntriesAsStale
+                } as any,
+                localPeerDescriptor,
+                replicateDataToContact,
+                getStorers: () => getClosestNodes(getDhtAddressFromRaw(DATA_ENTRY.key), ALL_NODES)
+                    .filter((peerDescriptor) => !areEqualPeerDescriptors(peerDescriptor, localPeerDescriptor))
+            })
+        })
+        
+        it('storeData', async () => {
+            const request = StoreDataRequest.create({
+                key: DATA_ENTRY.key
+            })
+            await storeRpcLocal.storeData(request)
+            expect(setAllEntriesAsStale).toHaveBeenCalled()
+        })
+
+        it('replicateData', async () => {
+            const request = {
+                entry: DATA_ENTRY
+            }
+            await storeRpcLocal.replicateData(request as any, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
+            expect(setAllEntriesAsStale).toHaveBeenCalledTimes(1)
+            // Wait for setImmediate
+            await wait(50)
+            expect(replicateDataToContact).toHaveBeenCalledTimes(1)
+        })
+
+    })
+
+    describe('data was not stored', () => {
+
+        beforeEach(() => {
+            const localPeerDescriptor = getNodeCloseToData(1)
+            storeRpcLocal = new StoreRpcLocal({
+                localDataStore: { 
+                    storeEntry: () => false,
+                    setAllEntriesAsStale
+                } as any,
+                localPeerDescriptor,
+                replicateDataToContact,
+                getStorers: () => getClosestNodes(getDhtAddressFromRaw(DATA_ENTRY.key), ALL_NODES)
+            })
+        })
+
+        it('replicateData', async () => {
+            const request = {
+                entry: DATA_ENTRY
+            }
+            await storeRpcLocal.replicateData(request as any, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
+            expect(setAllEntriesAsStale).toHaveBeenCalledTimes(0)
+            // Wait for setImmediate
+            await wait(50)
+            expect(replicateDataToContact).toHaveBeenCalledTimes(0)
+        })
+
+    })
+
+})

package/test/unit/WebsocketConnector.test.ts

@@ -1,7 +1,7 @@
 /* eslint-disable max-len */
 import { WebsocketConnector } from '../../src/connection/websocket/WebsocketConnector'
 import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('WebsocketConnector', () => {

package/test/unit/connectivityRequestHandler.test.ts

@@ -27,7 +27,7 @@ describe('connectivityRequestHandler', () => {
         await once(httpServer, 'listening')
         connection = new EventEmitter()
         connection.send = jest.fn()
-        connection.remoteIpAddress = HOST
+        connection.getRemoteIpAddress = () => HOST
     })
 
     afterEach(async () => {

package/test/unit/getClosestNodes.test.ts

@@ -0,0 +1,30 @@
+import { range, sampleSize, sortBy } from 'lodash'
+import { getDistance } from '../../src/dht/PeerManager'
+import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
+import { DhtAddress, createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } 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 = createRandomDhtAddress()
+        const excluded = new Set<DhtAddress>(sampleSize(peerDescriptors.map((n) => getNodeIdFromPeerDescriptor(n), 2)))
+
+        const actual = getClosestNodes(
+            referenceId,
+            peerDescriptors,
+            {
+                maxCount: 5,
+                excludedNodeIds: excluded
+            }
+        )
+
+        const expected = sortBy(
+            peerDescriptors.filter((n) => !excluded.has(getNodeIdFromPeerDescriptor(n))),
+            (peerDescriptor: PeerDescriptor) => getDistance(peerDescriptor.nodeId, getRawFromDhtAddress(referenceId))
+        ).slice(0, 5)
+        expect(actual).toEqual(expected)
+    })
+})

package/test/utils/FakeTransport.ts

@@ -2,8 +2,10 @@ import { EventEmitter } from 'eventemitter3'
 import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { Message, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DEFAULT_SEND_OPTIONS, ITransport, SendOptions, TransportEvents } from '../../src/transport/ITransport'
+import { ConnectionsView } from '../../src/exports'
 
-class FakeTransport extends EventEmitter<TransportEvents> implements ITransport {
+// TODO extract ConnectionsView functionality to FakeConnectionsView
+class FakeTransport extends EventEmitter<TransportEvents> implements ITransport, ConnectionsView {
 
     private onSend: (msg: Message) => void
     private readonly localPeerDescriptor: PeerDescriptor
@@ -60,7 +62,7 @@ export class FakeEnvironment {
 
     private transports: FakeTransport[] = []
 
-    createTransport(peerDescriptor: PeerDescriptor): ITransport {
+    createTransport(peerDescriptor: PeerDescriptor): FakeTransport {
         const transport = new FakeTransport(peerDescriptor, (msg) => {
             const targetNode = getDhtAddressFromRaw(msg.targetDescriptor!.nodeId)
             const targetTransport = this.transports.find((t) => getNodeIdFromPeerDescriptor(t.getLocalPeerDescriptor()) === targetNode)

package/test/utils/mock/MockConnectionsView.ts

@@ -0,0 +1,18 @@
+import { PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
+
+export class MockConnectionsView {
+    // eslint-disable-next-line class-methods-use-this
+    getConnections(): PeerDescriptor[] {
+        return []
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getConnectionCount(): number {
+        return 0
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    hasConnection(): boolean {
+        return false
+    }
+}

package/test/utils/mock/{Transport.ts → MockTransport.ts}

@@ -14,21 +14,6 @@ export class MockTransport extends EventEmitter<TransportEvents> implements ITra
         return PeerDescriptor.create()
     }
 
-    // eslint-disable-next-line class-methods-use-this
-    getConnections(): PeerDescriptor[] {
-        return []
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getConnectionCount(): number {
-        return 0
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    hasConnection(): boolean {
-        return false
-    }
-
     // eslint-disable-next-line class-methods-use-this
     stop(): void {
 

package/test/utils/utils.ts

@@ -89,6 +89,7 @@ export const createMockConnectionDhtNode = async (
     const opts = {
         peerDescriptor: peerDescriptor,
         transport: mockConnectionManager,
+        connectionsView: mockConnectionManager,
         connectionLocker: mockConnectionManager,
         numberOfNodesPerKBucket,
         maxConnections: maxConnections,
@@ -115,7 +116,9 @@ export const createMockConnectionLayer1Node = async (
         type: NodeType.NODEJS,
     }
     const node = new DhtNode({
-        peerDescriptor: descriptor, transport: layer0Node,
+        peerDescriptor: descriptor,
+        transport: layer0Node,
+        connectionsView: layer0Node.getConnectionsView(),
         serviceId: serviceId ? serviceId : 'layer1', numberOfNodesPerKBucket,
         rpcRequestTimeout: 10000
     })

package/tsconfig.jest.json

@@ -18,6 +18,7 @@
         { "path": "../test-utils/tsconfig.node.json" },
         { "path": "../proto-rpc/tsconfig.node.json" },
         { "path": "../autocertifier-client/tsconfig.node.json" },
-        { "path": "../cdn-location/tsconfig.node.json" }
+        { "path": "../cdn-location/tsconfig.node.json" },
+        { "path": "../geoip-location/tsconfig.node.json" }
     ]
 }

package/tsconfig.node.json

@@ -17,6 +17,7 @@
         { "path": "../test-utils/tsconfig.node.json" },
         { "path": "../proto-rpc/tsconfig.node.json" },
         { "path": "../autocertifier-client/tsconfig.node.json" },
-        { "path": "../cdn-location/tsconfig.node.json" }
+        { "path": "../cdn-location/tsconfig.node.json" },
+        { "path": "../geoip-location/tsconfig.node.json" }
     ]
 }

package/dist/src/connection/ManagedWebrtcConnection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ManagedWebrtcConnection.js","sourceRoot":"","sources":["../../../src/connection/ManagedWebrtcConnection.ts"],"names":[],"mappings":";;;AACA,+CAA8C;AAC9C,2DAAuD;AAGvD,MAAa,uBAAwB,SAAQ,qCAAiB;IAE1D,YAAY,mBAAmC,EAC3C,oBAA2C,EAC3C,mBAA0C;QAE1C,KAAK,CACD,mBAAmB,EACnB,4BAAc,CAAC,MAAM,EACrB,oBAAoB,EACpB,mBAAmB,CACtB,CAAA;IACL,CAAC;IAEM,mBAAmB;QACtB,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC,kBAAqD,CAAA;QACrE,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAC,kBAAqD,CAAA;QACrE,CAAC;IACL,CAAC;CACJ;AArBD,0DAqBC"}

package/dist/src/dht/contact/getClosestContacts.d.ts

@@ -1,7 +0,0 @@
-import { DhtAddress } from '../../identifiers';
-export declare const getClosestContacts: <C extends {
-    getNodeId: () => DhtAddress;
-}>(referenceId: DhtAddress, contacts: Iterable<C>, opts?: {
-    maxCount?: number;
-    excludedNodeIds?: Set<DhtAddress>;
-}) => C[];

package/dist/src/dht/contact/getClosestContacts.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getClosestContacts.js","sourceRoot":"","sources":["../../../../src/dht/contact/getClosestContacts.ts"],"names":[],"mappings":";;;AACA,2DAAuD;AAEhD,MAAM,kBAAkB,GAAG,CAC9B,WAAuB,EACvB,QAAqB,EACrB,IAGC,EACE,EAAE;IACL,MAAM,IAAI,GAAG,IAAI,qCAAiB,CAAI;QAClC,WAAW;QACX,yBAAyB,EAAE,IAAI;QAC/B,eAAe,EAAE,IAAI,EAAE,eAAe;QACtC,OAAO,EAAE,IAAI,EAAE,QAAQ;KAC1B,CAAC,CAAA;IACF,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAA;IAC5B,CAAC;IACD,OAAO,IAAI,CAAC,kBAAkB,EAAE,CAAA;AACpC,CAAC,CAAA;AAlBY,QAAA,kBAAkB,sBAkB9B"}

package/test/unit/getClosestContacts.test.ts

@@ -1,28 +0,0 @@
-import { range, sampleSize, sortBy, without } from 'lodash'
-import { getDistance } from '../../src/dht/PeerManager'
-import { getClosestContacts } from '../../src/dht/contact/getClosestContacts'
-import { DhtAddress, createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
-
-describe('getClosestContacts', () => {
-
-    it('happy path', () => {
-        const nodeIds = range(10).map(() => createRandomDhtAddress())
-        const referenceId = createRandomDhtAddress()
-        const excluded = new Set<DhtAddress>(sampleSize(nodeIds, 2))
-
-        const actual = getClosestContacts(
-            referenceId,
-            nodeIds.map((nodeId) => ({ getNodeId: () => nodeId })),
-            {
-                maxCount: 5,
-                excludedNodeIds: excluded
-            }
-        )
-
-        const expected = sortBy(
-            without(nodeIds, ...Array.from(excluded.values())),
-            (n: DhtAddress) => getDistance(getRawFromDhtAddress(n), getRawFromDhtAddress(referenceId))
-        ).slice(0, 5)
-        expect(actual.map((n) => n.getNodeId())).toEqual(expected)
-    })
-})