@streamr/dht 102.0.0-beta.0 → 102.0.0-beta.2

package/test/unit/RoutingSession.test.ts

@@ -1,79 +0,0 @@
-import { v4 } from 'uuid'
-import { RoutingMode, RoutingSession } from '../../src/dht/routing/RoutingSession'
-import { Message, PeerDescriptor, RouteMessageWrapper } from '../../generated/packages/dht/protos/DhtRpc'
-import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../utils/utils'
-import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
-import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
-import { DhtAddress, toNodeId } from '../../src/identifiers'
-import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
-import { RoutingTablesCache } from '../../src/dht/routing/RoutingTablesCache'
-
-describe('RoutingSession', () => {
-
-    let session: RoutingSession
-    let connections: Map<DhtAddress, DhtNodeRpcRemote>
-    let rpcCommunicator: RoutingRpcCommunicator
-    let routingTablesCache: RoutingTablesCache
-    const mockPeerDescriptor1 = createMockPeerDescriptor()
-    const mockPeerDescriptor2 = createMockPeerDescriptor()
-    const rpcWrapper = createWrappedClosestPeersRequest(mockPeerDescriptor1)
-    const message: Message = {
-        serviceId: 'unknown',
-        messageId: v4(),
-        body: {
-            oneofKind: 'rpcMessage',
-            rpcMessage: rpcWrapper
-        },
-        sourceDescriptor: mockPeerDescriptor1,
-        targetDescriptor: mockPeerDescriptor2
-    }
-    const routedMessage: RouteMessageWrapper = {
-        message,
-        requestId: 'REQ',
-        routingPath: [],
-        reachableThrough: [],
-        target: mockPeerDescriptor1.nodeId,
-        sourcePeer: mockPeerDescriptor2,
-        parallelRootNodeIds: []
-    }
-
-    const createMockDhtNodeRpcRemote = (destination: PeerDescriptor): DhtNodeRpcRemote => {
-        return new DhtNodeRpcRemote(mockPeerDescriptor1, destination, undefined as any, rpcCommunicator)
-    }
-
-    beforeEach(() => {
-        rpcCommunicator = new MockRpcCommunicator()
-        connections = new Map()
-        routingTablesCache = new RoutingTablesCache()
-        session = new RoutingSession({
-            rpcCommunicator: rpcCommunicator,
-            localPeerDescriptor: mockPeerDescriptor1,
-            routedMessage,
-            parallelism: 2,
-            mode: RoutingMode.ROUTE,
-            excludedNodeIds: new Set(),
-            routingTablesCache,
-            getConnections: () => [...connections.values()].map((c) => c.getPeerDescriptor())
-        })
-    })
-
-    afterEach(() => {
-        rpcCommunicator.stop()
-        session.stop()
-    })
-
-    it('findMoreContacts', () => {
-        connections.set(toNodeId(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
-        const contacts = session.updateAndGetRoutablePeers()
-        expect(contacts.length).toBe(1)
-    })
-
-    it('findMoreContacts peer disconnects', () => {
-        connections.set(toNodeId(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
-        expect(session.updateAndGetRoutablePeers().length).toBe(1)
-        connections.delete(toNodeId(mockPeerDescriptor2))
-        routingTablesCache.onNodeDisconnected(toNodeId(mockPeerDescriptor2))
-        expect(session.updateAndGetRoutablePeers().length).toBe(0)
-    })
-
-})

package/test/unit/SortedContactList.test.ts

@@ -1,115 +0,0 @@
-import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import { DhtAddress, DhtAddressRaw, randomDhtAddress, toDhtAddress } from '../../src/identifiers'
-
-const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress } => {
-    return { 
-        getNodeId: () => toDhtAddress(nodeId)
-    }
-}
-
-describe('SortedContactList', () => {
-
-    const item0 = createItem(new Uint8Array([0, 0, 0, 0]))
-    const item1 = createItem(new Uint8Array([0, 0, 0, 1]))
-    const item2 = createItem(new Uint8Array([0, 0, 0, 2]))
-    const item3 = createItem(new Uint8Array([0, 0, 0, 3]))
-    const item4 = createItem(new Uint8Array([0, 0, 0, 4]))
-
-    it('compares Ids correctly', async () => {
-        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 10, allowToContainReferenceId: true })
-        expect(list.compareIds(item0.getNodeId(), item0.getNodeId())).toBe(0)
-        expect(list.compareIds(item1.getNodeId(), item1.getNodeId())).toBe(0)
-        expect(list.compareIds(item0.getNodeId(), item1.getNodeId())).toBe(-1)
-        expect(list.compareIds(item0.getNodeId(), item2.getNodeId())).toBe(-2)
-        expect(list.compareIds(item1.getNodeId(), item0.getNodeId())).toBe(1)
-        expect(list.compareIds(item2.getNodeId(), item0.getNodeId())).toBe(2)
-        expect(list.compareIds(item2.getNodeId(), item3.getNodeId())).toBe(-1)
-        expect(list.compareIds(item1.getNodeId(), item4.getNodeId())).toBe(-3)
-    })
-
-    it('cannot exceed maxSize', async () => {
-        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 3, allowToContainReferenceId: false })
-        const onContactRemoved = jest.fn()
-        list.on('contactRemoved', onContactRemoved)
-        list.addContact(item1)
-        list.addContact(item4)
-        list.addContact(item3)
-        list.addContact(item2)
-        expect(list.getSize()).toEqual(3)
-        expect(list.getClosestContacts()).toEqual([item1, item2, item3])
-        expect(list.getContactIds()).toEqual([item1.getNodeId(), item2.getNodeId(), item3.getNodeId()])
-        expect(onContactRemoved).toBeCalledWith(item4)
-        expect(list.getContact(item4.getNodeId())).toBeFalsy()
-    })
-
-    it('removing contacts', async () => {
-        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 8, allowToContainReferenceId: false })
-        const onContactRemoved = jest.fn()
-        list.on('contactRemoved', onContactRemoved)
-        list.removeContact(randomDhtAddress())
-        list.addContact(item3)
-        list.removeContact(item3.getNodeId())
-        list.addContact(item4)
-        list.addContact(item3)
-        list.addContact(item2)
-        list.addContact(item1)
-        list.removeContact(item2.getNodeId())
-        expect(list.getSize()).toEqual(3)
-        expect(list.getContact(item2.getNodeId())).toBeFalsy()
-        expect(list.getContactIds()).toEqual(list.getContactIds().sort(list.compareIds))
-        expect(list.getClosestContacts()).toEqual([item1, item3, item4])
-        const ret = list.removeContact(toDhtAddress(Buffer.from([0, 0, 0, 6])))
-        expect(ret).toEqual(false)
-        list.removeContact(item3.getNodeId())
-        list.removeContact(randomDhtAddress())
-        expect(list.getClosestContacts()).toEqual([item1, item4])
-        expect(onContactRemoved).toHaveBeenNthCalledWith(1, item3)
-        expect(onContactRemoved).toHaveBeenNthCalledWith(2, item2)
-        expect(onContactRemoved).toHaveBeenNthCalledWith(3, item3)
-    })
-
-    it('get closest contacts', () => {
-        const list = new SortedContactList({
-            referenceId: item0.getNodeId(), 
-            maxSize: 8, 
-            allowToContainReferenceId: false
-        })
-        list.addContact(item1)
-        list.addContact(item3)
-        list.addContact(item4)
-        list.addContact(item2)
-        expect(list.getClosestContacts(2)).toEqual([item1, item2])
-        expect(list.getClosestContacts(10)).toEqual([item1, item2, item3, item4])
-        expect(list.getClosestContacts()).toEqual([item1, item2, item3, item4])
-        expect(list.getClosestContacts(-2)).toEqual([])
-    })
-
-    it('get furthest contacts', () => {
-        const list = new SortedContactList({
-            referenceId: item0.getNodeId(), 
-            maxSize: 8, 
-            allowToContainReferenceId: false
-        })
-        list.addContact(item1)
-        list.addContact(item3)
-        list.addContact(item4)
-        list.addContact(item2)
-        expect(list.getFurthestContacts(2)).toEqual([item4, item3])
-        expect(list.getFurthestContacts(10)).toEqual([item4, item3, item2, item1])
-        expect(list.getFurthestContacts()).toEqual([item4, item3, item2, item1])
-        expect(list.getFurthestContacts(-2)).toEqual([])
-    })
-
-    it('does not emit contactAdded if contact did not fit the structure', () => {
-        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 2, allowToContainReferenceId: false })
-        const onContactAdded = jest.fn()
-        list.on('contactAdded', onContactAdded)
-        list.addContact(item1)
-        list.addContact(item2)
-        expect(onContactAdded).toBeCalledTimes(2)
-        list.addContact(item3)
-        expect(onContactAdded).toBeCalledTimes(2)
-        expect(list.getClosestContacts().length).toEqual(2)
-    })
-
-})

