@streamr/dht 0.0.1-tatum.0

package/test/benchmark/kademlia-simulation/KademliaSimulation.ts

@@ -0,0 +1,94 @@
+/* eslint-disable no-console */
+
+import { SimulationNode } from './SimulationNode'
+import fs from 'fs'
+import { PeerID } from '../../../src/helpers/PeerID'
+
+export class KademliaSimulation {
+    
+    private static readonly NUM_NODES = 1000
+    private static readonly ID_LENGTH = 8
+
+    private readonly nodeNamesById: Record<string, number> = {} 
+    private readonly nodes: SimulationNode[] = []
+
+    private readonly dhtIds: Array<{ type: string, data: Array<number> }>
+    private readonly groundTruth: Record<string, Array<{ name: string, distance: number, id: { type: string, data: Array<number> } }>>
+
+    constructor() {
+        if (!fs.existsSync('test/data/nodeids.json')) {
+            throw ('Cannot find test/data/nodeids.json, please run "npm run prepare-kademlia-simulation first"')
+        }
+        this.dhtIds = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
+        this.groundTruth = JSON.parse(fs.readFileSync('test/data/orderedneighbors.json').toString())
+    }
+
+    public run(): void {
+        for (let i = 0; i < KademliaSimulation.NUM_NODES; i++) {
+            const node = new SimulationNode(PeerID.fromValue(Buffer.from(this.dhtIds[i].data.slice(0, KademliaSimulation.ID_LENGTH))))
+            this.nodeNamesById[JSON.stringify(node.getContact().id)] = i
+            this.nodes.push(node)
+            node.joinDht(this.nodes[0])
+           
+            process.stdout.write('.')
+        }
+
+        let minimumCorrectNeighbors = Number.MAX_SAFE_INTEGER
+        
+        let sumCorrectNeighbors = 0
+        let sumKbucketSize = 1
+        let sumOutgoingRpcCalls = 0
+        let maxOutgoingRpcCalls = 0
+
+        for (let i = this.nodes.length - 1; i >= 0; i--) {
+            
+            const numberOfOutgoingRpcCalls = this.nodes[i].getNumberOfOutgoingRpcCalls()
+            console.log('-----------')
+            console.log('Node: ' + i)
+            console.log('Kbucket size: ' + this.nodes[i].getKBucketSize())
+            console.log('Num incoming RPC calls: ' + this.nodes[i].getNumberOfIncomingRpcCalls())
+            console.log('Num outgoing RPC calls: ' + numberOfOutgoingRpcCalls)
+    
+            sumOutgoingRpcCalls += numberOfOutgoingRpcCalls
+    
+            if (maxOutgoingRpcCalls < numberOfOutgoingRpcCalls) {
+                maxOutgoingRpcCalls = numberOfOutgoingRpcCalls
+            }
+
+            const kademliaNeighbors = this.nodes[i].getNeightborList().getContactIds()
+
+            let correctNeighbors = 0
+            for (let j = 0; j < this.groundTruth[i + ''].length; j++) {
+                if (this.groundTruth[i + ''][j].name != (this.nodeNamesById[JSON.stringify(kademliaNeighbors[j])] + '')) {
+                    break
+                }
+                correctNeighbors++
+            }
+
+            if (correctNeighbors < minimumCorrectNeighbors) {
+                minimumCorrectNeighbors = correctNeighbors
+            }
+
+            console.log('Correct neighbors: ' + correctNeighbors)
+
+            if (i > 0) {                
+                sumKbucketSize += this.nodes[i].getKBucketSize()
+                sumCorrectNeighbors += correctNeighbors
+            }
+        }
+
+        const avgCorrectNeighbors = sumCorrectNeighbors / (KademliaSimulation.NUM_NODES - 1)
+        const avgKbucketSize = sumKbucketSize / (KademliaSimulation.NUM_NODES - 1)
+        const avgNumberOfOutgoingRpcCalls = sumOutgoingRpcCalls / (KademliaSimulation.NUM_NODES - 1)
+
+        console.log('----------- Simulation results ------------------')
+        console.log('Minimum correct neighbors: ' + minimumCorrectNeighbors)
+        console.log('Average correct neighbors: ' + avgCorrectNeighbors)
+        console.log('Average Kbucket size: ' + avgKbucketSize)
+        console.log('Average number of outgoing RPC calls: ' + avgNumberOfOutgoingRpcCalls)
+        console.log('MAX number of outgoing RPC calls: ' + maxOutgoingRpcCalls)
+    }
+}
+
+const simulation = new KademliaSimulation()
+simulation.run()

