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

package/test/integration/NodeInfoRpc.test.ts

@@ -1,109 +0,0 @@
-import { ListeningRpcCommunicator, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition } 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 waitForCondition(() => 
-            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)
-                    }]
-                }
-            ],
-            version: 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, waitForCondition } 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 waitForCondition(
-            () => contentDeliveryLayerNodes.every((node) => node.getNeighbors().length >= 3), 30000
-        )
-        await waitForCondition(() => {
-            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 waitForCondition(() => 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, waitForCondition } from '@streamr/utils'
-import { NetworkStack } from '../../src/NetworkStack'
-import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-import { Any } from '../../src/proto/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 waitForCondition(() => messageReceived, 40000)
-    }, 60000)
-
-})

package/test/integration/stream-without-default-entrypoints.test.ts

@@ -1,128 +0,0 @@
-import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
-import { range } from 'lodash'
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-import { ContentType, EncryptionType, SignatureType, StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
-
-describe('stream without default entrypoints', () => {
-
-    let entrypoint: NetworkNode
-    let nodes: NetworkNode[]
-    let receivedMessageCount: number
-    const entryPointPeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
-
-    const streamMessage: 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'),
-    }
-
-    beforeEach(async () => {
-        const simulator = new Simulator(LatencyType.REAL)
-        nodes = []
-        receivedMessageCount = 0
-        const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
-        await entryPointTransport.start()
-        entrypoint = createNetworkNode({
-            layer0: {
-                transport: entryPointTransport,
-                connectionsView: entryPointTransport,
-                peerDescriptor: entryPointPeerDescriptor,
-                entryPoints: [entryPointPeerDescriptor]
-            }
-        })
-        await entrypoint.start()
-        await Promise.all(range(20).map(async () => {
-            const peerDescriptor = createMockPeerDescriptor()
-            const transport = new SimulatorTransport(peerDescriptor, simulator)
-            await transport.start()
-            const node = createNetworkNode({
-                layer0: {
-                    peerDescriptor,
-                    transport,
-                    connectionsView: transport,
-                    entryPoints: [entryPointPeerDescriptor]
-                }
-            })
-            nodes.push(node)
-            await node.start()
-        }))
-    })
-
-    afterEach(async () => {
-        await entrypoint.stop()
-        await Promise.all(nodes.map((node) => node.stop()))
-    })
-
-    it('can join stream without configured entrypoints one by one', async () => {
-        await nodes[0].join(STREAM_PART_ID)
-        nodes[0].addMessageListener((_msg) => {
-            receivedMessageCount += 1
-        })
-        await Promise.all([
-            waitForCondition(() => receivedMessageCount === 1, 10000),
-            nodes[1].broadcast(streamMessage)
-        ])
-    })
-
-    it('can join without configured entrypoints simultaneously', async () => {
-        nodes[0].addMessageListener((_msg) => {
-            receivedMessageCount += 1
-        })
-        await Promise.all([
-            waitForCondition(() => receivedMessageCount === 1, 15000),
-            nodes[0].join(STREAM_PART_ID),
-            nodes[1].broadcast(streamMessage),
-        ])
-    })
-
-    it('multiple nodes can join without configured entrypoints simultaneously', async () => {
-        const subscriberCount = 8
-        await Promise.all(range(subscriberCount).map(async (i) => {
-            await nodes[i].join(STREAM_PART_ID, { minCount: 4, timeout: 15000 })
-            nodes[i].addMessageListener(() => {
-                receivedMessageCount += 1
-            })
-        }))
-        const nonjoinedNode = nodes[subscriberCount]
-        await nonjoinedNode.broadcast(streamMessage)
-        await waitForCondition(() => receivedMessageCount === subscriberCount, 15000)
-    }, 45000)
-
-    it('nodes store themselves as entrypoints on streamPart if number of entrypoints is low', async () => {
-        for (let i = 0; i < 10; i++) {
-            await nodes[i].join(STREAM_PART_ID, { minCount: (i > 0) ? 1 : 0, timeout: 15000 })
-        }
-        await waitForCondition(async () => {
-            const entryPointData = await nodes[15].stack.getControlLayerNode().fetchDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
-            return entryPointData.length >= 7
-        }, 15000)
-        
-    }, 90000)
-})

package/test/integration/streamEntryPointReplacing.test.ts

