@streamr/trackerless-network 102.0.0-beta.1 → 102.0.0-beta.3

package/test/end-to-end/proxy-connections.test.ts

@@ -1,226 +0,0 @@
-import { DhtAddress } from '@streamr/dht'
-import { randomUserId } from '@streamr/test-utils'
-import { StreamPartIDUtils, hexToBinary, toUserIdRaw, utf8ToBinary, wait, until, waitForEvent3 } from '@streamr/utils'
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
-import { ProxyClient } from '../../src/logic/proxy/ProxyClient'
-import {
-    ContentType,
-    EncryptionType,
-    ProxyDirection,
-    SignatureType,
-    StreamMessage
-} from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const PROXIED_NODE_USER_ID = randomUserId()
-const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
-const MESSAGE: StreamMessage = {
-    messageId: {
-        streamId: StreamPartIDUtils.getStreamID(STREAM_PART_ID),
-        streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
-        timestamp: 666,
-        sequenceNumber: 0,
-        publisherId: toUserIdRaw(randomUserId()),
-        messageChainId: 'msgChainId'
-    },
-    previousMessageRef: {
-        timestamp: 665,
-        sequenceNumber: 0
-    },
-    body: {
-        oneofKind: 'contentMessage',
-        contentMessage: {
-            content: utf8ToBinary(JSON.stringify({
-                hello: 'world'
-            })),
-            contentType: ContentType.JSON,
-            encryptionType: EncryptionType.NONE,
-        }
-    },
-    signatureType: SignatureType.SECP256K1,
-    signature: hexToBinary('0x1234')
-}
-
-describe('Proxy connections', () => {
-
-    let proxyNode1: NetworkNode
-    let proxyNode2: NetworkNode
-    let proxiedNode: NetworkNode
-
-    const hasConnectionFromProxy = (proxyNode: NetworkNode): boolean => {
-        const delivery = proxyNode.stack.getContentDeliveryManager().getStreamPartDelivery(STREAM_PART_ID)
-        return (delivery !== undefined)
-            ? ((delivery as { node: ContentDeliveryLayerNode }).node).hasProxyConnection(proxiedNode.getNodeId())
-            : false
-    }
-    
-    const hasConnectionToProxy = (proxyNodeId: DhtAddress, direction: ProxyDirection): boolean => {
-        const client = (proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(STREAM_PART_ID) as { client: ProxyClient }).client
-        return client.hasConnection(proxyNodeId, direction)
-    }
-
-    beforeEach(async () => {
-        const proxyNodeDescriptor1 = createMockPeerDescriptor({
-            websocket: { host: '127.0.0.1', port: 23132, tls: false }
-        })
-        const proxyNodeDescriptor2 = createMockPeerDescriptor({
-            websocket: { host: '127.0.0.1', port: 23133, tls: false }
-        })
-        const proxiedNodeDescriptor = createMockPeerDescriptor()
-        proxyNode1 = createNetworkNode({
-            layer0: {
-                entryPoints: [proxyNodeDescriptor1],
-                peerDescriptor: proxyNodeDescriptor1,
-                websocketServerEnableTls: false
-            },
-            networkNode: {
-                acceptProxyConnections: true
-            }
-        })
-        await proxyNode1.start()
-        proxyNode1.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        proxyNode2 = createNetworkNode({
-            layer0: {
-                entryPoints: [proxyNodeDescriptor1],
-                peerDescriptor: proxyNodeDescriptor2,
-                websocketServerEnableTls: false
-            },
-            networkNode: {
-                acceptProxyConnections: true
-            }
-        })
-        await proxyNode2.start()
-        proxyNode2.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        proxiedNode = createNetworkNode({
-            layer0: {
-                entryPoints: [proxyNode1.getPeerDescriptor()],
-                peerDescriptor: proxiedNodeDescriptor,
-            }
-        })
-        await proxiedNode.start(false)
-    }, 30000)
-
-    afterEach(async () => {
-        await proxyNode1.stop()
-        await proxyNode2.stop()
-        await proxiedNode.stop()
-    })
-
-    it('happy path publishing', async () => {
-        await proxiedNode.setProxies(STREAM_PART_ID, [proxyNode1.getPeerDescriptor()], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 1)
-        await Promise.all([
-            waitForEvent3(proxyNode1.stack.getContentDeliveryManager() as any, 'newMessage'),
-            proxiedNode.broadcast(MESSAGE)
-        ])
-    })
-
-    it('happy path subscribing', async () => {
-        await proxiedNode.setProxies(STREAM_PART_ID, [proxyNode1.getPeerDescriptor()], ProxyDirection.SUBSCRIBE, PROXIED_NODE_USER_ID, 1)
-        await Promise.all([
-            waitForEvent3(proxiedNode.stack.getContentDeliveryManager() as any, 'newMessage'),
-            proxyNode1.broadcast(MESSAGE)
-        ])
-    })
-
-    it('can leave proxy publish connection', async () => {
-        await proxiedNode.setProxies(STREAM_PART_ID, [proxyNode1.getPeerDescriptor()], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 1)
-        expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(true) 
-        expect(hasConnectionFromProxy(proxyNode1)).toBe(true) 
-        await proxiedNode.setProxies(STREAM_PART_ID, [], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 0)
-        expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(false) 
-        await until(() => hasConnectionFromProxy(proxyNode1) === false)
-    })
-
-    it('can leave proxy subscribe connection', async () => {
-        await proxiedNode.setProxies(STREAM_PART_ID, [proxyNode1.getPeerDescriptor()], ProxyDirection.SUBSCRIBE, PROXIED_NODE_USER_ID, 1)
-        expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(true) 
-        expect(hasConnectionFromProxy(proxyNode1)).toBe(true) 
-        await proxiedNode.setProxies(STREAM_PART_ID, [], ProxyDirection.SUBSCRIBE, PROXIED_NODE_USER_ID, 0)
-        expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(false)
-        await until(() => hasConnectionFromProxy(proxyNode1) === false)
-    })
-
-    it('can open multiple proxy connections', async () => {
-        await proxiedNode.setProxies(
-            STREAM_PART_ID,
-            [proxyNode1.getPeerDescriptor(), proxyNode2.getPeerDescriptor()],
-            ProxyDirection.SUBSCRIBE,
-            PROXIED_NODE_USER_ID
-        )
-        expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(true)
-        expect(hasConnectionFromProxy(proxyNode1)).toBe(true) 
-        expect(hasConnectionFromProxy(proxyNode2)).toBe(true) 
-    })
-
-    it('can open multiple proxy connections and close one', async () => {
-        await proxiedNode.setProxies(
-            STREAM_PART_ID,
-            [proxyNode1.getPeerDescriptor(), proxyNode2.getPeerDescriptor()],
-            ProxyDirection.SUBSCRIBE,
-            PROXIED_NODE_USER_ID
-        )
-        expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(true)
-        expect(hasConnectionFromProxy(proxyNode1)).toBe(true) 
-        expect(hasConnectionFromProxy(proxyNode2)).toBe(true)
-        await proxiedNode.setProxies(STREAM_PART_ID, [proxyNode1.getPeerDescriptor()], ProxyDirection.SUBSCRIBE, PROXIED_NODE_USER_ID)
-        expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(true)
-        await until(() => hasConnectionFromProxy(proxyNode2) === false)
-        expect(hasConnectionFromProxy(proxyNode1)).toBe(true)
-    })
-
-    it('can open and close all connections', async () => {
-        await proxiedNode.setProxies(
-            STREAM_PART_ID,
-            [proxyNode1.getPeerDescriptor(), proxyNode2.getPeerDescriptor()],
-            ProxyDirection.SUBSCRIBE,
-            PROXIED_NODE_USER_ID
-        )
-        expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(true)
-        expect(hasConnectionFromProxy(proxyNode1)).toBe(true) 
-        expect(hasConnectionFromProxy(proxyNode2)).toBe(true)
-
-        await proxiedNode.setProxies(STREAM_PART_ID, [], ProxyDirection.SUBSCRIBE, PROXIED_NODE_USER_ID)
-        expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(false)
-        await until(() => hasConnectionFromProxy(proxyNode1) === false)
-        await until(() => hasConnectionFromProxy(proxyNode2) === false)
-    })
-
-    it('will reconnect if proxy node goes offline and comes back online', async () => {
-        await proxiedNode.setProxies(
-            STREAM_PART_ID,
-            [proxyNode1.getPeerDescriptor()],
-            ProxyDirection.SUBSCRIBE,
-            PROXIED_NODE_USER_ID
-        )
-        expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(true)
-        await proxyNode1.leave(STREAM_PART_ID)
-        await until(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE))
-        expect(hasConnectionFromProxy(proxyNode1)).toBe(false)
-        proxyNode1.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        await until(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE), 25000)
-        // TODO why wait is needed?
-        await wait(100)
-        expect(hasConnectionFromProxy(proxyNode1)).toBe(true)
-    }, 30000)
-
-    it('can\'t join proxied stream part', async () => {
-        await proxiedNode.setProxies(
-            STREAM_PART_ID,
-            [proxyNode1.getPeerDescriptor()],
-            ProxyDirection.PUBLISH,
-            PROXIED_NODE_USER_ID
-        )
-        await expect(proxiedNode.join(STREAM_PART_ID)).rejects.toThrow('Cannot join')
-    })
-
-    it('can\'t broadcast to subscribe-only proxied stream part', async () => {
-        await proxiedNode.setProxies(
-            STREAM_PART_ID,
-            [proxyNode1.getPeerDescriptor()],
-            ProxyDirection.SUBSCRIBE,
-            PROXIED_NODE_USER_ID
-        )
-        await expect(proxiedNode.broadcast(MESSAGE)).rejects.toThrow('Cannot broadcast')
-    })
-})

