@streamr/dht 0.0.1-tatum.0

package/test/integration/ConnectionManager.test.ts

@@ -0,0 +1,291 @@
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerID } from '../../src/helpers/PeerID'
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { createPeerDescriptor } from '../../src/dht/DhtNode'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { Logger } from '@streamr/utils'
+
+const logger = new Logger(module)
+
+describe('ConnectionManager', () => {
+    const serviceId = 'demo'
+
+    const mockPeerDescriptor1: PeerDescriptor = {
+        kademliaId: PeerID.fromString('tester1').value,
+        nodeName: 'tester1',
+        type: NodeType.NODEJS
+    }
+    const mockPeerDescriptor2: PeerDescriptor = {
+        kademliaId: PeerID.fromString('tester2').value,
+        nodeName: 'tester2',
+        type: NodeType.NODEJS
+    }
+
+    const mockPeerDescriptor3: PeerDescriptor = {
+        kademliaId: PeerID.fromString('tester3').value,
+        nodeName: 'tester3',
+        type: NodeType.NODEJS
+    }
+    const mockPeerDescriptor4: PeerDescriptor = {
+        kademliaId: PeerID.fromString('tester4').value,
+        nodeName: 'tester4',
+        type: NodeType.NODEJS
+    }
+    const simulator = new Simulator()
+
+    const mockTransport = new ConnectionManager({ ownPeerDescriptor: mockPeerDescriptor1, simulator: simulator })
+    const mockConnectorTransport1 = new ConnectionManager({ ownPeerDescriptor: mockPeerDescriptor1, simulator })
+    const mockConnectorTransport2 = new ConnectionManager({ ownPeerDescriptor: mockPeerDescriptor2, simulator })
+
+    afterAll(async ()=> {
+        await mockTransport.stop()
+        await mockConnectorTransport1.stop()
+        await mockConnectorTransport2.stop()
+    })
+
+    it('Can start alone', async () => {
+        const connectionManager = new ConnectionManager({ transportLayer: mockTransport, webSocketHost: '127.0.0.1', webSocketPort: 9991 })
+
+        await connectionManager.start((report) => {
+            expect(report.ip).toEqual('127.0.0.1')
+            expect(report.openInternet).toEqual(true)
+            return createPeerDescriptor(report)
+        })
+
+        await connectionManager.stop()
+    })
+
+    it('Throws an async exception if fails to connect to entrypoints', async () => {
+
+        const connectionManager = new ConnectionManager({
+            transportLayer: mockTransport,
+            webSocketPort: 9992, entryPoints: [
+                { kademliaId: Uint8Array.from([1, 2, 3]), type: NodeType.NODEJS, websocket: { ip: '127.0.0.1', port: 12345 } }
+            ]
+        })
+
+        await expect(connectionManager.start((report) => {
+            return createPeerDescriptor(report)
+        })).rejects.toThrow('Failed to connect to the entrypoints')
+
+        await connectionManager.stop()
+    }, 15000)
+
+    it('Can probe connectivity in open internet', async () => {
+        const connectionManager1 = new ConnectionManager({ transportLayer: mockTransport, webSocketHost: '127.0.0.1', webSocketPort: 9993 })
+
+        await connectionManager1.start((report) => {
+            expect(report.ip).toEqual('127.0.0.1')
+            expect(report.openInternet).toEqual(true)
+            return createPeerDescriptor(report)
+        })
+
+        const connectionManager2 = new ConnectionManager({
+            transportLayer: mockConnectorTransport2,
+            webSocketPort: 9994, entryPoints: [
+                { kademliaId: Uint8Array.from([1, 2, 3]), type: NodeType.NODEJS, websocket: { ip: '127.0.0.1', port: 9993 } }
+            ]
+        })
+
+        await connectionManager2.start((report) => {
+            expect(report.ip).toEqual('127.0.0.1')
+            expect(report.openInternet).toEqual(true)
+            return createPeerDescriptor(report)
+        })
+
+        await connectionManager1.stop()
+        await connectionManager2.stop()
+    })
+
+    it('Can send data to other connectionmanager over websocket', async () => {
+        const connectionManager1 = new ConnectionManager({ transportLayer: mockConnectorTransport1, webSocketHost: '127.0.0.1', webSocketPort: 9995 })
+
+        let peerDescriptor: PeerDescriptor | undefined
+
+        await connectionManager1.start((report) => {
+            expect(report.ip).toEqual('127.0.0.1')
+            expect(report.openInternet).toEqual(true)
+            peerDescriptor = createPeerDescriptor(report)
+            return peerDescriptor
+        })
+
+        const connectionManager2 = new ConnectionManager({
+            transportLayer: mockConnectorTransport2,
+            webSocketPort: 9996, entryPoints: [
+                peerDescriptor!
+            ]
+        })
+
+        let peerDescriptor2: PeerDescriptor | undefined
+        await connectionManager2.start((report2) => {
+            expect(report2.ip).toEqual('127.0.0.1')
+            expect(report2.openInternet).toEqual(true)
+            peerDescriptor2 = createPeerDescriptor(report2)
+            return peerDescriptor2
+        })
+
+        const msg: Message = {
+            serviceId: serviceId,
+            messageType: MessageType.RPC,
+            messageId: '1',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            } 
+        }
+
+        const promise = new Promise<void>((resolve, _reject) => {
+            connectionManager2.on('message', async (message: Message) => {
+                expect(message.messageType).toBe(MessageType.RPC)
+                resolve()
+            })
+        })
+
+        const connectedPromise1 = new Promise<void>((resolve, _reject) => {
+            connectionManager1.on('connected', (_peerDescriptor: PeerDescriptor) => {
+                resolve()
+            })
+        })
+
+        const connectedPromise2 = new Promise<void>((resolve, _reject) => {
+            connectionManager2.on('connected', (_peerDescriptor: PeerDescriptor) => {
+                resolve()
+            })
+        })
+
+        msg.targetDescriptor = peerDescriptor2
+        connectionManager1.send(msg)
+
+        await Promise.all([promise, connectedPromise1, connectedPromise2])
+
+        await connectionManager1.stop()
+        await connectionManager2.stop()
+    })
+
+    it('Can disconnect websockets', async () => {
+        const connectionManager1 = new ConnectionManager({ transportLayer: mockConnectorTransport1, webSocketHost: '127.0.0.1', webSocketPort: 9997 })
+
+        let peerDescriptor: PeerDescriptor | undefined
+        await connectionManager1.start((report) => {
+            expect(report.ip).toEqual('127.0.0.1')
+            expect(report.openInternet).toEqual(true)
+            peerDescriptor = createPeerDescriptor(report)
+            return peerDescriptor
+        })
+
+        const connectionManager2 = new ConnectionManager({
+            transportLayer: mockConnectorTransport2,
+            webSocketPort: 9999, entryPoints: [
+                peerDescriptor!
+            ]
+        })
+
+        let peerDescriptor2: PeerDescriptor | undefined
+        await connectionManager2.start((report2) => {
+            peerDescriptor2 = createPeerDescriptor(report2)
+            return peerDescriptor2
+        })
+
+        const msg: Message = {
+            serviceId: serviceId,
+            messageType: MessageType.RPC,
+            messageId: '1',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            } 
+        }
+
+        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
+            connectionManager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+                logger.info('disconnectedPromise1')
+                resolve()
+            })
+        })
+
+        const disconnectedPromise2 = new Promise<void>((resolve, _reject) => {
+            connectionManager2.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+                logger.info('disconnectedPromise2')
+                resolve()
+            })
+        })
+
+        const promise = new Promise<void>((resolve, _reject) => {
+            connectionManager2.on('message', async (message: Message) => {
+                expect(message.messageType).toBe(MessageType.RPC)
+                resolve()
+            })
+        })
+        msg.targetDescriptor = peerDescriptor2
+        connectionManager1.send(msg)
+
+        await promise
+
+        // @ts-expect-error private field
+        connectionManager1.closeConnection(peerDescriptor2)
+
+        await Promise.all([disconnectedPromise1, disconnectedPromise2])
+
+        await connectionManager1.stop()
+        await connectionManager2.stop()
+    })
+
+    it('Connects and disconnects over simulated connections', async () => {
+        const simulator2 = new Simulator()
+        const connectionManager3 = new ConnectionManager({ ownPeerDescriptor: mockPeerDescriptor3, simulator: simulator2 })
+        const connectionManager4 = new ConnectionManager({ ownPeerDescriptor: mockPeerDescriptor4, simulator: simulator2 })
+
+        const msg: Message = {
+            serviceId: serviceId,
+            messageType: MessageType.RPC,
+            messageId: '1',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            } 
+        }
+
+        const dataPromise = new Promise<void>((resolve, _reject) => {
+            connectionManager4.on('message', async (message: Message) => {
+                expect(message.messageType).toBe(MessageType.RPC)
+                resolve()
+            })
+        })
+
+        const connectedPromise1 = new Promise<void>((resolve, _reject) => {
+            connectionManager4.on('connected', (_peerDescriptor: PeerDescriptor) => {
+                resolve()
+            })
+        })
+
+        const connectedPromise2 = new Promise<void>((resolve, _reject) => {
+            connectionManager3.on('connected', (_peerDescriptor: PeerDescriptor) => {
+                resolve()
+            })
+        })
+
+        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
+            connectionManager4.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+                resolve()
+            })
+        })
+
+        const disconnectedPromise2 = new Promise<void>((resolve, _reject) => {
+            connectionManager3.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+                resolve()
+            })
+        })
+        msg.targetDescriptor = mockPeerDescriptor4
+        connectionManager3.send(msg)
+        await Promise.all([dataPromise, connectedPromise1, connectedPromise2])
+
+        // @ts-expect-error private field
+        connectionManager3.closeConnection(mockPeerDescriptor4)
+
+        await Promise.all([disconnectedPromise1, disconnectedPromise2])
+        await connectionManager3.stop()
+        await connectionManager4.stop()
+    })
+
+})

