@streamr/trackerless-network 100.0.0-pretestnet.6 → 100.0.0-rc.0

package/test/unit/EntrypointDiscovery.test.ts

@@ -20,24 +20,24 @@ describe('EntryPointDiscovery', () => {
     const deletedPeerDescriptor = createMockPeerDescriptor()
 
     const fakeData: DataEntry = {
+        key: Uint8Array.from([1, 2, 3]),
         data: Any.pack(peerDescriptor, PeerDescriptor),
+        creator: peerDescriptor.nodeId,
         ttl: 1000,
-        storer: peerDescriptor,
-        kademliaId: Uint8Array.from([1, 2, 3]),
         stale: false,
         deleted: false
     }
 
     const fakeDeletedData: DataEntry = {
+        key: Uint8Array.from([1, 2, 3]),
         data: Any.pack(deletedPeerDescriptor, PeerDescriptor),
+        creator: deletedPeerDescriptor.nodeId,
         ttl: 1000,
-        storer: deletedPeerDescriptor,
-        kademliaId: Uint8Array.from([1, 2, 3]),
         stale: false,
         deleted: true
     }
 
-    const fakeGetEntryPointData = async (): Promise<DataEntry[]> => {
+    const fakeFetchEntryPointData = async (): Promise<DataEntry[]> => {
         return [fakeData, fakeDeletedData]
     }
 
@@ -46,7 +46,7 @@ describe('EntryPointDiscovery', () => {
         return [peerDescriptor]
     }
 
-    const fakeEmptyGetEntryPointData = async (): Promise<DataEntry[]> => {
+    const fakeEmptyFetchEntryPointData = async (): Promise<DataEntry[]> => {
         return []
     }
 
@@ -70,7 +70,7 @@ describe('EntryPointDiscovery', () => {
             localPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
             layer1Node,
-            getEntryPointData: fakeGetEntryPointData,
+            fetchEntryPointData: fakeFetchEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
             storeInterval: 2000
@@ -79,7 +79,7 @@ describe('EntryPointDiscovery', () => {
             localPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
             layer1Node,
-            getEntryPointData: fakeEmptyGetEntryPointData,
+            fetchEntryPointData: fakeEmptyFetchEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
             storeInterval: 2000
@@ -112,17 +112,20 @@ describe('EntryPointDiscovery', () => {
     it('store on empty stream', async () => {
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
+        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
     })
 
     it('store on stream without saturated entrypoint count', async () => {
         addNodesToStreamPart(layer1Node, 4)
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
+        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
     })
 
     it('will keep stored until destroyed', async () => {
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
+        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
         await wait(4500)
         await entryPointDiscoveryWithData.destroy()
         // we have configured storeInterval to 2 seconds, i.e. after 4.5 seconds it should have been called 2 more items 

package/test/unit/GroupKeyResponseTranslator.test.ts

@@ -15,7 +15,7 @@ describe('GroupKeyResponseTranslator', () => {
     })
     const newGroupKey: GroupKey = {
         id: 'id',
-        data: hexToBinary('0000')!
+        data: hexToBinary('0000')
     }
     const newGroupKeyResponse: GroupKeyResponse = {
         requestId: 'request',

package/test/unit/HandshakeRpcLocal.test.ts

@@ -1,10 +1,8 @@
-import { NodeType } from '@streamr/dht'
-import { hexToBinary } from '@streamr/utils'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { DhtAddress, NodeType, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '@streamr/dht'
 import { NodeList } from '../../src/logic/NodeList'
 import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
-import { InterleaveNotice, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor, createMockHandshakeRpcRemote, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { InterleaveRequest, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { createMockPeerDescriptor, createMockHandshakeRpcRemote, createMockDeliveryRpcRemote } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
@@ -15,27 +13,28 @@ describe('HandshakeRpcLocal', () => {
 
     const localPeerDescriptor = createMockPeerDescriptor()
 
-    let targetNeighbors: NodeList
-    let ongoingHandshakes: Set<NodeID>
+    let neighbors: NodeList
+    let ongoingHandshakes: Set<DhtAddress>
+    let ongoingInterleaves: Set<DhtAddress>
     let handshakeWithInterleaving: jest.Mock
 
     beforeEach(() => {
-        targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), 10)
+        neighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), 10)
         ongoingHandshakes = new Set()
-
+        ongoingInterleaves = new Set()
         handshakeWithInterleaving = jest.fn()
 
         rpcLocal = new HandshakeRpcLocal({
             streamPartId: STREAM_PART_ID,
-            connectionLocker: mockConnectionLocker,
             ongoingHandshakes,
+            ongoingInterleaves,
             createRpcRemote: (_p) => createMockHandshakeRpcRemote(),
             createDeliveryRpcRemote: (_p) => createMockDeliveryRpcRemote(),
             handshakeWithInterleaving: async (_p, _t) => {
                 handshakeWithInterleaving()
                 return true
             },
-            targetNeighbors,
+            neighbors,
             maxNeighborCount: 4
         })
     })
@@ -54,10 +53,10 @@ describe('HandshakeRpcLocal', () => {
     })
 
     it('handshake interleave', async () => {
-        targetNeighbors.add(createMockDeliveryRpcRemote())
-        targetNeighbors.add(createMockDeliveryRpcRemote())
-        targetNeighbors.add(createMockDeliveryRpcRemote())
-        targetNeighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
         const req = StreamPartHandshakeRequest.create({
             streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
@@ -70,10 +69,10 @@ describe('HandshakeRpcLocal', () => {
     })
 
     it('unaccepted handshake', async () => {
-        ongoingHandshakes.add('0x2222' as NodeID)
-        ongoingHandshakes.add('0x3333' as NodeID)
-        ongoingHandshakes.add('0x4444' as NodeID)
-        ongoingHandshakes.add('0x5555' as NodeID)
+        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'
@@ -85,31 +84,84 @@ describe('HandshakeRpcLocal', () => {
     })
 
     it('handshakeWithInterleaving success', async () => {
-        const req: InterleaveNotice = {
-            streamPartId: STREAM_PART_ID,
+        const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
-                kademliaId: hexToBinary('0x2222'),
+                nodeId: getRawFromDhtAddress('0x2222' as DhtAddress),
                 type: NodeType.NODEJS
             }
-
         }
-        await rpcLocal.interleaveNotice(req, {
+        await rpcLocal.interleaveRequest(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
     })
 
     it('handshakeWithInterleaving success', async () => {
-        const req: InterleaveNotice = {
-            streamPartId: StreamPartIDUtils.parse('other-stream#0'),
+        const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
-                kademliaId: hexToBinary('0x2222'),
+                nodeId: getRawFromDhtAddress('0x2222' as DhtAddress),
                 type: NodeType.NODEJS
             }
         }
-        await rpcLocal.interleaveNotice(req, {
+        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(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        const requestor = createMockPeerDescriptor()
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(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(createMockDeliveryRpcRemote(interleavingPeer1))
+        neighbors.add(createMockDeliveryRpcRemote(interleavingPeer2))
+        neighbors.add(createMockDeliveryRpcRemote(interleavingPeer3))
+        neighbors.add(createMockDeliveryRpcRemote())
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer1))
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer2))
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(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(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        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,9 +1,8 @@
-import { ListeningRpcCommunicator, Simulator, SimulatorTransport } from '@streamr/dht'
+import { ListeningRpcCommunicator, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { range } from 'lodash'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { NodeList } from '../../src/logic/NodeList'
 import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
-import { createMockPeerDescriptor, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, createMockDeliveryRpcRemote } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Handshaker', () => {
@@ -14,7 +13,9 @@ describe('Handshaker', () => {
     const maxNeighborCount = 4
     const streamPartId = StreamPartIDUtils.parse('stream#0')
 
-    let targetNeighbors: NodeList
+    let neighbors: NodeList
+    let leftNodeView: NodeList
+    let rightNodeView: NodeList
     let nearbyNodeView: NodeList
     let randomNodeView: NodeList
 
@@ -28,20 +29,24 @@ describe('Handshaker', () => {
         const rpcCommunicator = new ListeningRpcCommunicator(streamPartId, simulatorTransport)
 
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-        targetNeighbors = new NodeList(nodeId, 10)
+        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,
-            connectionLocker: mockConnectionLocker,
-            targetNeighbors,
+            neighbors,
+            leftNodeView,
+            rightNodeView,
             nearbyNodeView,
             randomNodeView,
             rpcCommunicator,
             maxNeighborCount,
-            rpcRequestTimeout: 5000
+            rpcRequestTimeout: 5000,
+            ongoingHandshakes: new Set()
         })
     })
 
@@ -56,7 +61,7 @@ describe('Handshaker', () => {
     })
 
     it('attemptHandshakesOnContact with known nodes that cannot be connected to', async () => {
-        range(2).forEach(() => nearbyNodeView.add(createMockDeliveryRpcRemote()))
+        range(2).forEach(() => randomNodeView.add(createMockDeliveryRpcRemote()))
         const res = await handshaker.attemptHandshakesOnContacts([])
         expect(res.length).toEqual(2)
     })

package/test/unit/InspectSession.test.ts

@@ -2,14 +2,13 @@ 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 { NodeID } from '../../src/identifiers'
-import { createRandomNodeId } from '../utils/utils'
+import { DhtAddress, createRandomDhtAddress } from '@streamr/dht'
 
 describe('InspectSession', () => {
 
     let inspectSession: InspectSession
-    let inspectedNode: NodeID
-    let anotherNode: NodeID
+    let inspectedNode: DhtAddress
+    let anotherNode: DhtAddress
 
     const publisherId = utf8ToBinary('publisherId')
     const messageId1: MessageID = {
@@ -31,8 +30,8 @@ describe('InspectSession', () => {
     }
 
     beforeEach(() => {
-        inspectedNode = createRandomNodeId()
-        anotherNode = createRandomNodeId()
+        inspectedNode = createRandomDhtAddress()
+        anotherNode = createRandomDhtAddress()
         inspectSession = new InspectSession({
             inspectedNode
         })

package/test/unit/Inspector.test.ts

@@ -1,9 +1,8 @@
-import { ListeningRpcCommunicator } from '@streamr/dht'
+import { ListeningRpcCommunicator, createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { utf8ToBinary } from '@streamr/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { Inspector } from '../../src/logic/inspect/Inspector'
 import { MockTransport } from '../utils/mock/Transport'
-import { createMockPeerDescriptor, createRandomNodeId, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, mockConnectionLocker } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Inspector', () => {
@@ -13,7 +12,7 @@ describe('Inspector', () => {
 
     const inspectedDescriptor = createMockPeerDescriptor()
 
-    const nodeId = createRandomNodeId()
+    const nodeId = createRandomDhtAddress()
     let mockConnect: jest.Mock
 
     const messageRef = {

package/test/unit/NeighborFinder.test.ts

@@ -3,34 +3,37 @@ import { NodeList } from '../../src/logic/NodeList'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { expect } from 'expect'
-import { createMockDeliveryRpcRemote, createRandomNodeId } from '../utils/utils'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { createMockDeliveryRpcRemote } from '../utils/utils'
+import { DhtAddress, createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 
 describe('NeighborFinder', () => {
 
-    const nodeId = createRandomNodeId()
-    let targetNeighbors: NodeList
+    const nodeId = createRandomDhtAddress()
+    let neighbors: NodeList
     let nearbyNodeView: NodeList
     let neighborFinder: NeighborFinder
 
     const minCount = 4
 
     beforeEach(() => {
-        targetNeighbors = new NodeList(nodeId, 15)
+        neighbors = new NodeList(nodeId, 15)
         nearbyNodeView = new NodeList(nodeId, 30)
         range(30).forEach(() => nearbyNodeView.add(createMockDeliveryRpcRemote()))
-        const mockDoFindNeighbors = async (excluded: NodeID[]) => {
+        const mockDoFindNeighbors = async (excluded: DhtAddress[]) => {
             const target = nearbyNodeView.getRandom(excluded)
             if (Math.random() < 0.5) {
-                targetNeighbors.add(target!)
+                neighbors.add(target!)
             } else {
                 excluded.push(getNodeIdFromPeerDescriptor(target!.getPeerDescriptor()))
             }
             return excluded
         }
         neighborFinder = new NeighborFinder({
-            targetNeighbors,
+            neighbors,
             nearbyNodeView,
+            leftNodeView: new NodeList(nodeId, 30),
+            rightNodeView: new NodeList(nodeId, 30),
+            randomNodeView: new NodeList(nodeId, 30),
             doFindNeighbors: (excluded) => mockDoFindNeighbors(excluded),
             minCount
         })
@@ -42,7 +45,7 @@ describe('NeighborFinder', () => {
 
     it('Finds target number of nodes', async () => {
         neighborFinder.start()
-        await waitForCondition(() => targetNeighbors.size() >= minCount, 10000)
+        await waitForCondition(() => neighbors.size() >= minCount, 10000)
         expect(neighborFinder.isRunning()).toEqual(false)
     })
 })

package/test/unit/NeighborUpdateRpcLocal.test.ts

@@ -0,0 +1,139 @@
+import { DhtAddress, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
+import { NeighborUpdateRpcLocal } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcLocal'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { NodeList } from '../../src/logic/NodeList'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { MockTransport } from '../utils/mock/Transport'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
+import { range } from 'lodash'
+
+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 DeliveryRpcRemote(
+                localPeerDescriptor,
+                createMockPeerDescriptor(),
+                rpcCommunicator,
+                DeliveryRpcClient
+            ))
+        }
+    }
+
+    beforeEach(() => {
+        rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
+        neighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), neighborTargetCount + 1)
+        nearbyNodeView = new NodeList(getNodeIdFromPeerDescriptor(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 DeliveryRpcRemote(
+            localPeerDescriptor,
+            caller,
+            rpcCommunicator,
+            DeliveryRpcClient
+        )
+        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 DeliveryRpcRemote(
+            localPeerDescriptor,
+            caller,
+            rpcCommunicator,
+            DeliveryRpcClient
+        )
+        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(getNodeIdFromPeerDescriptor(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(getNodeIdFromPeerDescriptor(caller))
+        const res = await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: [localPeerDescriptor],
+            removeMe: false
+        }, { incomingSourceDescriptor: caller } as any)
+        expect(res.removeMe).toEqual(false)
+    })
+
+})