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

package/test/benchmark/first-message.ts

@@ -1,171 +0,0 @@
-/* eslint-disable no-console */
-
-import {
-    DhtNode,
-    toNodeId,
-    getRandomRegion,
-    LatencyType,
-    PeerDescriptor,
-    Simulator
-} from '@streamr/dht'
-import {
-    hexToBinary,
-    StreamPartID,
-    StreamPartIDUtils,
-    toStreamID,
-    toStreamPartID,
-    toUserId,
-    toUserIdRaw,
-    utf8ToBinary, waitForEvent3
-} from '@streamr/utils'
-import fs from 'fs'
-import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
-import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
-import { NetworkNode } from '../../src/NetworkNode'
-import { ContentType, EncryptionType, SignatureType } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor, createNetworkNodeWithSimulator } from '../utils/utils'
-
-const numNodes = 10000
-
-let nodes: NetworkNode[]
-let simulator: Simulator
-let layer0Ep: PeerDescriptor
-const publishIntervals: NodeJS.Timeout[] = []
-const streamParts: Map<StreamPartID, NetworkNode> = new Map()
-let currentNode: NetworkNode
-let publishInterval: NodeJS.Timeout | undefined
-let i = 0
-
-const prepareLayer0 = async () => {
-    console.log('Preparing network')
-    nodes = []
-    simulator = new Simulator(LatencyType.REAL)
-    const peerDescriptor = createMockPeerDescriptor({
-        region: getRandomRegion()
-    })
-    layer0Ep = peerDescriptor
-    const entryPoint = await createNetworkNodeWithSimulator(peerDescriptor, simulator, [peerDescriptor])
-    await entryPoint.start()    
-    nodes.push(entryPoint)
-
-    console.log('Entrypoint ready')
-}
-
-const prepareStream = async (streamId: string) => {
-    console.log('Preparing stream ')
-    const peerDescriptor = createMockPeerDescriptor({
-        region: getRandomRegion()
-    })
-    const streamPartId = toStreamPartID(toStreamID(streamId), 0)
-    const streamPublisher = await createNetworkNodeWithSimulator(peerDescriptor, simulator, [layer0Ep])
-    await streamPublisher.start()
-    streamPublisher.join(streamPartId)
-    nodes.push(streamPublisher)
-    streamParts.set(streamPartId, streamPublisher)
-}
-
-const shutdownNetwork = async () => {
-    publishIntervals.forEach((interval) => clearInterval(interval))
-    await Promise.all([
-        ...nodes.map((node) => node.stop())
-    ])
-    simulator.stop()
-}
-
-const measureJoiningTime = async () => {
-    const peerDescriptor = createMockPeerDescriptor({
-        region: getRandomRegion()
-    })
-    console.log('starting node with id ', toNodeId(peerDescriptor))
-
-    // start publishing ons stream
-    const stream = Array.from(streamParts.keys())[Math.floor(Math.random() * streamParts.size)]
-    console.log(stream)
-    publishInterval = setInterval(() => {
-        i += 1
-        const streamMessage = {
-            messageId: {
-                streamId: StreamPartIDUtils.getStreamID(stream),
-                streamPartition: 0,
-                timestamp: i,
-                sequenceNumber: Math.floor(Math.random() * 20000),
-                publisherId: toUserIdRaw(toUserId('0x2222')),
-                messageChainId: 'msgChainId'
-            },
-            body: {
-                oneofKind: 'contentMessage' as const,
-                contentMessage: {
-                    content: utf8ToBinary(JSON.stringify({
-                        hello: 'world'
-                    })),
-                    contentType: ContentType.JSON,
-                    encryptionType: EncryptionType.NONE,
-                }
-            },
-            signature: hexToBinary('0x1234'),
-            signatureType: SignatureType.SECP256K1,
-        }
-        streamParts.get(stream)!.broadcast(streamMessage)
-    }, 1000)
-    // get random node from network to use as entrypoint
-    const randomNode = nodes[Math.floor(Math.random() * nodes.length)]
-    const streamSubscriber = await createNetworkNodeWithSimulator(
-        peerDescriptor,
-        simulator,
-        [randomNode.stack.getControlLayerNode().getLocalPeerDescriptor()]
-    )
-    currentNode = streamSubscriber
-    const start = performance.now()
-    await streamSubscriber.start()
-
-    await Promise.all([
-        waitForEvent3(streamSubscriber.stack.getContentDeliveryManager() as any, 'newMessage', 60000),
-        streamSubscriber.join(stream)
-    ])
-
-    const end = performance.now()
-
-    nodes.push(streamSubscriber)
-    clearInterval(publishInterval)
-    publishInterval = undefined
-    return end - start
-}
-
-const run = async () => {
-    await prepareLayer0()
-    for (let i = 0; i < 20; i++) {
-        await prepareStream(`stream-${i}`)
-    }
-    const logFile = fs.openSync('FirstMessageTime.log', 'w')
-    
-    fs.writeSync(logFile, 'Network size' + '\t' + 'Time to receive first message time (ms)' + '\n')
-    for (let i = 0; i < numNodes; i++) {
-        const time = await measureJoiningTime()
-        console.log(`Time to receive first message for ${i + 1} nodes network: ${time}ms`)
-        fs.writeSync(logFile, `${i + 1}` + '\t' + `${Math.round(time)}\n`)
-    }
-    fs.closeSync(logFile)
-    await shutdownNetwork()
-} 
-
-run().then(() => {
-    console.log('done')
-}).catch((err) => {
-    console.error(err)
-    const contentDeliveryManager = currentNode.stack.getContentDeliveryManager()
-    const streamParts = contentDeliveryManager.getStreamParts()
-    const foundData = nodes[0].stack.getControlLayerNode().fetchDataFromDht(streamPartIdToDataKey(streamParts[0]))
-    console.log(foundData)
-    const controlLayerNode = currentNode.stack.getControlLayerNode() as DhtNode
-    console.log(controlLayerNode.getNeighbors().length)
-    console.log(controlLayerNode.getConnectionsView().getConnectionCount())
-    const streamPartDelivery = contentDeliveryManager
-        .getStreamPartDelivery(streamParts[0])! as { discoveryLayerNode: DiscoveryLayerNode, node: ContentDeliveryLayerNode }
-    console.log(streamPartDelivery.discoveryLayerNode.getNeighbors())
-    console.log(streamPartDelivery.node.getNeighbors())
-    console.log(nodes[nodes.length - 1])
-    if (publishInterval) {
-        clearInterval(publishInterval)
-    }
-})