package/test/integration/DhtNodeExternalAPI.test.ts

@@ -0,0 +1,43 @@
+import { DhtNode } from '../../src/dht/DhtNode'
+import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { createMockConnectionDhtNode } from '../utils/utils'
+import { Any } from '../../src/proto/google/protobuf/any'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerID } from '../../src/helpers/PeerID'
+
+describe('DhtNodeExternalApi', () => {
+
+    let simulator: Simulator
+    let dhtNode1: DhtNode
+    let remote: DhtNode
+
+    beforeEach(async () => {
+        simulator = new Simulator(LatencyType.NONE)
+        dhtNode1 = await createMockConnectionDhtNode('node1', simulator)
+        remote = await createMockConnectionDhtNode('remote', simulator)
+        await dhtNode1.joinDht([dhtNode1.getPeerDescriptor()])
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            dhtNode1.stop(),
+            remote.stop()
+        ])
+        simulator.stop()
+    })
+
+    it('findData happy path', async () => {
+        const data = Any.pack(dhtNode1.getPeerDescriptor(), PeerDescriptor)
+        const key = PeerID.fromString('key').value
+        await dhtNode1.storeDataToDht(key, data)
+
+        const foundData = await remote.findDataViaPeer(key, dhtNode1.getPeerDescriptor())
+        expect(Any.unpack(foundData[0].data!, PeerDescriptor)).toEqual(dhtNode1.getPeerDescriptor())
+    })
+    
+    it('findData returns empty array if no data found', async () => {
+        const foundData = await remote.findDataViaPeer(PeerID.fromString('key').value, dhtNode1.getPeerDescriptor())
+        expect(foundData).toEqual([])
+    })
+  
+})