@@ -1,97 +0,0 @@
-import { LatencyType, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
-import { range } from 'lodash'
-import { NetworkStack } from '../../src/NetworkStack'
-import { MAX_NODE_COUNT } from '../../src/logic/PeerDescriptorStoreManager'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('Stream Entry Points are replaced when known entry points leave streams', () => {
-    
-    let simulator: Simulator
-    let layer0EntryPoint: NetworkStack
-    const entryPointPeerDescriptor = createMockPeerDescriptor()
-    let initialNodesOnStream: NetworkStack[]
-    let laterNodesOnStream: NetworkStack[]
-    let newNodeInStream: NetworkStack
-
-    const NUM_OF_LATER_NODES = 16
-
-    const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
-
-    const startNode = async () => {
-        const peerDescriptor = createMockPeerDescriptor()
-        const transport = new SimulatorTransport(peerDescriptor, simulator)
-        await transport.start()
-        const node = new NetworkStack({
-            layer0: {
-                transport,
-                connectionsView: transport,
-                peerDescriptor,
-                entryPoints: [entryPointPeerDescriptor]
-            }
-        })
-        await node.start()
-        return node
-    }
-
-    beforeEach(async () => {
-        simulator = new Simulator(LatencyType.REAL)
-        const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
-        layer0EntryPoint = new NetworkStack({
-            layer0: {
-                transport: entryPointTransport,
-                connectionsView: entryPointTransport,
-                peerDescriptor: entryPointPeerDescriptor,
-                entryPoints: [entryPointPeerDescriptor]
-            }
-        })
-        await entryPointTransport.start()
-        await layer0EntryPoint.start()
-
-        initialNodesOnStream = await Promise.all(range(MAX_NODE_COUNT).map(async () => {
-            return await startNode()
-        }))
-
-        laterNodesOnStream = await Promise.all(range(NUM_OF_LATER_NODES).map(async () => {
-            return await startNode()
-        }))
-        newNodeInStream = await startNode()
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            layer0EntryPoint.stop(),
-            ...initialNodesOnStream.map((node) => node.stop()),
-            ...laterNodesOnStream.map((node) => node.stop()),
-            newNodeInStream.stop()
-        ])
-        simulator.stop()
-    })
-
-    // TODO: Investigate why 60 second timeouts are needed
-    it('stream entry points are replaced when nodes leave streams', async () => {
-        await Promise.all(initialNodesOnStream.map((node) => node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 60000 })))
-
-        let receivedMessages = 0
-        for (const node of laterNodesOnStream) {
-            await node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 60000 }) 
-            node.getContentDeliveryManager().on('newMessage', () => {
-                receivedMessages += 1
-            })
-        }
-
-        await Promise.all(initialNodesOnStream.map((node) => node.getContentDeliveryManager().leaveStreamPart(STREAM_PART_ID)))
-        await waitForCondition(() => 
-            laterNodesOnStream.every((node) => node.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length >= 4), 60000, 1000
-        )
-
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            STREAM_PART_ID,
-            randomUserId()
-        )
-        newNodeInStream.getContentDeliveryManager().broadcast(msg)
-        await waitForCondition(() => receivedMessages === NUM_OF_LATER_NODES, 30000)
-    }, 200000)
-})

package/test/types/global.d.ts

@@ -1,2 +0,0 @@
-// eslint-disable-next-line import/no-unresolved
-import '@streamr/test-utils/customMatcherTypes'

package/test/unit/ContentDeliveryLayerNode.test.ts