package/test/end-to-end/proxy-key-exchange.test.ts

@@ -1,126 +0,0 @@
-import { randomUserId } from '@streamr/test-utils'
-import {
-    StreamPartIDUtils,
-    hexToBinary,
-    toUserIdRaw,
-    waitForEvent3
-} from '@streamr/utils'
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { ProxyDirection, SignatureType, StreamMessage } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
-
-describe('proxy group key exchange', () => {
-    const proxyNodeDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 23134, tls: false }
-    })
-    const publisherDescriptor = createMockPeerDescriptor()
-    const subscriberDescriptor = createMockPeerDescriptor()
-
-    const publisherUserId = randomUserId()
-    const subscriberUserId = randomUserId()
-
-    let proxyNode: NetworkNode
-    let publisher: NetworkNode
-    let subscriber: NetworkNode
-
-    beforeEach(async () => {
-        proxyNode = createNetworkNode({
-            layer0: {
-                entryPoints: [proxyNodeDescriptor],
-                peerDescriptor: proxyNodeDescriptor,
-                websocketServerEnableTls: false
-            },
-            networkNode: {
-                acceptProxyConnections: true
-            }
-        })
-        await proxyNode.start()
-        proxyNode.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        publisher = createNetworkNode({
-            layer0: {
-                entryPoints: [proxyNodeDescriptor],
-                peerDescriptor: publisherDescriptor,
-            }
-        })
-        await publisher.start(false)
-
-        subscriber = createNetworkNode({
-            layer0: {
-                entryPoints: [proxyNodeDescriptor],
-                peerDescriptor: subscriberDescriptor,
-            }
-        })
-        await subscriber.start(false)
-    })
-
-    afterEach(async () => {
-        await proxyNode.stop()
-        await publisher.stop()
-        await subscriber.stop()
-    })
-    
-    it('happy path request', async () => {
-        await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
-        await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
-
-        const request: StreamMessage = {
-            messageId: {
-                streamId: StreamPartIDUtils.getStreamID(STREAM_PART_ID),
-                streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
-                timestamp: Date.now(),
-                sequenceNumber: 0,
-                publisherId: toUserIdRaw(subscriberUserId),
-                messageChainId: '0'
-            },
-            body: {
-                oneofKind: 'groupKeyRequest' as const,
-                groupKeyRequest: {
-                    requestId: 'requestId',
-                    recipientId: toUserIdRaw(publisherUserId),
-                    rsaPublicKey: new Uint8Array(),
-                    groupKeyIds: ['mock']
-                }
-            },
-            signatureType: SignatureType.SECP256K1,
-            signature: hexToBinary('1234')
-        }
-
-        await Promise.all([
-            waitForEvent3(publisher.stack.getContentDeliveryManager() as any, 'newMessage'),
-            subscriber.broadcast(request)
-        ])
-    })
-
-    it('happy path response', async () => {
-        await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
-        await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
-
-        const response: StreamMessage = {
-            messageId: {
-                streamId: StreamPartIDUtils.getStreamID(STREAM_PART_ID),
-                streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
-                timestamp: Date.now(),
-                sequenceNumber: 0,
-                publisherId: toUserIdRaw(publisherUserId),
-                messageChainId: '0'
-            },
-            body: {
-                oneofKind: 'groupKeyResponse' as const,
-                groupKeyResponse: {
-                    requestId: 'requestId',
-                    recipientId: toUserIdRaw(publisherUserId),
-                    groupKeys: []
-                }
-            },
-            signatureType: SignatureType.SECP256K1,
-            signature: hexToBinary('1234')
-        }
-
-        await Promise.all([
-            waitForEvent3(subscriber.stack.getContentDeliveryManager() as any, 'newMessage'),
-            publisher.broadcast(response)
-        ])
-    })
-})