package/test/unit/StoreManager.test.ts

@@ -1,146 +0,0 @@
-import { wait, waitForCondition } from '@streamr/utils'
-import { range, without } from 'lodash'
-import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
-import { StoreManager } from '../../src/dht/store/StoreManager'
-import {
-    DhtAddress,
-    randomDhtAddress,
-    toDhtAddress,
-    toDhtAddressRaw
-} from '../../src/identifiers'
-import { PeerDescriptor, ReplicateDataRequest } from '../../generated/packages/dht/protos/DhtRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const NODE_COUNT = 10
-
-const DATA_ENTRY = {
-    key: toDhtAddressRaw(randomDhtAddress()),
-    creator: toDhtAddressRaw(randomDhtAddress())
-}
-const ALL_NODES = range(NODE_COUNT).map(() => createMockPeerDescriptor())
-
-const getNodeCloseToData = (distanceIndex: number) => {
-    const dataKey = toDhtAddress(DATA_ENTRY.key)
-    return getClosestNodes(dataKey, ALL_NODES)[distanceIndex]
-}
-
-describe('StoreManager', () => {
-
-    describe('new contact', () => {
-
-        const createStoreManager = (
-            localPeerDescriptor: PeerDescriptor,
-            redundancyFactor: number,
-            replicateData: (request: ReplicateDataRequest) => unknown,
-            setAllEntriesAsStale: (key: DhtAddress) => unknown
-        ): StoreManager => {
-            return new StoreManager({
-                rpcCommunicator: {
-                    registerRpcMethod: () => {},
-                    registerRpcNotification: () => {}
-                } as any,
-                recursiveOperationManager: undefined as any,
-                localPeerDescriptor,
-                localDataStore: { 
-                    keys: () => [toDhtAddress(DATA_ENTRY.key)],
-                    values: () => [DATA_ENTRY],
-                    setAllEntriesAsStale 
-                } as any,
-                serviceId: undefined as any,
-                highestTtl: undefined as any,
-                redundancyFactor,
-                getNeighbors: () => without(ALL_NODES, localPeerDescriptor),
-                createRpcRemote: () => ({ replicateData } as any)
-            })
-        }
-
-        describe('this node was primary storer', () => {
-
-            it('new node is within redundancy factor', async () => {
-                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
-                const localNode = getNodeCloseToData(0)
-                const manager = createStoreManager(
-                    localNode,
-                    3,
-                    replicateData,
-                    setAllEntriesAsStale
-                )
-                manager.onContactAdded(getNodeCloseToData(2))
-                await waitForCondition(() => replicateData.mock.calls.length === 1)
-                expect(replicateData).toHaveBeenCalledWith({
-                    entry: DATA_ENTRY
-                }, true)
-                expect(setAllEntriesAsStale).not.toHaveBeenCalled()
-            })
-    
-            it('new node is not within redundancy factor', async () => {
-                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
-                const localNode = getNodeCloseToData(0)
-                const manager = createStoreManager(
-                    localNode,
-                    3,
-                    replicateData,
-                    setAllEntriesAsStale
-                )
-                manager.onContactAdded(getNodeCloseToData(4))
-                await wait(50)
-                expect(replicateData).not.toHaveBeenCalled()
-                expect(setAllEntriesAsStale).not.toHaveBeenCalled()
-            })
-        })
-
-        describe('this node was not primary storer', () => {
-
-            it('this node is within redundancy factor', async () => {
-                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
-                const localNode = getNodeCloseToData(1)
-                const manager = createStoreManager(
-                    localNode,
-                    3,
-                    replicateData,
-                    setAllEntriesAsStale
-                )
-                manager.onContactAdded(getNodeCloseToData(4))
-                await wait(50)
-                expect(replicateData).not.toHaveBeenCalled()
-                expect(setAllEntriesAsStale).toHaveBeenCalledTimes(0)
-            })
-
-            it('this node is not within redundancy factor', async () => {
-                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
-                const localNode = getNodeCloseToData(3)
-                const manager = createStoreManager(
-                    localNode,
-                    3,
-                    replicateData,
-                    setAllEntriesAsStale
-                )
-                manager.onContactAdded(getNodeCloseToData(4))
-                await wait(50)
-                expect(replicateData).not.toHaveBeenCalled()
-                expect(setAllEntriesAsStale).toHaveBeenCalledTimes(1)
-                expect(setAllEntriesAsStale).toHaveBeenCalledWith(toDhtAddress(DATA_ENTRY.key))
-            })
-
-            it('this node is within redundancy factor, the node has less than redundancyFactor neighbors', async () => {
-                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
-                const localNode = getNodeCloseToData(3)
-                const manager = createStoreManager(
-                    localNode,
-                    100,
-                    replicateData,
-                    setAllEntriesAsStale
-                )
-                manager.onContactAdded(getNodeCloseToData(4))
-                await wait(50)
-                expect(replicateData).not.toHaveBeenCalled()
-                expect(setAllEntriesAsStale).toHaveBeenCalledTimes(0)
-            })
-        })
-    })
-})

