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

package/test/integration/ContentDeliveryLayerNode-Layer1Node.test.ts

@@ -1,162 +0,0 @@
-import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, toNodeId, getRandomRegion } from '@streamr/dht'
-import { Logger, StreamPartIDUtils, until } from '@streamr/utils'
-import { range } from 'lodash'
-import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
-import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
-import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const logger = new Logger(module)
-
-describe('ContentDeliveryLayerNode-DhtNode', () => {
-    const otherNodeCount = 64
-    let entryPointDiscoveryLayerNode: DiscoveryLayerNode
-    let otherDiscoveryLayerNodes: DiscoveryLayerNode[]
-    let entryPointContentDeliveryLayerNode: ContentDeliveryLayerNode
-    let otherContentDeliveryLayerNodes: ContentDeliveryLayerNode[]
-
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-    const entrypointDescriptor = createMockPeerDescriptor({
-        region: getRandomRegion()
-    })
-
-    const peerDescriptors: PeerDescriptor[] = range(otherNodeCount).map(() => {
-        return createMockPeerDescriptor({
-            region: getRandomRegion()
-        })
-    })
-    beforeEach(async () => {
-        const simulator = new Simulator()
-        const entrypointCm = new SimulatorTransport(
-            entrypointDescriptor,
-            simulator
-        )
-        await entrypointCm.start()
-
-        const cms: ConnectionManager[] = range(otherNodeCount).map((i) =>
-            new SimulatorTransport(
-                peerDescriptors[i],
-                simulator
-            )
-        )
-        await Promise.all(cms.map((cm) => cm.start()))
-
-        entryPointDiscoveryLayerNode = new DhtNode({
-            transport: entrypointCm,
-            connectionsView: entrypointCm,
-            peerDescriptor: entrypointDescriptor,
-            serviceId: streamPartId
-        })
-
-        otherDiscoveryLayerNodes = range(otherNodeCount).map((i) => new DhtNode({
-            transport: cms[i],
-            connectionsView: cms[i],
-            peerDescriptor: peerDescriptors[i],
-            serviceId: streamPartId
-        }))
-
-        otherContentDeliveryLayerNodes = range(otherNodeCount).map((i) => createContentDeliveryLayerNode({
-            streamPartId,
-            discoveryLayerNode: otherDiscoveryLayerNodes[i],
-            transport: cms[i],
-            connectionLocker: cms[i],
-            localPeerDescriptor: peerDescriptors[i],
-            neighborUpdateInterval: 2000,
-            isLocalNodeEntryPoint: () => false
-        }))
-
-        entryPointContentDeliveryLayerNode = createContentDeliveryLayerNode({
-            streamPartId,
-            discoveryLayerNode: entryPointDiscoveryLayerNode,
-            transport: entrypointCm,
-            connectionLocker: entrypointCm,
-            localPeerDescriptor: entrypointDescriptor,
-            neighborUpdateInterval: 2000,
-            isLocalNodeEntryPoint: () => false
-        })
-
-        await entryPointDiscoveryLayerNode.start()
-        await entryPointContentDeliveryLayerNode.start()
-        await entryPointDiscoveryLayerNode.joinDht([entrypointDescriptor])
-        await Promise.all(otherDiscoveryLayerNodes.map((node) => node.start()))
-    })
-
-    afterEach(async () => {
-        await entryPointDiscoveryLayerNode.stop()
-        entryPointContentDeliveryLayerNode.stop()
-        await Promise.all(otherDiscoveryLayerNodes.map((node) => node.stop()))
-        await Promise.all(otherContentDeliveryLayerNodes.map((node) => node.stop()))
-    })
-
-    it('happy path single node ', async () => {
-        await otherContentDeliveryLayerNodes[0].start()
-        await otherDiscoveryLayerNodes[0].joinDht([entrypointDescriptor])
-
-        await until(() => otherContentDeliveryLayerNodes[0].getNeighbors().length === 1)
-        expect(otherContentDeliveryLayerNodes[0].getNearbyNodeView().getIds().length).toEqual(1)
-        expect(otherContentDeliveryLayerNodes[0].getNeighbors().length).toEqual(1)
-    })
-
-    it('happy path 4 nodes', async () => {
-        range(4).forEach((i) => otherContentDeliveryLayerNodes[i].start())
-        await Promise.all(range(4).map(async (i) => {
-            await otherDiscoveryLayerNodes[i].joinDht([entrypointDescriptor])
-        }))
-
-        await until(() => range(4).every((i) => otherContentDeliveryLayerNodes[i].getNeighbors().length === 4))
-        range(4).forEach((i) => {
-            expect(otherContentDeliveryLayerNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
-            expect(otherContentDeliveryLayerNodes[i].getNeighbors().length).toBeGreaterThanOrEqual(4)
-        })
-
-        // Check bidirectionality
-        const allNodes = otherContentDeliveryLayerNodes
-        allNodes.push(entryPointContentDeliveryLayerNode)
-        range(5).forEach((i) => {
-            allNodes[i].getNearbyNodeView().getIds().forEach((nodeId) => {
-                const neighbor = allNodes.find((node) => {
-                    return node.getOwnNodeId() === nodeId
-                })
-                const neighborNodeIds = neighbor!.getNeighbors().map((n) => toNodeId(n))
-                expect(neighborNodeIds.includes(allNodes[i].getOwnNodeId())).toEqual(true)
-            })
-        })
-    }, 10000)
-
-    it('happy path 64 nodes', async () => {
-        await Promise.all(range(otherNodeCount).map((i) => otherContentDeliveryLayerNodes[i].start()))
-        await Promise.all(range(otherNodeCount).map((i) => {
-            otherDiscoveryLayerNodes[i].joinDht([entrypointDescriptor])
-        }))
-        await Promise.all(otherContentDeliveryLayerNodes.map((node) =>
-            until(() => node.getNeighbors().length >= 4, 10000)
-        ))
-
-        const avg = otherContentDeliveryLayerNodes.reduce((acc, curr) => {
-            return acc + curr.getNeighbors().length
-        }, 0) / otherNodeCount
-
-        logger.info(`AVG Number of neighbors: ${avg}`)
-        await Promise.all(otherContentDeliveryLayerNodes.map((node) =>
-            until(() => node.getOutgoingHandshakeCount() === 0)
-        ))
-        await until(() => {
-            let mismatchCounter = 0
-            otherContentDeliveryLayerNodes.forEach((node) => {
-                const nodeId = node.getOwnNodeId()
-                node.getNeighbors().forEach((neighbor) => {
-                    const neighborId = toNodeId(neighbor)
-                    if (neighborId !== entryPointContentDeliveryLayerNode.getOwnNodeId()) {
-                        const neighbor = otherContentDeliveryLayerNodes.find((n) => n.getOwnNodeId() === neighborId)
-                        const neighborNodeIds = neighbor!.getNeighbors().map((n) => toNodeId(n))
-                        if (!neighborNodeIds.includes(nodeId)) {
-                            mismatchCounter += 1
-                        }
-                    }
-                })
-            })
-            // NET-1074 Investigate why sometimes unidirectional connections remain.
-            return mismatchCounter <= 2
-        }, 20000, 1000)
-    }, 95000)
-})

package/test/integration/ContentDeliveryManager.test.ts

@@ -1,160 +0,0 @@
-import {
-    DhtNode,
-    Simulator,
-    SimulatorTransport
-} from '@streamr/dht'
-import { StreamPartIDUtils, until, waitForEvent3, wait } from '@streamr/utils'
-import { ContentDeliveryManager, Events } from '../../src/logic/ContentDeliveryManager'
-import { ControlLayerNode } from '../../src/logic/ControlLayerNode'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('ContentDeliveryManager', () => {
-
-    let controlLayerNode1: ControlLayerNode
-    let controlLayerNode2: ControlLayerNode
-    let transport1: SimulatorTransport
-    let transport2: SimulatorTransport
-    let manager1: ContentDeliveryManager
-    let manager2: ContentDeliveryManager
-
-    const peerDescriptor1 = createMockPeerDescriptor()
-    const peerDescriptor2 = createMockPeerDescriptor()
-    const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
-
-    const msg = createStreamMessage(
-        JSON.stringify({ hello: 'WORLD' }),
-        STREAM_PART_ID,
-        randomUserId()
-    )
-    let simulator: Simulator
-
-    beforeEach(async () => {
-        simulator = new Simulator()
-        transport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        await transport1.start()
-        transport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        await transport2.start()
-        controlLayerNode1 = new DhtNode({
-            transport: transport1,
-            connectionsView: transport1,
-            peerDescriptor: peerDescriptor1,
-            entryPoints: [peerDescriptor1]
-        })
-        controlLayerNode2 = new DhtNode({
-            transport: transport2,
-            connectionsView: transport2,
-            peerDescriptor: peerDescriptor2,
-            entryPoints: [peerDescriptor1]
-        })
-        await Promise.all([
-            controlLayerNode1.start(),
-            controlLayerNode2.start()
-        ])
-        await Promise.all([
-            controlLayerNode1.joinDht([peerDescriptor1]),
-            controlLayerNode2.joinDht([peerDescriptor1])
-        ])
-
-        manager1 = new ContentDeliveryManager({ neighborUpdateInterval: 100 })
-        manager2 = new ContentDeliveryManager({ neighborUpdateInterval: 100 })
-        await manager1.start(controlLayerNode1, transport1, transport1)
-        manager1.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
-        await manager2.start(controlLayerNode2, transport2, transport2)
-        manager2.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            manager1.destroy(),
-            manager2.destroy(),
-            controlLayerNode1.stop(),
-            controlLayerNode2.stop(),
-            transport1.stop(),
-            transport2.stop()
-        ])
-        simulator.stop()
-    })
-
-    it('starts', async () => {
-        expect(manager1.getPeerDescriptor()).toEqual(peerDescriptor1)
-        expect(manager2.getPeerDescriptor()).toEqual(peerDescriptor2)
-    })
-
-    it('Joining stream', async () => {
-        manager1.joinStreamPart(STREAM_PART_ID)
-        manager2.joinStreamPart(STREAM_PART_ID)
-        await until(() => manager1.getNeighbors(STREAM_PART_ID).length === 1)
-        await until(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
-        expect(manager1.getNeighbors(STREAM_PART_ID).length).toEqual(1)
-        expect(manager2.getNeighbors(STREAM_PART_ID).length).toEqual(1)
-    })
-
-    it('Publishing after joining and waiting for neighbors', async () => {
-        manager1.joinStreamPart(STREAM_PART_ID)
-        manager2.joinStreamPart(STREAM_PART_ID)
-        await until(() => manager1.getNeighbors(STREAM_PART_ID).length === 1)
-        await until(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
-        await Promise.all([
-            waitForEvent3<Events>(manager1, 'newMessage'),
-            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-            manager2.broadcast(msg)
-        ])
-    })
-
-    it('multi-stream pub/sub', async () => {
-        const streamPartId2 = StreamPartIDUtils.parse('test2#0')
-        manager1.setStreamPartEntryPoints(streamPartId2, [peerDescriptor1])
-        manager2.setStreamPartEntryPoints(streamPartId2, [peerDescriptor1])
-        manager1.joinStreamPart(STREAM_PART_ID)
-        manager1.joinStreamPart(streamPartId2)
-        manager2.joinStreamPart(STREAM_PART_ID)
-        manager2.joinStreamPart(streamPartId2)
-        await Promise.all([
-            until(() => manager1.getNeighbors(STREAM_PART_ID).length === 1),
-            until(() => manager2.getNeighbors(STREAM_PART_ID).length === 1),
-            until(() => manager1.getNeighbors(streamPartId2).length === 1),
-            until(() => manager2.getNeighbors(streamPartId2).length === 1)
-        ])
-        const msg2 = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            streamPartId2,
-            randomUserId()
-        )
-        await Promise.all([
-            waitForEvent3<Events>(manager1, 'newMessage'),
-            waitForEvent3<Events>(manager2, 'newMessage'),
-            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-            manager1.broadcast(msg2),
-            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-            manager2.broadcast(msg)
-        ])
-    })
-
-    it('leaving stream parts', async () => {
-        manager1.joinStreamPart(STREAM_PART_ID)
-        manager2.joinStreamPart(STREAM_PART_ID)
-        await Promise.all([
-            until(() => manager1.getNeighbors(STREAM_PART_ID).length === 1),
-            until(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
-        ])
-        await manager2.leaveStreamPart(STREAM_PART_ID)
-        await until(() => manager1.getNeighbors(STREAM_PART_ID).length === 0)
-    })
-
-    it('RTTs are updated for node info', async () => {
-        manager1.joinStreamPart(STREAM_PART_ID)
-        manager2.joinStreamPart(STREAM_PART_ID)
-        await Promise.all([
-            until(() => manager1.getNeighbors(STREAM_PART_ID).length === 1),
-            until(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
-        ])
-        // Wait for RTTs to be updated
-        await wait(500)
-        const nodeInfo1 = manager1.getNodeInfo()
-        const nodeInfo2 = manager2.getNodeInfo()
-        expect(nodeInfo1[0].contentDeliveryLayerNeighbors[0].rtt).toBeGreaterThanOrEqual(0)
-        expect(nodeInfo2[0].contentDeliveryLayerNeighbors[0].rtt).toBeGreaterThanOrEqual(0)
-    })
-
-})

package/test/integration/ContentDeliveryRpcRemote.test.ts

@@ -1,100 +0,0 @@
-import {
-    ListeningRpcCommunicator,
-    NodeType,
-    PeerDescriptor,
-    Simulator,
-    SimulatorTransport
-} from '@streamr/dht'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
-import { Empty } from '../../generated/google/protobuf/empty'
-import {
-    LeaveStreamPartNotice,
-    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('ContentDeliveryRpcRemote', () => {
-    let mockServerRpc: ListeningRpcCommunicator
-    let clientRpc: ListeningRpcCommunicator
-    let rpcRemote: ContentDeliveryRpcRemote
-
-    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 recvCounter: number
-
-    let simulator: Simulator
-    let mockConnectionManager1: SimulatorTransport
-    let mockConnectionManager2: SimulatorTransport
-
-    beforeEach(async () => {
-        recvCounter = 0
-        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.registerRpcNotification(
-            StreamMessage,
-            'sendStreamMessage',
-            async (): Promise<Empty> => {
-                recvCounter += 1
-                return Empty
-            }
-        )
-
-        mockServerRpc.registerRpcNotification(
-            LeaveStreamPartNotice,
-            'leaveStreamPartNotice',
-            async (): Promise<Empty> => {
-                recvCounter += 1
-                return Empty
-            }
-        )
-
-        rpcRemote = new ContentDeliveryRpcRemote(
-            clientNode,
-            serverNode,
-            clientRpc,
-            ContentDeliveryRpcClient
-        )
-    })
-
-    afterEach(async () => {
-        clientRpc.stop()
-        mockServerRpc.stop()
-        await mockConnectionManager1.stop()
-        await mockConnectionManager2.stop()
-        simulator.stop()
-    })
-
-    it('sendStreamMessage', async () => {
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            StreamPartIDUtils.parse('test-stream#0'),
-            randomUserId()
-        )
-
-        await rpcRemote.sendStreamMessage(msg)
-        await until(() => recvCounter === 1)
-    })
-
-    it('leaveNotice', async () => {
-        rpcRemote.leaveStreamPartNotice(StreamPartIDUtils.parse('test#0'), false)
-        await until(() => recvCounter === 1)
-    })
-
-})

package/test/integration/HandshakeRpcRemote.test.ts

@@ -1,79 +0,0 @@
-import {
-    ListeningRpcCommunicator,
-    NodeType,
-    PeerDescriptor,
-    Simulator,
-    SimulatorTransport
-} from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
-import {
-    StreamPartHandshakeRequest,
-    StreamPartHandshakeResponse
-} from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import {
-    HandshakeRpcClient,
-} from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-
-describe('HandshakeRpcRemote', () => {
-    let mockServerRpc: ListeningRpcCommunicator
-    let clientRpc: ListeningRpcCommunicator
-    let rpcRemote: HandshakeRpcRemote
-
-    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(
-            StreamPartHandshakeRequest,
-            StreamPartHandshakeResponse,
-            'handshake',
-            async (msg: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
-                const res: StreamPartHandshakeResponse = {
-                    requestId: msg.requestId,
-                    accepted: true
-                }
-                return res
-            }
-        )
-
-        rpcRemote = new HandshakeRpcRemote(
-            clientNode,
-            serverNode,
-            clientRpc,
-            HandshakeRpcClient
-        )
-    })
-
-    afterEach(async () => {
-        clientRpc.stop()
-        mockServerRpc.stop()
-        await mockConnectionManager1.stop()
-        await mockConnectionManager2.stop()
-        simulator.stop()
-    })
-
-    it('handshake', async () => {
-        const result = await rpcRemote.handshake(StreamPartIDUtils.parse('test#0'), [])
-        expect(result.accepted).toEqual(true)
-    })
-})