package/test/integration/DhtPeer.test.ts

@@ -0,0 +1,73 @@
+import { DhtPeer } from '../../src/dht/DhtPeer'
+import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
+import { getMockPeers, MockDhtRpc } from '../utils/utils'
+import {
+    ClosestPeersRequest,
+    ClosestPeersResponse,
+    PeerDescriptor,
+    PingRequest,
+    PingResponse
+} from '../../src/proto/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { DhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { generateId } from '../utils/utils'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
+
+describe('DhtPeer', () => {
+
+    let dhtPeer: DhtPeer
+    let clientRpcCommunicator: RpcCommunicator
+    let serverRpcCommunicator: RpcCommunicator
+    const serviceId = 'test'
+    const clientPeerDescriptor: PeerDescriptor = {
+        kademliaId: generateId('dhtPeer'),
+        type: 0
+    }
+    const serverPeerDescriptor: PeerDescriptor = {
+        kademliaId: generateId('server'),
+        type: 0
+    }
+
+    beforeEach(() => {
+        clientRpcCommunicator = new RpcCommunicator()
+        serverRpcCommunicator = new RpcCommunicator()
+        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
+        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', MockDhtRpc.ping)
+        clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+            serverRpcCommunicator.handleIncomingMessage(message)
+        })
+        serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+            clientRpcCommunicator.handleIncomingMessage(message)
+        })
+        const client = toProtoRpcClient(new DhtRpcServiceClient(clientRpcCommunicator.getRpcClientTransport()))
+        dhtPeer = new DhtPeer(clientPeerDescriptor, serverPeerDescriptor, client, serviceId)
+    })
+
+    afterEach(() => {
+        clientRpcCommunicator.stop()
+        serverRpcCommunicator.stop()
+    })
+
+    it('Ping happy path', async () => {
+        const active = await dhtPeer.ping()
+        expect(active).toEqual(true)
+    })
+
+    it('getClosestPeers happy path', async () => {
+        const neighbors = await dhtPeer.getClosestPeers(clientPeerDescriptor.kademliaId)
+        expect(neighbors.length).toEqual(getMockPeers().length)
+    })
+
+    it('ping error path', async () => {
+        serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', MockDhtRpc.throwPingError)
+        const active = await dhtPeer.ping()
+        expect(active).toEqual(false)
+    })
+
+    it('getClosestPeers error path', async () => {
+        serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.throwGetClosestPeersError)
+        await expect(dhtPeer.getClosestPeers(clientPeerDescriptor.kademliaId))
+            .rejects.toThrow('Closest peers error')
+    })
+
+})