package/test/end-to-end/webrtc-full-node-network.test.ts

@@ -1,83 +0,0 @@
-import { toNodeId, getRandomRegion } from '@streamr/dht'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { range } from 'lodash'
-import { NetworkStack } from '../../src/NetworkStack'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('Full node network with WebRTC connections', () => {
-
-    const NUM_OF_NODES = 22
-
-    const epPeerDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 14444, tls: false },
-        region: getRandomRegion()
-    })
-
-    const streamPartId = StreamPartIDUtils.parse('webrtc-network#0')
-
-    let entryPoint: NetworkStack
-
-    let nodes: NetworkStack[]
-
-    beforeEach(async () => {
-
-        nodes = []
-
-        entryPoint = new NetworkStack({
-            layer0: {
-                entryPoints: [epPeerDescriptor],
-                peerDescriptor: epPeerDescriptor,
-                websocketServerEnableTls: false
-            }
-        })
-        await entryPoint.start()
-        entryPoint.getContentDeliveryManager().joinStreamPart(streamPartId)
-
-        await Promise.all(range(NUM_OF_NODES).map(async () => {
-            const peerDescriptor = createMockPeerDescriptor()
-            const node = new NetworkStack({
-                layer0: {
-                    peerDescriptor,
-                    entryPoints: [epPeerDescriptor]
-                }
-            })
-            nodes.push(node)
-            await node.start()
-            node.getContentDeliveryManager().joinStreamPart(streamPartId)
-        }))
-
-    }, 90000)
-
-    afterEach(async () => {
-        await Promise.all([
-            entryPoint.stop(),
-            ...nodes.map((node) => node.stop())
-        ])
-    })
-
-    it('happy path', async () => {
-        await Promise.all(nodes.map((node) =>
-            until(() => {
-                return node.getContentDeliveryManager().getNeighbors(streamPartId).length >= 3
-            }
-            , 30000)
-        ))
-        let receivedMessageCount = 0
-        const successIds: string[] = []
-        nodes.forEach((node) => {
-            node.getContentDeliveryManager().on('newMessage', () => {
-                successIds.push(toNodeId(node.getContentDeliveryManager().getPeerDescriptor()))
-                receivedMessageCount += 1
-            })
-        })
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            streamPartId,
-            randomUserId()
-        )
-        entryPoint.getContentDeliveryManager().broadcast(msg)
-        await until(() => receivedMessageCount === NUM_OF_NODES)
-    }, 120000)
-
-})

