@streamr/dht 102.0.0-beta.1 → 102.0.0-beta.3

package/test/benchmark/WebsocketServerMemoryLeak.test.ts

@@ -1,41 +0,0 @@
-/* eslint-disable no-console */
-
-import { wait } from '@streamr/utils'
-import { WebsocketServer } from '../../src/connection/websocket/WebsocketServer'
-import { WebsocketClientConnection } from '../../src/connection/websocket/NodeWebsocketClientConnection'
-
-// This 'test' is meant to be run manually using the following command:
-// node --inspect ../../../../node_modules/.bin/jest WebsocketServerMemoryLeak.test.ts
-// while wathing for memory leaks in Chrome DevTools
-
-describe('WebsocketServermemoryLeak', () => {
-
-    it('Accepts and detroys connections', async () => {
-        const server = new WebsocketServer({
-            portRange: { min: 19792, max: 19792 },
-            enableTls: false
-        })
-
-        server.on('connected', (connection) => {
-            console.log('ServerWebsocket connected')
-            connection.destroy()
-            console.log('ServerWebsocket destroyed')
-        })
-
-        const port = await server.start()
-        expect(port).toEqual(19792)
-        
-        for (let i = 0; i < 10000; i++) {
-            const clientWebsocket: WebsocketClientConnection = new WebsocketClientConnection()
-            clientWebsocket.on('connected', () => {
-                console.log('clientWebsocket connected ' + i)
-            })
-            
-            clientWebsocket.connect(`ws://127.0.0.1:${port}`, false)
-            i++
-            await wait(3000)
-        }
-
-        await server.stop()
-    }, 120000000)
-})

package/test/benchmark/hybrid-network-simulation/RingContactList.test.ts

