@streamr/dht 100.0.0-testnet-two.4 → 100.0.0-testnet-three.0

package/test/integration/ConnectionLocking.test.ts

@@ -3,10 +3,11 @@ import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { ITransport } from '../../src/exports'
+import { ITransport } from '../../src/transport/ITransport'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { getRandomRegion } from '../../dist/src/connection/simulator/pings'
 import { createMockPeerDescriptor } from '../utils/utils'
+import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
@@ -55,114 +56,126 @@ describe('Connection Locking', () => {
     })
 
     it('can lock connections', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
         ])
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(true)
-        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
+        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
     })
 
     it('Multiple services on the same peer', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(true)
-        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
+        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
     })
 
     it('can unlock connections', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
         ])
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2))
-        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(false)
-        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager2.hasLocalLockedConnection(nodeId2)).toEqual(false)
+        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock')
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(false)
-        await waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1) === false)
-        expect(connectionManager1.hasConnection(mockPeerDescriptor1)).toEqual(false)
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(false)
+        await waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1) === false)
+        expect(connectionManager1.hasConnection(nodeId1)).toEqual(false)
     })
 
     it('unlocking multiple services', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
 
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2))
-        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)).toEqual(false)
+        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(false)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(true)
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock2')
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(false)
-        expect(connectionManager1.hasConnection(mockPeerDescriptor1)).toEqual(false)
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(false)
+        expect(connectionManager1.hasConnection(nodeId1)).toEqual(false)
     })
 
     it('maintains connection if both sides initially lock and then one end unlocks', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
-            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
             connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
         ])
 
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2))
-        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1))
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2))
+        expect(connectionManager2.hasLocalLockedConnection(nodeId1))
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
         await waitForCondition(() =>
-            connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)
-            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)
-            && !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)
-            && connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)
+            connectionManager1.hasRemoteLockedConnection(nodeId2)
+            && !connectionManager1.hasLocalLockedConnection(nodeId2)
+            && !connectionManager2.hasRemoteLockedConnection(nodeId1)
+            && connectionManager2.hasLocalLockedConnection(nodeId1)
         )
         
-        expect(connectionManager2.hasConnection(mockPeerDescriptor1)).toEqual(true)
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
+        expect(connectionManager2.hasConnection(nodeId1)).toEqual(true)
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
     })
 
     it('unlocks after graceful disconnect', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
-            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
             connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
         ])
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2))
-        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)).toEqual(true)
-        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(true)
+        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
 
         //@ts-expect-error private field
         await connectionManager1.gracefullyDisconnectAsync(mockPeerDescriptor2)
         
         await waitForCondition(() =>
-            !connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)
-            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)
+            !connectionManager1.hasRemoteLockedConnection(nodeId2)
+            && !connectionManager1.hasLocalLockedConnection(nodeId2)
         )
         await waitForCondition(() =>
-            !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)
-            && !connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)
+            !connectionManager2.hasRemoteLockedConnection(nodeId1)
+            && !connectionManager2.hasLocalLockedConnection(nodeId1)
         )
-        await waitForCondition(() => !connectionManager2.hasConnection(mockPeerDescriptor1))
-        await waitForCondition(() => !connectionManager1.hasConnection(mockPeerDescriptor2))
+        await waitForCondition(() => !connectionManager2.hasConnection(nodeId1))
+        await waitForCondition(() => !connectionManager1.hasConnection(nodeId2))
 
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(false)
-        expect(connectionManager2.hasConnection(mockPeerDescriptor1)).toEqual(false)
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(false)
+        expect(connectionManager2.hasConnection(nodeId1)).toEqual(false)
     }, 10000)
 })

package/test/integration/ConnectionManager.test.ts