package/test/benchmark/kademlia-simulation/SimulationNode.ts

@@ -0,0 +1,125 @@
+import KBucket from 'k-bucket'
+import { Contact } from './Contact'
+import { SortedContactList } from '../../../src/dht/contact/SortedContactList'
+import { PeerID } from '../../../src/helpers/PeerID'
+
+export class SimulationNode {
+
+    private numberOfNodesPerKBucket = 1
+    private K = 8
+    private ALPHA = 1
+
+    private bucket: KBucket<Contact>
+    private ownContact: Contact
+
+    private numberOfIncomingRpcCalls = 0
+    private numberOfOutgoingRpcCalls = 0
+
+    private neighborList: SortedContactList<Contact>
+    private ownId: PeerID
+
+    constructor(ownId: PeerID) {
+        this.ownId = ownId
+        this.ownContact = new Contact(this.ownId, this)
+        this.bucket = new KBucket({
+            localNodeId: this.ownId.value,
+            numberOfNodesPerKBucket: this.numberOfNodesPerKBucket
+        })
+
+        this.neighborList = new SortedContactList(this.ownId, 1000)
+    }
+
+    // For simulation use
+
+    public getNeightborList(): SortedContactList<Contact> {
+        return this.neighborList
+    }
+    public getContact(): Contact {
+        return this.ownContact
+    }
+
+    public getKBucketSize(): number {
+        return this.bucket.count()
+    }
+
+    public getNumberOfIncomingRpcCalls(): number {
+        return this.numberOfIncomingRpcCalls
+    }
+
+    public getNumberOfOutgoingRpcCalls(): number {
+        return this.numberOfOutgoingRpcCalls
+    }
+
+    // RPC call
+
+    public getClosestNodesTo(id: PeerID, caller: SimulationNode): Contact[] {
+        this.numberOfIncomingRpcCalls++
+        const ret = this.bucket.closest(id.value)
+
+        if (!this.bucket.get(id.value)) {
+            const contact = new Contact(PeerID.fromValue(id.value), caller)
+            this.bucket.add(contact)
+            this.neighborList.addContact(contact)
+        }
+
+        return ret
+    }
+
+    private findMoreContacts(contactList: Contact[], shortlist: SortedContactList<Contact>) {
+        contactList.forEach((contact) => {
+            shortlist.setContacted(contact.peerId)
+            shortlist.setActive(contact.peerId)
+            this.numberOfOutgoingRpcCalls++
+            const returnedContacts = contact.dhtNode!.getClosestNodesTo(this.ownId, this)
+            shortlist.addContacts(returnedContacts)
+            returnedContacts.forEach((returnedContact: Contact) => {
+                if (!this.bucket.get(returnedContact.id)) {
+                    this.bucket.add(returnedContact)
+                }
+            })
+        })
+    }
+
+    public joinDht(entryPoint: SimulationNode): void {
+        if (entryPoint.getContact().peerId.equals(this.ownId)) {
+            return
+        }
+
+        this.bucket.add(entryPoint.getContact())
+        const closest = this.bucket.closest(this.ownId.value, this.ALPHA)
+
+        this.neighborList.addContacts(closest)
+
+        /* eslint-disable no-constant-condition */
+        while (true) {
+            let oldClosestContactId = this.neighborList.getClosestContactId()
+            let uncontacted = this.neighborList.getUncontactedContacts(this.ALPHA)
+            if (uncontacted.length < 1) {
+                return
+            }
+
+            this.findMoreContacts(uncontacted, this.neighborList)
+
+            if (oldClosestContactId.equals(this.neighborList.getClosestContactId())) {
+                uncontacted = this.neighborList.getUncontactedContacts(this.K)
+                if (uncontacted.length < 1) {
+                    return
+                }
+
+                while (true) {
+                    oldClosestContactId = this.neighborList.getClosestContactId()
+                    this.findMoreContacts(uncontacted, this.neighborList)
+
+                    if (this.neighborList.getActiveContacts().length >= this.K ||
+                        oldClosestContactId.equals(this.neighborList.getClosestContactId())) {
+                        return
+                    }
+                    uncontacted = this.neighborList.getUncontactedContacts(this.ALPHA)
+                    if (uncontacted.length < 1) {
+                        return
+                    }
+                }
+            }
+        }
+    }
+}