@@ -1,71 +0,0 @@
-import { ConnectivityResponse, PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import { createPeerDescriptor } from '../../../src/helpers/createPeerDescriptor'
-import { NatType } from '../../../src/connection/ConnectionManager'
-import { ipv4ToNumber, Logger } from '@streamr/utils'
-import { RingContactList } from '../../../src/dht/contact/RingContactList'
-import { getRingIdRawFromPeerDescriptor } from '../../../src/dht/contact/ringIdentifiers'
-import { getRandomRegion } from '../../../src/connection/simulator/pings'
-
-const logger = new Logger(module)
-
-function ipv4ToString(ip: number): string {
-    return [
-        (ip >>> 24) & 0xFF,
-        (ip >>> 16) & 0xFF,
-        (ip >>> 8) & 0xFF,
-        ip & 0xFF
-    ].join('.')
-}
-
-class MockNode {
-    private readonly peerDescriptor: PeerDescriptor
-
-    constructor(_region: number, ipAddress: string) {
-
-        const connectivityResponse: ConnectivityResponse = {
-            host: 'localhost',
-            natType: NatType.UNKNOWN,
-            ipAddress: ipv4ToNumber(ipAddress),
-            protocolVersion: '0.0.0'
-
-        }
-        this.peerDescriptor = createPeerDescriptor(connectivityResponse, getRandomRegion())
-        logger.info(ipv4ToString(this.peerDescriptor.ipAddress!))
-    }
-
-    public getPeerDescriptor(): PeerDescriptor {
-        return this.peerDescriptor
-    }
-}
-
-// populate with mock ip addresses
-const mockData: [number, string][] = [
-    [0, '5.2.4.2'],
-    [0, '6.23.2.4'],
-    [0, '7.2.4.2'],
-    [0, '8.23.2.4'],
-    [0, '9.3.2.4'],
-    [0, '10.3.2.4'],
-    [0, '24.23.2.4'],
-    [0, '31.23.2.4'],
-    [0, '33.2.4.2'],
-    [0, '35.3.2.4'],
-    [0, '37.23.2.4'],
-    [0, '39.2.4.2'],
-    [0, '42.3.2.4'],
-    [0, '46.2.4.2'],
-    [0, '48.3.2.4'],
-    [0, '50.23.2.4']
-]
-
-const mockNodes: MockNode[] = mockData.map(([region, ipAddress]) => new MockNode(region, ipAddress))
-const referenceNode = mockNodes[5]
-const ringContactList: RingContactList<MockNode> = new RingContactList<MockNode>(
-    getRingIdRawFromPeerDescriptor(referenceNode.getPeerDescriptor())
-)
-
-mockNodes.forEach((node) => ringContactList.addContact(node))
-
-ringContactList.getClosestContacts().left.forEach((node) => logger.info(ipv4ToString(node.getPeerDescriptor().ipAddress!)))
-logger.info('reference node: ' + ipv4ToString(referenceNode.getPeerDescriptor().ipAddress!))
-ringContactList.getClosestContacts().right.forEach((node) => logger.info(ipv4ToString(node.getPeerDescriptor().ipAddress!)))

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

@@ -1,55 +0,0 @@
-import { WebsocketServerConnection } from '../../src/connection/websocket/WebsocketServerConnection'
-import { DhtNode } from '../../src/dht/DhtNode'
-import fs from 'fs'
-
-const WEBSOCKET_PORT_RANGE = { min: 10012, max: 10015 }
-
-// '51.120.98.194' is the IP address of norway.no in OSL = 7900
-const testIp = '51.120.98.194'
-const testRegion = 7900
-const dbPath = '/tmp/geoipdatabasesl0'
-
-describe('Layer0', () => {
-
-    let epDhtNode: DhtNode
-    let node1: DhtNode
-    let mock: jest.SpyInstance<string, [], any> 
-    
-    beforeEach(async () => {
-
-        epDhtNode = new DhtNode({
-            websocketHost: '127.0.0.1', websocketPortRange: { min: 10011, max: 10011 }, websocketServerEnableTls: false,
-            geoIpDatabaseFolder: dbPath
-        })
-        await epDhtNode.start()
-        await epDhtNode.joinDht([epDhtNode.getLocalPeerDescriptor()])
-
-        node1 = new DhtNode({
-            websocketPortRange: WEBSOCKET_PORT_RANGE,
-            websocketHost: '127.0.0.1',
-            entryPoints: [epDhtNode.getLocalPeerDescriptor()],
-            websocketServerEnableTls: false
-        })
-
-        mock = jest.spyOn(WebsocketServerConnection.prototype, 'getRemoteIpAddress').mockImplementation(() => testIp)
-
-    }, 10000)
-
-    afterEach(async () => {
-        await Promise.all([
-            epDhtNode.stop(),
-            node1.stop()
-        ])
-        fs.unlinkSync(dbPath + '/GeoLite2-City.mmdb')
-        fs.rmSync(dbPath, { recursive: true })
-        mock.mockRestore()
-    })
-
-    it('Gets the correct region number by IP address', async () => {
-        await node1.start()
-        await node1.joinDht([epDhtNode.getLocalPeerDescriptor()])
-        
-        expect(node1.getLocalPeerDescriptor().region).toBe(testRegion)
-
-    }, 10000)
-})

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

@@ -1,93 +0,0 @@
-import { DhtNode } from '../../src/dht/DhtNode'
-import { areEqualPeerDescriptors } from '../../src/identifiers'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const STREAM_ID1 = 'stream1'
-const STREAM_ID2 = 'stream2'
-const WEBSOCKET_PORT_RANGE = { min: 10017, max: 10018 }
-
-describe('Layer0-Layer1', () => {
-
-    const epPeerDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 10016, tls: false }
-    })
-    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, websocketServerEnableTls: false })
-        await epDhtNode.start()
-        await epDhtNode.joinDht([epPeerDescriptor])
-
-        node1 = new DhtNode({ 
-            websocketPortRange: WEBSOCKET_PORT_RANGE, 
-            entryPoints: [epPeerDescriptor], 
-            websocketServerEnableTls: false
-        })
-        node2 = new DhtNode({ 
-            websocketPortRange: WEBSOCKET_PORT_RANGE,
-            entryPoints: [epPeerDescriptor],
-            websocketServerEnableTls: false
-        })
-
-        await node1.start()
-        await node2.start()
-
-        stream1Node1 = new DhtNode({ transport: epDhtNode, connectionsView: epDhtNode.getConnectionsView(), serviceId: STREAM_ID1 })
-        stream1Node2 = new DhtNode({ transport: node1, connectionsView: node1.getConnectionsView(), serviceId: STREAM_ID1 })
-
-        stream2Node1 = new DhtNode({ transport: epDhtNode, connectionsView: epDhtNode.getConnectionsView(), serviceId: STREAM_ID2 })
-        stream2Node2 = new DhtNode({ transport: node2, connectionsView: node2.getConnectionsView(), 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.getClosestContacts()).toHaveLength(1)
-        expect(stream1Node2.getClosestContacts()).toHaveLength(1)
-        expect(stream2Node1.getClosestContacts()).toHaveLength(1)
-        expect(stream2Node2.getClosestContacts()).toHaveLength(1)
-
-        expect(areEqualPeerDescriptors(stream1Node1.getClosestContacts()[0], node1.getLocalPeerDescriptor())).toBe(true)
-        expect(areEqualPeerDescriptors(stream1Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
-        expect(areEqualPeerDescriptors(stream2Node1.getClosestContacts()[0], node2.getLocalPeerDescriptor())).toBe(true)
-        expect(areEqualPeerDescriptors(stream2Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
-    })
-})

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

@@ -1,76 +0,0 @@
-import { DhtNode } from '../../src/dht/DhtNode'
-
-const WEBSOCKET_PORT_RANGE = { min: 10012, max: 10015 } 
-
-describe('Layer0', () => {
-
-    let epDhtNode: DhtNode
-    let node1: DhtNode
-    let node2: DhtNode
-    let node3: DhtNode
-    let node4: DhtNode
-
-    beforeEach(async () => {
-        
-        epDhtNode = new DhtNode({ websocketHost: '127.0.0.1', websocketPortRange: { min: 10011, max: 10011 }, websocketServerEnableTls: false })
-        await epDhtNode.start()
-        await epDhtNode.joinDht([epDhtNode.getLocalPeerDescriptor()])
-
-        node1 = new DhtNode({ 
-            websocketPortRange: WEBSOCKET_PORT_RANGE,
-            websocketHost: '127.0.0.1',
-            entryPoints: [epDhtNode.getLocalPeerDescriptor()],
-            websocketServerEnableTls: false
-        })
-        node2 = new DhtNode({ 
-            websocketPortRange: WEBSOCKET_PORT_RANGE,
-            websocketHost: '127.0.0.1',
-            entryPoints: [epDhtNode.getLocalPeerDescriptor()],
-            websocketServerEnableTls: false
-        })
-        node3 = new DhtNode({ 
-            websocketPortRange: WEBSOCKET_PORT_RANGE,
-            websocketHost: '127.0.0.1',
-            entryPoints: [epDhtNode.getLocalPeerDescriptor()],
-            websocketServerEnableTls: false
-        })
-        node4 = new DhtNode({ 
-            websocketPortRange: WEBSOCKET_PORT_RANGE, 
-            websocketHost: '127.0.0.1',
-            entryPoints: [epDhtNode.getLocalPeerDescriptor()],
-            websocketServerEnableTls: false
-        })
-        
-        await Promise.all([
-            node1.start(),
-            node2.start(),
-            node3.start(),
-            node4.start()
-        ])
-
-    }, 10000)
-
-    afterEach(async () => {
-        await Promise.all([
-            epDhtNode.stop(),
-            node1.stop(),
-            node2.stop(),
-            node3.stop(),
-            node4.stop()
-        ])
-    })
-
-    it('Happy path', async () => {
-        await Promise.all([
-            node1.joinDht([epDhtNode.getLocalPeerDescriptor()]),
-            node2.joinDht([epDhtNode.getLocalPeerDescriptor()]),
-            node3.joinDht([epDhtNode.getLocalPeerDescriptor()]),
-            node4.joinDht([epDhtNode.getLocalPeerDescriptor()])
-        ])
-
-        expect(node1.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
-    }, 10000)
-})

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

@@ -1,110 +0,0 @@
-import { DhtNode } from '../../src/dht/DhtNode'
-import { waitForEvent3 } from '@streamr/utils'
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { TransportEvents } from '../../src/transport/ITransport'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const WEBSOCKET_PORT_RANGE = { min: 11222, max: 11223 }
-
-describe('Layer0MixedConnectionTypes', () => {
-
-    const epPeerDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 11221, tls: false }
-    })
-    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,
-            websocketServerEnableTls: false
-        })
-        await epDhtNode.start()
-
-        await epDhtNode.joinDht([epPeerDescriptor])
-        node1 = new DhtNode({ 
-            websocketPortRange: WEBSOCKET_PORT_RANGE,
-            entryPoints: [epPeerDescriptor],
-            websocketServerEnableTls: false
-        })
-        node2 = new DhtNode({ 
-            websocketPortRange: WEBSOCKET_PORT_RANGE,
-            entryPoints: [epPeerDescriptor],
-            websocketServerEnableTls: false
-        })
-        node3 = new DhtNode({ 
-            entryPoints: [epPeerDescriptor]
-        })
-        node4 = new DhtNode({ 
-            entryPoints: [epPeerDescriptor]
-        })
-        node5 = new DhtNode({
-            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 () => {
-
-        await Promise.all([
-            waitForEvent3<TransportEvents>((node3.getTransport() as ConnectionManager), 'connected'),
-            waitForEvent3<TransportEvents>((node4.getTransport() as ConnectionManager), 'connected'),
-            node3.joinDht([epPeerDescriptor]),
-            node4.joinDht([epPeerDescriptor])
-        ])
-
-        await Promise.all([
-            node1.joinDht([epPeerDescriptor]),
-            node2.joinDht([epPeerDescriptor]),
-            node5.joinDht([epPeerDescriptor])
-        ])
-
-        expect(node1.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node5.getNeighborCount()).toBeGreaterThanOrEqual(1)
-
-    }, 20000)
-
-    it('Simultaneous joins', async () => {
-        await Promise.all([
-            node1.joinDht([epPeerDescriptor]),
-            node2.joinDht([epPeerDescriptor]),
-            node3.joinDht([epPeerDescriptor]),
-            node4.joinDht([epPeerDescriptor]),
-            node5.joinDht([epPeerDescriptor])
-        ])
-        expect(node1.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(node5.getNeighborCount()).toBeGreaterThanOrEqual(2)
-    }, 40000)
-})

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