package/test/end-to-end/content-delivery-layer-node-with-real-connections.test.ts

@@ -1,165 +0,0 @@
-import { ConnectionManager, DhtNode, PeerDescriptor } from '@streamr/dht'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
-import { ControlLayerNode } from '../../src/logic/ControlLayerNode'
-import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
-import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('content delivery layer node with real connections', () => {
-
-    const epPeerDescriptor: PeerDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 12221, tls: false }
-    })
-
-    const streamPartId = StreamPartIDUtils.parse('random-graph#0')
-    // Currently the nodes here are practically layer0 nodes acting as layer1 nodes, for the purpose of this test
-    // they are layer1 nodes as the DHT is per stream
-    // TODO refactor the test to use normal layering style (i.e. have separate objects for layer0 and layer1 nodes)
-    let epDhtNode: ControlLayerNode & DiscoveryLayerNode
-    let dhtNode1: ControlLayerNode & DiscoveryLayerNode
-    let dhtNode2: ControlLayerNode & DiscoveryLayerNode
-    let dhtNode3: ControlLayerNode & DiscoveryLayerNode
-    let dhtNode4: ControlLayerNode & DiscoveryLayerNode
-    let contentDeliveryLayerNode1: ContentDeliveryLayerNode
-    let contentDeliveryLayerNode2: ContentDeliveryLayerNode
-    let contentDeliveryLayerNode3: ContentDeliveryLayerNode
-    let contentDeliveryLayerNode4: ContentDeliveryLayerNode
-    let contentDeliveryLayerNode5: ContentDeliveryLayerNode
-    const websocketPortRange = { min: 12222, max: 12225 } 
-
-    beforeEach(async () => {
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, websocketServerEnableTls: false })
-        await epDhtNode.start()
-        dhtNode1 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor], websocketServerEnableTls: false })
-        dhtNode2 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor], websocketServerEnableTls: false })
-        dhtNode3 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor], websocketServerEnableTls: false })
-        dhtNode4 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor], websocketServerEnableTls: false })
-        await dhtNode1.start()
-        await dhtNode2.start()
-        await dhtNode3.start()
-        await dhtNode4.start()
-
-        contentDeliveryLayerNode1 = createContentDeliveryLayerNode(
-            {
-                streamPartId,
-                discoveryLayerNode: epDhtNode,
-                transport: epDhtNode.getTransport(),
-                connectionLocker: epDhtNode.getTransport() as ConnectionManager,
-                localPeerDescriptor: epPeerDescriptor,
-                isLocalNodeEntryPoint: () => false
-            }
-        )
-        contentDeliveryLayerNode2 = createContentDeliveryLayerNode({
-            streamPartId,
-            discoveryLayerNode: dhtNode1,
-            transport: dhtNode1.getTransport(),
-            connectionLocker: dhtNode1.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode1.getLocalPeerDescriptor(),
-            isLocalNodeEntryPoint: () => false
-        })
-        contentDeliveryLayerNode3 = createContentDeliveryLayerNode({
-            streamPartId,
-            discoveryLayerNode: dhtNode2,
-            transport: dhtNode2.getTransport(),
-            connectionLocker: dhtNode2.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode2.getLocalPeerDescriptor(),
-            isLocalNodeEntryPoint: () => false
-        })
-        contentDeliveryLayerNode4 = createContentDeliveryLayerNode({
-            streamPartId,
-            discoveryLayerNode: dhtNode3,
-            transport: dhtNode3.getTransport(),
-            connectionLocker: dhtNode3.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode3.getLocalPeerDescriptor(),
-            isLocalNodeEntryPoint: () => false
-        })
-        contentDeliveryLayerNode5 = createContentDeliveryLayerNode({
-            streamPartId,
-            discoveryLayerNode: dhtNode4,
-            transport: dhtNode4.getTransport(),
-            connectionLocker: dhtNode4.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode4.getLocalPeerDescriptor(),
-            isLocalNodeEntryPoint: () => false
-        })
-        await Promise.all([
-            contentDeliveryLayerNode1.start(),
-            contentDeliveryLayerNode2.start(),
-            contentDeliveryLayerNode3.start(),
-            contentDeliveryLayerNode4.start(),
-            contentDeliveryLayerNode5.start()
-        ])
-        await epDhtNode.joinDht([epPeerDescriptor])
-        await Promise.all([
-            dhtNode1.joinDht([epPeerDescriptor]),
-            dhtNode2.joinDht([epPeerDescriptor]),
-            dhtNode3.joinDht([epPeerDescriptor]),
-            dhtNode4.joinDht([epPeerDescriptor])
-        ])
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            epDhtNode.stop(),
-            dhtNode1.stop(),
-            dhtNode2.stop(),
-            dhtNode3.stop(),
-            dhtNode4.stop(),
-            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-            contentDeliveryLayerNode1.stop(),
-            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-            contentDeliveryLayerNode2.stop(),
-            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-            contentDeliveryLayerNode3.stop(),
-            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-            contentDeliveryLayerNode4.stop(),
-            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-            contentDeliveryLayerNode5.stop(),
-            (epDhtNode.getTransport() as ConnectionManager).stop(),
-            (dhtNode1.getTransport() as ConnectionManager).stop(),
-            (dhtNode2.getTransport() as ConnectionManager).stop(),
-            (dhtNode3.getTransport() as ConnectionManager).stop(),
-            (dhtNode4.getTransport() as ConnectionManager).stop()
-        ])
-    })
-
-    it('can fully connected topologies ', async () => {
-        await until(() => {
-            return contentDeliveryLayerNode1.getNeighbors().length >= 3
-                && contentDeliveryLayerNode2.getNeighbors().length >= 3
-                && contentDeliveryLayerNode3.getNeighbors().length >= 3
-                && contentDeliveryLayerNode4.getNeighbors().length >= 3
-                && contentDeliveryLayerNode5.getNeighbors().length >= 3
-        }, 10000)
-        expect(contentDeliveryLayerNode1.getNeighbors().length).toBeGreaterThanOrEqual(3)
-        expect(contentDeliveryLayerNode2.getNeighbors().length).toBeGreaterThanOrEqual(3)
-        expect(contentDeliveryLayerNode3.getNeighbors().length).toBeGreaterThanOrEqual(3)
-        expect(contentDeliveryLayerNode4.getNeighbors().length).toBeGreaterThanOrEqual(3)
-        expect(contentDeliveryLayerNode5.getNeighbors().length).toBeGreaterThanOrEqual(3)
-    })
-
-    it('can propagate messages', async () => {
-        let receivedMessageCount = 0
-        contentDeliveryLayerNode2.on('message', () => receivedMessageCount += 1)
-        contentDeliveryLayerNode3.on('message', () => receivedMessageCount += 1)
-        contentDeliveryLayerNode4.on('message', () => receivedMessageCount += 1)
-        contentDeliveryLayerNode5.on('message', () => receivedMessageCount += 1)
-
-        await until(() => {
-            return contentDeliveryLayerNode1.getNeighbors().length >= 3
-                && contentDeliveryLayerNode2.getNeighbors().length >= 3
-                && contentDeliveryLayerNode3.getNeighbors().length >= 3
-                && contentDeliveryLayerNode4.getNeighbors().length >= 3
-                && contentDeliveryLayerNode5.getNeighbors().length >= 3
-        }, 10000)
-
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            streamPartId,
-            randomUserId()
-        )
-        contentDeliveryLayerNode1.broadcast(msg)
-        await until(() => receivedMessageCount >= 4)
-    })
-})

