@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/test/integration/DhtNodeRpcRemote.test.ts

@@ -1,46 +1,39 @@
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
-import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { getMockPeers, MockDhtRpc } from '../utils/utils'
+import { RpcCommunicator } from '@streamr/proto-rpc'
+import { createMockDhtRpc, createMockPeerDescriptor, createMockPeers } from '../utils/utils'
 import {
     ClosestPeersRequest,
     ClosestPeersResponse,
-    NodeType,
-    PeerDescriptor,
     PingRequest,
     PingResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { generateId } from '../utils/utils'
+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
-    const serviceId = 'test'
-    const clientPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('client'),
-        type: NodeType.NODEJS
-    }
-    const serverPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('server'),
-        type: NodeType.NODEJS
-    }
+    let clientRpcCommunicator: RpcCommunicator<DhtCallContext>
+    let serverRpcCommunicator: RpcCommunicator<DhtCallContext>
+    const clientPeerDescriptor = createMockPeerDescriptor()
+    const serverPeerDescriptor = createMockPeerDescriptor()
+    const mockDhtRpc = createMockDhtRpc(createMockPeers())
 
     beforeEach(() => {
         clientRpcCommunicator = new RpcCommunicator()
         serverRpcCommunicator = new RpcCommunicator()
-        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
-        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', MockDhtRpc.ping)
+        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
+        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', mockDhtRpc.ping)
         clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             serverRpcCommunicator.handleIncomingMessage(message)
         })
         serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        const client = toProtoRpcClient(new DhtNodeRpcClient(clientRpcCommunicator.getRpcClientTransport()))
-        rpcRemote = new DhtNodeRpcRemote(clientPeerDescriptor, serverPeerDescriptor, client, serviceId)
+        rpcRemote = new DhtNodeRpcRemote(clientPeerDescriptor, serverPeerDescriptor, SERVICE_ID, clientRpcCommunicator)
     })
 
     afterEach(() => {
@@ -54,19 +47,19 @@ describe('DhtNodeRpcRemote', () => {
     })
 
     it('getClosestPeers happy path', async () => {
-        const neighbors = await rpcRemote.getClosestPeers(clientPeerDescriptor.kademliaId)
-        expect(neighbors.length).toEqual(getMockPeers().length)
+        const neighbors = await rpcRemote.getClosestPeers(getNodeIdFromPeerDescriptor(clientPeerDescriptor))
+        expect(neighbors.length).toEqual(createMockPeers().length)
     })
 
     it('ping error path', async () => {
-        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', MockDhtRpc.throwPingError)
+        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', mockDhtRpc.throwPingError)
         const active = await rpcRemote.ping()
         expect(active).toEqual(false)
     })
 
     it('getClosestPeers error path', async () => {
-        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.throwGetClosestPeersError)
-        await expect(rpcRemote.getClosestPeers(clientPeerDescriptor.kademliaId))
+        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.throwGetClosestPeersError)
+        await expect(rpcRemote.getClosestPeers(getNodeIdFromPeerDescriptor(clientPeerDescriptor)))
             .rejects.toThrow('Closest peers error')
     })
 

package/test/integration/DhtRpc.test.ts

@@ -1,26 +1,22 @@
-import { getMockPeers, MockDhtRpc } from '../utils/utils'
+import { createMockDhtRpc, createMockPeerDescriptor, createMockPeers } from '../utils/utils'
 import { ProtoRpcClient, RpcCommunicator, RpcError, toProtoRpcClient } from '@streamr/proto-rpc'
 import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { generateId } from '../utils/utils'
