@streamr/dht 100.2.5-beta.0 → 101.0.0-beta.0

package/src/transport/RoutingRpcCommunicator.ts

@@ -1,6 +1,6 @@
 import { Message, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { v4 } from 'uuid'
-import { RpcCommunicator, RpcCommunicatorConfig } from '@streamr/proto-rpc'
+import { RpcCommunicator, RpcCommunicatorOptions } from '@streamr/proto-rpc'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 import { RpcMessage } from '../proto/packages/proto-rpc/protos/ProtoRpc'
 import { ServiceID } from '../types/ServiceID'
@@ -13,9 +13,9 @@ export class RoutingRpcCommunicator extends RpcCommunicator<DhtCallContext> {
     constructor(
         ownServiceId: ServiceID,
         sendFn: (msg: Message, opts: SendOptions) => Promise<void>,
-        config?: RpcCommunicatorConfig
+        options?: RpcCommunicatorOptions
     ) {
-        super(config)
+        super(options)
         this.ownServiceId = ownServiceId
         this.sendFn = sendFn
 

package/test/end-to-end/Layer0Webrtc.test.ts

@@ -1,6 +1,5 @@
 import { areEqualBinaries, waitForEvent3 } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { ConnectionType } from '../../src/connection/IConnection'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -69,11 +68,6 @@ describe('Layer0 with WebRTC connections', () => {
         const nodeId2 = getNodeIdFromPeerDescriptor(node2.getLocalPeerDescriptor())
         expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
         expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
-        expect((node1.getTransport() as ConnectionManager).getConnection(nodeId2)!.connectionType)
-            .toEqual(ConnectionType.WEBRTC)
-        expect((node2.getTransport() as ConnectionManager).getConnection(nodeId1)!.connectionType)
-            .toEqual(ConnectionType.WEBRTC)
-
     }, 60000)
 
     it('Happy path simultaneous joins', async () => {
@@ -87,9 +81,5 @@ describe('Layer0 with WebRTC connections', () => {
         const nodeId2 = getNodeIdFromPeerDescriptor(node2.getLocalPeerDescriptor())
         expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
         expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
-        expect((node1.getTransport() as ConnectionManager).getConnection(nodeId2)!.connectionType)
-            .toEqual(ConnectionType.WEBRTC)
-        expect((node2.getTransport() as ConnectionManager).getConnection(nodeId1)!.connectionType)
-            .toEqual(ConnectionType.WEBRTC)
     })
 })

package/test/integration/ConnectionManager.test.ts

@@ -1,7 +1,7 @@
 import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
 import { MarkOptional } from 'ts-essentials'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
+import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { createPeerDescriptor } from '../../src/helpers/createPeerDescriptor'
@@ -30,7 +30,7 @@ describe('ConnectionManager', () => {
     const mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)
     let createLocalPeerDescriptor: jest.Mock<PeerDescriptor, [ConnectivityResponse]>
 
-    const createConnectionManager = (opts: MarkOptional<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
+    const createConnectionManager = (opts: MarkOptional<DefaultConnectorFacadeOptions, 'createLocalPeerDescriptor'>) => {
         return new ConnectionManager({
             createConnectorFacade: () => new DefaultConnectorFacade({
                 createLocalPeerDescriptor: async (response) => createLocalPeerDescriptor(response),
@@ -304,6 +304,7 @@ describe('ConnectionManager', () => {
         })
         msg.targetDescriptor = mockPeerDescriptor4
         connectionManager3.send(msg)
+
         await Promise.all([dataPromise, connectedPromise1, connectedPromise2])
 
         // @ts-expect-error private field

package/test/integration/GeoIpConnectivityChecking.test.ts

@@ -47,7 +47,7 @@ describe('ConnectivityChecking', () => {
         })
         await server.start()
         mock = jest.spyOn(WebsocketServerConnection.prototype, 'getRemoteIpAddress').mockImplementation(() => testIp)
-    })
+    }, 15000)
 
     afterEach(async () => {
         await server.stop()

package/test/integration/SimultaneousConnections.test.ts

@@ -1,6 +1,6 @@
 import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
+import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { Message, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
@@ -19,7 +19,7 @@ const BASE_MESSAGE: Message = {
     }
 }
 
-const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
+const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeOptions, 'createLocalPeerDescriptor'>) => {
     return new ConnectionManager({
         createConnectorFacade: () => new DefaultConnectorFacade({
             createLocalPeerDescriptor: async () => localPeerDescriptor,

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -2,14 +2,12 @@ import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { Message, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { ConnectionType } from '../../src/connection/IConnection'
 import { ITransport } from '../../src/transport/ITransport'
 import * as Err from '../../src/helpers/errors'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { MetricsContext } from '@streamr/utils'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
@@ -32,7 +30,7 @@ describe('WebRTC Connection Management', () => {
     let connectorTransport2: SimulatorTransport
 
     beforeEach(async () => {
-        simulator = new Simulator(LatencyType.FIXED, 500)
+        simulator = new Simulator(LatencyType.FIXED, 20)
         connectorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
         await connectorTransport1.start()
         manager1 = createConnectionManager(peerDescriptor1, connectorTransport1)
@@ -68,8 +66,6 @@ describe('WebRTC Connection Management', () => {
 
         manager2.on('message', (message: Message) => {
             expect(message.messageId).toEqual('mockerer')
-            expect(manager1.getConnection(getNodeIdFromPeerDescriptor(peerDescriptor2))!.connectionType).toEqual(ConnectionType.WEBRTC)
-            expect(manager2.getConnection(getNodeIdFromPeerDescriptor(peerDescriptor1))!.connectionType).toEqual(ConnectionType.WEBRTC)
 
             done()
         })
@@ -77,7 +73,7 @@ describe('WebRTC Connection Management', () => {
         manager1.send(dummyMessage).catch((e) => {
             throw e
         })
-    }, 60000)
+    }, 15000)
 
     it('Peer2 can open WebRTC Datachannel', (done) => {
         const dummyMessage: Message = {
@@ -90,9 +86,6 @@ describe('WebRTC Connection Management', () => {
         }
         manager1.on('message', (message: Message) => {
             expect(message.messageId).toEqual('mockerer')
-            expect(manager1.getConnection(getNodeIdFromPeerDescriptor(peerDescriptor2))!.connectionType).toEqual(ConnectionType.WEBRTC)
-            expect(manager2.getConnection(getNodeIdFromPeerDescriptor(peerDescriptor1))!.connectionType).toEqual(ConnectionType.WEBRTC)
-
             done()
         })
         dummyMessage.targetDescriptor = peerDescriptor1
@@ -221,6 +214,5 @@ describe('WebRTC Connection Management', () => {
             manager1.send(msg),
             disconnectedPromise1
         ])
-        expect(manager1.getConnection(getNodeIdFromPeerDescriptor(msg.targetDescriptor))).toBeUndefined()
     }, 20000)
 })

package/test/integration/{WebsocketConnectorRpc.test.ts → WebsocketClientConnectorRpc.test.ts}

@@ -1,20 +1,20 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebsocketConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { WebsocketClientConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { createMockPeerDescriptor } from '../utils/utils'
 import {
     WebsocketConnectionRequest
 } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { mockWebsocketConnectorRpc } from '../utils/utils'
+import { mockWebsocketClientConnectorRpc } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
-describe('WebsocketConnectorRpc', () => {
+describe('WebsocketClientConnectorRpc', () => {
 
     let rpcCommunicator1: RpcCommunicator<DhtCallContext>
     let rpcCommunicator2: RpcCommunicator<DhtCallContext>
-    let client1: ProtoRpcClient<WebsocketConnectorRpcClient>
-    let client2: ProtoRpcClient<WebsocketConnectorRpcClient>
+    let client1: ProtoRpcClient<WebsocketClientConnectorRpcClient>
+    let client2: ProtoRpcClient<WebsocketClientConnectorRpcClient>
     const peerDescriptor1 = createMockPeerDescriptor()
     const peerDescriptor2 = createMockPeerDescriptor()
 
@@ -24,7 +24,7 @@ describe('WebsocketConnectorRpc', () => {
             WebsocketConnectionRequest,
             Empty,
             'requestConnection',
-            mockWebsocketConnectorRpc.requestConnection
+            mockWebsocketClientConnectorRpc.requestConnection
         )
 
         rpcCommunicator2 = new RpcCommunicator()
@@ -32,7 +32,7 @@ describe('WebsocketConnectorRpc', () => {
             WebsocketConnectionRequest,
             Empty,
             'requestConnection',
-            mockWebsocketConnectorRpc.requestConnection
+            mockWebsocketClientConnectorRpc.requestConnection
         )
 
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
@@ -43,8 +43,8 @@ describe('WebsocketConnectorRpc', () => {
             rpcCommunicator1.handleIncomingMessage(message)
         })
 
-        client1 = toProtoRpcClient(new WebsocketConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
-        client2 = toProtoRpcClient(new WebsocketConnectorRpcClient(rpcCommunicator2.getRpcClientTransport()))
+        client1 = toProtoRpcClient(new WebsocketClientConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
+        client2 = toProtoRpcClient(new WebsocketClientConnectorRpcClient(rpcCommunicator2.getRpcClientTransport()))
     })
 
     afterEach(async () => {

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -2,8 +2,7 @@
 
 import { MetricsContext, waitForCondition, waitForEvent3 } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
-import { ConnectionType } from '../../src/connection/IConnection'
+import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import * as Err from '../../src/helpers/errors'
@@ -14,7 +13,7 @@ import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const SERVICE_ID = 'test'
 
-const createConfig = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
+const createOptions = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeOptions, 'createLocalPeerDescriptor'>) => {
     return {
         createConnectorFacade: () => new DefaultConnectorFacade({
             createLocalPeerDescriptor: async () => localPeerDescriptor,
@@ -61,21 +60,21 @@ describe('Websocket Connection Management', () => {
         connectorTransport3 = new SimulatorTransport(biggerNoWsServerConnectorPeerDescriptor, simulator)
         await connectorTransport3.start()
 
-        const config1 = createConfig(wsServerConnectorPeerDescriptor, {
+        const options1 = createOptions(wsServerConnectorPeerDescriptor, {
             transport: connectorTransport1,
             websocketHost: '127.0.0.1',
             websocketPortRange: { min: 12223, max: 12223 }
         })
-        const config2 = createConfig(noWsServerConnectorPeerDescriptor, {
+        const options2 = createOptions(noWsServerConnectorPeerDescriptor, {
             transport: connectorTransport2
         })
-        const config3 = createConfig(biggerNoWsServerConnectorPeerDescriptor, {
+        const options3 = createOptions(biggerNoWsServerConnectorPeerDescriptor, {
             transport: connectorTransport3
         })
 
-        wsServerManager = new ConnectionManager(config1)
-        noWsServerManager = new ConnectionManager(config2)
-        biggerNoWsServerManager = new ConnectionManager(config3)
+        wsServerManager = new ConnectionManager(options1)
+        noWsServerManager = new ConnectionManager(options2)
+        biggerNoWsServerManager = new ConnectionManager(options3)
 
         await wsServerManager.start()
         await noWsServerManager.start()
@@ -103,12 +102,6 @@ describe('Websocket Connection Management', () => {
         }
         noWsServerManager.on('message', (message: Message) => {
             expect(message.messageId).toEqual('mockerer')
-            expect(wsServerManager.getConnection(getNodeIdFromPeerDescriptor(noWsServerConnectorPeerDescriptor))!.connectionType).toEqual(
-                ConnectionType.WEBSOCKET_SERVER
-            )
-            expect(noWsServerManager.getConnection(getNodeIdFromPeerDescriptor(wsServerConnectorPeerDescriptor))!.connectionType).toEqual(
-                ConnectionType.WEBSOCKET_CLIENT
-            )
 
             done()
         })
@@ -128,13 +121,6 @@ describe('Websocket Connection Management', () => {
         }
         biggerNoWsServerManager.on('message', (message: Message) => {
             expect(message.messageId).toEqual('mockerer')
-            expect(wsServerManager.getConnection(getNodeIdFromPeerDescriptor(biggerNoWsServerConnectorPeerDescriptor))!.connectionType).toEqual(
-                ConnectionType.WEBSOCKET_SERVER
-            )
-            expect(biggerNoWsServerManager.getConnection(getNodeIdFromPeerDescriptor(wsServerConnectorPeerDescriptor))!.connectionType).toEqual(
-                ConnectionType.WEBSOCKET_CLIENT
-            )
-
             done()
         })
 
@@ -159,7 +145,7 @@ describe('Websocket Connection Management', () => {
             waitForEvent3<TransportEvents>(wsServerManager, 'disconnected', 15000),
             wsServerManager.send(dummyMessage)
         ])
-        expect(wsServerManager.getConnection(getNodeIdFromPeerDescriptor(dummyMessage.targetDescriptor!))).toBeUndefined()
+        expect(wsServerManager.hasConnection(getNodeIdFromPeerDescriptor(dummyMessage.targetDescriptor!))).toBeFalse()
     }, 20000)
     
     it('Can open connections to peer with server', async () => {
@@ -176,15 +162,11 @@ describe('Websocket Connection Management', () => {
         await waitForCondition(
             () => {
                 const nodeId = getNodeIdFromPeerDescriptor(noWsServerConnectorPeerDescriptor)
-                return (!!wsServerManager.getConnection(nodeId)
-                    && wsServerManager.getConnection(nodeId)!.connectionType === ConnectionType.WEBSOCKET_SERVER)
+                return wsServerManager.hasConnection(nodeId)
             }
         )
         await waitForCondition(
-            () => {
-                const connection = noWsServerManager.getConnection(getNodeIdFromPeerDescriptor(wsServerConnectorPeerDescriptor))!
-                return connection.connectionType === ConnectionType.WEBSOCKET_CLIENT
-            }
+            () => noWsServerManager.hasConnection(getNodeIdFromPeerDescriptor(wsServerConnectorPeerDescriptor))
         )
     })
 

package/test/unit/ConnectionManager.test.ts

@@ -0,0 +1,64 @@
+import { MetricsContext } from '@streamr/utils'
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { getNodeIdFromPeerDescriptor, PendingConnection } from '../../src/exports'
+import { FakeConnectorFacade } from '../utils/FakeConnectorFacade'
+import { MockConnection } from '../utils/mock/MockConnection'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { getOfferer } from '../../src/helpers/offering'
+
+describe('ConnetionManager', () => {
+
+    let connectionManager: ConnectionManager
+    let fakeConnectorFacade: FakeConnectorFacade
+    const localPeerDescriptor = createMockPeerDescriptor()
+
+    beforeEach(async () => {
+        connectionManager = new ConnectionManager({
+            metricsContext: new MetricsContext(),
+            createConnectorFacade: () => { 
+                fakeConnectorFacade = new FakeConnectorFacade(localPeerDescriptor)
+                return fakeConnectorFacade
+            }
+        })
+        await connectionManager.start()
+    })
+
+    afterEach(async () => {
+        await connectionManager.stop()
+    })
+
+    it('should replace a duplicate connecting connection', () => {
+        const remotePeerDescriptor = createMockPeerDescriptor()
+        const pendingConnection1 = new PendingConnection(remotePeerDescriptor)
+        const offerer = getOfferer(getNodeIdFromPeerDescriptor(localPeerDescriptor), getNodeIdFromPeerDescriptor(remotePeerDescriptor))
+        const accepted1 = fakeConnectorFacade.callOnNewConnection(pendingConnection1)
+        expect(accepted1).toBeTrue()
+        const pendingConnection2 = new PendingConnection(remotePeerDescriptor)
+        const accepted2 = fakeConnectorFacade.callOnNewConnection(pendingConnection2)
+
+        expect(accepted2).toBe(offerer === 'remote')
+
+        pendingConnection1.close(true)
+        pendingConnection2.close(true)
+    })
+
+    it('should replace a duplicate connected connection', () => {
+        const remotePeerDescriptor = createMockPeerDescriptor()
+        const pendingConnection1 = new PendingConnection(remotePeerDescriptor)
+        const offerer = getOfferer(getNodeIdFromPeerDescriptor(localPeerDescriptor), getNodeIdFromPeerDescriptor(remotePeerDescriptor))
+        const accepted1 = fakeConnectorFacade.callOnNewConnection(pendingConnection1)
+        expect(accepted1).toBeTrue()
+        pendingConnection1.onHandshakeCompleted(new MockConnection())
+        const pendingConnection2 = new PendingConnection(remotePeerDescriptor)
+        const accepted2 = fakeConnectorFacade.callOnNewConnection(pendingConnection2)
+        if (accepted2) {
+            pendingConnection1.onHandshakeCompleted(new MockConnection())
+        }
+        expect(accepted2).toBe(offerer === 'remote')
+
+        pendingConnection1.close(true)
+        pendingConnection2.close(true)
+    })
+
+})
+

package/test/unit/DiscoverySession.test.ts

@@ -12,7 +12,7 @@ const NODE_COUNT = 40
 const MIN_NEIGHBOR_COUNT = 2  // nodes can get more neighbors when we merge network partitions
 const PARALLELISM = 1
 const NO_PROGRESS_LIMIT = 1
-const QUERY_BATCH_SIZE = 5  // the default value in DhtNode's config, not relevant in this test
+const QUERY_BATCH_SIZE = 5  // the default value in DhtNode's options, not relevant in this test
 
 const createPeerDescriptor = (nodeId: DhtAddress): PeerDescriptor => {
     return {

package/test/unit/Handshaker.test.ts

@@ -0,0 +1,169 @@
+import EventEmitter from 'eventemitter3'
+import { 
+    acceptHandshake,
+    createHandshakeRequest,
+    createHandshakeResponse,
+    createIncomingHandshaker,
+    createOutgoingHandshaker,
+    Handshaker,
+    rejectHandshake
+} from '../../src/connection/Handshaker'
+import { ConnectionEvents, IConnection } from '../../src/connection/IConnection'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { HandshakeError, Message } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PendingConnection } from '../../src/connection/PendingConnection'
+
+describe('Handshaker', () => {
+
+    let handshaker: Handshaker
+    let pendingConnection: PendingConnection
+    let connection: IConnection
+
+    let mockOnHandshakeCompleted: () => void
+    let mockSend: () => void
+    let mockConnectionClose: () => void
+    let mockPendingConnectionClose: () => void
+    let mockPendingConnectionDestroy: () => void
+    let mockConnectionDestroy: () => void
+
+    beforeEach(() => {
+        mockOnHandshakeCompleted = jest.fn()
+        mockPendingConnectionClose = jest.fn()
+        mockPendingConnectionDestroy = jest.fn()
+        mockConnectionDestroy = jest.fn()
+        pendingConnection = new class extends EventEmitter {
+            // eslint-disable-next-line class-methods-use-this
+            attachConnection() { 
+                mockOnHandshakeCompleted()
+            }
+            // eslint-disable-next-line class-methods-use-this
+            close() {
+                mockPendingConnectionClose()
+            }
+
+            // eslint-disable-next-line class-methods-use-this
+            destroy() {
+                mockPendingConnectionDestroy()
+            }
+
+            // eslint-disable-next-line class-methods-use-this
+            onHandshakeCompleted(_connection: IConnection) {
+                mockOnHandshakeCompleted()
+            }
+        } as any
+
+        mockSend = jest.fn()
+        mockConnectionClose = jest.fn()
+        connection = new class extends EventEmitter<ConnectionEvents> {
+            // eslint-disable-next-line class-methods-use-this
+            send(_message: any) {
+                mockSend()
+            }
+            // eslint-disable-next-line class-methods-use-this
+            close() {
+                mockConnectionClose()
+            }
+
+            // eslint-disable-next-line class-methods-use-this
+            destroy() {
+                mockConnectionDestroy()
+            }
+        } as any    
+    })
+
+    describe('Outgoing', () => {
+
+        beforeEach(() => {
+            handshaker = createOutgoingHandshaker(
+                createMockPeerDescriptor(),
+                pendingConnection,
+                connection,
+                createMockPeerDescriptor()
+            )
+        })
+
+        afterEach(() => {
+            handshaker.stop()
+        })
+
+        it('sends request after connected', () => {
+            (connection as any).emit('connected')
+            expect(mockSend).toHaveBeenCalledTimes(1)
+        })
+
+        it('onHandshakeCompleted', () => {
+            const message = createHandshakeResponse(createMockPeerDescriptor());
+            (connection as any).emit('data', Message.toBinary(message))
+            handshaker.emit('handshakeCompleted', createMockPeerDescriptor())
+            expect(mockOnHandshakeCompleted).toHaveBeenCalledTimes(1)
+        })
+
+        it('onHandshakeFailed invalid PeerDescriptor', () => {
+            handshaker.emit('handshakeFailed', HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
+            expect(mockOnHandshakeCompleted).not.toHaveBeenCalled()
+        })
+
+        it('onHandshakeFailed unsupported version', () => {
+            handshaker.emit('handshakeFailed', HandshakeError.UNSUPPORTED_VERSION)
+            expect(mockOnHandshakeCompleted).not.toHaveBeenCalled()
+            expect(mockPendingConnectionClose).toHaveBeenCalledTimes(1)
+        })
+
+        it('onHandShakeFailed ', () => {
+            handshaker.emit('handshakeFailed', HandshakeError.DUPLICATE_CONNECTION)
+            expect(mockPendingConnectionDestroy).not.toHaveBeenCalled()
+            expect(mockOnHandshakeCompleted).not.toHaveBeenCalled()
+        })
+
+        it('calls pending connection close if connection closes', () => {
+            (connection as any).emit('disconnected')
+            expect(mockPendingConnectionClose).toHaveBeenCalledTimes(1)
+        })
+
+        it('closes connection if managed connection closes', () => {
+            (pendingConnection as any).emit('disconnected')
+            expect(mockConnectionClose).toHaveBeenCalledTimes(1)
+        })
+
+    })
+
+    describe('Incoming', () => {
+
+        beforeEach(() => {
+            handshaker = createIncomingHandshaker(createMockPeerDescriptor(), pendingConnection, connection)
+        })
+
+        afterEach(() => {
+            handshaker.stop()
+        })
+
+        it('onHandshakeRequest', () => {
+            const message = createHandshakeRequest(createMockPeerDescriptor(), createMockPeerDescriptor());
+            (connection as any).emit('data', Message.toBinary(message))
+            handshaker.emit('handshakeRequest', createMockPeerDescriptor(), '1.0')
+        })
+
+        it('calls pending connection onDisconnected if connection closes', () => {
+            (connection as any).emit('disconnected')
+            expect(mockPendingConnectionClose).toHaveBeenCalledTimes(1)
+        })
+
+        it('closes connection if managed connection closes', () => {
+            (pendingConnection as any).emit('disconnected')
+            expect(mockConnectionClose).toHaveBeenCalledTimes(1)
+        })
+
+        it('destroys connection if handshake is rejected', () => {
+            rejectHandshake(pendingConnection, connection, handshaker, HandshakeError.DUPLICATE_CONNECTION)
+            expect(mockPendingConnectionDestroy).toHaveBeenCalled()
+            expect(mockConnectionDestroy).toHaveBeenCalled()
+        })
+
+        it('calls onHandshakeCompleted if handshake is accepted', () => {
+            acceptHandshake(handshaker, pendingConnection, connection)
+            expect(mockOnHandshakeCompleted).toHaveBeenCalled()
+        })
+
+    })
+
+})

package/test/unit/ManagedConnection.test.ts

@@ -0,0 +1,58 @@
+import { wait } from '@streamr/utils'
+import { ManagedConnection } from '../../src/exports'
+import { MockConnection } from '../utils/mock/MockConnection'
+import { createMockPeerDescriptor } from '../utils/utils'
+
+describe('ManagedConnection', () => {
+
+    let managedConnection: ManagedConnection
+    let connection: MockConnection
+    beforeEach(() => {
+        connection = new MockConnection()
+        managedConnection = new ManagedConnection(createMockPeerDescriptor(), connection)
+    })
+
+    afterEach(() => {
+        managedConnection.close(false)
+    })
+
+    it('emits disconnected after close', (done) => {
+        managedConnection.once('disconnected', (graceful) => {
+            expect(graceful).toBe(true)
+            done()
+        })
+        managedConnection.close(true)
+    })
+
+    it('sends data', () => {
+        const data = new Uint8Array([1, 2, 3])
+        managedConnection.send(data)
+        expect(connection.sentData[0]).toEqual(data)
+    })
+
+    it('emits data', (done) => {
+        const data = new Uint8Array([1, 2, 3])
+        managedConnection.on('managedData', (data) => {
+            expect(data).toEqual(data)
+            done()
+        })
+        connection.emitData(data)
+    })
+
+    it('sets lastUsedTimestamp on send', async () => {
+        const createdTimestamp = managedConnection.getLastUsedTimestamp()
+        await wait(5)
+        managedConnection.send(new Uint8Array([1, 2, 3]))
+        expect(managedConnection.getLastUsedTimestamp()).toBeGreaterThan(createdTimestamp)
+    })
+
+    it('replace as duplicate', async () => {
+        managedConnection.once('disconnected', () => {
+            throw new Error('disconnected')
+        })
+        managedConnection.replaceAsDuplicate()
+        managedConnection.close(true)
+        await wait(50)
+    })
+
+})