@streamr/trackerless-network 0.0.1-tatum.0

package/test/end-to-end/proxy-key-exchange.test.ts

@@ -0,0 +1,142 @@
+import { NodeType, PeerDescriptor, PeerID } from '@streamr/dht'
+import { 
+    EncryptionType,
+    GroupKeyRequest,
+    GroupKeyResponse,
+    MessageID,
+    StreamMessage,
+    StreamMessageType,
+    StreamPartIDUtils,
+    toStreamID,
+    toStreamPartID
+} from '@streamr/protocol'
+import { NetworkNode } from '../../src/NetworkNode'
+import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { toEthereumAddress, waitForEvent3 } from '@streamr/utils'
+
+describe('proxy group key exchange', () => {
+    const proxyNodeDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`proxyNode1`).value,
+        type: NodeType.NODEJS,
+        nodeName: 'proxyNode',
+        websocket: { ip: 'localhost', port: 23134 }
+    }
+    const publisherDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`publisher`).value,
+        type: NodeType.NODEJS,
+    }
+    const subscriberDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`subscriber`).value,
+        type: NodeType.NODEJS,
+    }
+
+    const publisherUserId = toEthereumAddress('0x823A026e226EB47980c88616e01E1D3305Ef8Ecb')
+    const subscriberUserId = toEthereumAddress('0x73E6183bf9b79D30533bEC7B28e982e9Af649B23')
+
+    const streamPartId = toStreamPartID(toStreamID('proxy-test'), 0)
+
+    let proxyNode: NetworkNode
+    let publisher: NetworkNode
+    let subscriber: NetworkNode
+
+    beforeEach(async () => {
+        proxyNode = new NetworkNode({
+            layer0: {
+                entryPoints: [proxyNodeDescriptor],
+                peerDescriptor: proxyNodeDescriptor,
+            },
+            networkNode: {
+                acceptProxyConnections: true
+            }
+        })
+        await proxyNode.start()
+        proxyNode.setStreamPartEntryPoints(streamPartId, [proxyNodeDescriptor])
+        await proxyNode.stack.getStreamrNode()!.joinStream(streamPartId)
+        publisher = new NetworkNode({
+            layer0: {
+                entryPoints: [publisherDescriptor],
+                peerDescriptor: publisherDescriptor,
+            },
+            networkNode: {}
+        })
+        await publisher.start(false)
+
+        subscriber = new NetworkNode({
+            layer0: {
+                entryPoints: [subscriberDescriptor],
+                peerDescriptor: subscriberDescriptor,
+            },
+            networkNode: {}
+        })
+        await subscriber.start(false)
+    })
+
+    afterEach(async () => {
+        await proxyNode.stop()
+        await publisher.stop()
+        await subscriber.stop()
+    })
+    
+    it('happy path request', async () => {
+        await publisher.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.PUBLISH, async () => publisherUserId)
+        await subscriber.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, async () => subscriberUserId)
+
+        const requestContent = new GroupKeyRequest({
+            recipient: publisherUserId,
+            requestId: 'requestId',
+            rsaPublicKey: 'mockKey',
+            groupKeyIds: [
+                'mock'
+            ],
+        }).toArray()
+        const request = new StreamMessage({
+            messageId: new MessageID(
+                StreamPartIDUtils.getStreamID(streamPartId),
+                StreamPartIDUtils.getStreamPartition(streamPartId),
+                Date.now(),
+                0,
+                subscriberUserId,
+                '0'
+            ),
+            messageType: StreamMessageType.GROUP_KEY_REQUEST,
+            encryptionType: EncryptionType.NONE,
+            content: requestContent,
+            signature: 'signature'
+        })
+
+        await Promise.all([
+            waitForEvent3(publisher.stack.getStreamrNode()! as any, 'newMessage'),
+            subscriber.publish(request)
+        ])
+    })
+
+    it('happy path response', async () => {
+        await publisher.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.PUBLISH, async () => publisherUserId)
+        await subscriber.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, async () => subscriberUserId)
+
+        const responseContent = new GroupKeyResponse({
+            recipient: publisherUserId,
+            requestId: 'requestId',
+            encryptedGroupKeys: []
+        }).toArray()
+        const response = new StreamMessage({
+            messageId: new MessageID(
+                StreamPartIDUtils.getStreamID(streamPartId),
+                StreamPartIDUtils.getStreamPartition(streamPartId),
+                Date.now(),
+                0,
+                publisherUserId,
+                '0'
+            ),
+            messageType: StreamMessageType.GROUP_KEY_RESPONSE,
+            encryptionType: EncryptionType.RSA,
+            content: responseContent,
+            signature: 'signature'
+        })
+
+        await Promise.all([
+            waitForEvent3(subscriber.stack.getStreamrNode()! as any, 'newMessage'),
+            publisher.publish(response)
+        ])
+    })
+})