package/test/integration/DhtRpc.test.ts

@@ -0,0 +1,131 @@
+import { getMockPeers, MockDhtRpc } from '../utils/utils'
+import { ProtoRpcClient, RpcCommunicator, RpcError, toProtoRpcClient } from '@streamr/proto-rpc'
+import { DhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { generateId } from '../utils/utils'
+import { ClosestPeersRequest, ClosestPeersResponse, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { wait } from '@streamr/utils'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+
+describe('DhtRpc', () => {
+    let rpcCommunicator1: RpcCommunicator
+    let rpcCommunicator2: RpcCommunicator
+    let client1: ProtoRpcClient<DhtRpcServiceClient>
+    let client2: ProtoRpcClient<DhtRpcServiceClient>
+
+    const peerDescriptor1: PeerDescriptor = {
+        kademliaId: generateId('peer1'),
+        type: 0
+    }
+
+    const peerDescriptor2: PeerDescriptor = {
+        kademliaId: generateId('peer2'),
+        type: 0
+    }
+
+    const outgoingListener2 = (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator1.handleIncomingMessage(message)
+    }
+
+    beforeEach(() => {
+        rpcCommunicator1 = new RpcCommunicator()
+        rpcCommunicator1.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
+
+        rpcCommunicator2 = new RpcCommunicator()
+        rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
+
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+            rpcCommunicator2.handleIncomingMessage(message)
+        })
+
+        rpcCommunicator2.on('outgoingMessage', outgoingListener2)
+
+        client1 = toProtoRpcClient(new DhtRpcServiceClient(rpcCommunicator1.getRpcClientTransport()))
+        client2 = toProtoRpcClient(new DhtRpcServiceClient(rpcCommunicator1.getRpcClientTransport()))
+    })
+
+    afterEach(async () => {
+        await rpcCommunicator1.stop()
+        await rpcCommunicator2.stop()
+    })
+
+    it('Happy path', async () => {
+        const response1 = client1.getClosestPeers(
+            { kademliaId: peerDescriptor1.kademliaId, requestId: '1' },
+            {
+                sourceDescriptor: peerDescriptor1,
+                targetDescriptor: peerDescriptor2,
+            }
+        )
+        const res1 = await response1
+        expect(res1.peers).toEqual(getMockPeers())
+
+        const response2 = client2.getClosestPeers(
+            { kademliaId: peerDescriptor2.kademliaId, requestId: '1' },
+            {
+                sourceDescriptor: peerDescriptor2,
+                targetDescriptor: peerDescriptor1
+            }
+        )
+        const res2 = await response2
+        expect(res2.peers).toEqual(getMockPeers())
+    })
+
+    it('Default RPC timeout, client side', async () => {
+        rpcCommunicator2.off('outgoingMessage', outgoingListener2)
+        rpcCommunicator2.on('outgoingMessage', async (_message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+            await wait(3000)
+        })
+        const response2 = client2.getClosestPeers(
+            { kademliaId: peerDescriptor2.kademliaId, requestId: '1' },
+            {
+                sourceDescriptor: peerDescriptor2,
+                targetDescriptor: peerDescriptor1
+            }
+        )
+        await expect(response2).rejects.toEqual(
+            new RpcError.RpcTimeout('Rpc request timed out')
+        )
+    }, 15000)
+
+    it('Server side timeout', async () => {
+        let timeout: NodeJS.Timeout
+
+        function respondGetClosestPeersWithTimeout(_request: ClosestPeersRequest, _context: ServerCallContext): Promise<ClosestPeersResponse> {
+            const neighbors = getMockPeers()
+            const response: ClosestPeersResponse = {
+                peers: neighbors,
+                requestId: 'why am i still here'
+            }
+            return new Promise((resolve, _reject) => {
+                timeout = setTimeout(() => {
+                    resolve(response)
+                }, 5000)
+            })
+        }
+
+        rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', respondGetClosestPeersWithTimeout)
+        const response = client2.getClosestPeers(
+            { kademliaId: peerDescriptor2.kademliaId, requestId: '1' },
+            {
+                sourceDescriptor: peerDescriptor2,
+                targetDescriptor: peerDescriptor1
+            }
+        )
+        await expect(response).rejects.toEqual(
+            new RpcError.RpcTimeout('Server timed out on request')
+        )
+        clearTimeout(timeout!)
+    })
+
+    it('Server responds with error on unknown method', async () => {
+        const response = client2.ping(
+            { requestId: '1' },
+            { targetDescriptor: peerDescriptor1 }
+        )
+        await expect(response).rejects.toEqual(
+            new RpcError.UnknownRpcMethod('Server does not implement method ping')
+        )
+    })
+})

