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

package/test/integration/Inspect.test.ts

@@ -1,89 +0,0 @@
-import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils } 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('inspect', () => {
-
-    let simulator: Simulator
-
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-    let sequenceNumber: number
-
-    const publisherDescriptor = createMockPeerDescriptor()
-    const inspectorPeerDescriptor = createMockPeerDescriptor()
-
-    const inspectedNodeCount = 12
-
-    let publisherNode: NetworkStack
-    let inspectorNode: NetworkStack
-    let inspectedNodes: NetworkStack[]
-
-    let publishInterval: NodeJS.Timeout
-
-    const initiateNode = async (peerDescriptor: PeerDescriptor, simulator: Simulator): Promise<NetworkStack> => {
-        const transport = new SimulatorTransport(peerDescriptor, simulator)
-        await transport.start()
-        const node = new NetworkStack({
-            layer0: {
-                entryPoints: [publisherDescriptor],
-                peerDescriptor,
-                transport,
-                connectionsView: transport
-            }
-        })
-        await node.start()
-        return node
-    }
-
-    beforeEach(async () => {
-        simulator = new Simulator(LatencyType.REAL)
-
-        publisherNode = await initiateNode(publisherDescriptor, simulator)
-        inspectorNode = await initiateNode(inspectorPeerDescriptor, simulator)
-
-        inspectedNodes = []
-        await Promise.all(range(inspectedNodeCount).map(async () => {
-            const peerDescriptor = createMockPeerDescriptor()
-            const node = await initiateNode(peerDescriptor, simulator)
-            inspectedNodes.push(node)
-        }))
-        await Promise.all([
-            publisherNode.joinStreamPart(streamPartId, { minCount: 4, timeout: 15000 }),
-            inspectorNode.joinStreamPart(streamPartId, { minCount: 4, timeout: 15000 }),
-            ...inspectedNodes.map((node) => node.joinStreamPart(streamPartId, { minCount: 4, timeout: 15000 }))
-        ])
-        sequenceNumber = 0
-    }, 30000)
-
-    afterEach(async () => {
-        clearInterval(publishInterval)
-        await Promise.all([
-            publisherNode.stop(),
-            inspectorNode.stop(),
-            ...inspectedNodes.map((node) => node.stop())
-        ])
-    })
-
-    it('gets successful inspections from all suspects', async () => {
-        publishInterval = setInterval(async () => {
-            const msg = createStreamMessage(
-                JSON.stringify({ hello: 'WORLD' }),
-                streamPartId,
-                randomUserId(),
-                123123,
-                sequenceNumber
-            )
-            publisherNode.getContentDeliveryManager().broadcast(msg)
-            sequenceNumber += 1
-        }, 200)
-
-        for (const node of inspectedNodes) {
-            const result = await inspectorNode.getContentDeliveryManager().inspect(node.getControlLayerNode().getLocalPeerDescriptor(), streamPartId)
-            expect(result).toEqual(true)
-        }
-    }, 25000)
-
-})

package/test/integration/NeighborUpdateRpcRemote.test.ts

@@ -1,82 +0,0 @@
-import {
-    ListeningRpcCommunicator,
-    NodeType,
-    PeerDescriptor,
-    Simulator,
-    SimulatorTransport
-} from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { NeighborUpdateRpcRemote } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcRemote'
-import { NeighborUpdate } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import {
-    NeighborUpdateRpcClient,
-} from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-
-describe('NeighborUpdateRpcRemote', () => {
-    let mockServerRpc: ListeningRpcCommunicator
-    let clientRpc: ListeningRpcCommunicator
-    let rpcRemote: NeighborUpdateRpcRemote
-
-    const clientNode: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 1, 1]),
-        type: NodeType.NODEJS
-    }
-    const serverNode: PeerDescriptor = {
-        nodeId: new Uint8Array([2, 2, 2]),
-        type: NodeType.NODEJS
-    }
-
-    let simulator: Simulator
-    let mockConnectionManager1: SimulatorTransport
-    let mockConnectionManager2: SimulatorTransport
-
-    beforeEach(async () => {
-        simulator = new Simulator()
-        mockConnectionManager1 = new SimulatorTransport(serverNode, simulator)
-        await mockConnectionManager1.start()
-        mockConnectionManager2 = new SimulatorTransport(clientNode, simulator)
-        await mockConnectionManager2.start()
-
-        mockServerRpc = new ListeningRpcCommunicator('test', mockConnectionManager1)
-        clientRpc = new ListeningRpcCommunicator('test', mockConnectionManager2)
-
-        mockServerRpc.registerRpcMethod(
-            NeighborUpdate,
-            NeighborUpdate,
-            'neighborUpdate',
-            async (): Promise<NeighborUpdate> => {
-                const node: PeerDescriptor = {
-                    nodeId: new Uint8Array([4, 2, 4]),
-                    type: NodeType.NODEJS
-                }
-                const update: NeighborUpdate = {
-                    streamPartId: StreamPartIDUtils.parse('stream#0'),
-                    neighborDescriptors: [
-                        node
-                    ],
-                    removeMe: false
-                }
-                return update
-            }
-        )
-        rpcRemote = new NeighborUpdateRpcRemote(
-            clientNode,
-            serverNode,
-            clientRpc,
-            NeighborUpdateRpcClient
-        )
-    })
-
-    afterEach(async () => {
-        clientRpc.stop()
-        mockServerRpc.stop()
-        await mockConnectionManager1.stop()
-        await mockConnectionManager2.stop()
-        simulator.stop()
-    })
-
-    it('updateNeighbors', async () => {
-        const res = await rpcRemote.updateNeighbors(StreamPartIDUtils.parse('test#0'), [])
-        expect(res.peerDescriptors.length).toEqual(1)
-    })
-})