package/test/end-to-end/random-graph-with-real-connections.test.ts

@@ -0,0 +1,154 @@
+import { ConnectionManager, DhtNode, PeerDescriptor, NodeType, peerIdFromPeerDescriptor } from '@streamr/dht'
+import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
+import { waitForCondition } from '@streamr/utils'
+import { createStreamMessage } from '../utils/utils'
+import { ContentMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
+
+describe('random graph with real connections', () => {
+
+    const epPeerDescriptor: PeerDescriptor = {
+        kademliaId: Uint8Array.from([1, 2, 3]),
+        type: NodeType.NODEJS,
+        websocket: { ip: 'localhost', port: 12221 }
+    }
+
+    const randomGraphId = 'random-graph'
+    let epDhtNode: DhtNode
+    let dhtNode1: DhtNode
+    let dhtNode2: DhtNode
+    let dhtNode3: DhtNode
+    let dhtNode4: DhtNode
+    let randomGraphNode1: RandomGraphNode
+    let randomGraphNode2: RandomGraphNode
+    let randomGraphNode3: RandomGraphNode
+    let randomGraphNode4: RandomGraphNode
+    let randomGraphNode5: RandomGraphNode
+
+    beforeEach(async () => {
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        await epDhtNode.start()
+        dhtNode1 = new DhtNode({ peerIdString: '1', webSocketPort: 12222, entryPoints: [epPeerDescriptor] })
+        dhtNode2 = new DhtNode({ peerIdString: '2', webSocketPort: 12223, entryPoints: [epPeerDescriptor] })
+        dhtNode3 = new DhtNode({ peerIdString: '3', webSocketPort: 12224, entryPoints: [epPeerDescriptor] })
+        dhtNode4 = new DhtNode({ peerIdString: '4', webSocketPort: 12225, entryPoints: [epPeerDescriptor] })
+        await dhtNode1.start()
+        await dhtNode2.start()
+        await dhtNode3.start()
+        await dhtNode4.start()
+
+        randomGraphNode1 = createRandomGraphNode(
+            {
+                randomGraphId,
+                layer1: epDhtNode,
+                P2PTransport: epDhtNode.getTransport(),
+                connectionLocker: epDhtNode.getTransport() as ConnectionManager,
+                ownPeerDescriptor: epPeerDescriptor
+            }
+        )
+        randomGraphNode2 = createRandomGraphNode({
+            randomGraphId,
+            layer1: dhtNode1,
+            P2PTransport: dhtNode1.getTransport(),
+            connectionLocker: dhtNode1.getTransport() as ConnectionManager,
+            ownPeerDescriptor: dhtNode1.getPeerDescriptor()
+        })
+        randomGraphNode3 = createRandomGraphNode({
+            randomGraphId,
+            layer1: dhtNode2,
+            P2PTransport: dhtNode2.getTransport(),
+            connectionLocker: dhtNode2.getTransport() as ConnectionManager,
+            ownPeerDescriptor: dhtNode2.getPeerDescriptor()
+        })
+        randomGraphNode4 = createRandomGraphNode({
+            randomGraphId,
+            layer1: dhtNode3,
+            P2PTransport: dhtNode3.getTransport(),
+            connectionLocker: dhtNode3.getTransport() as ConnectionManager,
+            ownPeerDescriptor: dhtNode3.getPeerDescriptor()
+        })
+        randomGraphNode5 = createRandomGraphNode({
+            randomGraphId,
+            layer1: dhtNode4,
+            P2PTransport: dhtNode4.getTransport(),
+            connectionLocker: dhtNode4.getTransport() as ConnectionManager,
+            ownPeerDescriptor: dhtNode4.getPeerDescriptor()
+        })
+        await epDhtNode.joinDht([epPeerDescriptor])
+        await Promise.all([
+            dhtNode1.joinDht([epPeerDescriptor]),
+            dhtNode2.joinDht([epPeerDescriptor]),
+            dhtNode3.joinDht([epPeerDescriptor]),
+            dhtNode4.joinDht([epPeerDescriptor])
+        ])
+        await Promise.all([
+            randomGraphNode1.start(),
+            randomGraphNode2.start(),
+            randomGraphNode3.start(),
+            randomGraphNode4.start(),
+            randomGraphNode5.start()
+        ])
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            epDhtNode.stop(),
+            dhtNode1.stop(),
+            dhtNode2.stop(),
+            dhtNode3.stop(),
+            dhtNode4.stop(),
+            randomGraphNode1.stop(),
+            randomGraphNode2.stop(),
+            randomGraphNode3.stop(),
+            randomGraphNode4.stop(),
+            randomGraphNode5.stop(),
+            (epDhtNode.getTransport() as ConnectionManager).stop(),
+            (dhtNode1.getTransport() as ConnectionManager).stop(),
+            (dhtNode2.getTransport() as ConnectionManager).stop(),
+            (dhtNode3.getTransport() as ConnectionManager).stop(),
+            (dhtNode4.getTransport() as ConnectionManager).stop()
+        ])
+    })
+
+    it('can fully connected topologies ', async () => {
+        await waitForCondition(() => {
+            return randomGraphNode1.getTargetNeighborStringIds().length >= 3
+                && randomGraphNode2.getTargetNeighborStringIds().length >= 3
+                && randomGraphNode3.getTargetNeighborStringIds().length >= 3
+                && randomGraphNode4.getTargetNeighborStringIds().length >= 3
+                && randomGraphNode5.getTargetNeighborStringIds().length >= 3
+        }, 10000)
+        expect(randomGraphNode1.getTargetNeighborStringIds().length).toBeGreaterThanOrEqual(3)
+        expect(randomGraphNode2.getTargetNeighborStringIds().length).toBeGreaterThanOrEqual(3)
+        expect(randomGraphNode3.getTargetNeighborStringIds().length).toBeGreaterThanOrEqual(3)
+        expect(randomGraphNode4.getTargetNeighborStringIds().length).toBeGreaterThanOrEqual(3)
+        expect(randomGraphNode5.getTargetNeighborStringIds().length).toBeGreaterThanOrEqual(3)
+    })
+
+    it('can propagate messages', async () => {
+        let numOfMessagesReceived = 0
+        randomGraphNode2.on('message', () => numOfMessagesReceived += 1)
+        randomGraphNode3.on('message', () => numOfMessagesReceived += 1)
+        randomGraphNode4.on('message', () => numOfMessagesReceived += 1)
+        randomGraphNode5.on('message', () => numOfMessagesReceived += 1)
+
+        await waitForCondition(() => {
+            return randomGraphNode1.getTargetNeighborStringIds().length >= 3
+                && randomGraphNode2.getTargetNeighborStringIds().length >= 3
+                && randomGraphNode3.getTargetNeighborStringIds().length >= 3
+                && randomGraphNode4.getTargetNeighborStringIds().length >= 3
+                && randomGraphNode5.getTargetNeighborStringIds().length >= 3
+        }, 10000)
+
+        const content: ContentMessage = {
+            body: JSON.stringify({ hello: 'WORLD' })
+        }
+        const msg = createStreamMessage(
+            content,
+            randomGraphId,
+            peerIdFromPeerDescriptor(epPeerDescriptor).toString()
+        )
+        randomGraphNode1.broadcast(msg)
+        await waitForCondition(() => numOfMessagesReceived >= 4)
+    })
+})

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