package/test/integration/Handshakes.test.ts

@@ -1,141 +0,0 @@
-import {
-    ListeningRpcCommunicator,
-    NodeType,
-    PeerDescriptor,
-    Simulator,
-    SimulatorTransport,
-    toNodeId
-} from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { NodeList } from '../../src/logic/NodeList'
-import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
-import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
-
-describe('Handshakes', () => {
-
-    const peerDescriptor1: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 1, 1]),
-        type: NodeType.NODEJS
-    }
-    const peerDescriptor2: PeerDescriptor = {
-        nodeId: new Uint8Array([2, 1, 1]),
-        type: NodeType.NODEJS
-    }
-    const peerDescriptor3: PeerDescriptor = {
-        nodeId: new Uint8Array([3, 1, 1]),
-        type: NodeType.NODEJS
-    }
-    let rpcCommunicator1: ListeningRpcCommunicator
-    let rpcCommunicator2: ListeningRpcCommunicator
-    let rpcCommunicator3: ListeningRpcCommunicator
-    let neighbors: NodeList
-    let leftNodeView: NodeList
-    let rightNodeView: NodeList
-    let nodeView: NodeList
-    let handshaker: Handshaker
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-
-    const acceptHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
-        const response: StreamPartHandshakeResponse = {
-            requestId: request.requestId,
-            accepted: true
-        }
-        return response
-    }
-
-    const rejectHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
-        const response: StreamPartHandshakeResponse = {
-            requestId: request.requestId,
-            accepted: false
-        }
-        return response
-    }
-
-    const interleavingHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
-        const response: StreamPartHandshakeResponse = {
-            requestId: request.requestId,
-            accepted: true,
-            interleaveTargetDescriptor: peerDescriptor3
-        }
-        return response
-    }
-
-    let simulator: Simulator
-    let simulatorTransport1: SimulatorTransport
-    let simulatorTransport2: SimulatorTransport
-    let simulatorTransport3: SimulatorTransport
-
-    beforeEach(async () => {
-        simulator = new Simulator()
-        simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        await simulatorTransport1.start()
-        simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        await simulatorTransport2.start()
-        simulatorTransport3 = new SimulatorTransport(peerDescriptor3, simulator)
-        await simulatorTransport3.start()
-
-        rpcCommunicator1 = new ListeningRpcCommunicator(streamPartId, simulatorTransport1)
-        rpcCommunicator2 = new ListeningRpcCommunicator(streamPartId, simulatorTransport2)
-        rpcCommunicator3 = new ListeningRpcCommunicator(streamPartId, simulatorTransport3)
-
-        const handshakerNodeId = toNodeId(peerDescriptor2)
-        leftNodeView = new NodeList(handshakerNodeId, 10)
-        rightNodeView = new NodeList(handshakerNodeId, 10)
-        nodeView = new NodeList(handshakerNodeId, 10)
-        nodeView.add(new ContentDeliveryRpcRemote(
-            peerDescriptor2,
-            peerDescriptor1,
-            rpcCommunicator2,
-            ContentDeliveryRpcClient
-        ))
-        neighbors = new NodeList(handshakerNodeId, 4)
-        handshaker = new Handshaker({
-            localPeerDescriptor: peerDescriptor2,
-            streamPartId,
-            nearbyNodeView: nodeView,
-            randomNodeView: nodeView,
-            leftNodeView,
-            rightNodeView,
-            neighbors,
-            rpcCommunicator: rpcCommunicator2,
-            maxNeighborCount: 4,
-            ongoingHandshakes: new Set()
-        })
-
-    })
-
-    afterEach(async () => {
-        rpcCommunicator1.stop()
-        rpcCommunicator2.stop()
-        rpcCommunicator3.stop()
-        await simulatorTransport1.stop()
-        await simulatorTransport2.stop()
-        await simulatorTransport3.stop()
-        simulator.stop()
-    })
-
-    it('Handshake accepted', async () => {
-        rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
-        const res = await handshaker.attemptHandshakesOnContacts([])
-        expect(res).toHaveLength(0)
-        expect(neighbors.has(toNodeId(peerDescriptor1))).toEqual(true)
-    })
-
-    it('Handshake rejected', async () => {
-        rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', rejectHandshake)
-        const res = await handshaker.attemptHandshakesOnContacts([])
-        expect(res[0]).toEqual(toNodeId(peerDescriptor1))
-        expect(neighbors.has(toNodeId(peerDescriptor1))).toEqual(false)
-    })
-
-    it('Handshake with Interleaving', async () => {
-        rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', interleavingHandshake)
-        rpcCommunicator3.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
-        const res = await handshaker.attemptHandshakesOnContacts([])
-        expect(res).toHaveLength(0)
-        expect(neighbors.has(toNodeId(peerDescriptor1))).toEqual(true)
-        expect(neighbors.has(toNodeId(peerDescriptor3))).toEqual(true)
-    })
-})