@@ -1,137 +0,0 @@
-import { DhtNode } from '../../src/dht/DhtNode'
-import { randomDhtAddress, toNodeId } from '../../src/identifiers'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('Layer 1 on Layer 0 with mocked connections', () => {
-
-    const entrypointDescriptor = createMockPeerDescriptor({
-        websocket: {
-            host: '127.0.0.1',
-            port: 23232,
-            tls: false
-        }
-    })
-    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, websocketServerEnableTls: false })
-
-        const layer0Node1Id = randomDhtAddress()
-        layer0Node1 = new DhtNode({
-            nodeId: layer0Node1Id,
-            entryPoints: [entrypointDescriptor]
-        })
-
-        const layer0Node2Id = randomDhtAddress()
-        layer0Node2 = new DhtNode({
-            nodeId: layer0Node2Id,
-            entryPoints: [entrypointDescriptor]
-        })
-
-        const layer0Node3Id = randomDhtAddress()
-        layer0Node3 = new DhtNode({
-            nodeId: layer0Node3Id,
-            entryPoints: [entrypointDescriptor]
-        })
-
-        const layer0Node4Id = randomDhtAddress()
-        layer0Node4 = new DhtNode({
-            nodeId: layer0Node4Id,
-            entryPoints: [entrypointDescriptor]
-        })
-
-        await layer0EntryPoint.start()
-        await layer0Node1.start()
-        await layer0Node2.start()
-        await layer0Node3.start()
-        await layer0Node4.start()
-
-        layer1EntryPoint = new DhtNode({
-            nodeId: toNodeId(entrypointDescriptor),
-            transport: layer0EntryPoint,
-            connectionsView: layer0EntryPoint.getConnectionsView(),
-            serviceId: 'layer1'
-        })
-
-        layer1Node1 = new DhtNode({
-            nodeId: layer0Node1Id,
-            transport: layer0Node1,
-            connectionsView: layer0Node1.getConnectionsView(),
-            serviceId: 'layer1'
-        })
-
-        layer1Node2 = new DhtNode({
-            nodeId: layer0Node2Id,
-            transport: layer0Node2,
-            connectionsView: layer0Node2.getConnectionsView(),
-            serviceId: 'layer1'
-        })
-
-        layer1Node3 = new DhtNode({
-            nodeId: layer0Node3Id,
-            transport: layer0Node3,
-            connectionsView: layer0Node3.getConnectionsView(),
-            serviceId: 'layer1'
-        })
-
-        layer1Node4 = new DhtNode({
-            nodeId: layer0Node4Id,
-            transport: layer0Node4,
-            connectionsView: layer0Node4.getConnectionsView(),
-            serviceId: 'layer1'
-        })
-
-        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.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
-    }, 60000)
-})

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