@@ -0,0 +1,97 @@
+import { PeerDescriptor, NodeType, PeerID, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '@streamr/dht'
+import { range } from 'lodash'
+import { waitForCondition } from '@streamr/utils'
+import { ContentMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { getRandomRegion } from '@streamr/dht'
+import { createStreamMessage } from '../utils/utils'
+import { NetworkStack } from '../../src/NetworkStack'
+
+describe('Full node network with WebRTC connections', () => {
+
+    const NUM_OF_NODES = 22
+
+    const epPeerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`entrypoint`).value,
+        type: NodeType.NODEJS,
+        websocket: { ip: 'localhost', port: 14444 },
+        region: getRandomRegion()
+    }
+
+    const randomGraphId = 'webrtc-network'
+
+    let entryPoint: NetworkStack
+
+    let nodes: NetworkStack[]
+
+    beforeEach(async () => {
+
+        nodes = []
+
+        entryPoint = new NetworkStack({
+            layer0: {
+                entryPoints: [epPeerDescriptor],
+                peerDescriptor: epPeerDescriptor
+            },
+            networkNode: {}
+        })
+        await entryPoint.start()
+        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
+        await entryPoint.getStreamrNode()!.joinStream(randomGraphId)
+
+        await Promise.all(range(NUM_OF_NODES).map(async (i) => {
+            const peerId = PeerID.fromString(`${i}`)
+            const peerDescriptor: PeerDescriptor = {
+                kademliaId: peerId.value,
+                type: NodeType.NODEJS,
+            }
+            const node = new NetworkStack({
+                layer0: {
+                    peerDescriptor,
+                    entryPoints: [epPeerDescriptor]
+                }, 
+                networkNode: {}
+            })
+            nodes.push(node)
+            await node.start()
+            node.getStreamrNode().setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
+            await node.getStreamrNode().joinStream(randomGraphId)
+            node.getStreamrNode!().subscribeToStream(randomGraphId)
+        }))
+
+    }, 90000)
+
+    afterEach(async () => {
+        await Promise.all([
+            entryPoint.stop(),
+            ...nodes.map((node) => node.stop())
+        ])
+    })
+
+    it('happy path', async () => {
+        await Promise.all(nodes.map((node) =>
+            waitForCondition(() => {
+                return node.getStreamrNode()!.getStream(randomGraphId)!.layer2.getTargetNeighborStringIds().length >= 3
+            }
+            , 120000)
+        ))
+        let numOfMessagesReceived = 0
+        const successIds: string[] = []
+        nodes.map((node) => {
+            node.getStreamrNode()!.on('newMessage', () => {
+                successIds.push(keyFromPeerDescriptor(node.getStreamrNode()!.getPeerDescriptor()))
+                numOfMessagesReceived += 1
+            })
+        })
+        const content: ContentMessage = {
+            body: JSON.stringify({ hello: 'WORLD' })
+        }
+        const msg = createStreamMessage(
+            content,
+            randomGraphId,
+            peerIdFromPeerDescriptor(epPeerDescriptor).toString()
+        )
+        entryPoint.getStreamrNode()!.publishToStream(randomGraphId, msg)
+        await waitForCondition(() => numOfMessagesReceived === NUM_OF_NODES)
+    }, 120000)
+
+})

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