package/test/end-to-end/websocket-full-node-network.test.ts

@@ -1,82 +0,0 @@
-import { toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { range } from 'lodash'
-import { NetworkStack } from '../../src/NetworkStack'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('Full node network with WebSocket connections only', () => {
-
-    const NUM_OF_NODES = 12
-    const epPeerDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 15555, tls: false }
-    })
-    const streamPartId = StreamPartIDUtils.parse('websocket-network#0')
-
-    let entryPoint: NetworkStack
-
-    let nodes: NetworkStack[]
-
-    beforeEach(async () => {
-
-        nodes = []
-
-        entryPoint = new NetworkStack({
-            layer0: {
-                entryPoints: [epPeerDescriptor],
-                peerDescriptor: epPeerDescriptor,
-                websocketServerEnableTls: false
-            }
-        })
-        await entryPoint.start()
-        entryPoint.getContentDeliveryManager().joinStreamPart(streamPartId)
-
-        await Promise.all(range(NUM_OF_NODES).map(async (i) => {
-            const node = new NetworkStack({
-                layer0: {
-                    entryPoints: [epPeerDescriptor],
-                    websocketPortRange: { min: 15556 + i, max: 15556 + i },
-                    numberOfNodesPerKBucket: 4,
-                    websocketServerEnableTls: false
-                }
-            })
-            nodes.push(node)
-            await node.start()
-            node.getContentDeliveryManager().joinStreamPart(streamPartId)
-        }))
-
-    }, 120000)
-
-    afterEach(async () => {
-        await Promise.all([
-            entryPoint.stop(),
-            ...nodes.map((node) => node.stop())
-        ])
-    })
-
-    it('happy path', async () => {
-        await Promise.all(nodes.map((node) =>
-            until(() => {
-                return node.getContentDeliveryManager().getNeighbors(streamPartId).length >= 4
-            }
-            , 30000)
-        ))
-        let receivedMessageCount = 0
-        const successIds: string[] = []
-        nodes.forEach((node) => {
-            node.getContentDeliveryManager().on('newMessage', () => {
-                successIds.push(toNodeId(node.getContentDeliveryManager().getPeerDescriptor()))
-                receivedMessageCount += 1
-            })
-        })
-
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            streamPartId,
-            randomUserId()
-        )
-        entryPoint.getContentDeliveryManager().broadcast(msg)
-        await until(() => receivedMessageCount === NUM_OF_NODES)
-    }, 220000)
-
-})