package/test/data/generateGroundTruthData.ts

@@ -0,0 +1,70 @@
+import fs from 'fs'
+import crypto from 'crypto'
+import KBucket from 'k-bucket'
+
+const ID_LENGTH = 8
+const NUM_NODES = 2000
+const NUM_NEAREST = 10
+
+const generateId = function(): Uint8Array {
+    return crypto.randomBytes(ID_LENGTH)
+}
+
+const findNNearestNeighbors = function(ownIndex: number, ownId: Uint8Array, nodes: Array<Uint8Array>, n: number): Array<number> {
+    const retIndex: Array<number> = []
+
+    for (let i = 0; i < n; i++) {
+        let closestIndex: number = Number.MAX_VALUE 
+        let closestDistance: number = Number.MAX_VALUE
+        
+        for (let j = 0; j < nodes.length; j++) {
+            if (j == ownIndex || retIndex.includes(j)) {
+                continue
+            }
+            const distance = KBucket.distance(ownId, nodes[j])
+            if (distance < closestDistance) {
+                closestDistance = distance
+                closestIndex = j
+            }
+        }
+        retIndex.push(closestIndex)
+    }
+    return retIndex
+}
+
+const writer = fs.createWriteStream('nodeids.json', {})
+const neighborWriter = fs.createWriteStream('orderedneighbors.json', {})
+
+neighborWriter.write('{\n')
+
+const nodes: Array<Uint8Array> = []
+
+// generate nodeIds
+
+for (let i = 0; i < NUM_NODES; i++) {
+    const id = generateId()
+    nodes.push(id)
+}
+
+writer.write(JSON.stringify(nodes, null, 4))
+writer.end()
+
+for (let i = 0; i < NUM_NODES; i++) {
+
+    const neighborIds = findNNearestNeighbors(i, nodes[i], nodes, NUM_NEAREST)
+
+    const neighborNames: Array<{ name: number, distance: number, id: Uint8Array }> = []
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let j = 0; j < neighborIds.length; j++) {
+        neighborNames.push({ name: neighborIds[j], distance: KBucket.distance(nodes[i], nodes[neighborIds[j]]), id: nodes[neighborIds[j]] })
+    }
+    neighborWriter.write('"' + i + '": ' + JSON.stringify(neighborNames))
+    process.stdout.write('.')
+
+    if (i != NUM_NODES - 1) {
+        neighborWriter.write(',\n')
+    }
+}
+
+neighborWriter.write('}')
+neighborWriter.end()

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

