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

package/test/unit/HandshakeRpcLocal.test.ts

@@ -1,168 +0,0 @@
-import { DhtAddress, NodeType, toNodeId, toDhtAddressRaw } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { NodeList } from '../../src/logic/NodeList'
-import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
-import { InterleaveRequest, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { createMockContentDeliveryRpcRemote, createMockHandshakeRpcRemote, createMockPeerDescriptor } from '../utils/utils'
-
-const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
-
-describe('HandshakeRpcLocal', () => {
-
-    let rpcLocal: HandshakeRpcLocal
-
-    const localPeerDescriptor = createMockPeerDescriptor()
-
-    let neighbors: NodeList
-    let ongoingHandshakes: Set<DhtAddress>
-    let ongoingInterleaves: Set<DhtAddress>
-    let handshakeWithInterleaving: jest.Mock
-
-    beforeEach(() => {
-        neighbors = new NodeList(toNodeId(localPeerDescriptor), 10)
-        ongoingHandshakes = new Set()
-        ongoingInterleaves = new Set()
-        handshakeWithInterleaving = jest.fn()
-
-        rpcLocal = new HandshakeRpcLocal({
-            streamPartId: STREAM_PART_ID,
-            ongoingHandshakes,
-            ongoingInterleaves,
-            createRpcRemote: (_p) => createMockHandshakeRpcRemote(),
-            createContentDeliveryRpcRemote: (_p) => createMockContentDeliveryRpcRemote(),
-            handshakeWithInterleaving: async (_p, _t) => {
-                handshakeWithInterleaving()
-                return true
-            },
-            neighbors,
-            maxNeighborCount: 4
-        })
-    })
-
-    it('handshake', async () => {
-        const req = StreamPartHandshakeRequest.create({
-            streamPartId: STREAM_PART_ID,
-            requestId: 'requestId'
-        })
-        const res = await rpcLocal.handshake(req, {
-            incomingSourceDescriptor: createMockPeerDescriptor()
-        } as any)
-        expect(res.accepted).toEqual(true)
-        expect(res.interleaveTargetDescriptor).toBeUndefined()
-        expect(res.requestId).toEqual('requestId')
-    })
-
-    it('handshake interleave', async () => {
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        const req = StreamPartHandshakeRequest.create({
-            streamPartId: STREAM_PART_ID,
-            requestId: 'requestId'
-        })
-        const res = await rpcLocal.handshake(req, {
-            incomingSourceDescriptor: createMockPeerDescriptor()
-        } as any)
-        expect(res.accepted).toEqual(true)
-        expect(res.interleaveTargetDescriptor).toBeDefined()
-    })
-
-    it('unaccepted handshake', async () => {
-        ongoingHandshakes.add('0x2222' as DhtAddress)
-        ongoingHandshakes.add('0x3333' as DhtAddress)
-        ongoingHandshakes.add('0x4444' as DhtAddress)
-        ongoingHandshakes.add('0x5555' as DhtAddress)
-        const req = StreamPartHandshakeRequest.create({
-            streamPartId: STREAM_PART_ID,
-            requestId: 'requestId'
-        })
-        const res = await rpcLocal.handshake(req, {
-            incomingSourceDescriptor: createMockPeerDescriptor()
-        } as any)
-        expect(res.accepted).toEqual(false)
-    })
-
-    it('handshakeWithInterleaving success', async () => {
-        const req: InterleaveRequest = {
-            interleaveTargetDescriptor: {
-                nodeId: toDhtAddressRaw('0x2222' as DhtAddress),
-                type: NodeType.NODEJS
-            }
-        }
-        await rpcLocal.interleaveRequest(req, {
-            incomingSourceDescriptor: createMockPeerDescriptor()
-        } as any)
-        expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
-    })
-
-    it('handshakeWithInterleaving success', async () => {
-        const req: InterleaveRequest = {
-            interleaveTargetDescriptor: {
-                nodeId: toDhtAddressRaw('0x2222' as DhtAddress),
-                type: NodeType.NODEJS
-            }
-        }
-        await rpcLocal.interleaveRequest(req, {
-            incomingSourceDescriptor: createMockPeerDescriptor()
-        } as any)
-        expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
-    })
-
-    it('rejects handshakes if interleaving to the requestor is ongoing', async () => {
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        const requestor = createMockPeerDescriptor()
-        ongoingInterleaves.add(toNodeId(requestor))
-        const req = StreamPartHandshakeRequest.create({
-            streamPartId: STREAM_PART_ID,
-            requestId: 'requestId'
-        })
-        const res = await rpcLocal.handshake(req, {
-            incomingSourceDescriptor: requestor
-        } as any)
-        expect(res.accepted).toEqual(false)
-    })
-
-    it('Rejects if interleaving is required and too many interleaving requests are ongoing', async () => {
-        const interleavingPeer1 = createMockPeerDescriptor()
-        const interleavingPeer2 = createMockPeerDescriptor()
-        const interleavingPeer3 = createMockPeerDescriptor()
-        neighbors.add(createMockContentDeliveryRpcRemote(interleavingPeer1))
-        neighbors.add(createMockContentDeliveryRpcRemote(interleavingPeer2))
-        neighbors.add(createMockContentDeliveryRpcRemote(interleavingPeer3))
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        ongoingInterleaves.add(toNodeId(interleavingPeer1))
-        ongoingInterleaves.add(toNodeId(interleavingPeer2))
-        ongoingInterleaves.add(toNodeId(interleavingPeer3))
-        const req = StreamPartHandshakeRequest.create({
-            streamPartId: STREAM_PART_ID,
-            requestId: 'requestId'
-        })
-        const res = await rpcLocal.handshake(req, {
-            incomingSourceDescriptor: createMockPeerDescriptor()
-        } as any)
-        expect(res.accepted).toEqual(false)
-        expect(handshakeWithInterleaving).toHaveBeenCalledTimes(0)
-    })
-
-    it('rejects handshakes if the requestor has more than maxNeighborCount neighbors', async () => {
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        neighbors.add(createMockContentDeliveryRpcRemote())
-        const req = StreamPartHandshakeRequest.create({
-            streamPartId: STREAM_PART_ID,
-            requestId: 'requestId'
-        })
-        const res = await rpcLocal.handshake(req, {
-            incomingSourceDescriptor: createMockPeerDescriptor()
-        } as any)
-        expect(res.accepted).toEqual(false)
-        expect(handshakeWithInterleaving).toHaveBeenCalledTimes(0)
-    })
-
-})

package/test/unit/Handshaker.test.ts

@@ -1,69 +0,0 @@
-import { ListeningRpcCommunicator, Simulator, SimulatorTransport, toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { range } from 'lodash'
-import { NodeList } from '../../src/logic/NodeList'
-import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
-import { createMockContentDeliveryRpcRemote, createMockPeerDescriptor } from '../utils/utils'
-
-describe('Handshaker', () => {
-
-    let handshaker: Handshaker
-    const peerDescriptor = createMockPeerDescriptor()
-
-    const maxNeighborCount = 4
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-
-    let neighbors: NodeList
-    let leftNodeView: NodeList
-    let rightNodeView: NodeList
-    let nearbyNodeView: NodeList
-    let randomNodeView: NodeList
-
-    let simulator: Simulator
-    let simulatorTransport: SimulatorTransport
-    
-    beforeEach(async () => {
-        simulator = new Simulator()
-        simulatorTransport = new SimulatorTransport(peerDescriptor, simulator)
-        await simulatorTransport.start()
-        const rpcCommunicator = new ListeningRpcCommunicator(streamPartId, simulatorTransport)
-
-        const nodeId = toNodeId(peerDescriptor)
-        neighbors = new NodeList(nodeId, 10)
-        leftNodeView = new NodeList(nodeId, 20)
-        rightNodeView = new NodeList(nodeId, 20)
-        nearbyNodeView = new NodeList(nodeId, 20)
-        randomNodeView = new NodeList(nodeId, 20)
-
-        handshaker = new Handshaker({
-            localPeerDescriptor: peerDescriptor,
-            streamPartId,
-            neighbors,
-            leftNodeView,
-            rightNodeView,
-            nearbyNodeView,
-            randomNodeView,
-            rpcCommunicator,
-            maxNeighborCount,
-            rpcRequestTimeout: 5000,
-            ongoingHandshakes: new Set()
-        })
-    })
-
-    afterEach(async () => {
-        await simulatorTransport.stop()
-        simulator.stop()
-    })
-
-    it('attemptHandshakesOnContact works with empty structures', async () => {
-        const res = await handshaker.attemptHandshakesOnContacts([])
-        expect(res.length).toEqual(0)
-    })
-
-    it('attemptHandshakesOnContact with known nodes that cannot be connected to', async () => {
-        range(2).forEach(() => randomNodeView.add(createMockContentDeliveryRpcRemote()))
-        const res = await handshaker.attemptHandshakesOnContacts([])
-        expect(res.length).toEqual(2)
-    })
-
-})

package/test/unit/InspectSession.test.ts

@@ -1,80 +0,0 @@
-import { InspectSession, Events } from '../../src/logic/inspect/InspectSession'
-import { MessageID } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { waitForEvent3 } from '../../../utils/dist/src/waitForEvent3'
-import { utf8ToBinary } from '@streamr/utils'
-import { DhtAddress, randomDhtAddress } from '@streamr/dht'
-
-describe('InspectSession', () => {
-
-    let inspectSession: InspectSession
-    let inspectedNode: DhtAddress
-    let anotherNode: DhtAddress
-
-    const publisherId = utf8ToBinary('publisherId')
-    const messageId1: MessageID = {
-        streamId: 'stream',
-        messageChainId: 'messageChain0',
-        streamPartition: 0,
-        sequenceNumber: 0,
-        timestamp: 12345,
-        publisherId
-    }
-
-    const messageId2: MessageID = {
-        streamId: 'stream',
-        messageChainId: 'messageChain1',
-        streamPartition: 0,
-        sequenceNumber: 0,
-        timestamp: 12345,
-        publisherId
-    }
-
-    beforeEach(() => {
-        inspectedNode = randomDhtAddress()
-        anotherNode = randomDhtAddress()
-        inspectSession = new InspectSession({
-            inspectedNode
-        })
-    })
-
-    afterEach(() => {
-        inspectSession.stop()
-    })
-
-    it('should mark message', () => {
-        inspectSession.markMessage(inspectedNode, messageId1)
-        expect(inspectSession.getInspectedMessageCount()).toBe(1)
-        inspectSession.markMessage(inspectedNode, messageId2)
-        expect(inspectSession.getInspectedMessageCount()).toBe(2)
-    })
-
-    it('should emit done event when inspected node sends seen message', async () => {
-        inspectSession.markMessage(anotherNode, messageId1)
-        await Promise.all([
-            waitForEvent3<Events>(inspectSession, 'done', 100),
-            inspectSession.markMessage(inspectedNode, messageId1)
-        ])
-        expect(inspectSession.getInspectedMessageCount()).toBe(1)
-    })
-
-    it('should emit done event another node sends message after inspected node', async () => {
-        inspectSession.markMessage(inspectedNode, messageId1)
-        await Promise.all([
-            waitForEvent3<Events>(inspectSession, 'done', 100),
-            inspectSession.markMessage(anotherNode, messageId1)
-        ])
-        expect(inspectSession.getInspectedMessageCount()).toBe(1)
-    })
-
-    it('should not emit done if messageIds do not match', async () => {
-        inspectSession.markMessage(inspectedNode, messageId1)
-        await expect(async () => {
-            await Promise.all([
-                waitForEvent3<Events>(inspectSession, 'done', 100),
-                inspectSession.markMessage(anotherNode, messageId2)
-            ])
-        }).rejects.toThrow('waitForEvent3')
-        
-        expect(inspectSession.getInspectedMessageCount()).toBe(2)
-    })
-})

package/test/unit/Inspector.test.ts

@@ -1,51 +0,0 @@
-import { ListeningRpcCommunicator, randomDhtAddress, toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils, utf8ToBinary } from '@streamr/utils'
-import { Inspector } from '../../src/logic/inspect/Inspector'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor, mockConnectionLocker } from '../utils/utils'
-
-describe('Inspector', () => {
-    
-    let inspector: Inspector
-    const inspectorDescriptor = createMockPeerDescriptor()
-
-    const inspectedDescriptor = createMockPeerDescriptor()
-
-    const nodeId = randomDhtAddress()
-    let mockConnect: jest.Mock
-
-    const messageRef = {
-        streamId: 'stream',
-        messageChainId: 'messageChain0',
-        streamPartition: 0,
-        sequenceNumber: 0,
-        timestamp: 12345,
-        publisherId: utf8ToBinary('publisher')
-    }
-
-    beforeEach(() => {
-        mockConnect = jest.fn(() => {})
-        inspector = new Inspector({
-            localPeerDescriptor: inspectorDescriptor,
-            streamPartId: StreamPartIDUtils.parse('stream#0'),
-            rpcCommunicator: new ListeningRpcCommunicator('inspector', new MockTransport()),
-            connectionLocker: mockConnectionLocker,
-            openInspectConnection: async () => mockConnect()
-        })
-    })
-
-    afterEach(() => {
-        inspector.stop()
-    })
-
-    it('Opens inspection connection and runs successfully', async () => {
-        setTimeout(() => {
-            inspector.markMessage(toNodeId(inspectedDescriptor), messageRef)
-            inspector.markMessage(nodeId, messageRef)
-        }, 250)
-        await inspector.inspect(inspectedDescriptor)
-        expect(inspector.isInspected(toNodeId(inspectedDescriptor))).toBe(false)
-        expect(mockConnect).toBeCalledTimes(1)
-    })
-
-})

package/test/unit/NeighborFinder.test.ts

@@ -1,51 +0,0 @@
-import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
-import { NodeList } from '../../src/logic/NodeList'
-import { waitForCondition } from '@streamr/utils'
-import { range } from 'lodash'
-import { expect } from 'expect'
-import { createMockContentDeliveryRpcRemote } from '../utils/utils'
-import { DhtAddress, randomDhtAddress, toNodeId } from '@streamr/dht'
-
-describe('NeighborFinder', () => {
-
-    const nodeId = randomDhtAddress()
-    let neighbors: NodeList
-    let nearbyNodeView: NodeList
-    let neighborFinder: NeighborFinder
-
-    const minCount = 4
-
-    beforeEach(() => {
-        neighbors = new NodeList(nodeId, 15)
-        nearbyNodeView = new NodeList(nodeId, 30)
-        range(30).forEach(() => nearbyNodeView.add(createMockContentDeliveryRpcRemote()))
-        const mockDoFindNeighbors = async (excluded: DhtAddress[]) => {
-            const target = nearbyNodeView.getRandom(excluded)
-            if (Math.random() < 0.5) {
-                neighbors.add(target!)
-            } else {
-                excluded.push(toNodeId(target!.getPeerDescriptor()))
-            }
-            return excluded
-        }
-        neighborFinder = new NeighborFinder({
-            neighbors,
-            nearbyNodeView,
-            leftNodeView: new NodeList(nodeId, 30),
-            rightNodeView: new NodeList(nodeId, 30),
-            randomNodeView: new NodeList(nodeId, 30),
-            doFindNeighbors: (excluded) => mockDoFindNeighbors(excluded),
-            minCount
-        })
-    })
-
-    afterEach(() => {
-        neighborFinder.stop()
-    })
-
-    it('Finds target number of nodes', async () => {
-        neighborFinder.start()
-        await waitForCondition(() => neighbors.size() >= minCount, 10000)
-        expect(neighborFinder.isRunning()).toEqual(false)
-    })
-})

package/test/unit/NeighborUpdateRpcLocal.test.ts

@@ -1,139 +0,0 @@
-import { DhtAddress, ListeningRpcCommunicator, toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { range } from 'lodash'
-import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
-import { NodeList } from '../../src/logic/NodeList'
-import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
-import { NeighborUpdateRpcLocal } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcLocal'
-import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('NeighborUpdateRpcLocal', () => {
-
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-    const localPeerDescriptor = createMockPeerDescriptor()
-    const neighborTargetCount = 4
-
-    let rpcLocal: NeighborUpdateRpcLocal
-    let neighbors: NodeList
-    let nearbyNodeView: NodeList
-    let neighborFinder: NeighborFinder
-    let rpcCommunicator: ListeningRpcCommunicator
-    let ongoingHandshakes: Set<DhtAddress>
-
-    const addNeighbors = (count: number) => {
-        for (let i = 0; i < count; i++) {
-            neighbors.add(new ContentDeliveryRpcRemote(
-                localPeerDescriptor,
-                createMockPeerDescriptor(),
-                rpcCommunicator,
-                ContentDeliveryRpcClient
-            ))
-        }
-    }
-
-    beforeEach(() => {
-        rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
-        neighbors = new NodeList(toNodeId(localPeerDescriptor), neighborTargetCount + 1)
-        nearbyNodeView = new NodeList(toNodeId(localPeerDescriptor), neighborTargetCount)
-        neighborFinder = {
-            start: jest.fn()
-        } as any
-        ongoingHandshakes = new Set()
-
-        rpcLocal = new NeighborUpdateRpcLocal({
-            localPeerDescriptor,
-            neighbors,
-            nearbyNodeView,
-            neighborFinder,
-            streamPartId,
-            rpcCommunicator,
-            neighborTargetCount,
-            ongoingHandshakes
-        })
-    })
-
-    afterEach(() => {
-        rpcCommunicator.destroy()
-    })
-
-    it('response contains neighbor list of expected size', async () => {
-        addNeighbors(neighborTargetCount)
-        const res = await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: [localPeerDescriptor],
-            removeMe: false
-        }, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
-        expect(res.neighborDescriptors.length).toEqual(neighborTargetCount)
-    })
-
-    it('updates contacts based on callers neighbors', async () => {
-        addNeighbors(neighborTargetCount)
-        expect(nearbyNodeView.size()).toEqual(0)
-        await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: range(neighborTargetCount).map(() => createMockPeerDescriptor()),
-            removeMe: false
-        }, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
-        expect(nearbyNodeView.size()).toEqual(4)
-    })
-
-    it('does not ask to be removed if caller is a neighbor', async () => {
-        const caller = createMockPeerDescriptor()
-        const neighbor = new ContentDeliveryRpcRemote(
-            localPeerDescriptor,
-            caller,
-            rpcCommunicator,
-            ContentDeliveryRpcClient
-        )
-        neighbors.add(neighbor)
-        const res = await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: [localPeerDescriptor],
-            removeMe: false
-        }, { incomingSourceDescriptor: caller } as any)
-        expect(res.removeMe).toEqual(false)
-    })
-
-    it('asks to be removed if caller is not a neighbor', async () => {
-        const caller = createMockPeerDescriptor()
-        const res = await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: [localPeerDescriptor],
-            removeMe: false
-        }, { incomingSourceDescriptor: caller } as any)
-        expect(res.removeMe).toEqual(true)
-    })
-
-    it('asks to be removed if caller is a neighbor and both have too many neighbors', async () => {
-        const caller = createMockPeerDescriptor()
-        const neighbor = new ContentDeliveryRpcRemote(
-            localPeerDescriptor,
-            caller,
-            rpcCommunicator,
-            ContentDeliveryRpcClient
-        )
-        neighbors.add(neighbor)
-        addNeighbors(neighborTargetCount)
-        const res = await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: [localPeerDescriptor, ...range(neighborTargetCount).map(() => createMockPeerDescriptor())],
-            removeMe: false
-        }, { incomingSourceDescriptor: caller } as any)
-        expect(res.removeMe).toEqual(true)
-        expect(neighbors.has(toNodeId(caller))).toEqual(false)
-    })
-
-    it('does not ask to be removed if there is an ongoing handshake to the caller', async () => {
-        const caller = createMockPeerDescriptor()
-        ongoingHandshakes.add(toNodeId(caller))
-        const res = await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: [localPeerDescriptor],
-            removeMe: false
-        }, { incomingSourceDescriptor: caller } as any)
-        expect(res.removeMe).toEqual(false)
-    })
-
-})