package/test/end-to-end/external-network-rpc.test.ts

@@ -1,67 +0,0 @@
-import { NetworkNode } from '../../src/NetworkNode'
-import { NetworkStack } from '../../src/NetworkStack'
-import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { HandshakeRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('ExternalNetworkRpc', () => {
-
-    let clientNode: NetworkNode
-    let serverNode: NetworkNode
-
-    const serverPeerDescriptor = createMockPeerDescriptor({
-        websocket: {
-            host: '127.0.0.1',
-            port: 15499,
-            tls: false
-        }
-    })
-
-    const clientPeerDescriptor = createMockPeerDescriptor()
-
-    beforeEach(async () => {
-        const clientStack = new NetworkStack({
-            layer0: {
-                entryPoints: [serverPeerDescriptor],
-                peerDescriptor: clientPeerDescriptor,
-                websocketServerEnableTls: false
-            }
-        })
-        const serverStack = new NetworkStack({
-            layer0: {
-                entryPoints: [serverPeerDescriptor],
-                peerDescriptor: serverPeerDescriptor,
-                websocketServerEnableTls: false
-            }
-        })
-        clientNode = new NetworkNode(clientStack)
-        serverNode = new NetworkNode(serverStack)
-
-        await serverNode.start()
-        await clientNode.start()
-
-    })
-
-    afterEach(() => {
-        serverNode.stop()
-        clientNode.stop()
-    })
-
-    it('can make queries', async () => {
-        const requestId = 'TEST'
-        serverNode.registerExternalNetworkRpcMethod(
-            StreamPartHandshakeRequest,
-            StreamPartHandshakeResponse,
-            'handshake',
-            async () => StreamPartHandshakeResponse.create({ requestId })
-        )
-        const client = clientNode.createExternalRpcClient(HandshakeRpcClient)
-        const response = await client.handshake(StreamPartHandshakeRequest.create(), {
-            sourceDescriptor: clientPeerDescriptor,
-            targetDescriptor: serverPeerDescriptor
-        })
-        expect(response.requestId).toEqual(requestId)
-
-    })
-
-})

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

@@ -1,124 +0,0 @@
-import { randomUserId } from '@streamr/test-utils'
-import { StreamPartIDUtils, hexToBinary, toUserIdRaw, utf8ToBinary, until } from '@streamr/utils'
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { ContentType, EncryptionType, SignatureType, StreamMessage } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
-
-describe('inspect', () => {
-
-    const publisherDescriptor = createMockPeerDescriptor({
-        websocket: {
-            host: '127.0.0.1',
-            port: 15478,
-            tls: false
-        }
-    })
-
-    const inspectedDescriptor = createMockPeerDescriptor({
-        websocket: {
-            host: '127.0.0.1',
-            port: 15479,
-            tls: false
-        }
-    })
-
-    const inspectorDescriptor = createMockPeerDescriptor({
-        websocket: {
-            host: '127.0.0.1',
-            port: 15480,
-            tls: false
-        }
-    })
-
-    let publisherNode: NetworkNode
-
-    let inspectedNode: NetworkNode
-
-    let inspectorNode: NetworkNode
-
-    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'),
-    }
-    
-    beforeEach(async () => {
-        publisherNode = createNetworkNode({
-            layer0: {
-                entryPoints: [publisherDescriptor],
-                peerDescriptor: publisherDescriptor,
-                websocketServerEnableTls: false
-            }
-        })
-
-        inspectedNode = createNetworkNode({
-            layer0: {
-                entryPoints: [publisherDescriptor],
-                peerDescriptor: inspectedDescriptor,
-                websocketServerEnableTls: false
-            }
-        })
-
-        inspectorNode = createNetworkNode({
-            layer0: {
-                entryPoints: [publisherDescriptor],
-                peerDescriptor: inspectorDescriptor,
-                websocketServerEnableTls: false
-            }
-        })
-
-        await publisherNode.start()
-        await inspectedNode.start()
-        await inspectorNode.start()
-
-        publisherNode.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        inspectedNode.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        inspectorNode.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-
-        await until(() => 
-            publisherNode.stack.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length === 2 
-            && inspectedNode.stack.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length === 2 
-            && inspectorNode.stack.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length === 2
-        )
-    }, 30000)
-
-    afterEach(async () => {
-        await Promise.all([
-            publisherNode.stop(),
-            inspectedNode.stop(),
-            inspectorNode.stop()
-        ])
-    })
-
-    it('should inspect succesfully', async () => {
-        setTimeout(async () => {
-            await publisherNode.broadcast(message)
-        }, 250)
-        const success = await inspectorNode.inspect(inspectedDescriptor, STREAM_PART_ID)
-        expect(success).toBe(true)
-    })
-
-})