@@ -0,0 +1,87 @@
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+
+describe('Layer0-Layer1', () => {
+    const epPeerDescriptor: PeerDescriptor = {
+        kademliaId: Uint8Array.from([1, 2, 3]),
+        type: NodeType.NODEJS,
+        websocket: { ip: '127.0.0.1', port: 10016 }
+    }
+
+    const STREAM_ID1 = 'stream1'
+    const STREAM_ID2 = 'stream2'
+
+    let epDhtNode: DhtNode
+    let node1: DhtNode
+    let node2: DhtNode
+
+    let stream1Node1: DhtNode
+    let stream1Node2: DhtNode
+    let stream2Node1: DhtNode
+    let stream2Node2: DhtNode
+
+    beforeEach(async () => {
+
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        await epDhtNode.start()
+        await epDhtNode.joinDht([epPeerDescriptor])
+
+        node1 = new DhtNode({ peerIdString: '1', webSocketPort: 10017, entryPoints: [epPeerDescriptor] })
+        node2 = new DhtNode({ peerIdString: '2', webSocketPort: 10018, entryPoints: [epPeerDescriptor] })
+
+        await node1.start()
+        await node2.start()
+
+        stream1Node1 = new DhtNode({ transportLayer: epDhtNode, serviceId: STREAM_ID1 })
+        stream1Node2 = new DhtNode({ transportLayer: node1, serviceId: STREAM_ID1 })
+
+        stream2Node1 = new DhtNode({ transportLayer: epDhtNode, serviceId: STREAM_ID2 })
+        stream2Node2 = new DhtNode({ transportLayer: node2, serviceId: STREAM_ID2 })
+
+        await Promise.all([
+            stream1Node1.start(),
+            stream1Node2.start(),
+            stream2Node1.start(),
+            stream2Node2.start()
+        ])
+
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            node1.stop(),
+            node2.stop(),
+            epDhtNode.stop(),
+            stream1Node1.stop(),
+            stream1Node2.stop(),
+            stream2Node1.stop(),
+            stream2Node2.stop()
+        ])
+    })
+
+    it('Happy path', async () => {
+        await Promise.all([
+            node1.joinDht([epPeerDescriptor]),
+            node2.joinDht([epPeerDescriptor])
+        ])
+        await Promise.all([
+            stream1Node1.joinDht([epPeerDescriptor]),
+            stream1Node2.joinDht([epPeerDescriptor])
+        ])
+        
+        await Promise.all([
+            stream2Node1.joinDht([epPeerDescriptor]),
+            stream2Node2.joinDht([epPeerDescriptor])
+        ])
+        expect(stream1Node1.getNeighborList().getSize()).toEqual(1)
+        expect(stream1Node2.getNeighborList().getSize()).toEqual(1)
+        expect(stream2Node1.getNeighborList().getSize()).toEqual(1)
+        expect(stream2Node2.getNeighborList().getSize()).toEqual(1)
+
+        expect(stream1Node1.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(node1.getPeerDescriptor()))).toEqual(true)
+        expect(stream1Node2.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(epPeerDescriptor))).toEqual(true)
+        expect(stream2Node1.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(node2.getPeerDescriptor()))).toEqual(true)
+        expect(stream2Node2.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(epPeerDescriptor))).toEqual(true)
+    })
+})

package/test/end-to-end/Layer0.test.ts

@@ -0,0 +1,60 @@
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtNode } from '../../src/dht/DhtNode'
+
+describe('Layer0', () => {
+
+    const epPeerDescriptor: PeerDescriptor = {
+        kademliaId: Uint8Array.from([1, 2, 3]),
+        type: NodeType.NODEJS,
+        websocket: { ip: '127.0.0.1', port: 10011 }
+    }
+    
+    let epDhtNode: DhtNode
+    let node1: DhtNode
+    let node2: DhtNode
+    let node3: DhtNode
+    let node4: DhtNode
+
+    beforeEach(async () => {
+        
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        await epDhtNode.start()
+        
+        await epDhtNode.joinDht([epPeerDescriptor])
+
+        node1 = new DhtNode({ peerIdString: '1', webSocketPort: 10012, entryPoints: [epPeerDescriptor] })
+        node2 = new DhtNode({ peerIdString: '2', webSocketPort: 10013, entryPoints: [epPeerDescriptor] })
+        node3 = new DhtNode({ peerIdString: '3', webSocketPort: 10014, entryPoints: [epPeerDescriptor] })
+        node4 = new DhtNode({ peerIdString: '4', webSocketPort: 10015, entryPoints: [epPeerDescriptor] })
+        
+        await node1.start()
+        await node2.start()
+        await node3.start()
+        await node4.start()
+
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            epDhtNode.stop(),
+            node1.stop(),
+            node2.stop(),
+            node3.stop(),
+            node4.stop()
+        ])
+    })
+
+    it('Happy path', async () => {
+        await Promise.all([
+            node1.joinDht([epPeerDescriptor]),
+            node2.joinDht([epPeerDescriptor]),
+            node3.joinDht([epPeerDescriptor]),
+            node4.joinDht([epPeerDescriptor])
+        ])
+
+        expect(node1.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node2.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node3.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node4.getBucketSize()).toBeGreaterThanOrEqual(2)
+    }, 10000)
+})