@@ -1,85 +0,0 @@
-import { areEqualBinaries, waitForEvent3 } from '@streamr/utils'
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { toNodeId } from '../../src/exports'
-
-describe('Layer0 with WebRTC connections', () => {
-
-    const epPeerDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 10029, tls: false }
-    })
-    let epDhtNode: DhtNode
-    let node1: DhtNode
-    let node2: DhtNode
-    let node3: DhtNode
-    let node4: DhtNode
-
-    beforeEach(async () => {
-
-        epDhtNode = new DhtNode({
-            peerDescriptor: epPeerDescriptor,
-            numberOfNodesPerKBucket: 8,
-            websocketServerEnableTls: false
-        })
-        await epDhtNode.start()
-
-        await epDhtNode.joinDht([epPeerDescriptor])
-
-        node1 = new DhtNode({ entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ entryPoints: [epPeerDescriptor] })
-        node3 = new DhtNode({ entryPoints: [epPeerDescriptor] })
-        node4 = new DhtNode({ entryPoints: [epPeerDescriptor] })
-
-        await Promise.all([
-            node1.start(),
-            node2.start(),
-            node3.start(),
-            node4.start()
-        ])
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            node1.stop(),
-            node2.stop(),
-            node3.stop(),
-            node4.stop()
-        ])
-        await epDhtNode.stop()
-    })
-
-    it('Happy path two peers', async () => {
-
-        await Promise.all([
-            waitForEvent3<any>(
-                node2 as any,
-                'connected',
-                20000,
-                (peerDescriptor: PeerDescriptor) => {
-                    return areEqualBinaries(peerDescriptor.nodeId, node1.getLocalPeerDescriptor().nodeId)
-                }
-            ),
-            node2.joinDht([epPeerDescriptor]),
-            node1.joinDht([epPeerDescriptor])
-        ])
-        const nodeId1 = toNodeId(node1.getLocalPeerDescriptor())
-        const nodeId2 = toNodeId(node2.getLocalPeerDescriptor())
-        expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
-    }, 60000)
-
-    it('Happy path simultaneous joins', async () => {
-        await Promise.all([
-            node1.joinDht([epPeerDescriptor]),
-            node2.joinDht([epPeerDescriptor]),
-            node3.joinDht([epPeerDescriptor]),
-            node4.joinDht([epPeerDescriptor])
-        ])
-        const nodeId1 = toNodeId(node1.getLocalPeerDescriptor())
-        const nodeId2 = toNodeId(node2.getLocalPeerDescriptor())
-        expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
-    })
-})