@@ -0,0 +1,93 @@
+import { PeerDescriptor, NodeType, PeerID, peerIdFromPeerDescriptor, keyFromPeerDescriptor } from '@streamr/dht'
+import { range } from 'lodash'
+import { waitForCondition } from '@streamr/utils'
+import { ContentMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { createStreamMessage } from '../utils/utils'
+import { NetworkStack } from '../../src/NetworkStack'
+
+describe('Full node network with WebSocket connections only', () => {
+
+    const NUM_OF_NODES = 48
+    const epPeerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`entrypoint`).value,
+        type: NodeType.NODEJS,
+        nodeName: 'entrypoint',
+        websocket: { ip: 'localhost', port: 15555 }
+    }
+    const randomGraphId = 'websocket-network'
+
+    let entryPoint: NetworkStack
+
+    let nodes: NetworkStack[]
+
+    beforeEach(async () => {
+
+        nodes = []
+
+        entryPoint = new NetworkStack({
+            layer0: {
+                entryPoints: [epPeerDescriptor],
+                peerDescriptor: epPeerDescriptor,
+            },
+            networkNode: {}
+        })
+        await entryPoint.start()
+        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
+        await entryPoint.getStreamrNode()!.joinStream(randomGraphId)
+
+        await Promise.all(range(NUM_OF_NODES).map(async (i) => {
+            const node = new NetworkStack({
+                layer0: {
+                    entryPoints: [epPeerDescriptor],
+                    webSocketPort: 15556 + i,
+                    webSocketHost: 'localhost',
+                    peerIdString: `${i}`,
+                    nodeName: `${i}`,
+                    numberOfNodesPerKBucket: 4
+                }, 
+                networkNode: {}
+            })
+            nodes.push(node)
+            await node.start()
+            node.getStreamrNode!().setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
+            await node.getStreamrNode().joinStream(randomGraphId)
+            node.getStreamrNode!().subscribeToStream(randomGraphId)
+        }))
+
+    }, 120000)
+
+    afterEach(async () => {
+        await Promise.all([
+            entryPoint.stop(),
+            ...nodes.map((node) => node.stop())
+        ])
+    })
+
+    it('happy path', async () => {
+        await Promise.all(nodes.map((node) =>
+            waitForCondition(() => {
+                return node.getStreamrNode()!.getStream(randomGraphId)!.layer2.getTargetNeighborStringIds().length >= 3
+            }
+            , 120000)
+        ))
+        let numOfMessagesReceived = 0
+        const successIds: string[] = []
+        nodes.map((node) => {
+            node.getStreamrNode()!.on('newMessage', () => {
+                successIds.push(keyFromPeerDescriptor(node.getStreamrNode()!.getPeerDescriptor()))
+                numOfMessagesReceived += 1
+            })
+        })
+        const content: ContentMessage = {
+            body: JSON.stringify({ hello: 'WORLD' })
+        }
+        const msg = createStreamMessage(
+            content,
+            randomGraphId,
+            peerIdFromPeerDescriptor(epPeerDescriptor).toString()
+        )
+        entryPoint.getStreamrNode()!.publishToStream(randomGraphId, msg)
+        await waitForCondition(() => numOfMessagesReceived === NUM_OF_NODES)
+    }, 220000)
+
+})