package/test/end-to-end/Layer0MixedConnectionTypes.test.ts

@@ -0,0 +1,94 @@
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { waitForEvent3 } from '@streamr/utils'
+import { ConnectionManager, Events as ConnectionManagerEvents } from '../../src/connection/ConnectionManager'
+
+describe('Layer0MixedConnectionTypes', () => {
+
+    const epPeerDescriptor: PeerDescriptor = {
+        kademliaId: Uint8Array.from([1, 2, 3]),
+        type: NodeType.NODEJS,
+        websocket: { ip: '127.0.0.1', port: 11221 }
+    }
+
+    let epDhtNode: DhtNode
+    let node1: DhtNode
+    let node2: DhtNode
+    let node3: DhtNode
+    let node4: DhtNode
+    let node5: DhtNode
+
+    beforeEach(async () => {
+
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, numberOfNodesPerKBucket: 2 })
+        await epDhtNode.start()
+
+        await epDhtNode.joinDht([epPeerDescriptor])
+        node1 = new DhtNode({ peerIdString: 'Peer1', webSocketPort: 11222, entryPoints: [epPeerDescriptor] })
+        node2 = new DhtNode({ peerIdString: 'Peer2', webSocketPort: 11228, entryPoints: [epPeerDescriptor] })
+        node3 = new DhtNode({ peerIdString: 'Peer3', entryPoints: [epPeerDescriptor] })
+        node4 = new DhtNode({ peerIdString: 'Peer4', entryPoints: [epPeerDescriptor] })
+        node5 = new DhtNode({ peerIdString: 'Peer5', entryPoints: [epPeerDescriptor] })
+
+        await Promise.all([
+            node1.start(),
+            node2.start(),
+            node3.start(),
+            node4.start(),
+            node5.start()
+        ])
+
+        await epDhtNode.joinDht([epPeerDescriptor])
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            epDhtNode.stop(),
+            node1.stop(),
+            node2.stop(),
+            node3.stop(),
+            node4.stop(),
+            node5.stop()
+        ])
+    })
+
+    it('2 non-server peers join first', async () => {
+
+        const promise = Promise.all([
+            waitForEvent3<ConnectionManagerEvents>((node3.getTransport() as ConnectionManager), 'newConnection'),
+            waitForEvent3<ConnectionManagerEvents>((node4.getTransport() as ConnectionManager), 'newConnection'),
+        ])
+
+        node3.joinDht([epPeerDescriptor])
+        node4.joinDht([epPeerDescriptor])
+
+        await promise
+        await Promise.all([
+            node1.joinDht([epPeerDescriptor]),
+            node2.joinDht([epPeerDescriptor]),
+            node5.joinDht([epPeerDescriptor])
+        ])
+
+        expect(node1.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node2.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node3.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node4.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node5.getBucketSize()).toBeGreaterThanOrEqual(1)
+
+    }, 15000)
+
+    it('Simultaneous joins', async () => {
+        await Promise.all([
+            node1.joinDht([epPeerDescriptor]),
+            node2.joinDht([epPeerDescriptor]),
+            node3.joinDht([epPeerDescriptor]),
+            node4.joinDht([epPeerDescriptor]),
+            node5.joinDht([epPeerDescriptor])
+        ])
+        expect(node1.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node2.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node3.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node4.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node5.getBucketSize()).toBeGreaterThanOrEqual(2)
+    }, 30000)
+})

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

