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

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, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import {
-    ContentType,
-    EncryptionType,
-    ProxyDirection,
-    SignatureType,
-    StreamMessage
-} from '../../src/proto/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: hexToBinary(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)
-    })
-
-})

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

@@ -1,228 +0,0 @@
-import { DhtAddress } from '@streamr/dht'
-import { randomUserId } from '@streamr/test-utils'
-import { StreamPartIDUtils, hexToBinary, utf8ToBinary, wait, waitForCondition, 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 '../../src/proto/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: hexToBinary(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.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor1])
-        proxyNode1.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        proxyNode2 = createNetworkNode({
-            layer0: {
-                entryPoints: [proxyNodeDescriptor1],
-                peerDescriptor: proxyNodeDescriptor2,
-                websocketServerEnableTls: false
-            },
-            networkNode: {
-                acceptProxyConnections: true
-            }
-        })
-        await proxyNode2.start()
-        proxyNode2.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor1])
-        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 waitForCondition(() => 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 waitForCondition(() => 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 waitForCondition(() => 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 waitForCondition(() => hasConnectionFromProxy(proxyNode1) === false)
-        await waitForCondition(() => 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 waitForCondition(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE))
-        expect(hasConnectionFromProxy(proxyNode1)).toBe(false)
-        proxyNode1.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        await waitForCondition(() => 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,
-    waitForEvent3
-} from '@streamr/utils'
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { ProxyDirection, SignatureType, StreamMessage } from '../../src/proto/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.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor])
-        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: hexToBinary(subscriberUserId),
-                messageChainId: '0'
-            },
-            body: {
-                oneofKind: 'groupKeyRequest' as const,
-                groupKeyRequest: {
-                    requestId: 'requestId',
-                    recipientId: hexToBinary(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: hexToBinary(publisherUserId),
-                messageChainId: '0'
-            },
-            body: {
-                oneofKind: 'groupKeyResponse' as const,
-                groupKeyResponse: {
-                    requestId: 'requestId',
-                    recipientId: hexToBinary(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,85 +0,0 @@
-import { toNodeId, getRandomRegion } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition } 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().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
-        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().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
-            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) =>
-            waitForCondition(() => {
-                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 waitForCondition(() => receivedMessageCount === NUM_OF_NODES)
-    }, 120000)
-
-})

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

@@ -1,84 +0,0 @@
-import { toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition } 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 = 20
-    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().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
-        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().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
-            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) =>
-            waitForCondition(() => {
-                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 waitForCondition(() => receivedMessageCount === NUM_OF_NODES)
-    }, 220000)
-
-})