package/test/end-to-end/proxy-and-full-node.test.ts

@@ -1,143 +0,0 @@
-import { randomUserId } from '@streamr/test-utils'
-import { StreamPartID, StreamPartIDUtils, hexToBinary, toUserIdRaw, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-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 createMessage = (streamPartId: StreamPartID): StreamMessage => {
-    return {
-        messageId: {
-            streamId: StreamPartIDUtils.getStreamID(streamPartId),
-            streamPartition: StreamPartIDUtils.getStreamPartition(streamPartId),
-            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 and full node', () => {
-
-    const proxyNodeDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 23135, tls: false }
-    })
-    const proxiedNodeDescriptor = createMockPeerDescriptor()
-    const proxiedStreamPart = StreamPartIDUtils.parse('proxy-stream#0')
-    const regularStreamPart1 = StreamPartIDUtils.parse('regular-stream1#0')
-    const regularStreamPart2 = StreamPartIDUtils.parse('regular-stream2#0')
-    const regularStreamPart3 = StreamPartIDUtils.parse('regular-stream3#0')
-    const regularStreamPart4 = StreamPartIDUtils.parse('regular-stream4#0')
-    let proxyNode: NetworkNode
-    let proxiedNode: NetworkNode
-
-    beforeEach(async () => {
-        proxyNode = createNetworkNode({
-            layer0: {
-                entryPoints: [proxyNodeDescriptor],
-                peerDescriptor: proxyNodeDescriptor,
-                websocketServerEnableTls: false
-            },
-            networkNode: {
-                acceptProxyConnections: true
-            }
-        })
-        await proxyNode.start()
-        proxyNode.stack.getContentDeliveryManager().joinStreamPart(proxiedStreamPart)
-        proxyNode.stack.getContentDeliveryManager().joinStreamPart(regularStreamPart1)
-        proxyNode.stack.getContentDeliveryManager().joinStreamPart(regularStreamPart2)
-        proxyNode.stack.getContentDeliveryManager().joinStreamPart(regularStreamPart3)
-        proxyNode.stack.getContentDeliveryManager().joinStreamPart(regularStreamPart4)
-
-        proxiedNode = createNetworkNode({
-            layer0: {
-                entryPoints: [proxyNodeDescriptor],
-                peerDescriptor: proxiedNodeDescriptor,
-            }
-        })
-        await proxiedNode.start(false)
-    })
-
-    afterEach(async () => {
-        await proxyNode.stop()
-        await proxiedNode.stop()
-    })
-
-    it('proxied node can act as full node on another stream part', async () => {
-        await proxiedNode.setProxies(proxiedStreamPart, [proxyNodeDescriptor], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 1)
-        expect(proxiedNode.stack.getControlLayerNode().hasJoined()).toBe(false)
-
-        await Promise.all([
-            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage'),
-            proxiedNode.broadcast(createMessage(regularStreamPart1))
-        ])
-
-        expect(proxiedNode.stack.getControlLayerNode().hasJoined()).toBe(true)
-
-        await Promise.all([
-            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage'),
-            proxiedNode.broadcast(createMessage(proxiedStreamPart))
-        ])
-
-        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(proxiedStreamPart)!.proxied).toBe(true)
-        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(regularStreamPart1)!.proxied).toBe(false)
-    })
-
-    it('proxied node can act as full node on multiple stream parts', async () => {
-        await proxiedNode.setProxies(proxiedStreamPart, [proxyNodeDescriptor], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 1)
-        expect(proxiedNode.stack.getControlLayerNode().hasJoined()).toBe(false)
-
-        await Promise.all([
-            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
-                (streamMessage: StreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart1)),
-            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
-                (streamMessage: StreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart2)),
-            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
-                (streamMessage: StreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart3)),
-            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
-                (streamMessage: StreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart4)),
-            proxiedNode.broadcast(createMessage(regularStreamPart1)),
-            proxiedNode.broadcast(createMessage(regularStreamPart2)),
-            proxiedNode.broadcast(createMessage(regularStreamPart3)),
-            proxiedNode.broadcast(createMessage(regularStreamPart4))
-        ])
-
-        expect(proxiedNode.stack.getControlLayerNode().hasJoined()).toBe(true)
-
-        await Promise.all([
-            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage'),
-            proxiedNode.broadcast(createMessage(proxiedStreamPart))
-        ])
-
-        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(proxiedStreamPart)!.proxied).toBe(true)
-        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(regularStreamPart1)!.proxied).toBe(false)
-        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(regularStreamPart2)!.proxied).toBe(false)
-        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(regularStreamPart3)!.proxied).toBe(false)
-        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(regularStreamPart4)!.proxied).toBe(false)
-    })
-
-})