@@ -0,0 +1,134 @@
+import { DhtNode } from '../../src/dht/DhtNode'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerID } from '../../src/exports'
+
+describe('Layer 1 on Layer 0 with mocked connections', () => {
+    const entryPointId = '00000'
+
+    const entrypointDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString(entryPointId).value,
+        type: NodeType.NODEJS,
+        websocket: {
+            ip: '127.0.0.1',
+            port: 23232
+        }
+    }
+
+    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
+
+    beforeEach(async () => {
+
+        layer0EntryPoint = new DhtNode({ peerDescriptor: entrypointDescriptor })
+
+        const layer0Node1Id = 'layer0Node1'
+        layer0Node1 = new DhtNode({
+            peerIdString: layer0Node1Id
+        })
+
+        const layer0Node2Id = 'layer0Node2'
+        layer0Node2 = new DhtNode({
+            peerIdString: layer0Node2Id
+        })
+
+        const layer0Node3Id = 'layer0Node3'
+        layer0Node3 = new DhtNode({
+            peerIdString: layer0Node3Id
+        })
+
+        const layer0Node4Id = 'layer0Node4'
+        layer0Node4 = new DhtNode({
+            peerIdString: layer0Node4Id
+        })
+
+        layer1EntryPoint = new DhtNode({
+            peerIdString: entryPointId,
+            transportLayer: layer0EntryPoint,
+            serviceId: 'layer1'
+        })
+
+        layer1Node1 = new DhtNode({
+            peerIdString: layer0Node1Id,
+            transportLayer: layer0Node1,
+            serviceId: 'layer1'
+        })
+
+        layer1Node2 = new DhtNode({
+            peerIdString: layer0Node2Id,
+            transportLayer: layer0Node2,
+            serviceId: 'layer1'
+        })
+
+        layer1Node3 = new DhtNode({
+            peerIdString: layer0Node3Id,
+            transportLayer: layer0Node3,
+            serviceId: 'layer1'
+        })
+
+        layer1Node4 = new DhtNode({
+            peerIdString: layer0Node4Id,
+            transportLayer: layer0Node4,
+            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()
+        await layer1Node3.start()
+        await layer1Node4.start()
+
+        await layer0EntryPoint.joinDht([entrypointDescriptor])
+        await layer1EntryPoint.joinDht([entrypointDescriptor])
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            layer0EntryPoint.stop(),
+            layer0Node1.stop(),
+            layer0Node2.stop(),
+            layer0Node3.stop(),
+            layer0Node4.stop(),
+            layer1EntryPoint.stop(),
+            layer1Node1.stop(),
+            layer1Node2.stop(),
+            layer1Node3.stop(),
+            layer1Node4.stop()
+        ])
+    })
+
+    it('Happy Path', async () => {
+        await Promise.all([
+            layer0Node1.joinDht([entrypointDescriptor]),
+            layer0Node2.joinDht([entrypointDescriptor]),
+            layer0Node3.joinDht([entrypointDescriptor]),
+            layer0Node4.joinDht([entrypointDescriptor])
+        ])
+
+        await layer1Node1.joinDht([entrypointDescriptor])
+        await layer1Node2.joinDht([entrypointDescriptor])
+        await layer1Node3.joinDht([entrypointDescriptor])
+        await layer1Node4.joinDht([entrypointDescriptor])
+
+        expect(layer1Node1.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node2.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node3.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node4.getBucketSize()).toBeGreaterThanOrEqual(2)
+    }, 60000)
+})