package/test/integration/DhtWithMockConnectionLatencies.test.ts

@@ -0,0 +1,46 @@
+import { DhtNode } from '../../src/dht/DhtNode'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockConnectionDhtNode } from '../utils/utils'
+import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+
+describe('Mock connection Dht joining with latencies', () => {
+    let entryPoint: DhtNode
+    let nodes: DhtNode[]
+    let simulator: Simulator
+    let entrypointDescriptor: PeerDescriptor
+    
+    beforeEach(async () => {
+        nodes = []
+        simulator = new Simulator(LatencyType.RANDOM)
+        const entryPointId = '0'
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator)
+        entrypointDescriptor = {
+            kademliaId: entryPoint.getNodeId().value,
+            type: 0,
+            nodeName: '0'
+        }
+        for (let i = 1; i < 100; i++) {
+            const nodeId = `${i}`
+            const node = await createMockConnectionDhtNode(nodeId, simulator)
+            nodes.push(node)
+        }
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            entryPoint.stop(),
+            ...nodes.map((node) => node.stop())
+        ])
+        simulator.stop()
+    })
+
+    it('Happy path', async () => {
+        await entryPoint.joinDht([entrypointDescriptor])
+        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
+        nodes.forEach((node) => {
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 2)
+            expect(node.getNeighborList().getSize()).toBeGreaterThanOrEqual(node.getK() - 2)
+        })
+        expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(entryPoint.getK() - 2)
+    }, 60 * 1000)
+})