@@ -1,112 +0,0 @@
-import { toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
-import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
-import { NodeList } from '../../src/logic/NodeList'
-import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
-import { MockDiscoveryLayerNode } from '../utils/mock/MockDiscoveryLayerNode'
-import { MockHandshaker } from '../utils/mock/MockHandshaker'
-import { MockNeighborFinder } from '../utils/mock/MockNeighborFinder'
-import { MockNeighborUpdateManager } from '../utils/mock/MockNeighborUpdateManager'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockContentDeliveryRpcRemote, createMockPeerDescriptor, mockConnectionLocker } from '../utils/utils'
-
-describe('ContentDeliveryLayerNode', () => {
-
-    let contentDeliveryLayerNode: ContentDeliveryLayerNode
-    const peerDescriptor = createMockPeerDescriptor()
-
-    let neighbors: NodeList
-    let nearbyNodeView: NodeList
-    let randomNodeView: NodeList
-
-    let discoveryLayerNode: MockDiscoveryLayerNode
-
-    beforeEach(async () => {
-        const nodeId = toNodeId(peerDescriptor)
-
-        neighbors = new NodeList(nodeId, 10)
-        randomNodeView = new NodeList(nodeId, 10)
-        nearbyNodeView = new NodeList(nodeId, 10)
-        discoveryLayerNode = new MockDiscoveryLayerNode()
-
-        contentDeliveryLayerNode = createContentDeliveryLayerNode({
-            neighbors,
-            randomNodeView,
-            nearbyNodeView,
-            transport: new MockTransport(),
-            localPeerDescriptor: peerDescriptor,
-            discoveryLayerNode,
-            connectionLocker: mockConnectionLocker,
-            handshaker: new MockHandshaker() as any,
-            neighborUpdateManager: new MockNeighborUpdateManager() as any,
-            neighborFinder: new MockNeighborFinder() as any,
-            streamPartId: StreamPartIDUtils.parse('stream#0'),
-            isLocalNodeEntryPoint: () => false
-        })
-        await contentDeliveryLayerNode.start()
-    })
-
-    afterEach(() => {
-        contentDeliveryLayerNode.stop()
-    })
-
-    it('getNeighbors', () => {
-        const mockRemote = createMockContentDeliveryRpcRemote()
-        neighbors.add(mockRemote)
-        const result = contentDeliveryLayerNode.getNeighbors()
-        expect(toNodeId(result[0])).toEqual(toNodeId(mockRemote.getPeerDescriptor()))
-    })
-
-    it('getNearbyNodeView', () => {
-        const mockRemote = createMockContentDeliveryRpcRemote()
-        nearbyNodeView.add(mockRemote)
-        const ids = contentDeliveryLayerNode.getNearbyNodeView().getIds()
-        expect(ids[0]).toEqual(toNodeId(mockRemote.getPeerDescriptor()))
-    })
-
-    it('Adds Closest Nodes from layer1 nearbyContactAdded event to nearbyNodeView', async () => {
-        const peerDescriptor1 = createMockPeerDescriptor()
-        const peerDescriptor2 = createMockPeerDescriptor()
-        discoveryLayerNode.setClosestContacts([peerDescriptor1, peerDescriptor2])
-        discoveryLayerNode.emit('nearbyContactAdded', peerDescriptor1)
-        await waitForCondition(() => nearbyNodeView.size() === 2)
-        expect(nearbyNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
-    })
-
-    it('Adds Random Nodes from layer1 randomContactAdded event to randomNodeView', async () => {
-        const peerDescriptor1 = createMockPeerDescriptor()
-        const peerDescriptor2 = createMockPeerDescriptor()
-        discoveryLayerNode.setRandomContacts([peerDescriptor1, peerDescriptor2])
-        discoveryLayerNode.emit('randomContactAdded', peerDescriptor1)
-        await waitForCondition(() => randomNodeView.size() === 2)
-        expect(randomNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
-        expect(randomNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
-    })
-
-    it('Adds Nodes from layer1 neighbors to nearbyNodeView if its size is below nodeViewSize', async () => {
-        const peerDescriptor1 = createMockPeerDescriptor()
-        const peerDescriptor2 = createMockPeerDescriptor()
-        discoveryLayerNode.addNewRandomPeerToKBucket()
-        discoveryLayerNode.setClosestContacts([peerDescriptor1, peerDescriptor2])
-        discoveryLayerNode.emit('nearbyContactAdded', peerDescriptor1)
-        await waitForCondition(() => {
-            return nearbyNodeView.size() === 3
-        }, 20000)
-        expect(nearbyNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
-    }, 25000)
-
-    it('getInfo', () => {
-        const nodeWithRtt = createMockContentDeliveryRpcRemote()
-        neighbors.add(nodeWithRtt)
-        const nodeWithoutRtt = createMockContentDeliveryRpcRemote()
-        neighbors.add(nodeWithoutRtt)
-        nodeWithRtt.setRtt(100)
-        const info = contentDeliveryLayerNode.getInfos()
-        expect(info[0].rtt).toEqual(100)
-        expect(info[0].peerDescriptor).toEqual(nodeWithRtt.getPeerDescriptor())
-        expect(info[1].rtt).toBeUndefined()
-        expect(info[1].peerDescriptor).toEqual(nodeWithoutRtt.getPeerDescriptor())
-    })
-})