@streamr/dht 100.0.0-pretestnet.2 → 100.0.0-pretestnet.4

package/test/benchmark/KademliaCorrectness.test.ts

@@ -1,8 +1,8 @@
 /* eslint-disable no-console */
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { PeerID } from '../../src/helpers/PeerID'
-import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
@@ -88,7 +88,7 @@ describe('Kademlia correctness', () => {
                     correctNeighbors++
                 }
             } catch (e) {
-                console.error('Node ' + keyFromPeerDescriptor(nodes[i].getPeerDescriptor()) + ' had only ' 
+                console.error('Node ' + getNodeIdFromPeerDescriptor(nodes[i].getLocalPeerDescriptor()) + ' had only ' 
                     + kademliaNeighbors.length + ' kademlia neighbors')
             }
             if (correctNeighbors === 0) {

package/test/benchmark/kademlia-simulation/SimulationNode.ts

@@ -94,7 +94,7 @@ export class SimulationNode {
         while (true) {
             let oldClosestContactId = this.neighborList.getClosestContactId()
             let uncontacted = this.neighborList.getUncontactedContacts(this.ALPHA)
-            if (uncontacted.length < 1) {
+            if (uncontacted.length === 0) {
                 return
             }
 
@@ -102,7 +102,7 @@ export class SimulationNode {
 
             if (oldClosestContactId.equals(this.neighborList.getClosestContactId())) {
                 uncontacted = this.neighborList.getUncontactedContacts(this.K)
-                if (uncontacted.length < 1) {
+                if (uncontacted.length === 0) {
                     return
                 }
 
@@ -115,7 +115,7 @@ export class SimulationNode {
                         return
                     }
                     uncontacted = this.neighborList.getUncontactedContacts(this.ALPHA)
-                    if (uncontacted.length < 1) {
+                    if (uncontacted.length === 0) {
                         return
                     }
                 }

package/test/end-to-end/Layer0-Layer1.test.ts

@@ -25,12 +25,20 @@ describe('Layer0-Layer1', () => {
 
     beforeEach(async () => {
 
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, websocketServerEnableTls: false })
         await epDhtNode.start()
         await epDhtNode.joinDht([epPeerDescriptor])
 
-        node1 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ 
+            websocketPortRange, 
+            entryPoints: [epPeerDescriptor], 
+            websocketServerEnableTls: false
+        })
+        node2 = new DhtNode({ 
+            websocketPortRange,
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
 
         await node1.start()
         await node2.start()
@@ -81,9 +89,9 @@ describe('Layer0-Layer1', () => {
         expect(stream2Node1.getClosestContacts()).toHaveLength(1)
         expect(stream2Node2.getClosestContacts()).toHaveLength(1)
 
-        expect(areEqualPeerDescriptors(stream1Node1.getClosestContacts()[0], node1.getPeerDescriptor())).toBe(true)
+        expect(areEqualPeerDescriptors(stream1Node1.getClosestContacts()[0], node1.getLocalPeerDescriptor())).toBe(true)
         expect(areEqualPeerDescriptors(stream1Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
-        expect(areEqualPeerDescriptors(stream2Node1.getClosestContacts()[0], node2.getPeerDescriptor())).toBe(true)
+        expect(areEqualPeerDescriptors(stream2Node1.getClosestContacts()[0], node2.getLocalPeerDescriptor())).toBe(true)
         expect(areEqualPeerDescriptors(stream2Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
     })
 })

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

@@ -1,13 +1,9 @@
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 
 describe('Layer0', () => {
 
-    const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: Uint8Array.from([1, 2, 3]),
-        type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 10011, tls: false }
-    }
+    let epPeerDescriptor: PeerDescriptor
     
     let epDhtNode: DhtNode
     let node1: DhtNode
@@ -18,22 +14,44 @@ describe('Layer0', () => {
     const websocketPortRange = { min: 10012, max: 10015 } 
     beforeEach(async () => {
         
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        epDhtNode = new DhtNode({ websocketHost: '127.0.0.1', websocketPortRange: { min: 10011, max: 10011 }, websocketServerEnableTls: false })
         await epDhtNode.start()
-        
+        epPeerDescriptor = epDhtNode.getLocalPeerDescriptor()
         await epDhtNode.joinDht([epPeerDescriptor])
 
-        node1 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node3 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node4 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ 
+            websocketPortRange,
+            websocketHost: '127.0.0.1',
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node2 = new DhtNode({ 
+            websocketPortRange,
+            websocketHost: '127.0.0.1',
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node3 = new DhtNode({ 
+            websocketPortRange,
+            websocketHost: '127.0.0.1',
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node4 = new DhtNode({ 
+            websocketPortRange, 
+            websocketHost: '127.0.0.1',
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
         
-        await node1.start()
-        await node2.start()
-        await node3.start()
-        await node4.start()
+        await Promise.all([
+            node1.start(),
+            node2.start(),
+            node3.start(),
+            node4.start()
+        ])
 
-    })
+    }, 10000)
 
     afterEach(async () => {
         await Promise.all([

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

@@ -1,7 +1,8 @@
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { waitForEvent3 } from '@streamr/utils'
-import { ConnectionManager, Events as ConnectionManagerEvents } from '../../src/connection/ConnectionManager'
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { TransportEvents } from '../../src/transport/ITransport'
 
 describe('Layer0MixedConnectionTypes', () => {
 
@@ -21,15 +22,33 @@ describe('Layer0MixedConnectionTypes', () => {
     const websocketPortRange = { min: 11222, max: 11223 }
     beforeEach(async () => {
 
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, numberOfNodesPerKBucket: 2 })
+        epDhtNode = new DhtNode({ 
+            peerDescriptor: epPeerDescriptor,
+            numberOfNodesPerKBucket: 2,
+            websocketServerEnableTls: false
+        })
         await epDhtNode.start()
 
         await epDhtNode.joinDht([epPeerDescriptor])
-        node1 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ websocketPortRange, entryPoints: [epPeerDescriptor] })
-        node3 = new DhtNode({ entryPoints: [epPeerDescriptor] })
-        node4 = new DhtNode({ entryPoints: [epPeerDescriptor] })
-        node5 = new DhtNode({ entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ 
+            websocketPortRange,
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node2 = new DhtNode({ 
+            websocketPortRange,
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node3 = new DhtNode({ 
+            entryPoints: [epPeerDescriptor]
+        })
+        node4 = new DhtNode({ 
+            entryPoints: [epPeerDescriptor]
+        })
+        node5 = new DhtNode({
+            entryPoints: [epPeerDescriptor]
+        })
 
         await Promise.all([
             node1.start(),
@@ -56,8 +75,8 @@ describe('Layer0MixedConnectionTypes', () => {
     it('2 non-server peers join first', async () => {
 
         const promise = Promise.all([
-            waitForEvent3<ConnectionManagerEvents>((node3.getTransport() as ConnectionManager), 'newConnection'),
-            waitForEvent3<ConnectionManagerEvents>((node4.getTransport() as ConnectionManager), 'newConnection'),
+            waitForEvent3<TransportEvents>((node3.getTransport() as ConnectionManager), 'connected'),
+            waitForEvent3<TransportEvents>((node4.getTransport() as ConnectionManager), 'connected'),
         ])
 
         node3.joinDht([epPeerDescriptor])

package/test/end-to-end/{Layer0WebRTC-Layer1.test.ts → Layer0Webrtc-Layer1.test.ts}

@@ -30,7 +30,7 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
     beforeEach(async () => {
 
-        layer0EntryPoint = new DhtNode({ peerDescriptor: entrypointDescriptor })
+        layer0EntryPoint = new DhtNode({ peerDescriptor: entrypointDescriptor, websocketServerEnableTls: false })
 
         const layer0Node1Id = '11'
         layer0Node1 = new DhtNode({

package/test/end-to-end/{Layer0WebRTC.test.ts → Layer0Webrtc.test.ts}

@@ -19,7 +19,11 @@ describe('Layer0 with WebRTC connections', () => {
 
     beforeEach(async () => {
 
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, numberOfNodesPerKBucket: 8 })
+        epDhtNode = new DhtNode({
+            peerDescriptor: epPeerDescriptor,
+            numberOfNodesPerKBucket: 8,
+            websocketServerEnableTls: false
+        })
         await epDhtNode.start()
 
         await epDhtNode.joinDht([epPeerDescriptor])
@@ -57,18 +61,18 @@ describe('Layer0 with WebRTC connections', () => {
                 'connected',
                 20000,
                 (peerDescriptor: PeerDescriptor) => {
-                    return areEqualBinaries(peerDescriptor.kademliaId, node1.getPeerDescriptor().kademliaId)
+                    return areEqualBinaries(peerDescriptor.kademliaId, node1.getLocalPeerDescriptor().kademliaId)
                 }
             ),
             node2.joinDht([epPeerDescriptor]),
             node1.joinDht([epPeerDescriptor])
         ])
 
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getPeerDescriptor())).toEqual(true)
-        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getPeerDescriptor())!.connectionType)
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getLocalPeerDescriptor())!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
-        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getPeerDescriptor())!.connectionType)
+        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getLocalPeerDescriptor())!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
 
     }, 60000)
@@ -81,11 +85,11 @@ describe('Layer0 with WebRTC connections', () => {
             node4.joinDht([epPeerDescriptor])
         ])
 
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getPeerDescriptor())).toEqual(true)
-        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getPeerDescriptor())!.connectionType)
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getLocalPeerDescriptor())!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
-        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getPeerDescriptor())!.connectionType)
+        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getLocalPeerDescriptor())!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
     })
 })

package/test/end-to-end/Layer1-Scale-WebSocket.test.ts

@@ -25,7 +25,10 @@ describe('Layer1 Scale', () => {
     const websocketPortRange = { min: 62200, max: 62200 + NUM_OF_NODES }
 
     beforeEach(async () => {
-        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        epLayer0Node = new DhtNode({
+            peerDescriptor: epPeerDescriptor,
+            websocketServerEnableTls: false
+        })
         await epLayer0Node.start()
         await epLayer0Node.joinDht([epPeerDescriptor])
 
@@ -38,8 +41,9 @@ describe('Layer1 Scale', () => {
 
         for (let i = 0; i < NUM_OF_NODES; i++) {
             const node = new DhtNode({ 
-                websocketPortRange, 
+                websocketPortRange,
                 entryPoints: [epPeerDescriptor],
+                websocketServerEnableTls: false,
                 numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
             })
             await node.start()
@@ -47,7 +51,7 @@ describe('Layer1 Scale', () => {
             const layer1 = new DhtNode({
                 transport: node,
                 entryPoints: [epPeerDescriptor],
-                peerDescriptor: node.getPeerDescriptor(),
+                peerDescriptor: node.getLocalPeerDescriptor(),
                 serviceId: STREAM_ID,
                 numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
             })
@@ -59,7 +63,7 @@ describe('Layer1 Scale', () => {
 
         await Promise.all(layer1Nodes.map((node) => node.joinDht([epPeerDescriptor])))
 
-    }, 60000)
+    }, 120000)
 
     afterEach(async () => {
         await Promise.all(layer1Nodes.map((node) => node.stop()))

package/test/end-to-end/{Layer1-Scale-WebRTC.test.ts → Layer1-Scale-Webrtc.test.ts}

@@ -23,7 +23,7 @@ describe('Layer1 Scale', () => {
     let epLayer1Node: DhtNode
 
     beforeEach(async () => {
-        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor, websocketServerEnableTls: false })
         await epLayer0Node.start()
         await epLayer0Node.joinDht([epPeerDescriptor])
 
@@ -44,7 +44,7 @@ describe('Layer1 Scale', () => {
             const layer1 = new DhtNode({
                 transport: node,
                 entryPoints: [epPeerDescriptor],
-                peerDescriptor: node.getPeerDescriptor(),
+                peerDescriptor: node.getLocalPeerDescriptor(),
                 serviceId: STREAM_ID,
                 rpcRequestTimeout: 5000,
                 numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET

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

@@ -0,0 +1,52 @@
+import { DhtNode } from '../../src/dht/DhtNode'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import os from 'os'
+
+describe('Failed autocertification', () => {
+    
+    let entryPoint: DhtNode
+    let failedAutocertificationNode: DhtNode
+    let node: DhtNode
+    let entryPointPeerDescriptor: PeerDescriptor
+
+    beforeEach(async () => {
+        entryPoint = new DhtNode({ websocketHost: '127.0.0.1', websocketPortRange: { min: 11112, max: 11112 }, websocketServerEnableTls: false })
+        await entryPoint.start()
+        entryPointPeerDescriptor = entryPoint.getLocalPeerDescriptor()
+        await entryPoint.joinDht([entryPointPeerDescriptor])
+        
+        failedAutocertificationNode = new DhtNode({ 
+            websocketPortRange: { min: 11113, max: 11113 },
+            websocketHost: '127.0.0.1',
+            entryPoints: [entryPointPeerDescriptor],
+            websocketServerEnableTls: true,
+            autoCertifierConfigFile: os.tmpdir() + '/failedAutoCertificationConfigFile.json',
+            autoCertifierUrl: 'http://localhost:44444'
+        })
+
+        node = new DhtNode({
+            websocketPortRange: { min: 11114, max: 11114 },
+            websocketHost: '127.0.0.1',
+            entryPoints: [entryPointPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+    
+        await node.start()
+        await node.joinDht([entryPointPeerDescriptor])
+    })
+
+    afterEach(async () => {
+        await failedAutocertificationNode.stop()
+        await entryPoint.stop()
+        await node.stop()
+    })
+
+    it('failed auto certification should default to no tls', async () => {
+        await failedAutocertificationNode.start()
+        const failedAutocertificationPeerDescriptor = failedAutocertificationNode.getLocalPeerDescriptor()
+        expect(failedAutocertificationPeerDescriptor.websocket!.tls).toBe(false)
+        await failedAutocertificationNode.joinDht([entryPointPeerDescriptor])
+        expect(failedAutocertificationNode.getBucketSize()).toEqual(2)
+    })
+
+})

package/test/end-to-end/{WebSocketConnectionRequest.test.ts → WebsocketConnectionRequest.test.ts}

@@ -5,7 +5,7 @@ import { PeerID } from '../../src/helpers/PeerID'
 import { waitForCondition } from '@streamr/utils'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 
-describe('WebSocket IConnection Requests', () => {
+describe('Websocket IConnection Requests', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: PeerID.fromString('3').value,
         type: NodeType.NODEJS,
@@ -17,13 +17,21 @@ describe('WebSocket IConnection Requests', () => {
 
     beforeEach(async () => {
 
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, websocketServerEnableTls: false })
         await epDhtNode.start()
 
         await epDhtNode.joinDht([epPeerDescriptor])
 
-        node1 = new DhtNode({ websocketPortRange: { min: 10022, max: 10022 }, entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ 
+            websocketPortRange: { min: 10022, max: 10022 },
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+        node2 = new DhtNode({ 
+            entryPoints: [epPeerDescriptor],
+            websocketServerEnableTls: false
+        })
+
         await node1.start()
         await node2.start()
     })
@@ -40,12 +48,12 @@ describe('WebSocket IConnection Requests', () => {
         let connected2 = false
 
         node1.on('connected', (peerDescriptor: PeerDescriptor) => {
-            if (areEqualPeerDescriptors(peerDescriptor, node2.getPeerDescriptor())) {
+            if (areEqualPeerDescriptors(peerDescriptor, node2.getLocalPeerDescriptor())) {
                 connected1 = true
             }
         })
         node2.on('connected', (peerDescriptor: PeerDescriptor) => {
-            if (areEqualPeerDescriptors(peerDescriptor, node1.getPeerDescriptor())) {
+            if (areEqualPeerDescriptors(peerDescriptor, node1.getLocalPeerDescriptor())) {
                 connected2 = true
             }
         })
@@ -55,8 +63,8 @@ describe('WebSocket IConnection Requests', () => {
 
         await waitForCondition(() => { return (connected1 && connected2) })
 
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getPeerDescriptor())).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
 
     }, 10000)
 })

package/test/end-to-end/memory-leak.test.ts

@@ -0,0 +1,85 @@
+import LeakDetector from 'jest-leak-detector'
+import { binaryToHex, waitForCondition } from '@streamr/utils'
+import { randomBytes } from 'crypto'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { Message, MessageType, NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+
+const MESSAGE_ID = 'mock-message-id'
+
+describe('memory leak', () => {
+
+    it('send message', async () => {
+        const entryPointDescriptor = {
+            kademliaId: randomBytes(10),
+            type: NodeType.NODEJS,
+            websocket: {
+                host: '127.0.0.1',
+                port: 11224,
+                tls: false
+            }
+        }
+        let entryPoint: DhtNode | undefined = new DhtNode({
+            peerId: binaryToHex(entryPointDescriptor.kademliaId),
+            websocketHost: entryPointDescriptor.websocket!.host,
+            websocketPortRange: {
+                min: entryPointDescriptor.websocket.port,
+                max: entryPointDescriptor.websocket.port
+            },
+            entryPoints: [entryPointDescriptor],
+            websocketServerEnableTls: false
+        })
+        await entryPoint.start()
+        await entryPoint.joinDht([entryPointDescriptor])
+        let sender: DhtNode | undefined = new DhtNode({})
+        let receiver: DhtNode | undefined = new DhtNode({})
+        /*TODO should this work? await Promise.all([
+            async () => {
+                await sender.start()
+                await sender.joinDht([entryPointDescriptor])
+            },
+            async () => {
+                await receiver.start()
+                await receiver.joinDht([entryPointDescriptor])
+            }
+        ])*/
+        await sender.start()
+        await sender.joinDht([entryPointDescriptor])
+        await receiver.start()
+        await receiver.joinDht([entryPointDescriptor])
+
+        let receivedMessage: Message | undefined = undefined
+        receiver.on('message', (msg: Message) => receivedMessage = msg)
+        const msg: Message = {
+            serviceId: 'mock-service-id',
+            targetDescriptor: receiver.getLocalPeerDescriptor(),
+            messageType: MessageType.RPC,
+            messageId: 'mock-message-id',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            }
+        }
+        await sender.send(msg)
+        await waitForCondition(() => receivedMessage !== undefined)
+        expect(receivedMessage!.messageId).toEqual(MESSAGE_ID)
+
+        await Promise.all([
+            entryPoint.stop(),
+            sender.stop(),
+            receiver.stop()
+        ])
+
+        const detector1 = new LeakDetector(entryPoint)
+        entryPoint = undefined
+        expect(await detector1.isLeaking()).toBe(false)
+
+        const detector2 = new LeakDetector(sender)
+        sender = undefined
+        expect(await detector2.isLeaking()).toBe(false)
+
+        const detector3 = new LeakDetector(receiver)
+        receiver = undefined
+        expect(await detector3.isLeaking()).toBe(false)
+    })
+})

package/test/integration/ConnectionLocking.test.ts

@@ -1,17 +1,18 @@
 import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
-import { Simulator } from '../../src/connection/Simulator/Simulator'
-import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
+import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { ITransport } from '../../src/exports'
 import { PeerID } from '../../src/helpers/PeerID'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { getRandomRegion } from '../../dist/src/connection/simulator/pings'
 
-const createConnectionManager = (ownPeerDescriptor: PeerDescriptor, transport: ITransport) => {
+const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
         createConnectorFacade: () => new DefaultConnectorFacade({
             transport,
-            createOwnPeerDescriptor: () => ownPeerDescriptor
+            createLocalPeerDescriptor: () => localPeerDescriptor
         }),
         metricsContext: new MetricsContext()
     })
@@ -21,11 +22,13 @@ describe('Connection Locking', () => {
 
     const mockPeerDescriptor1: PeerDescriptor = {
         kademliaId: PeerID.fromString('mock1').value,
-        type: NodeType.NODEJS
+        type: NodeType.NODEJS,
+        region: getRandomRegion()
     }
     const mockPeerDescriptor2: PeerDescriptor = {
         kademliaId: PeerID.fromString('mock2').value,
-        type: NodeType.NODEJS
+        type: NodeType.NODEJS,
+        region: getRandomRegion()
     }
 
     let mockConnectorTransport1: ConnectionManager
@@ -37,7 +40,7 @@ describe('Connection Locking', () => {
     let simulator: Simulator
 
     beforeEach(async () => {
-        simulator = new Simulator()
+        simulator = new Simulator(LatencyType.REAL)
         mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
         await mockConnectorTransport1.start()
         mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)