package/test/integration/NetworkNode.test.ts

@@ -1,115 +0,0 @@
-import { PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-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('test#0')
-
-describe('NetworkNode', () => {
-
-    let transport1: SimulatorTransport
-    let transport2: SimulatorTransport
-
-    let node1: NetworkNode
-    let node2: NetworkNode
-
-    const pd1: PeerDescriptor = createMockPeerDescriptor()
-
-    const pd2: PeerDescriptor = createMockPeerDescriptor()
-
-    beforeEach(async () => {
-        const simulator = new Simulator()
-        transport1 = new SimulatorTransport(pd1, simulator)
-        await transport1.start()
-        transport2 = new SimulatorTransport(pd2, simulator)
-        await transport2.start()
-
-        node1 = createNetworkNode({
-            layer0: {
-                entryPoints: [pd1],
-                peerDescriptor: pd1,
-                transport: transport1,
-                connectionsView: transport1
-            }
-        })
-        node2 = createNetworkNode({
-            layer0: {
-                entryPoints: [pd1],
-                peerDescriptor: pd2,
-                transport: transport2,
-                connectionsView: transport2
-            }
-        })
-
-        await node1.start()
-        node1.setStreamPartEntryPoints(STREAM_PART_ID, [pd1])
-        await node2.start()
-        node2.setStreamPartEntryPoints(STREAM_PART_ID, [pd1])
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            node1.stop(),
-            node2.stop()
-        ])
-    })
-
-    it('wait for join + broadcast and subscribe', async () => {
-        const streamMessage: 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'),
-        }
-
-        let msgCount = 0
-        await node1.join(STREAM_PART_ID)
-        node1.addMessageListener((msg) => {
-            expect(msg.messageId!.timestamp).toEqual(666)
-            expect(msg.messageId!.sequenceNumber).toEqual(0)
-            msgCount += 1
-        })
-        await node2.broadcast(streamMessage)
-        await until(() => msgCount === 1)
-    })
-
-    it('fetchNodeInfo', async () => {
-        await node1.join(STREAM_PART_ID)
-        await node2.join(STREAM_PART_ID)
-        const result1 = await node1.fetchNodeInfo(pd2)
-        const result2 = await node2.fetchNodeInfo(pd1)
-        const result3 = await node1.fetchNodeInfo(node1.getPeerDescriptor())
-        expect(result1.streamPartitions.length).toEqual(1)
-        expect(result2.streamPartitions.length).toEqual(1)
-        expect(result3.streamPartitions.length).toEqual(1)
-        expect(result1.controlLayer.connections.length).toEqual(1)
-        expect(result2.controlLayer.connections.length).toEqual(1)
-        expect(result3.controlLayer.connections.length).toEqual(1)
-        expect(result1.controlLayer.neighbors.length).toEqual(1)
-        expect(result2.controlLayer.neighbors.length).toEqual(1)
-        expect(result3.controlLayer.neighbors.length).toEqual(1)
-    })
-
-})

package/test/integration/NetworkRpc.test.ts