@@ -1,15 +1,15 @@
+import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
+import { MarkOptional } from 'ts-essentials'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { ConnectivityResponse, Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
 import { Simulator } from '../../src/connection/simulator/Simulator'
-import { createPeerDescriptor } from '../../src/dht/DhtNode'
+import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
+import { createPeerDescriptor } from '../../src/helpers/createPeerDescriptor'
+import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+import { ConnectivityResponse, Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
-import { SimulatorTransport } from '../../src/exports'
-import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
-import { MarkOptional } from 'ts-essentials'
 import { TransportEvents } from '../../src/transport/ITransport'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
 
 const SERVICE_ID = 'demo'
 
@@ -292,6 +292,7 @@ describe('ConnectionManager', () => {
         await Promise.all([disconnectedPromise1, disconnectedPromise2])
         await connectionManager3.stop()
         await connectionManager4.stop()
+        simulator2.stop()
     })
 
     it('Cannot send to own WebsocketServer if nodeIds do not match', async () => {

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -21,10 +21,10 @@ const runTest = async (latencyType: LatencyType) => {
     await entryPoint.joinDht([entrypointDescriptor])
     await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
     nodes.forEach((node) => {
-        expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+        expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         expect(node.getClosestContacts().length).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
     })
-    expect(entryPoint.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+    expect(entryPoint.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
 
     await Promise.all([
         entryPoint.stop(),

package/test/integration/DhtNodeExternalAPI.test.ts

@@ -1,7 +1,6 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
-import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { createRandomDhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
 import { createMockConnectionDhtNode } from '../utils/utils'
 

package/test/integration/DhtNodeRpcRemote.test.ts

@@ -8,15 +8,16 @@ import {
     PingResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
+import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const SERVICE_ID = 'test'
 
 describe('DhtNodeRpcRemote', () => {
 
     let rpcRemote: DhtNodeRpcRemote
-    let clientRpcCommunicator: RpcCommunicator
-    let serverRpcCommunicator: RpcCommunicator
+    let clientRpcCommunicator: RpcCommunicator<DhtCallContext>
+    let serverRpcCommunicator: RpcCommunicator<DhtCallContext>
     const clientPeerDescriptor = createMockPeerDescriptor()
     const serverPeerDescriptor = createMockPeerDescriptor()
     const mockDhtRpc = createMockDhtRpc(createMockPeers())

package/test/integration/DhtRpc.test.ts

@@ -4,12 +4,13 @@ import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.cli
 import { ClosestPeersRequest, ClosestPeersResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { wait } from '@streamr/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
 describe('DhtRpc', () => {
 
-    let rpcCommunicator1: RpcCommunicator
-    let rpcCommunicator2: RpcCommunicator
+    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
+    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
     let client1: ProtoRpcClient<DhtNodeRpcClient>
     let client2: ProtoRpcClient<DhtNodeRpcClient>
     const peerDescriptor1 = createMockPeerDescriptor()

package/test/integration/Find.test.ts

@@ -2,12 +2,10 @@ import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator
 import { DhtNode } from '../../src/dht/DhtNode'
 import { PeerDescriptor, RecursiveOperation } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
-import { PeerID } from '../../src/helpers/PeerID'
-import { peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { getDhtAddressFromRaw, getRawFromDhtAddress } from '../../src/identifiers'
+import { getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
 
 const NUM_NODES = 100
-const K = 2
+const K = 8
 
 describe('Find correctness', () => {
 
@@ -22,7 +20,7 @@ describe('Find correctness', () => {
         nodes.push(entryPoint)
         entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
         for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator, undefined, K, 20, 60000)
+            const node = await createMockConnectionDhtNode(simulator, undefined, K, 40, 60000)
             nodes.push(node)
         }
         await entryPoint.joinDht([entrypointDescriptor])
@@ -41,7 +39,7 @@ describe('Find correctness', () => {
         const targetId = getRawFromDhtAddress(nodes[45].getNodeId())
         const results = await entryPoint.executeRecursiveOperation(getDhtAddressFromRaw(targetId), RecursiveOperation.FIND_NODE)
         expect(results.closestNodes.length).toBeGreaterThanOrEqual(5)
-        expect(PeerID.fromValue(targetId).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
+        expect(getDhtAddressFromRaw(targetId)).toEqual(getNodeIdFromPeerDescriptor(results.closestNodes[0]))
     }, 30000)
 
 })

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.getNumberOfConnections()).toEqual(layer0Node.getNumberOfConnections())
-            expect(layer1Node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
-            expect(layer1Node.getAllConnectionPeerDescriptors()).toEqual(layer0Node.getAllConnectionPeerDescriptors())
+            expect(layer1Node.getConnectionCount()).toEqual(layer0Node.getConnectionCount())
+            expect(layer1Node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(layer1Node.getConnections()).toEqual(layer0Node.getConnections())
         }
     }, 120000)
 
@@ -119,10 +119,10 @@ describe('Layer1', () => {
             const stream3Node = stream3[i]
             const stream4Node = stream4[i]
 
-            expect(layer0Node.getNumberOfConnections()).toEqual(stream1Node.getNumberOfConnections())
-            expect(layer0Node.getNumberOfConnections()).toEqual(stream2Node.getNumberOfConnections())
-            expect(layer0Node.getNumberOfConnections()).toEqual(stream3Node.getNumberOfConnections())
-            expect(layer0Node.getNumberOfConnections()).toEqual(stream4Node.getNumberOfConnections())
+            expect(layer0Node.getConnectionCount()).toEqual(stream1Node.getConnectionCount())
+            expect(layer0Node.getConnectionCount()).toEqual(stream2Node.getConnectionCount())
+            expect(layer0Node.getConnectionCount()).toEqual(stream3Node.getConnectionCount())
+            expect(layer0Node.getConnectionCount()).toEqual(stream4Node.getConnectionCount())
 
         }
     }, 120000)

package/test/integration/Mock-Layer1-Layer0.test.ts

@@ -2,13 +2,10 @@ import { Logger } from '@streamr/utils'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'
-import { PeerID } from '../../src/exports'
-import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { createRandomDhtAddress } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
-// TODO refactor the test to not to use PeerID
-
 describe('Layer 1 on Layer 0 with mocked connections', () => {
 
     const simulator = new Simulator()
@@ -25,11 +22,11 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
     beforeEach(async () => {
 
-        layer0EntryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString('layer0entrypoint').value))
-        layer0Node1 = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString('node1').value))
-        layer0Node2 = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString('node2').value))
-        layer0Node3 = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString('node3').value))
-        layer0Node4 = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString('node4').value))
+        layer0EntryPoint = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
+        layer0Node1 = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
+        layer0Node2 = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
+        layer0Node3 = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
+        layer0Node4 = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
 
         layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint)
 
@@ -68,21 +65,21 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         await layer1Node3.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
         await layer1Node4.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
 
-        logger.info('layer1EntryPoint.getNumberOfNeighbors() ' + layer1EntryPoint.getNumberOfNeighbors())
-        logger.info('layer1Node1.getNumberOfNeighbors()' + layer1Node1.getNumberOfNeighbors())
-        logger.info('layer1Node2.getNumberOfNeighbors()' + layer1Node2.getNumberOfNeighbors())
-        logger.info('layer1Node3.getNumberOfNeighbors()' + layer1Node3.getNumberOfNeighbors())
-        logger.info('layer1Node4.getNumberOfNeighbors()' + layer1Node4.getNumberOfNeighbors())
-
-        expect(layer1Node1.getNumberOfNeighbors()).toEqual(layer0Node1.getNumberOfNeighbors())
-        expect(layer1Node2.getNumberOfNeighbors()).toEqual(layer0Node2.getNumberOfNeighbors())
-        expect(layer1Node3.getNumberOfNeighbors()).toEqual(layer0Node3.getNumberOfNeighbors())
-        expect(layer1Node4.getNumberOfNeighbors()).toEqual(layer0Node4.getNumberOfNeighbors())
-
-        expect(layer1Node1.getAllNeighborPeerDescriptors()).toContainValues(layer0Node1.getAllNeighborPeerDescriptors())
-        expect(layer1Node2.getAllNeighborPeerDescriptors()).toContainValues(layer0Node2.getAllNeighborPeerDescriptors())
-        expect(layer1Node3.getAllNeighborPeerDescriptors()).toContainValues(layer0Node3.getAllNeighborPeerDescriptors())
-        expect(layer1Node4.getAllNeighborPeerDescriptors()).toContainValues(layer0Node4.getAllNeighborPeerDescriptors())
+        logger.info('layer1EntryPoint.getNeighborCount() ' + layer1EntryPoint.getNeighborCount())
+        logger.info('layer1Node1.getNeighborCount()' + layer1Node1.getNeighborCount())
+        logger.info('layer1Node2.getNeighborCount()' + layer1Node2.getNeighborCount())
+        logger.info('layer1Node3.getNeighborCount()' + layer1Node3.getNeighborCount())
+        logger.info('layer1Node4.getNeighborCount()' + layer1Node4.getNeighborCount())
+
+        expect(layer1Node1.getNeighborCount()).toEqual(layer0Node1.getNeighborCount())
+        expect(layer1Node2.getNeighborCount()).toEqual(layer0Node2.getNeighborCount())
+        expect(layer1Node3.getNeighborCount()).toEqual(layer0Node3.getNeighborCount())
+        expect(layer1Node4.getNeighborCount()).toEqual(layer0Node4.getNeighborCount())
+
+        expect(layer1Node1.getNeighbors()).toContainValues(layer0Node1.getNeighbors())
+        expect(layer1Node2.getNeighbors()).toContainValues(layer0Node2.getNeighbors())
+        expect(layer1Node3.getNeighbors()).toContainValues(layer0Node3.getNeighbors())
+        expect(layer1Node4.getNeighbors()).toContainValues(layer0Node4.getNeighbors())
 
     }, 60000)
 })

package/test/integration/MultipleEntryPointJoining.test.ts

@@ -42,9 +42,9 @@ describe('multiple entry point joining', () => {
                 node2.joinDht(entryPoints),
                 node3.joinDht(entryPoints)
             ])
-            expect(node1.getNumberOfNeighbors()).toEqual(2)
-            expect(node2.getNumberOfNeighbors()).toEqual(2)
-            expect(node3.getNumberOfNeighbors()).toEqual(2)
+            expect(node1.getNeighborCount()).toEqual(2)
+            expect(node2.getNeighborCount()).toEqual(2)
+            expect(node3.getNeighborCount()).toEqual(2)
         })
 
         it('can join even if a node is offline', async () => {
@@ -53,8 +53,8 @@ describe('multiple entry point joining', () => {
                 node1.joinDht(entryPoints),
                 node2.joinDht(entryPoints)
             ])
-            expect(node1.getNumberOfNeighbors()).toEqual(1)
-            expect(node2.getNumberOfNeighbors()).toEqual(1)
+            expect(node1.getNeighborCount()).toEqual(1)
+            expect(node2.getNeighborCount()).toEqual(1)
         }, 10000)
     })
 
@@ -96,9 +96,9 @@ describe('multiple entry point joining', () => {
 
         it('non-entry point nodes can join', async () => {
             await node1.joinDht(entryPoints)
-            expect(node1.getNumberOfNeighbors()).toEqual(2)
+            expect(node1.getNeighborCount()).toEqual(2)
             await node2.joinDht(entryPoints)
-            expect(node2.getNumberOfNeighbors()).toEqual(3)
+            expect(node2.getNeighborCount()).toEqual(3)
         })
 
     })