package/test/unit/NetworkNode.test.ts

@@ -1,42 +0,0 @@
-import { StreamPartIDUtils } from '@streamr/utils'
-import { EventEmitter } from 'eventemitter3'
-import { NetworkNode } from '../../src/NetworkNode'
-import { NetworkStack } from '../../src/NetworkStack'
-import { Events } from '../../src/logic/ContentDeliveryManager'
-import { StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-const STREAM_PART = StreamPartIDUtils.parse('stream#0')
-const PUBLISHER_ID = randomUserId()
-
-const createMessage = (id: number): StreamMessage => {
-    return createStreamMessage(`${id}`, STREAM_PART, PUBLISHER_ID)
-}
-
-describe('NetworkNode', () => {
-
-    it('message listener', async () => {
-        const contentDeliveryManager = new EventEmitter<Events>()
-        const stack: Partial<NetworkStack> = {
-            getContentDeliveryManager: () => contentDeliveryManager as any,
-            joinStreamPart: async () => {}
-        }
-        const node = new NetworkNode(stack as any)
-        await node.join(STREAM_PART)
-        const onMessage = jest.fn()
-
-        node.addMessageListener(onMessage)
-        const msg1 = createMessage(1)
-        const msg2 = createMessage(2)
-        contentDeliveryManager.emit('newMessage', msg1)
-        contentDeliveryManager.emit('newMessage', msg2)
-        expect(onMessage.mock.calls[0][0]).toEqual(msg1)
-        expect(onMessage.mock.calls[1][0]).toEqual(msg2)
-        expect(onMessage).toBeCalledTimes(2)
-
-        node.removeMessageListener(onMessage)
-        contentDeliveryManager.emit('newMessage', createMessage(3))
-        expect(onMessage).toBeCalledTimes(2)
-    })
-})