package/test/integration/DhtWithMockConnections.test.ts

@@ -0,0 +1,46 @@
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockConnectionDhtNode } from '../utils/utils'
+
+describe('Mock IConnection DHT Joining', () => {
+    let entryPoint: DhtNode
+    let nodes: DhtNode[]
+    let entrypointDescriptor: PeerDescriptor
+    let simulator: Simulator
+
+    beforeEach(async () => {
+        nodes = []
+        simulator = new Simulator()
+        const entryPointId = '0'
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator)
+        entrypointDescriptor = {
+            kademliaId: entryPoint.getNodeId().value,
+            type: 0,
+            nodeName: '0'
+        }
+        for (let i = 1; i < 100; i++) {
+            const nodeId = `${i}`
+            const node = await createMockConnectionDhtNode(nodeId, simulator)
+            nodes.push(node)
+        }
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            entryPoint.stop(),
+            ...nodes.map(async (node) => node.stop())
+        ])
+        simulator.stop()
+    })
+
+    it('Happy path', async () => {
+        await entryPoint.joinDht([entrypointDescriptor])
+        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
+        nodes.forEach((node) => {
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 2)
+            expect(node.getNeighborList().getSize()).toBeGreaterThanOrEqual(node.getK() - 2)
+        })
+        expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(entryPoint.getK() - 2)
+    }, 60000)
+})

package/test/integration/DhtWithRealConnectionLatencies.test.ts

@@ -0,0 +1,47 @@
+import { DhtNode } from '../../src/dht/DhtNode'
+import { createMockConnectionDhtNode } from '../utils/utils'
+import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { getRandomRegion } from '../../src/connection/Simulator/pings'
+
+describe('Mock connection Dht joining with real latencies', () => {
+    let entryPoint: DhtNode
+    let nodes: DhtNode[]
+    let simulator: Simulator
+    let entrypointDescriptor: PeerDescriptor
+    
+    beforeEach(async () => {
+        nodes = []
+        simulator = new Simulator(LatencyType.REAL)
+        const entryPointId = '0'
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator)
+        entrypointDescriptor = {
+            kademliaId: entryPoint.getNodeId().value,
+            type: 0,
+            region: getRandomRegion()
+        }
+        for (let i = 1; i < 100; i++) {
+            const nodeId = `${i}`
+            const node = await createMockConnectionDhtNode(nodeId, simulator)
+            nodes.push(node)
+        }
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            entryPoint.stop(),
+            ...nodes.map((node) => node.stop())
+        ])
+        simulator.stop()
+    })
+
+    it('Happy path', async () => {
+        await entryPoint.joinDht([entrypointDescriptor])
+        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
+        nodes.forEach((node) => {
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 3)
+            expect(node.getNeighborList().getSize()).toBeGreaterThanOrEqual(node.getK() - 3)
+        })
+        expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(entryPoint.getK())
+    }, 60 * 1000)
+})