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

package/test/unit/DuplicateMessageDetector.test.ts

@@ -1,192 +0,0 @@
-import { DuplicateMessageDetector, NumberPair, GapMisMatchError, InvalidNumberingError } from '../../src/logic/DuplicateMessageDetector'
-
-test('starts empty', () => {
-    const detector = new DuplicateMessageDetector()
-    expect(detector.toString()).toEqual('')
-})
-
-test('first check initializes default gap', () => {
-    const detector = new DuplicateMessageDetector()
-    const result = detector.markAndCheck(new NumberPair(1, 5), new NumberPair(10, 10))
-    const state = detector.toString()
-    expect(result).toEqual(true)
-    expect(state).toEqual('(10|10, Infinity|Infinity]')
-})
-
-test('checking numbers in order introduces no new gaps', () => {
-    const detector = new DuplicateMessageDetector()
-    detector.markAndCheck(null, new NumberPair(10, 0))
-    expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0))).toEqual(true)
-    expect(detector.markAndCheck(new NumberPair(20, 0), new NumberPair(30, 0))).toEqual(true)
-    expect(detector.markAndCheck(null, new NumberPair(30, 1))).toEqual(true)
-    expect(detector.markAndCheck(new NumberPair(30, 1), new NumberPair(30, 5))).toEqual(true)
-    const state = detector.toString()
-    expect(state).toEqual('(30|5, Infinity|Infinity]')
-})
-
-test('skipping next expected messages creates gaps', () => {
-    const detector = new DuplicateMessageDetector()
-    detector.markAndCheck(null, new NumberPair(10, 0))
-
-    expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 0))).toEqual(true)
-    expect(detector.toString()).toEqual('(10|0, 15|0], (20|0, Infinity|Infinity]')
-
-    expect(detector.markAndCheck(new NumberPair(30, 0), new NumberPair(40, 0))).toEqual(true)
-    expect(detector.toString()).toEqual('(10|0, 15|0], (20|0, 30|0], (40|0, Infinity|Infinity]')
-
-    expect(detector.markAndCheck(new NumberPair(40, 10), new NumberPair(80, 20))).toEqual(true)
-    expect(detector.toString()).toEqual('(10|0, 15|0], (20|0, 30|0], (40|0, 40|10], (80|20, Infinity|Infinity]')
-})
-
-test('only last gap is checked if no previous number given', () => {
-    const detector = new DuplicateMessageDetector()
-    detector.markAndCheck(null, new NumberPair(10, 0))
-    detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0))
-
-    expect(detector.markAndCheck(null, new NumberPair(15, 0))).toEqual(false)
-    expect(detector.markAndCheck(null, new NumberPair(30, 5))).toEqual(true)
-    const state = detector.toString()
-    expect(state).toEqual('(30|5, Infinity|Infinity]')
-})
-
-describe('gap handling', () => {
-    let detector: DuplicateMessageDetector
-    beforeEach(() => {
-        detector = new DuplicateMessageDetector()
-        detector.markAndCheck(null, new NumberPair(10, 0))
-        detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
-        detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
-        expect(detector.toString()).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-    })
-
-    test('gap division', () => {
-        expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(18, 0))).toEqual(true)
-        expect(detector.toString()).toEqual('(10|0, 15|0], (18|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-
-        expect(detector.markAndCheck(new NumberPair(60, 0), new NumberPair(79, 5))).toEqual(true)
-        expect(detector.toString()).toEqual('(10|0, 15|0], (18|0, 20|0], (40|0, 60|0], (79|5, 80|10], (100|0, Infinity|Infinity]')
-    })
-
-    test('left-side gap contraction', () => {
-        expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(15, 0))).toEqual(true)
-        expect(detector.toString()).toEqual('(15|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-
-        expect(detector.markAndCheck(new NumberPair(40, 0), new NumberPair(80, 9))).toEqual(true)
-        expect(detector.toString()).toEqual('(15|0, 20|0], (80|9, 80|10], (100|0, Infinity|Infinity]')
-    })
-
-    test('right-side gap contraction', () => {
-        expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 0))).toEqual(true)
-        expect(detector.toString()).toEqual('(10|0, 15|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-
-        expect(detector.markAndCheck(new NumberPair(40, 1), new NumberPair(80, 10))).toEqual(true)
-        expect(detector.toString()).toEqual('(10|0, 15|0], (40|0, 40|1], (100|0, Infinity|Infinity]')
-    })
-
-    test('full contraction', () => {
-        expect(detector.markAndCheck(new NumberPair(40, 0), new NumberPair(80, 10))).toEqual(true)
-        expect(detector.toString()).toEqual('(10|0, 20|0], (100|0, Infinity|Infinity]')
-
-        expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0))).toEqual(true)
-        expect(detector.toString()).toEqual('(100|0, Infinity|Infinity]')
-    })
-})
-
-describe('duplicates return false and do not change state', () => {
-    let detector: DuplicateMessageDetector
-    let expectedState: string
-    beforeEach(() => {
-        detector = new DuplicateMessageDetector()
-        detector.markAndCheck(new NumberPair(1, 0), new NumberPair(10, 0))
-        detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
-        detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
-        expectedState = detector.toString()
-        expect(expectedState).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-    })
-
-    it('way below 1st gap', () => {
-        expect(detector.markAndCheck(new NumberPair(5, 0), new NumberPair(7, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('number touches lower bound of 1st gap', () => {
-        expect(detector.markAndCheck(new NumberPair(8, 0), new NumberPair(10, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('in-between gaps', () => {
-        expect(detector.markAndCheck(new NumberPair(25, 5), new NumberPair(30, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('number touches lower bound of 2nd gap', () => {
-        expect(detector.markAndCheck(new NumberPair(25, 0), new NumberPair(40, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('previous number touches upper bound of 2nd gap', () => {
-        expect(detector.markAndCheck(new NumberPair(80, 10), new NumberPair(90, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('previous number not provided, number is below last gap', () => {
-        expect(detector.markAndCheck(null, new NumberPair(80, 10))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('previous number not provided, number touches lower bound of last gap', () => {
-        expect(detector.markAndCheck(null, new NumberPair(100, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-})
-
-describe('erroneous messages that overlap gaps', () => {
-    let detector: DuplicateMessageDetector
-    let expectedState
-    beforeEach(() => {
-        detector = new DuplicateMessageDetector()
-        detector.markAndCheck(new NumberPair(1, 0), new NumberPair(10, 0))
-        detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
-        detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
-        expectedState = detector.toString()
-        expect(expectedState).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-    })
-
-    it('completely around gap', () => {
-        expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(30, 0))).toThrow(GapMisMatchError)
-    })
-
-    it('previousNumber below gap while number in gap', () => {
-        expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(15, 0))).toThrow(GapMisMatchError)
-    })
-
-    it('previousNumber in gap while number over gap', () => {
-        expect(() => detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 5))).toThrow(GapMisMatchError)
-    })
-
-    it('completely around multiple gaps', () => {
-        expect(() => detector.markAndCheck(new NumberPair(10, 0), new NumberPair(200, 0))).toThrow(GapMisMatchError)
-    })
-})
-
-test('checks that number > previousNumber', () => {
-    const detector = new DuplicateMessageDetector()
-    expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(1, 0)))
-        .toThrow(InvalidNumberingError)
-    expect(() => detector.markAndCheck(new NumberPair(5, 5), new NumberPair(5, 5)))
-        .toThrow(InvalidNumberingError)
-})
-
-test('lowest gaps get dropped when reaching maximum number of gaps', () => {
-    const detector = new DuplicateMessageDetector(3)
-    detector.markAndCheck(new NumberPair(1, 0), new NumberPair(10, 0))
-    detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
-    detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
-    expect(detector.toString()).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-
-    detector.markAndCheck(new NumberPair(150, 0), new NumberPair(200, 0))
-    expect(detector.toString()).toEqual('(40|0, 80|10], (100|0, 150|0], (200|0, Infinity|Infinity]')
-
-    detector.markAndCheck(new NumberPair(50, 0), new NumberPair(70, 0))
-    expect(detector.toString()).toEqual('(70|0, 80|10], (100|0, 150|0], (200|0, Infinity|Infinity]')
-})

package/test/unit/ExternalNetworkRpc.test.ts

@@ -1,48 +0,0 @@
-import { Message } from '@streamr/dht'
-import { ExternalNetworkRpc, SERVICE_ID } from '../../src/logic/ExternalNetworkRpc'
-import { HandshakeRequest, HandshakeResponse } from '../../generated/packages/dht/protos/DhtRpc'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { RpcMessage } from '@streamr/proto-rpc'
-import { Any } from '../../generated/google/protobuf/any'
-import { HandshakeRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-
-describe('ExternalNetworkRpc', () => {
-
-    let rpc: ExternalNetworkRpc
-    let fn: jest.Mock
-    let transport: MockTransport
-
-    beforeEach(() => {
-        transport = new MockTransport
-        rpc = new ExternalNetworkRpc(transport)
-        fn = jest.fn()
-    })
-
-    afterEach(() => {
-        rpc.destroy()
-    })
-
-    it('registers method', async () => {
-        rpc.registerRpcMethod(HandshakeRequest, HandshakeResponse, 'handshake', () => fn())
-        transport.emit('message', Message.create({
-            serviceId: SERVICE_ID,
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create({
-                    header: {
-                        request: 'request',
-                        method: 'handshake'
-                    },
-                    body: Any.pack(HandshakeRequest.create(), HandshakeRequest)
-                })
-            }
-        }))
-        expect(fn).toHaveBeenCalledTimes(1)
-    })
-
-    it('creates clients', async () => {
-        const client = rpc.createRpcClient(HandshakeRpcClient)
-        expect(client.methods.length).toEqual(2)
-    })
-
-})

package/test/unit/FifoMapWithTtl.test.ts

@@ -1,253 +0,0 @@
-import { FifoMapWithTTL } from '../../src/logic/propagation/FifoMapWithTTL'
-
-describe('FifoMapWithTtl', () => {
-    describe('invalid constructor arguments', () => {
-        it('cannot instantiate with negative ttl', () => {
-            expect(() => new FifoMapWithTTL({ ttlInMs: -5, maxSize: 10 }))
-                .toThrow('ttlInMs (-5) cannot be < 0')
-        })
-
-        it('cannot instantiate with negative maxSize', () => {
-            expect(() => new FifoMapWithTTL({ ttlInMs: 100, maxSize: -6 }))
-                .toThrow('maxSize (-6) cannot be < 0')
-        })
-    })
-
-    it('of maxSize=0 always remains empty', () => {
-        const fifoMap = new FifoMapWithTTL<string, string>({
-            ttlInMs: 100,
-            maxSize: 0
-        })
-        fifoMap.set('hello', 'world')
-        fifoMap.set('are', 'you empty?')
-        expect(fifoMap.get('hello')).toBeUndefined()
-        expect(fifoMap.get('are')).toBeUndefined()
-    })
-
-    describe('of maxSize=5', () => {
-        let fifoMap: FifoMapWithTTL<string, string>
-
-        beforeEach(() => {
-            fifoMap = new FifoMapWithTTL<string, string>({
-                ttlInMs: 100,
-                maxSize: 5
-            })
-        })
-
-        function setFirstFiveMessages() {
-            fifoMap.set('1st', 'foo')
-            fifoMap.set('2nd', 'bar')
-            fifoMap.set('3rd', 'hello')
-            fifoMap.set('4th', 'world')
-            fifoMap.set('5th', '!')
-        }
-
-        function set6thAnd7thMessages() {
-            fifoMap.set('6th', 'new')
-            fifoMap.set('7th', 'messages')
-        }
-
-        it('can insert 5 items and retrieve all of them', () => {
-            setFirstFiveMessages()
-            expect(fifoMap.get('1st')).toEqual('foo')
-            expect(fifoMap.get('2nd')).toEqual('bar')
-            expect(fifoMap.get('3rd')).toEqual('hello')
-            expect(fifoMap.get('4th')).toEqual('world')
-            expect(fifoMap.get('5th')).toEqual('!')
-        })
-
-        it('inserting items when full causes oldest items to get dropped', () => {
-            setFirstFiveMessages()
-            set6thAnd7thMessages()
-            expect(fifoMap.get('1st')).toBeUndefined()
-            expect(fifoMap.get('2nd')).toBeUndefined()
-            expect(fifoMap.get('3rd')).toEqual('hello')
-            expect(fifoMap.get('4th')).toEqual('world')
-            expect(fifoMap.get('5th')).toEqual('!')
-            expect(fifoMap.get('6th')).toEqual('new')
-            expect(fifoMap.get('7th')).toEqual('messages')
-        })
-
-        describe('(re-)setting an item', () => {
-            beforeEach(() => {
-                setFirstFiveMessages()
-                fifoMap.set('4th', 'modified-once')
-                fifoMap.set('4th', 'modified-twice')
-            })
-
-            it('does not cause oldest items to drop', () => {
-                expect(fifoMap.get('1st')).toEqual('foo')
-                expect(fifoMap.get('2nd')).toEqual('bar')
-                expect(fifoMap.get('3rd')).toEqual('hello')
-                expect(fifoMap.get('5th')).toEqual('!')
-            })
-
-            it('newest value stays in place', () => {
-                expect(fifoMap.get('4th')).toEqual('modified-twice')
-            })
-        })
-
-        describe('#delete', () => {
-            it('can delete an item', () => {
-                setFirstFiveMessages()
-                fifoMap.delete('4th')
-                expect(fifoMap.get('1st')).toEqual('foo')
-                expect(fifoMap.get('2nd')).toEqual('bar')
-                expect(fifoMap.get('3rd')).toEqual('hello')
-                expect(fifoMap.get('4th')).toBeUndefined()
-                expect(fifoMap.get('5th')).toEqual('!')
-            })
-
-            it('deleting items makes room for new ones', () => {
-                setFirstFiveMessages()
-                fifoMap.delete('2nd')
-                fifoMap.delete('4th')
-                set6thAnd7thMessages()
-                expect(fifoMap.get('1st')).toEqual('foo')
-                expect(fifoMap.get('2nd')).toBeUndefined()
-                expect(fifoMap.get('3rd')).toEqual('hello')
-                expect(fifoMap.get('4th')).toBeUndefined()
-                expect(fifoMap.get('5th')).toEqual('!')
-                expect(fifoMap.get('6th')).toEqual('new')
-                expect(fifoMap.get('7th')).toEqual('messages')
-            })
-
-            it('deleting a non-existing item does not throw', () => {
-                setFirstFiveMessages()
-                expect(() =>fifoMap.delete('non-existing-key')).not.toThrow()
-            })
-
-            it('deleting a non-existing item keeps existing items intact', () => {
-                setFirstFiveMessages()
-                fifoMap.delete('non-existing-key')
-                expect(fifoMap.get('1st')).toEqual('foo')
-                expect(fifoMap.get('2nd')).toEqual('bar')
-                expect(fifoMap.get('3rd')).toEqual('hello')
-                expect(fifoMap.get('4th')).toEqual('world')
-                expect(fifoMap.get('5th')).toEqual('!')
-            })
-        })
-
-        describe('TTL', () => {
-            let time: number
-
-            beforeEach(() => {
-                time = 0
-                fifoMap = new FifoMapWithTTL<string, string>({
-                    ttlInMs: 100,
-                    maxSize: 5,
-                    timeProvider: () => time
-                })
-            })
-
-            it('#get returns undefined after TTL', () => {
-                time = 0
-                fifoMap.set('hello', 'world')
-                time = 50
-                fifoMap.set('foo', 'bar')
-
-                time = 100
-                expect(fifoMap.get('hello')).toBeUndefined()
-                expect(fifoMap.get('foo')).toEqual('bar')
-
-                time = 160
-                expect(fifoMap.get('hello')).toBeUndefined()
-                expect(fifoMap.get('foo')).toBeUndefined()
-            })
-
-            it('re-setting an item resets TTL', () => {
-                time = 0
-                fifoMap.set('hello', 'world')
-
-                time = 90
-                fifoMap.set('hello', 'world')
-
-                time = 100
-                expect(fifoMap.get('hello')).toEqual('world')
-            })
-
-            it('re-setting expired resets TTL', () => {
-                time = 0
-                fifoMap.set('hello', 'world')
-
-                time = 110
-                expect(fifoMap.get('hello')).toBeUndefined() // sanity check
-                fifoMap.set('hello', 'world')
-
-                time = 150
-                expect(fifoMap.get('hello')).toEqual('world')
-            })
-
-            it('#values returns non-expired items', () => {
-                time = 0
-                fifoMap.set('hello', 'world')
-                time = 50
-                fifoMap.set('foo', 'bar')
-                time = 100
-                fifoMap.set('lorem', 'ipsum')
-                time = 120
-                fifoMap.set('dolor', 'sit')
-
-                expect(fifoMap.values()).toEqual(['bar', 'ipsum', 'sit'])
-
-                time = 130
-                fifoMap.set('amet', 'consectetur')
-
-                expect(fifoMap.values()).toEqual(['bar', 'ipsum', 'sit', 'consectetur'])
-
-                time = 200
-                expect(fifoMap.values()).toEqual(['sit', 'consectetur'])
-
-                time = 300
-                expect(fifoMap.values()).toEqual([])
-            })
-        })
-
-        describe('onItemDropped callback', () => {
-            let time: number
-            let onItemDropped: jest.Mock<undefined, [string]>
-
-            beforeEach(() => {
-                time = 0
-                onItemDropped = jest.fn<undefined, [string]>()
-                fifoMap = new FifoMapWithTTL<string, string>({
-                    ttlInMs: 100,
-                    maxSize: 5,
-                    onItemDropped,
-                    timeProvider: () => time
-                })
-            })
-
-            it('invoked when deleting an item', () => {
-                setFirstFiveMessages()
-                fifoMap.delete('3rd')
-                expect(onItemDropped).toHaveBeenCalledTimes(1)
-                expect(onItemDropped).toHaveBeenCalledWith('3rd')
-            })
-
-            it('invoked when items are dropped due to being full', () => {
-                setFirstFiveMessages()
-                set6thAnd7thMessages()
-                expect(onItemDropped).toHaveBeenCalledTimes(2)
-                expect(onItemDropped).toHaveBeenNthCalledWith(1, '1st')
-                expect(onItemDropped).toHaveBeenNthCalledWith(2, '2nd')
-            })
-
-            it('invoked when re-setting an item', () => {
-                setFirstFiveMessages()
-                fifoMap.set('4th', '!!!')
-                expect(onItemDropped).toHaveBeenCalledTimes(1)
-                expect(onItemDropped).toHaveBeenNthCalledWith(1, '4th')
-            })
-
-            it('invoked when getting a stale item', () => {
-                time = 0
-                setFirstFiveMessages()
-                time = 500
-                expect(fifoMap.get('1st')).toBeUndefined()
-                expect(onItemDropped).toHaveBeenCalledTimes(1)
-                expect(onItemDropped).toHaveBeenNthCalledWith(1, '1st')
-            })
-        })
-    })
-})

package/test/unit/HandshakeRpcLocal.test.ts

@@ -1,155 +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 '../../generated/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('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)
-    })
-
-})