@@ -1,52 +0,0 @@
-import { DhtCallContext } from '@streamr/dht'
-import {
-    ProtoRpcClient,
-    RpcCommunicator,
-    toProtoRpcClient
-} from '@streamr/proto-rpc'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { Empty } from '../../generated/google/protobuf/empty'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { StreamMessage } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-import { createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('Network RPC', () => {
-    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
-    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
-    let client: ProtoRpcClient<ContentDeliveryRpcClient>
-    let recvCounter = 0
-
-    beforeEach(() => {
-        rpcCommunicator1 = new RpcCommunicator()
-        rpcCommunicator2 = new RpcCommunicator()
-        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
-        })
-        client = toProtoRpcClient(new ContentDeliveryRpcClient(rpcCommunicator1.getRpcClientTransport()))
-        rpcCommunicator2.registerRpcNotification(
-            StreamMessage,
-            'sendStreamMessage',
-            async (): Promise<Empty> => {
-                recvCounter += 1
-                return {}
-            }
-        )
-    })
-
-    afterEach(() => {
-        rpcCommunicator1.stop()
-        rpcCommunicator2.stop()
-    })
-
-    it('sends Data', async () => {
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            StreamPartIDUtils.parse('testStream#0'),
-            randomUserId()
-        )
-        await client.sendStreamMessage(msg)
-        await until(() => recvCounter === 1)
-    })
-})

package/test/integration/NetworkStack.test.ts

@@ -1,72 +0,0 @@
-import {
-    StreamPartIDUtils,
-    until
-} from '@streamr/utils'
-import { NetworkStack } from '../../src/NetworkStack'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
-
-describe('NetworkStack', () => {
-
-    let stack1: NetworkStack
-    let stack2: NetworkStack
-
-    const epDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 32222, tls: false }
-    })
-
-    beforeEach(async () => {
-        stack1 = new NetworkStack({
-            layer0: {
-                peerDescriptor: epDescriptor,
-                entryPoints: [epDescriptor],
-                websocketServerEnableTls: false
-            }
-        })
-        stack2 = new NetworkStack({
-            layer0: {
-                websocketPortRange: { min: 32223, max: 32223 },
-                entryPoints: [epDescriptor],
-                websocketServerEnableTls: false
-            }
-        })
-
-        await stack1.start()
-        stack1.getContentDeliveryManager().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
-        await stack2.start()
-        stack2.getContentDeliveryManager().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            stack1.stop(),
-            stack2.stop()
-        ])
-    })
-
-    it('Can use NetworkNode pub/sub via NetworkStack', async () => {
-        let receivedMessages = 0
-        stack1.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        stack1.getContentDeliveryManager().on('newMessage', () => {
-            receivedMessages += 1
-        })
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            STREAM_PART_ID,
-            randomUserId()
-        )
-        stack2.getContentDeliveryManager().broadcast(msg)
-        await until(() => receivedMessages === 1)
-    })
-
-    it('join and wait for neighbors', async () => {
-        await Promise.all([
-            stack1.joinStreamPart(STREAM_PART_ID, { minCount: 1, timeout: 5000 }),
-            stack2.joinStreamPart(STREAM_PART_ID, { minCount: 1, timeout: 5000 }),
-        ])
-        expect(stack1.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length).toBe(1)
-        expect(stack2.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length).toBe(1)
-    })
-})

package/test/integration/NodeInfoRpc.test.ts