package/test/unit/StoreRpcLocal.test.ts

@@ -1,167 +0,0 @@
-import { range } from 'lodash'
-import { StoreRpcLocal } from '../../src/dht/store/StoreRpcLocal'
-import { areEqualPeerDescriptors, randomDhtAddress, DhtAddress, toDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
-import { DataEntry, PeerDescriptor, StoreDataRequest } from '../../generated/packages/dht/protos/DhtRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
-import { wait } from '@streamr/utils'
-
-describe('StoreRpcLocal', () => {
-
-    const NODE_COUNT = 5
-    const DATA_ENTRY = {
-        key: toDhtAddressRaw(randomDhtAddress()),
-        creator: toDhtAddressRaw(randomDhtAddress())
-    }
-
-    const ALL_NODES = range(NODE_COUNT).map(() => createMockPeerDescriptor())
-
-    const getNodeCloseToData = (distanceIndex: number) => {
-        const dataKey = toDhtAddress(DATA_ENTRY.key)
-        return getClosestNodes(dataKey, ALL_NODES)[distanceIndex]
-    }
-
-    let storeRpcLocal: StoreRpcLocal
-    let setAllEntriesAsStale: jest.Mock<undefined, [DhtAddress]>
-    let replicateDataToContact: jest.Mock<Promise<void>, [DataEntry, PeerDescriptor]>
-
-    beforeEach(() => {
-        setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
-        replicateDataToContact = jest.fn<Promise<void>, [DataEntry, PeerDescriptor]>()
-    })
-
-    describe('local node is primary storer', () => {
-
-        beforeEach(() => {
-            const localPeerDescriptor = getNodeCloseToData(0)
-            storeRpcLocal = new StoreRpcLocal({
-                localDataStore: { 
-                    storeEntry: () => true,
-                    setAllEntriesAsStale
-                } as any,
-                localPeerDescriptor,
-                replicateDataToContact,
-                getStorers: () => getClosestNodes(toDhtAddress(DATA_ENTRY.key), ALL_NODES)
-            })
-        })
-
-        it('storeData', async () => {
-            const request = StoreDataRequest.create({
-                key: DATA_ENTRY.key,
-            })
-            await storeRpcLocal.storeData(request)
-            expect(setAllEntriesAsStale).not.toHaveBeenCalled()
-        })
-
-        it('replicateData', async () => {
-            const request = {
-                entry: DATA_ENTRY
-            }
-            await storeRpcLocal.replicateData(request as any, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
-            expect(setAllEntriesAsStale).not.toHaveBeenCalled()
-            // Wait for setImmediate
-            await wait(50)
-            expect(replicateDataToContact).toHaveBeenCalledTimes(NODE_COUNT - 1)
-        })
-        
-    })
-
-    describe('local node is storer', () => {
-        beforeEach(() => {
-            const localPeerDescriptor = getNodeCloseToData(1)
-            storeRpcLocal = new StoreRpcLocal({
-                localDataStore: { 
-                    storeEntry: () => true,
-                    setAllEntriesAsStale
-                } as any,
-                localPeerDescriptor,
-                replicateDataToContact,
-                getStorers: () => getClosestNodes(toDhtAddress(DATA_ENTRY.key), ALL_NODES)
-            })
-        })
-
-        it('storeData', async () => {
-            const request = StoreDataRequest.create({
-                key: DATA_ENTRY.key
-            })
-            await storeRpcLocal.storeData(request)
-            expect(setAllEntriesAsStale).not.toHaveBeenCalled()
-        })
-
-        it('replicateData', async () => {
-            const request = {
-                entry: DATA_ENTRY
-            }
-            await storeRpcLocal.replicateData(request as any, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
-            expect(setAllEntriesAsStale).not.toHaveBeenCalled()
-            // Wait for setImmediate
-            await wait(50)
-            expect(replicateDataToContact).toHaveBeenCalledTimes(1)
-        })
-    })
-
-    describe('local node is not storer', () => {
-        beforeEach(() => {
-            const localPeerDescriptor = getNodeCloseToData(NODE_COUNT - 1)
-            storeRpcLocal = new StoreRpcLocal({
-                localDataStore: { 
-                    storeEntry: () => true,
-                    setAllEntriesAsStale
-                } as any,
-                localPeerDescriptor,
-                replicateDataToContact,
-                getStorers: () => getClosestNodes(toDhtAddress(DATA_ENTRY.key), ALL_NODES)
-                    .filter((peerDescriptor) => !areEqualPeerDescriptors(peerDescriptor, localPeerDescriptor))
-            })
-        })
-        
-        it('storeData', async () => {
-            const request = StoreDataRequest.create({
-                key: DATA_ENTRY.key
-            })
-            await storeRpcLocal.storeData(request)
-            expect(setAllEntriesAsStale).toHaveBeenCalled()
-        })
-
-        it('replicateData', async () => {
-            const request = {
-                entry: DATA_ENTRY
-            }
-            await storeRpcLocal.replicateData(request as any, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
-            expect(setAllEntriesAsStale).toHaveBeenCalledTimes(1)
-            // Wait for setImmediate
-            await wait(50)
-            expect(replicateDataToContact).toHaveBeenCalledTimes(1)
-        })
-
-    })
-
-    describe('data was not stored', () => {
-
-        beforeEach(() => {
-            const localPeerDescriptor = getNodeCloseToData(1)
-            storeRpcLocal = new StoreRpcLocal({
-                localDataStore: { 
-                    storeEntry: () => false,
-                    setAllEntriesAsStale
-                } as any,
-                localPeerDescriptor,
-                replicateDataToContact,
-                getStorers: () => getClosestNodes(toDhtAddress(DATA_ENTRY.key), ALL_NODES)
-            })
-        })
-
-        it('replicateData', async () => {
-            const request = {
-                entry: DATA_ENTRY
-            }
-            await storeRpcLocal.replicateData(request as any, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
-            expect(setAllEntriesAsStale).toHaveBeenCalledTimes(0)
-            // Wait for setImmediate
-            await wait(50)
-            expect(replicateDataToContact).toHaveBeenCalledTimes(0)
-        })
-
-    })
-
-})

package/test/unit/WebrtcConnection.test.ts

@@ -1,29 +0,0 @@
-import { waitForEvent3 } from '@streamr/utils'
-import { NodeWebrtcConnection } from '../../src/connection/webrtc/NodeWebrtcConnection'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { ConnectionEvents } from '../../src/connection/IConnection'
-
-describe('WebrtcConnection', () => {
-
-    let connection: NodeWebrtcConnection
-
-    beforeEach(() => {
-        const peerDescriptor = createMockPeerDescriptor()
-        connection = new NodeWebrtcConnection({
-            remotePeerDescriptor: peerDescriptor
-        })
-    })
-
-    afterEach(() => {
-        connection.close(true)
-    })
-
-    it('Disconnects early if remote descriptor is not set', async () => {
-        connection.start(true)
-        await waitForEvent3<ConnectionEvents>(connection as any, 'disconnected', 5001, (_graceful: boolean, _code: number, reason: string) => {
-            expect(reason).toBe('timed out due to remote descriptor not being set')
-            return true
-        })
-    })
-
-})

package/test/unit/WebrtcConnector.test.ts

@@ -1,56 +0,0 @@
-import { WebrtcConnector } from '../../src/connection/webrtc/WebrtcConnector'
-import { MockConnection } from '../utils/mock/MockConnection'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('WebrtcConnector', () => {
-
-    let connector: WebrtcConnector
-
-    beforeEach(() => {
-        
-        connector = new WebrtcConnector({
-            transport: new MockTransport() 
-        } as any) 
-    })
-
-    afterEach(() => {
-        connector.stop()
-    })
-    
-    describe('Connect', () => {
-
-        it('Returns existing connecting connection', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor())
-            const remotePeerDescriptor = createMockPeerDescriptor()
-            const firstConnection = connector.connect(remotePeerDescriptor, false)
-            const secondConnection = connector.connect(remotePeerDescriptor, false)
-            expect(firstConnection).toEqual(secondConnection)
-            firstConnection.close(false)
-        })
-
-        it('Disconnected event removes connecting connection', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor())
-            const remotePeerDescriptor = createMockPeerDescriptor()
-            const firstConnection = connector.connect(remotePeerDescriptor, false)
-            firstConnection.emit('disconnected', false)
-            const secondConnection = connector.connect(remotePeerDescriptor, false)
-            expect(firstConnection).not.toEqual(secondConnection)
-            firstConnection.close(false)
-            secondConnection.close(false)
-        })
-
-        it('Connected event removes connecting connection', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor())
-            const remotePeerDescriptor = createMockPeerDescriptor()
-            const firstConnection = connector.connect(remotePeerDescriptor, false)
-            firstConnection.onHandshakeCompleted(new MockConnection())
-            const secondConnection = connector.connect(remotePeerDescriptor, false)
-            expect(firstConnection).not.toEqual(secondConnection)
-            firstConnection.close(false)
-            secondConnection.close(false)
-        })
-
-    })
-
-})