-import { ClosestPeersRequest, ClosestPeersResponse, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+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/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: PeerDescriptor = {
-        kademliaId: generateId('peer1'),
-        type: NodeType.NODEJS
-    }
-
-    const peerDescriptor2: PeerDescriptor = {
-        kademliaId: generateId('peer2'),
-        type: NodeType.NODEJS
-    }
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
+    const neighbors = createMockPeers()
+    const mockDhtRpc = createMockDhtRpc(neighbors)
 
     const outgoingListener2 = (message: RpcMessage) => {
         rpcCommunicator1.handleIncomingMessage(message)
@@ -28,10 +24,10 @@ describe('DhtRpc', () => {
 
     beforeEach(() => {
         rpcCommunicator1 = new RpcCommunicator()
-        rpcCommunicator1.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
+        rpcCommunicator1.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
 
         rpcCommunicator2 = new RpcCommunicator()
-        rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
+        rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
 
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
@@ -50,24 +46,24 @@ describe('DhtRpc', () => {
 
     it('Happy path', async () => {
         const response1 = client1.getClosestPeers(
-            { kademliaId: peerDescriptor1.kademliaId, requestId: '1' },
+            { nodeId: peerDescriptor1.nodeId, requestId: '1' },
             {
                 sourceDescriptor: peerDescriptor1,
                 targetDescriptor: peerDescriptor2,
             }
         )
         const res1 = await response1
-        expect(res1.peers).toEqual(getMockPeers())
+        expect(res1.peers.map((p) => getNodeIdFromPeerDescriptor(p))).toEqual(neighbors.map((n) => getNodeIdFromPeerDescriptor(n)))
 
         const response2 = client2.getClosestPeers(
-            { kademliaId: peerDescriptor2.kademliaId, requestId: '1' },
+            { nodeId: peerDescriptor2.nodeId, requestId: '1' },
             {
                 sourceDescriptor: peerDescriptor2,
                 targetDescriptor: peerDescriptor1
             }
         )
         const res2 = await response2
-        expect(res2.peers).toEqual(getMockPeers())
+        expect(res2.peers.map((p) => getNodeIdFromPeerDescriptor(p))).toEqual(neighbors.map((n) => getNodeIdFromPeerDescriptor(n)))
     })
 
     it('Default RPC timeout, client side', async () => {
@@ -76,7 +72,7 @@ describe('DhtRpc', () => {
             await wait(3000)
         })
         const response2 = client2.getClosestPeers(
-            { kademliaId: peerDescriptor2.kademliaId, requestId: '1' },
+            { nodeId: peerDescriptor2.nodeId, requestId: '1' },
             {
                 sourceDescriptor: peerDescriptor2,
                 targetDescriptor: peerDescriptor1
@@ -91,7 +87,7 @@ describe('DhtRpc', () => {
         let timeout: NodeJS.Timeout
 
         async function respondGetClosestPeersWithTimeout(): Promise<ClosestPeersResponse> {
-            const neighbors = getMockPeers()
+            const neighbors = createMockPeers()
             const response: ClosestPeersResponse = {
                 peers: neighbors,
                 requestId: 'why am i still here'
@@ -102,7 +98,7 @@ describe('DhtRpc', () => {
 
         rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', respondGetClosestPeersWithTimeout)
         const response = client2.getClosestPeers(
-            { kademliaId: peerDescriptor2.kademliaId, requestId: '1' },
+            { nodeId: peerDescriptor2.nodeId, requestId: '1' },
             {
                 sourceDescriptor: peerDescriptor2,
                 targetDescriptor: peerDescriptor1

package/test/integration/Find.test.ts

@@ -2,8 +2,10 @@ import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator
 import { DhtNode } from '../../src/dht/DhtNode'
 import { PeerDescriptor } 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, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
+
+const NUM_NODES = 100
+const K = 8
 
 describe('Find correctness', () => {
 
@@ -11,18 +13,14 @@ describe('Find correctness', () => {
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator(LatencyType.REAL)
-    const NUM_NODES = 100
-    const K = 2
 
     beforeEach(async () => {
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, K)
+        entryPoint = await createMockConnectionDhtNode(simulator, undefined, K)
         nodes.push(entryPoint)
         entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, K, 20, 60000)
+            const node = await createMockConnectionDhtNode(simulator, undefined, K, 40, 60000)
             nodes.push(node)
         }
         await entryPoint.joinDht([entrypointDescriptor])
@@ -38,10 +36,10 @@ describe('Find correctness', () => {
     })
 
     it('Entrypoint can find a node from the network (exact match)', async () => {
-        const kademliaIdToFind = nodes[45].getNodeId().value
-        const results = await entryPoint.startFind(kademliaIdToFind)
-        expect(results.closestNodes.length).toBeGreaterThanOrEqual(5)
-        expect(PeerID.fromValue(kademliaIdToFind).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
+        const targetId = getRawFromDhtAddress(nodes[45].getNodeId())
+        const closestNodes = await entryPoint.findClosestNodesFromDht(getDhtAddressFromRaw(targetId))
+        expect(closestNodes.length).toBeGreaterThanOrEqual(5)
+        expect(getDhtAddressFromRaw(targetId)).toEqual(getNodeIdFromPeerDescriptor(closestNodes[0]))
     }, 30000)
 
 })

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

@@ -1,32 +1,22 @@
 import { Simulator } from '../../src/connection/simulator/Simulator'
-import { PeerID } from '../../src/helpers/PeerID'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'
-import { UUID } from '../../src/helpers/UUID'
-import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { createMockConnectionDhtNode, createMockConnectionLayer1Node, createMockPeerDescriptor } from '../utils/utils'
 
+const NODE_COUNT = 48
 const NUM_OF_NODES_PER_KBUCKET = 8
 
 describe('Layer1', () => {
 
     let simulator: Simulator
-    const layer0EntryPointId = new UUID().toString()
-
-    const entryPoint0Descriptor = {
-        kademliaId: PeerID.fromString(layer0EntryPointId).value,
-        type: NodeType.NODEJS
-    }
-
+    const entryPoint0Descriptor = createMockPeerDescriptor()
     let layer0EntryPoint: DhtNode
-
-    const NODE_COUNT = 48
     let nodes: DhtNode[]
-
     let layer1CleanUp: DhtNode[]
 
     beforeEach(async () => {
         simulator = new Simulator()
-        layer0EntryPoint = await createMockConnectionDhtNode(layer0EntryPointId, simulator)
+        layer0EntryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(entryPoint0Descriptor.nodeId))
         await layer0EntryPoint.joinDht([entryPoint0Descriptor])
 
         nodes = []
@@ -34,7 +24,6 @@ describe('Layer1', () => {
 
         for (let i = 0; i < NODE_COUNT; i++) {
             const node = await createMockConnectionDhtNode(
-                new UUID().toString(),
                 simulator,
                 undefined,
                 undefined,
@@ -56,14 +45,14 @@ describe('Layer1', () => {
     })
 
     it('single layer1 dht', async () => {
-        const layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint)
+        const layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint)
         await layer1EntryPoint.joinDht([entryPoint0Descriptor])
         layer1CleanUp.push(layer1EntryPoint)
 
         const layer1Nodes: DhtNode[] = []
         for (let i = 0; i < NODE_COUNT; i++) {
             const layer0 = nodes[i]
-            const layer1 = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, undefined, NUM_OF_NODES_PER_KBUCKET)
+            const layer1 = await createMockConnectionLayer1Node(layer0, undefined, NUM_OF_NODES_PER_KBUCKET)
             layer1Nodes.push(layer1)
             layer1CleanUp.push(layer1)
         }
@@ -73,24 +62,24 @@ describe('Layer1', () => {
         for (let i = 0; i < NODE_COUNT; i++) {
             const layer0Node = nodes[i]
             const layer1Node = layer1Nodes[i]
-            expect(layer1Node.getNodeId().equals(layer0Node.getNodeId())).toEqual(true)
-            expect(layer1Node.getNumberOfConnections()).toEqual(layer0Node.getNumberOfConnections())
-            expect(layer1Node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
-            expect(layer1Node.getAllConnectionPeerDescriptors()).toEqual(layer0Node.getAllConnectionPeerDescriptors())
+            expect(layer1Node.getNodeId()).toEqual(layer0Node.getNodeId())
+            expect(layer1Node.getConnectionCount()).toEqual(layer0Node.getConnectionCount())
+            expect(layer1Node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(layer1Node.getConnections()).toEqual(layer0Node.getConnections())
         }
     }, 120000)
 
     it('multiple layer1 dht', async () => {
-        const stream1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'one')
+        const stream1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'one')
         await stream1EntryPoint.joinDht([entryPoint0Descriptor])
 
-        const stream2EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'two')
+        const stream2EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'two')
         await stream2EntryPoint.joinDht([entryPoint0Descriptor])
 
-        const stream3EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'three')
+        const stream3EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'three')
         await stream3EntryPoint.joinDht([entryPoint0Descriptor])
 
-        const stream4EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'four')
+        const stream4EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'four')
         await stream4EntryPoint.joinDht([entryPoint0Descriptor])
 
         layer1CleanUp.push(stream1EntryPoint)
@@ -105,10 +94,10 @@ describe('Layer1', () => {
 
         for (let i = 0; i < NODE_COUNT; i++) {
             const layer0 = nodes[i]
-            const one = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'one')
-            const two = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'two')
-            const three = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'three')
-            const four = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'four')
+            const one = await createMockConnectionLayer1Node(layer0, 'one')
+            const two = await createMockConnectionLayer1Node(layer0, 'two')
+            const three = await createMockConnectionLayer1Node(layer0, 'three')
+            const four = await createMockConnectionLayer1Node(layer0, 'four')
 
             stream1.push(one)
             stream2.push(two)
@@ -130,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)
@@ -155,7 +144,7 @@ describe('Layer1', () => {
     //             layer1CleanUp.push(layer1)
     //             receivedMessages.set(layer0.getNodeId().toKey(), new Set())
     //             layer1.on('message', (msg: Message) => {
-    //                 const peerId = PeerID.fromValue(msg.sourceDescriptor!.kademliaId)
+    //                 const peerId = PeerID.fromValue(msg.sourceDescriptor!.nodeId)
     //                 receivedMessages.get(layer0.getNodeId().toKey())!.add(peerId.toKey())
     //             })
     //         }
@@ -170,7 +159,6 @@ describe('Layer1', () => {
     //                 const message: Message = {
     //                     serviceId: 'service',
     //                     messageId: v4(),
-    //                     messageType: MessageType.RPC,
     //                     body: {
     //                         oneofKind: 'rpcMessage',
     //                         rpcMessage: rpcWrapper
@@ -180,7 +168,7 @@ describe('Layer1', () => {
     //                 }
     //                 await sender.doRouteMessage({
     //                     message,
-    //                     destinationPeer: receiver.getPeerDescriptor(),
+    //                     target: receiver.getPeerDescriptor().nodeId,
     //                     sourcePeer: sender.getPeerDescriptor(),
     //                     requestId: v4(),
     //                     reachableThrough: [],

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

@@ -1,62 +1,42 @@
 import { Logger } from '@streamr/utils'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'
+import { createRandomDhtAddress } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
 describe('Layer 1 on Layer 0 with mocked connections', () => {
-    const simulator = new Simulator()
-    const layer0EntryPointId = 'layer0entrypoint'
 
+    const simulator = new Simulator()
     let layer0EntryPoint: DhtNode
     let layer1Node1: DhtNode
-
     let layer0Node1: DhtNode
     let layer1EntryPoint: DhtNode
-
     let layer0Node2: DhtNode
     let layer1Node2: DhtNode
-
     let layer0Node3: DhtNode
     let layer1Node3: DhtNode
-
     let layer0Node4: DhtNode
     let layer1Node4: DhtNode
 
-    let entryPointDescriptor: PeerDescriptor
-
     beforeEach(async () => {
 
-        layer0EntryPoint = await createMockConnectionDhtNode(layer0EntryPointId, simulator)
-
-        const layer0Node1Id = 'node1'
-        layer0Node1 = await createMockConnectionDhtNode(layer0Node1Id, simulator)
+        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())
 
-        const layer0Node2Id = 'node2'
-        layer0Node2 = await createMockConnectionDhtNode(layer0Node2Id, simulator)
+        layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint)
 
-        const layer0Node3Id = 'node3'
-        layer0Node3 = await createMockConnectionDhtNode(layer0Node3Id, simulator)
+        layer1Node1 = await createMockConnectionLayer1Node(layer0Node1)
+        layer1Node2 = await createMockConnectionLayer1Node(layer0Node2)
+        layer1Node3 = await createMockConnectionLayer1Node(layer0Node3)
+        layer1Node4 = await createMockConnectionLayer1Node(layer0Node4)
 
-        const layer0Node4Id = 'node4'
-        layer0Node4 = await createMockConnectionDhtNode(layer0Node4Id, simulator)
-
-        layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPointId, layer0EntryPoint)
-
-        layer1Node1 = await createMockConnectionLayer1Node(layer0Node1Id, layer0Node1)
-        layer1Node2 = await createMockConnectionLayer1Node(layer0Node2Id, layer0Node2)
-        layer1Node3 = await createMockConnectionLayer1Node(layer0Node3Id, layer0Node3)
-        layer1Node4 = await createMockConnectionLayer1Node(layer0Node4Id, layer0Node4)
-
-        entryPointDescriptor = {
-            kademliaId: layer0EntryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
-
-        await layer0EntryPoint.joinDht([entryPointDescriptor])
-        await layer1EntryPoint.joinDht([entryPointDescriptor])
+        await layer0EntryPoint.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer1EntryPoint.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
     })
 
     afterEach(async () => {
@@ -75,31 +55,31 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
     })
 
     it('Happy Path', async () => {
-        await layer0Node1.joinDht([entryPointDescriptor])
-        await layer0Node2.joinDht([entryPointDescriptor])
-        await layer0Node3.joinDht([entryPointDescriptor])
-        await layer0Node4.joinDht([entryPointDescriptor])
-
-        await layer1Node1.joinDht([entryPointDescriptor])
-        await layer1Node2.joinDht([entryPointDescriptor])
-        await layer1Node3.joinDht([entryPointDescriptor])
-        await layer1Node4.joinDht([entryPointDescriptor])
-
-        logger.info('layer1EntryPoint.getBucketSize() ' + layer1EntryPoint.getBucketSize())
-        logger.info('layer1Node1.getBucketSize()' + layer1Node1.getBucketSize())
-        logger.info('layer1Node2.getBucketSize()' + layer1Node2.getBucketSize())
-        logger.info('layer1Node3.getBucketSize()' + layer1Node3.getBucketSize())
-        logger.info('layer1Node4.getBucketSize()' + layer1Node4.getBucketSize())
-
-        expect(layer1Node1.getBucketSize()).toEqual(layer0Node1.getBucketSize())
-        expect(layer1Node2.getBucketSize()).toEqual(layer0Node2.getBucketSize())
-        expect(layer1Node3.getBucketSize()).toEqual(layer0Node3.getBucketSize())
-        expect(layer1Node4.getBucketSize()).toEqual(layer0Node4.getBucketSize())
-
-        expect(layer1Node1.getKBucketPeers()).toContainValues(layer0Node1.getKBucketPeers())
-        expect(layer1Node2.getKBucketPeers()).toContainValues(layer0Node2.getKBucketPeers())
-        expect(layer1Node3.getKBucketPeers()).toContainValues(layer0Node3.getKBucketPeers())
-        expect(layer1Node4.getKBucketPeers()).toContainValues(layer0Node4.getKBucketPeers())
+        await layer0Node1.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer0Node2.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer0Node3.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer0Node4.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+
+        await layer1Node1.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer1Node2.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer1Node3.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer1Node4.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+
+        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

@@ -16,9 +16,9 @@ describe('multiple entry point joining', () => {
         beforeEach(async () => {
             simulator = new Simulator(LatencyType.REAL)
 
-            node1 = await createMockConnectionDhtNode('node1', simulator)
-            node2 = await createMockConnectionDhtNode('node2', simulator)
-            node3 = await createMockConnectionDhtNode('node3', simulator)
+            node1 = await createMockConnectionDhtNode(simulator)
+            node2 = await createMockConnectionDhtNode(simulator)
+            node3 = await createMockConnectionDhtNode(simulator)
 
             entryPoints = [
                 node1.getLocalPeerDescriptor(),
@@ -42,9 +42,9 @@ describe('multiple entry point joining', () => {
                 node2.joinDht(entryPoints),
                 node3.joinDht(entryPoints)
             ])
-            expect(node1.getBucketSize()).toEqual(2)
-            expect(node2.getBucketSize()).toEqual(2)
-            expect(node3.getBucketSize()).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.getBucketSize()).toEqual(1)
-            expect(node2.getBucketSize()).toEqual(1)
+            expect(node1.getNeighborCount()).toEqual(1)
+            expect(node2.getNeighborCount()).toEqual(1)
         }, 10000)
     })
 
@@ -69,11 +69,11 @@ describe('multiple entry point joining', () => {
         beforeEach(async () => {
             simulator = new Simulator(LatencyType.REAL)
             
-            entryPoint1 = await createMockConnectionDhtNode('entryPoint1', simulator)
-            entryPoint2 = await createMockConnectionDhtNode('entryPoint2', simulator)
+            entryPoint1 = await createMockConnectionDhtNode(simulator)
+            entryPoint2 = await createMockConnectionDhtNode(simulator)
             
-            node1 = await createMockConnectionDhtNode('node1', simulator)
-            node2 = await createMockConnectionDhtNode('node2', simulator)
+            node1 = await createMockConnectionDhtNode(simulator)
+            node2 = await createMockConnectionDhtNode(simulator)
 
             entryPoints = [
                 entryPoint1.getLocalPeerDescriptor(),
@@ -96,9 +96,9 @@ describe('multiple entry point joining', () => {
 
         it('non-entry point nodes can join', async () => {
             await node1.joinDht(entryPoints)
-            expect(node1.getBucketSize()).toEqual(2)
+            expect(node1.getNeighborCount()).toEqual(2)
             await node2.joinDht(entryPoints)
-            expect(node2.getBucketSize()).toEqual(3)
+            expect(node2.getNeighborCount()).toEqual(3)
         })
 
     })