package/test/integration/ContentDeliveryLayerNode-Layer1Node-Latencies.test.ts

@@ -1,139 +0,0 @@
-import { DhtNode, LatencyType, PeerDescriptor, Simulator, SimulatorTransport, toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { range } from 'lodash'
-import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
-import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
-import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('ContentDeliveryLayerNode-DhtNode-Latencies', () => {
-    const otherNodeCount = 64
-    let otherDiscoveryLayerNodes: DiscoveryLayerNode[]
-    let entryPointDiscoveryLayerNode: DiscoveryLayerNode
-    let entryPointContentDeliveryLayerNode: ContentDeliveryLayerNode
-    let otherContentDeliveryLayerNodes: ContentDeliveryLayerNode[]
-
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-    const entrypointDescriptor = createMockPeerDescriptor()
-
-    const peerDescriptors: PeerDescriptor[] = range(otherNodeCount).map(() => createMockPeerDescriptor())
-    beforeEach(async () => {
-        const simulator = new Simulator(LatencyType.FIXED, 50)
-        const entrypointCm = new SimulatorTransport(entrypointDescriptor, simulator)
-        const cms: SimulatorTransport[] = range(otherNodeCount).map((i) =>
-            new SimulatorTransport(peerDescriptors[i], simulator)
-        )
-        await entrypointCm.start()
-        await Promise.all(cms.map((cm) => cm.start()))
-
-        entryPointDiscoveryLayerNode = new DhtNode({
-            transport: entrypointCm,
-            connectionsView: entrypointCm,
-            peerDescriptor: entrypointDescriptor,
-            serviceId: streamPartId
-        })
-        otherDiscoveryLayerNodes = range(otherNodeCount).map((i) => new DhtNode({
-            transport: cms[i],
-            connectionsView: cms[i],
-            peerDescriptor: peerDescriptors[i],
-            serviceId: streamPartId
-        }))
-        otherContentDeliveryLayerNodes = range(otherNodeCount).map((i) => createContentDeliveryLayerNode({
-            streamPartId,
-            discoveryLayerNode: otherDiscoveryLayerNodes[i],
-            transport: cms[i],
-            connectionLocker: cms[i],
-            localPeerDescriptor: peerDescriptors[i],
-            isLocalNodeEntryPoint: () => false
-        }))
-        entryPointContentDeliveryLayerNode = createContentDeliveryLayerNode({
-            streamPartId,
-            discoveryLayerNode: entryPointDiscoveryLayerNode,
-            transport: entrypointCm,
-            connectionLocker: entrypointCm,
-            localPeerDescriptor: entrypointDescriptor,
-            isLocalNodeEntryPoint: () => false
-        })
-
-        await entryPointDiscoveryLayerNode.start()
-        entryPointContentDeliveryLayerNode.start()
-        await entryPointDiscoveryLayerNode.joinDht([entrypointDescriptor])
-        await Promise.all(otherDiscoveryLayerNodes.map((node) => node.start()))
-    })
-
-    afterEach(async () => {
-        entryPointDiscoveryLayerNode.stop()
-        entryPointContentDeliveryLayerNode.stop()
-        await Promise.all(otherDiscoveryLayerNodes.map((node) => node.stop()))
-        await Promise.all(otherContentDeliveryLayerNodes.map((node) => node.stop()))
-    })
-
-    it('happy path single node', async () => {
-        await otherContentDeliveryLayerNodes[0].start()
-        await otherDiscoveryLayerNodes[0].joinDht([entrypointDescriptor])
-        await Promise.all([
-            until(() => otherContentDeliveryLayerNodes[0].getNearbyNodeView().getIds().length === 1),
-            until(() => otherContentDeliveryLayerNodes[0].getNeighbors().length === 1)
-        ])
-        expect(otherContentDeliveryLayerNodes[0].getNearbyNodeView().getIds().length).toEqual(1)
-        expect(otherContentDeliveryLayerNodes[0].getNeighbors().length).toEqual(1)
-    })
-
-    it('happy path 5 nodes', async () => {
-        range(4).forEach((i) => otherContentDeliveryLayerNodes[i].start())
-        await Promise.all(range(4).map(async (i) => {
-            await otherDiscoveryLayerNodes[i].joinDht([entrypointDescriptor])
-        }))
-        await until(() => range(4).every((i) => otherContentDeliveryLayerNodes[i].getNeighbors().length >= 4), 15000, 1000)
-        range(4).forEach((i) => {
-            expect(otherContentDeliveryLayerNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
-            expect(otherContentDeliveryLayerNodes[i].getNeighbors().length).toBeGreaterThanOrEqual(4)
-        })
-        // Check bidirectionality
-        const allNodes = otherContentDeliveryLayerNodes
-        allNodes.push(entryPointContentDeliveryLayerNode)
-        range(5).forEach((i) => {
-            const ownNodeId = allNodes[i].getOwnNodeId()
-            allNodes[i].getNearbyNodeView().getIds().forEach((nodeId) => {
-                const neighbor = allNodes.find((node) => {
-                    return node.getOwnNodeId() === ownNodeId
-                })
-                const neighborNodeIds = neighbor!.getNeighbors().map((n) => toNodeId(n))
-                expect(neighborNodeIds).toContain(nodeId)
-            })
-        })
-    }, 60000)
-
-    it('happy path 64 nodes', async () => {
-        await Promise.all(range(otherNodeCount).map((i) => otherContentDeliveryLayerNodes[i].start()))
-        await Promise.all(range(otherNodeCount).map((i) => {
-            otherDiscoveryLayerNodes[i].joinDht([entrypointDescriptor])
-        }))
-        await Promise.all(otherContentDeliveryLayerNodes.map((node) =>
-            until(() => node.getNeighbors().length >= 4, 10000)
-        ))
-
-        await Promise.all(otherContentDeliveryLayerNodes.map((node) =>
-            until(() => node.getOutgoingHandshakeCount() === 0)
-        ))
-
-        await until(() => {
-            let mismatchCounter = 0
-            otherContentDeliveryLayerNodes.forEach((node) => {
-                const nodeId = node.getOwnNodeId()
-                node.getNeighbors().forEach((neighbor) => {
-                    const neighborId = toNodeId(neighbor)
-                    if (neighborId !== entryPointContentDeliveryLayerNode.getOwnNodeId()) {
-                        const neighbor = otherContentDeliveryLayerNodes.find((n) => n.getOwnNodeId() === neighborId)
-                        const neighborNodeIds = neighbor!.getNeighbors().map((n) => toNodeId(n))
-                        if (!neighborNodeIds.includes(nodeId)) {
-                            mismatchCounter += 1
-                        }
-                    }
-                })
-            })
-            // NET-1074 Investigate why sometimes unidirectional connections remain.
-            return mismatchCounter <= 2
-        }, 20000, 1000)
-    }, 90000)
-})