@@ -1,109 +0,0 @@
-import { ListeningRpcCommunicator, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { NetworkStack } from '../../src/NetworkStack'
-import { NodeInfoClient } from '../../src/logic/node-info/NodeInfoClient'
-import { NODE_INFO_RPC_SERVICE_ID } from '../../src/logic/node-info/NodeInfoRpcLocal'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-// TODO add Jest utility so that the normalization is not needed (NET-1254)
-const normalizePeerDescriptor = (peerDescriptor: PeerDescriptor) => {
-    return {
-        ...peerDescriptor,
-        nodeId: new Uint8Array(peerDescriptor.nodeId)
-    }
-}
-
-describe('NetworkStack NodeInfoRpc', () => {
-
-    let requesteStack: NetworkStack
-    let otherStack: NetworkStack
-    let nodeInfoClient: NodeInfoClient
-    let requesteeTransport1: SimulatorTransport
-    let otherTransport: SimulatorTransport
-    let requestorTransport: SimulatorTransport
-
-    let simulator: Simulator
-
-    const requesteePeerDescriptor = createMockPeerDescriptor()
-    const otherPeerDescriptor = createMockPeerDescriptor()
-    const requestorPeerDescriptor = createMockPeerDescriptor()
-
-    beforeEach(async () => {
-        simulator = new Simulator()
-        requesteeTransport1 = new SimulatorTransport(requesteePeerDescriptor, simulator)
-        otherTransport = new SimulatorTransport(otherPeerDescriptor, simulator)
-        requestorTransport = new SimulatorTransport(requestorPeerDescriptor, simulator)
-        await requesteeTransport1.start()
-        await otherTransport.start()
-        await requestorTransport.start()
-        requesteStack = new NetworkStack({
-            layer0: {
-                transport: requesteeTransport1,
-                connectionsView: requesteeTransport1,
-                peerDescriptor: requesteePeerDescriptor,
-                entryPoints: [requesteePeerDescriptor]
-            }
-        })
-        otherStack = new NetworkStack({
-            layer0: {
-                transport: otherTransport,
-                connectionsView: otherTransport,
-                peerDescriptor: otherPeerDescriptor,
-                entryPoints: [requesteePeerDescriptor]
-            }
-        })
-        await requesteStack.start()
-        await otherStack.start()
-        nodeInfoClient = new NodeInfoClient(requestorPeerDescriptor, new ListeningRpcCommunicator(NODE_INFO_RPC_SERVICE_ID, requestorTransport))
-    })
-
-    afterEach(async () => {
-        await requesteStack.stop()
-        await otherStack.stop()
-        await requesteeTransport1.stop()
-        await otherTransport.stop()
-        await requestorTransport.stop()
-    })
-
-    it('happy path', async () => {
-        const streamPartId1 = StreamPartIDUtils.parse('stream1#0')
-        const streamPartId2 = StreamPartIDUtils.parse('stream2#0')
-        requesteStack.getContentDeliveryManager().joinStreamPart(streamPartId1)
-        otherStack.getContentDeliveryManager().joinStreamPart(streamPartId1)
-        requesteStack.getContentDeliveryManager().joinStreamPart(streamPartId2)
-        otherStack.getContentDeliveryManager().joinStreamPart(streamPartId2)
-        await until(() => 
-            requesteStack.getContentDeliveryManager().getNeighbors(streamPartId1).length === 1 
-            && otherStack.getContentDeliveryManager().getNeighbors(streamPartId1).length === 1
-            && requesteStack.getContentDeliveryManager().getNeighbors(streamPartId2).length === 1
-            && otherStack.getContentDeliveryManager().getNeighbors(streamPartId2).length === 1
-        )
-        const result = await nodeInfoClient.getInfo(requesteePeerDescriptor)
-        expect(result).toMatchObject({
-            peerDescriptor: normalizePeerDescriptor(requesteePeerDescriptor),
-            controlLayer: {
-                neighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
-                connections: [normalizePeerDescriptor(otherPeerDescriptor), normalizePeerDescriptor(requestorPeerDescriptor)]
-            },
-            streamPartitions: [
-                {
-                    id: streamPartId1,
-                    controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
-                    contentDeliveryLayerNeighbors: [{
-                        peerDescriptor: normalizePeerDescriptor(otherPeerDescriptor)
-                    }]
-                },
-                {
-                    id: streamPartId2,
-                    controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
-                    contentDeliveryLayerNeighbors: [{
-                        peerDescriptor: normalizePeerDescriptor(otherPeerDescriptor)
-                    }]
-                }
-            ],
-            applicationVersion: expect.any(String)
-        })
-        expect(result.streamPartitions.length).toEqual(2)
-    })
-
-})

package/test/integration/Propagation.test.ts

@@ -1,76 +0,0 @@
-import { Simulator } 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 { createMockContentDeliveryLayerNodeAndDhtNode, createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('Propagation', () => {
-    const entryPointDescriptor = createMockPeerDescriptor()
-    let discoveryLayerNodes: DiscoveryLayerNode[]
-    let contentDeliveryLayerNodes: ContentDeliveryLayerNode[]
-    const STREAM_PART_ID = StreamPartIDUtils.parse('testingtesting#0')
-    let totalReceived: number
-    const NUM_OF_NODES = 256
-
-    beforeEach(async () => {
-        const simulator = new Simulator()
-        totalReceived = 0
-        discoveryLayerNodes = []
-        contentDeliveryLayerNodes = []
-        const [entryPoint, node1] = await createMockContentDeliveryLayerNodeAndDhtNode(
-            entryPointDescriptor,
-            entryPointDescriptor,
-            STREAM_PART_ID,
-            simulator
-        )
-        await entryPoint.start()
-        await entryPoint.joinDht([entryPointDescriptor])
-        await node1.start()
-        node1.on('message', () => {totalReceived += 1})
-        discoveryLayerNodes.push(entryPoint)
-        contentDeliveryLayerNodes.push(node1)
-
-        await Promise.all(range(NUM_OF_NODES).map(async (_i) => {
-            const descriptor = createMockPeerDescriptor()
-            const [layer1, contentDeliveryLayerNode] = await createMockContentDeliveryLayerNodeAndDhtNode(
-                descriptor,
-                entryPointDescriptor,
-                STREAM_PART_ID,
-                simulator
-            )
-            await layer1.start()
-            await contentDeliveryLayerNode.start()
-            await layer1.joinDht([entryPointDescriptor]).then(() => {
-                contentDeliveryLayerNode.on('message', () => { totalReceived += 1 })
-                discoveryLayerNodes.push(layer1)
-                contentDeliveryLayerNodes.push(contentDeliveryLayerNode)
-            })
-        }))
-    }, 45000)
-
-    afterEach(async () => {
-        await Promise.all(contentDeliveryLayerNodes.map((node) => node.stop()))
-        await Promise.all(discoveryLayerNodes.map((node) => node.stop()))
-    })
-
-    it('All nodes receive messages', async () => {
-        await until(
-            () => contentDeliveryLayerNodes.every((node) => node.getNeighbors().length >= 3), 30000
-        )
-        await until(() => {
-            const avg = contentDeliveryLayerNodes.reduce((acc, curr) => {
-                return acc + curr.getNeighbors().length
-            }, 0) / contentDeliveryLayerNodes.length
-            return avg >= 4
-        }, 20000)
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            STREAM_PART_ID,
-            randomUserId()
-        )
-        contentDeliveryLayerNodes[0].broadcast(msg)
-        await until(() => totalReceived >= NUM_OF_NODES, 10000)
-    }, 45000)
-})

package/test/integration/joining-streams-on-offline-peers.test.ts

@@ -1,82 +0,0 @@
-import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { NetworkStack } from '../../src/NetworkStack'
-import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-import { Any } from '../../generated/google/protobuf/any'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
-
-describe('Joining stream parts on offline nodes', () => {
-
-    const entryPointPeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
-    const node1PeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
-    const node2PeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
-    const offlineDescriptor1: PeerDescriptor = createMockPeerDescriptor()
-    const offlineDescriptor2: PeerDescriptor = createMockPeerDescriptor()
-
-    let entryPoint: NetworkStack
-    let node1: NetworkStack
-    let node2: NetworkStack
-    let simulator: Simulator
-
-    beforeEach(async () => {
-        simulator = new Simulator(LatencyType.REAL)
-        const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
-        entryPoint = new NetworkStack({
-            layer0: {
-                transport: entryPointTransport,
-                connectionsView: entryPointTransport,
-                peerDescriptor: entryPointPeerDescriptor,
-                entryPoints: [entryPointPeerDescriptor]
-            }
-        })
-        const node1Transport = new SimulatorTransport(node1PeerDescriptor, simulator)
-        node1 = new NetworkStack({
-            layer0: {
-                transport: node1Transport,
-                connectionsView: node1Transport,
-                peerDescriptor: node1PeerDescriptor,
-                entryPoints: [entryPointPeerDescriptor]
-            }
-        })
-        const node2Transport = new SimulatorTransport(node2PeerDescriptor, simulator)
-        node2 = new NetworkStack({
-            layer0: {
-                transport: node2Transport,
-                connectionsView: node2Transport,
-                peerDescriptor: node2PeerDescriptor,
-                entryPoints: [entryPointPeerDescriptor]
-            }
-        })
-        await entryPointTransport.start()
-        await node1Transport.start()
-        await node2Transport.start()
-        await entryPoint.start()
-        await node1.start()
-        await node2.start()
-    })
-
-    afterEach(async () => {
-        await entryPoint.stop()
-        await node1.stop()
-        await node2.stop()
-        simulator.stop()
-    })
-
-    it('should recover if discovered nodes are offline', async () => {
-        let messageReceived = false
-
-        // store offline peer descriptors to DHT
-        await entryPoint.getControlLayerNode().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor1, PeerDescriptor))
-        await entryPoint.getControlLayerNode().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor2, PeerDescriptor))
-        
-        node1.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        node1.getContentDeliveryManager().on('newMessage', () => { messageReceived = true })
-        const msg = createStreamMessage(JSON.stringify({ hello: 'WORLD' }), STREAM_PART_ID, randomUserId())
-        node2.getContentDeliveryManager().broadcast(msg)
-        await until(() => messageReceived, 40000)
-    }, 60000)
-
-})