package/test/integration/Handshakes.test.ts

@@ -0,0 +1,167 @@
+import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
+import {
+    NodeType,
+    PeerDescriptor,
+    ListeningRpcCommunicator,
+    Simulator,
+    SimulatorTransport,
+    peerIdFromPeerDescriptor
+} from '@streamr/dht'
+import { toProtoRpcClient } from '@streamr/proto-rpc'
+import {
+    HandshakeRpcClient
+} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { PeerList } from '../../src/logic/PeerList'
+import { mockConnectionLocker } from '../utils/utils'
+import { StreamHandshakeRequest, StreamHandshakeResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { RemoteHandshaker } from '../../src/logic/neighbor-discovery/RemoteHandshaker'
+
+describe('Handshakes', () => {
+
+    const peerDescriptor1: PeerDescriptor = {
+        kademliaId: new Uint8Array([1, 1, 1]),
+        type: NodeType.NODEJS
+    }
+    const peerDescriptor2: PeerDescriptor = {
+        kademliaId: new Uint8Array([2, 1, 1]),
+        type: NodeType.NODEJS
+    }
+    const peerDescriptor3: PeerDescriptor = {
+        kademliaId: new Uint8Array([3, 1, 1]),
+        type: NodeType.NODEJS
+    }
+    let rpcCommunicator1: ListeningRpcCommunicator
+    let rpcCommunicator2: ListeningRpcCommunicator
+    let rpcCommunicator3: ListeningRpcCommunicator
+    let contactPool: PeerList
+    let targetNeighbors: PeerList
+    let handshaker: Handshaker
+    const randomGraphId = 'handshaker'
+
+    const acceptHandshake = async (request: StreamHandshakeRequest, _context: ServerCallContext): Promise<StreamHandshakeResponse> => {
+        const response: StreamHandshakeResponse = {
+            requestId: request.requestId,
+            accepted: true
+        }
+        return response
+    }
+
+    const rejectHandshake = async (request: StreamHandshakeRequest, _context: ServerCallContext): Promise<StreamHandshakeResponse> => {
+        const response: StreamHandshakeResponse = {
+            requestId: request.requestId,
+            accepted: false
+        }
+        return response
+    }
+
+    const interleavingHandshake = async (request: StreamHandshakeRequest, _context: ServerCallContext): Promise<StreamHandshakeResponse> => {
+        const response: StreamHandshakeResponse = {
+            requestId: request.requestId,
+            accepted: true,
+            interleaveTarget: peerDescriptor3
+        }
+        return response
+    }
+
+    let simulator: Simulator
+    let simulatorTransport1: SimulatorTransport
+    let simulatorTransport2: SimulatorTransport
+    let simulatorTransport3: SimulatorTransport
+
+    beforeEach(() => {
+        Simulator.useFakeTimers()
+        simulator = new Simulator()
+        simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        simulatorTransport3 = new SimulatorTransport(peerDescriptor3, simulator)
+
+        rpcCommunicator1 = new ListeningRpcCommunicator(randomGraphId, simulatorTransport1)
+        rpcCommunicator2 = new ListeningRpcCommunicator(randomGraphId, simulatorTransport2)
+        rpcCommunicator3 = new ListeningRpcCommunicator(randomGraphId, simulatorTransport3)
+
+        const handshakerPeerId = peerIdFromPeerDescriptor(peerDescriptor2)
+        contactPool = new PeerList(handshakerPeerId, 10)
+        targetNeighbors = new PeerList(handshakerPeerId, 4)
+        handshaker = new Handshaker({
+            ownPeerDescriptor: peerDescriptor2,
+            randomGraphId: randomGraphId,
+            nearbyContactPool: contactPool,
+            randomContactPool: contactPool,
+            targetNeighbors: targetNeighbors,
+            connectionLocker: mockConnectionLocker,
+            rpcCommunicator: rpcCommunicator2,
+            N: 4
+        })
+
+    })
+
+    afterEach(async () => {
+        rpcCommunicator1.stop()
+        rpcCommunicator2.stop()
+        rpcCommunicator3.stop()
+        await simulatorTransport1.stop()
+        await simulatorTransport2.stop()
+        await simulatorTransport3.stop()
+        simulator.stop()
+        Simulator.useFakeTimers(false)
+    })
+
+    it('Two peers can handshake', async () => {
+        rpcCommunicator1.registerRpcMethod(StreamHandshakeRequest, StreamHandshakeResponse, 'handshake', acceptHandshake)
+        // @ts-expect-error private
+        const res = await handshaker.handshakeWithTarget(
+            new RemoteHandshaker(
+                peerDescriptor1,
+                randomGraphId,
+                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport())),
+            )
+        )
+        expect(res).toEqual(true)
+        expect(targetNeighbors.hasPeer(peerDescriptor1)).toEqual(true)
+    })
+
+    it('Handshake accepted', async () => {
+        rpcCommunicator1.registerRpcMethod(StreamHandshakeRequest, StreamHandshakeResponse, 'handshake', acceptHandshake)
+        // @ts-expect-error private
+        const res = await handshaker.handshakeWithTarget(
+            new RemoteHandshaker(
+                peerDescriptor1,
+                randomGraphId,
+                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport())),
+            )
+        )
+        expect(res).toEqual(true)
+        expect(targetNeighbors.hasPeer(peerDescriptor1)).toEqual(true)
+    })
+
+    it('Handshake rejected', async () => {
+        rpcCommunicator1.registerRpcMethod(StreamHandshakeRequest, StreamHandshakeResponse, 'handshake', rejectHandshake)
+        // @ts-expect-error private
+        const res = await handshaker.handshakeWithTarget(
+            new RemoteHandshaker(
+                peerDescriptor1,
+                randomGraphId,
+                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport())),
+            )
+        )
+        expect(res).toEqual(false)
+        expect(targetNeighbors.hasPeer(peerDescriptor1)).toEqual(false)
+    })
+
+    it('Handshake with Interleaving', async () => {
+        rpcCommunicator1.registerRpcMethod(StreamHandshakeRequest, StreamHandshakeResponse, 'handshake', interleavingHandshake)
+        rpcCommunicator3.registerRpcMethod(StreamHandshakeRequest, StreamHandshakeResponse, 'handshake', acceptHandshake)
+        // @ts-expect-error private
+        const res = await handshaker.handshakeWithTarget(
+            new RemoteHandshaker(
+                peerDescriptor1,
+                randomGraphId,
+                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport())),
+            )
+        )
+        expect(res).toEqual(true)
+        expect(targetNeighbors.hasPeer(peerDescriptor1)).toEqual(true)
+        expect(targetNeighbors.hasPeer(peerDescriptor3)).toEqual(true)
+    })
+})