@streamr/dht 100.0.0-testnet-one.0 → 100.0.0-testnet-one.2

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

@@ -89,11 +89,11 @@ describe('Layer0MixedConnectionTypes', () => {
             node5.joinDht([epPeerDescriptor])
         ])
 
-        expect(node1.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node2.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node3.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node4.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node5.getBucketSize()).toBeGreaterThanOrEqual(1)
+        expect(node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node5.getNumberOfNeighbors()).toBeGreaterThanOrEqual(1)
 
     }, 15000)
 
@@ -105,10 +105,10 @@ describe('Layer0MixedConnectionTypes', () => {
             node4.joinDht([epPeerDescriptor]),
             node5.joinDht([epPeerDescriptor])
         ])
-        expect(node1.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node2.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node3.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node4.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node5.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node5.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
     }, 30000)
 })

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

@@ -125,9 +125,9 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         await layer1Node3.joinDht([entrypointDescriptor])
         await layer1Node4.joinDht([entrypointDescriptor])
 
-        expect(layer1Node1.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node2.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node3.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node4.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
     }, 60000)
 })

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

@@ -75,10 +75,10 @@ describe('Layer1 Scale', () => {
     // TODO: fix flaky test in NET-1021
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
+            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node ) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

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

@@ -65,10 +65,10 @@ describe('Layer1 Scale', () => {
 
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
+            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

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

@@ -46,7 +46,7 @@ describe('Failed autocertification', () => {
         const failedAutocertificationPeerDescriptor = failedAutocertificationNode.getLocalPeerDescriptor()
         expect(failedAutocertificationPeerDescriptor.websocket!.tls).toBe(false)
         await failedAutocertificationNode.joinDht([entryPointPeerDescriptor])
-        expect(failedAutocertificationNode.getBucketSize()).toEqual(2)
+        expect(failedAutocertificationNode.getNumberOfNeighbors()).toEqual(2)
     })
 
 })

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

@@ -68,6 +68,7 @@ describe('memory leak', () => {
 
         const detector1 = new LeakDetector(entryPoint)
         entryPoint = undefined
+        await detector1.isLeaking()
         expect(await detector1.isLeaking()).toBe(false)
 
         const detector2 = new LeakDetector(sender)

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -25,10 +25,10 @@ const runTest = async (latencyType: LatencyType) => {
     await entryPoint.joinDht([entrypointDescriptor])
     await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
     nodes.forEach((node) => {
-        expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+        expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         expect(node.getClosestContacts().length).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
     })
-    expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+    expect(entryPoint.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
 
     await Promise.all([
         entryPoint.stop(),

package/test/integration/Layer1-scale.test.ts

@@ -75,7 +75,7 @@ describe('Layer1', () => {
             const layer1Node = layer1Nodes[i]
             expect(layer1Node.getNodeId().equals(layer0Node.getNodeId())).toEqual(true)
             expect(layer1Node.getNumberOfConnections()).toEqual(layer0Node.getNumberOfConnections())
-            expect(layer1Node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(layer1Node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
             expect(layer1Node.getAllConnectionPeerDescriptors()).toEqual(layer0Node.getAllConnectionPeerDescriptors())
         }
     }, 120000)

package/test/integration/Mock-Layer1-Layer0.test.ts

@@ -85,21 +85,21 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         await layer1Node3.joinDht([entryPointDescriptor])
         await layer1Node4.joinDht([entryPointDescriptor])
 
-        logger.info('layer1EntryPoint.getBucketSize() ' + layer1EntryPoint.getBucketSize())
-        logger.info('layer1Node1.getBucketSize()' + layer1Node1.getBucketSize())
-        logger.info('layer1Node2.getBucketSize()' + layer1Node2.getBucketSize())
-        logger.info('layer1Node3.getBucketSize()' + layer1Node3.getBucketSize())
-        logger.info('layer1Node4.getBucketSize()' + layer1Node4.getBucketSize())
-
-        expect(layer1Node1.getBucketSize()).toEqual(layer0Node1.getBucketSize())
-        expect(layer1Node2.getBucketSize()).toEqual(layer0Node2.getBucketSize())
-        expect(layer1Node3.getBucketSize()).toEqual(layer0Node3.getBucketSize())
-        expect(layer1Node4.getBucketSize()).toEqual(layer0Node4.getBucketSize())
-
-        expect(layer1Node1.getKBucketPeers()).toContainValues(layer0Node1.getKBucketPeers())
-        expect(layer1Node2.getKBucketPeers()).toContainValues(layer0Node2.getKBucketPeers())
-        expect(layer1Node3.getKBucketPeers()).toContainValues(layer0Node3.getKBucketPeers())
-        expect(layer1Node4.getKBucketPeers()).toContainValues(layer0Node4.getKBucketPeers())
+        logger.info('layer1EntryPoint.getNumberOfNeighbors() ' + layer1EntryPoint.getNumberOfNeighbors())
+        logger.info('layer1Node1.getNumberOfNeighbors()' + layer1Node1.getNumberOfNeighbors())
+        logger.info('layer1Node2.getNumberOfNeighbors()' + layer1Node2.getNumberOfNeighbors())
+        logger.info('layer1Node3.getNumberOfNeighbors()' + layer1Node3.getNumberOfNeighbors())
+        logger.info('layer1Node4.getNumberOfNeighbors()' + layer1Node4.getNumberOfNeighbors())
+
+        expect(layer1Node1.getNumberOfNeighbors()).toEqual(layer0Node1.getNumberOfNeighbors())
+        expect(layer1Node2.getNumberOfNeighbors()).toEqual(layer0Node2.getNumberOfNeighbors())
+        expect(layer1Node3.getNumberOfNeighbors()).toEqual(layer0Node3.getNumberOfNeighbors())
+        expect(layer1Node4.getNumberOfNeighbors()).toEqual(layer0Node4.getNumberOfNeighbors())
+
+        expect(layer1Node1.getAllNeighborPeerDescriptors()).toContainValues(layer0Node1.getAllNeighborPeerDescriptors())
+        expect(layer1Node2.getAllNeighborPeerDescriptors()).toContainValues(layer0Node2.getAllNeighborPeerDescriptors())
+        expect(layer1Node3.getAllNeighborPeerDescriptors()).toContainValues(layer0Node3.getAllNeighborPeerDescriptors())
+        expect(layer1Node4.getAllNeighborPeerDescriptors()).toContainValues(layer0Node4.getAllNeighborPeerDescriptors())
 
     }, 60000)
 })

package/test/integration/MultipleEntryPointJoining.test.ts

@@ -42,9 +42,9 @@ describe('multiple entry point joining', () => {
                 node2.joinDht(entryPoints),
                 node3.joinDht(entryPoints)
             ])
-            expect(node1.getBucketSize()).toEqual(2)
-            expect(node2.getBucketSize()).toEqual(2)
-            expect(node3.getBucketSize()).toEqual(2)
+            expect(node1.getNumberOfNeighbors()).toEqual(2)
+            expect(node2.getNumberOfNeighbors()).toEqual(2)
+            expect(node3.getNumberOfNeighbors()).toEqual(2)
         })
 
         it('can join even if a node is offline', async () => {
@@ -53,8 +53,8 @@ describe('multiple entry point joining', () => {
                 node1.joinDht(entryPoints),
                 node2.joinDht(entryPoints)
             ])
-            expect(node1.getBucketSize()).toEqual(1)
-            expect(node2.getBucketSize()).toEqual(1)
+            expect(node1.getNumberOfNeighbors()).toEqual(1)
+            expect(node2.getNumberOfNeighbors()).toEqual(1)
         }, 10000)
     })
 
@@ -96,9 +96,9 @@ describe('multiple entry point joining', () => {
 
         it('non-entry point nodes can join', async () => {
             await node1.joinDht(entryPoints)
-            expect(node1.getBucketSize()).toEqual(2)
+            expect(node1.getNumberOfNeighbors()).toEqual(2)
             await node2.joinDht(entryPoints)
-            expect(node2.getBucketSize()).toEqual(3)
+            expect(node2.getNumberOfNeighbors()).toEqual(3)
         })
 
     })

package/test/integration/ReplicateData.test.ts

@@ -80,7 +80,12 @@ describe('Replicate data from node to node in DHT', () => {
 
         // calculate offline which node is closest to the data
 
-        const sortedList = new SortedContactList<Contact>(dataKey, 10000)
+        const sortedList = new SortedContactList<Contact>({ 
+            referenceId: dataKey, 
+            maxSize: 10000, 
+            allowToContainReferenceId: true, 
+            emitEvents: false 
+        })
 
         nodes.forEach((node) => {
             sortedList.addContact(new Contact(node.getLocalPeerDescriptor())

package/test/integration/SimultaneousConnections.test.ts

@@ -20,8 +20,8 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit
 describe('SimultaneousConnections', () => {
 
     let simulator: Simulator
-    let simulatorTransport1: SimulatorTransport
-    let simulatorTransport2: SimulatorTransport
+    let simTransport1: SimulatorTransport
+    let simTransport2: SimulatorTransport
 
     const peerDescriptor1 = {
         nodeId: PeerID.fromString('mock1').value,
@@ -45,15 +45,15 @@ describe('SimultaneousConnections', () => {
 
     beforeEach(async () => {
         simulator = new Simulator()
-        simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        await simulatorTransport1.start()
-        simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        await simulatorTransport2.start()
+        simTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        await simTransport1.start()
+        simTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        await simTransport2.start()
     })
 
     afterEach(async () => {
-        await simulatorTransport1.stop()
-        await simulatorTransport2.stop()
+        await simTransport1.stop()
+        await simTransport2.stop()
     })
 
     it('simultanous simulated connection', async () => {
@@ -67,13 +67,13 @@ describe('SimultaneousConnections', () => {
         }
 
         const promise1 = new Promise<void>((resolve, _reject) => {
-            simulatorTransport1.on('message', async (message: Message) => {
+            simTransport1.on('message', async (message: Message) => {
                 expect(message.messageType).toBe(MessageType.RPC)
                 resolve()
             })
         })
         const promise2 = new Promise<void>((resolve, _reject) => {
-            simulatorTransport2.on('message', async (message: Message) => {
+            simTransport2.on('message', async (message: Message) => {
                 expect(message.messageType).toBe(MessageType.RPC)
                 resolve()
             })
@@ -81,19 +81,21 @@ describe('SimultaneousConnections', () => {
         await Promise.all([
             promise1,
             promise2,
-            simulatorTransport1.send(msg1),
-            simulatorTransport2.send(msg2)
+            simTransport1.send(msg1),
+            simTransport2.send(msg2)
         ])
-        await waitForCondition(() => simulatorTransport2.hasConnection(peerDescriptor1))
-        await waitForCondition(() => simulatorTransport1.hasConnection(peerDescriptor2))
+        await waitForCondition(() => simTransport2.hasConnection(peerDescriptor1))
+        await waitForCondition(() => simTransport1.hasConnection(peerDescriptor2))
     })
 
     describe('Websocket 2 servers', () => {
 
+        let simTransport1: SimulatorTransport
+        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
-
-        const wsPeer1: PeerDescriptor = {
+        
+        const wsPeerDescriptor1: PeerDescriptor = {
             nodeId: PeerID.fromString('mock1').value,
             type: NodeType.NODEJS,
             websocket: {
@@ -103,7 +105,7 @@ describe('SimultaneousConnections', () => {
             }
         }
 
-        const wsPeer2: PeerDescriptor = {
+        const wsPeerDescriptor2: PeerDescriptor = {
             nodeId: PeerID.fromString('mock2').value,
             type: NodeType.NODEJS,
             websocket: {
@@ -114,17 +116,26 @@ describe('SimultaneousConnections', () => {
         }
 
         beforeEach(async () => {
+            
+            // SimulatorTransport needs to have exatly same peerDescriptor as ConnectionManager
+            // that is why we need to create new SimulatorTransports here
+            simulator = new Simulator()
+            simTransport1 = new SimulatorTransport(wsPeerDescriptor1, simulator)
+            await simTransport1.start()
+            simTransport2 = new SimulatorTransport(wsPeerDescriptor2, simulator)
+            await simTransport2.start()
+            
             const websocketPortRange = { min: 43432, max: 43433 }
-            connectionManager1 = createConnectionManager(wsPeer1, {
-                transport: simulatorTransport1,
+            connectionManager1 = createConnectionManager(wsPeerDescriptor1, {
+                transport: simTransport1,
                 websocketPortRange,
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
-            connectionManager2 = createConnectionManager(wsPeer2, {
-                transport: simulatorTransport2,
+            connectionManager2 = createConnectionManager(wsPeerDescriptor2, {
+                transport: simTransport2,
                 websocketPortRange,
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
             await connectionManager1.start()
@@ -134,16 +145,18 @@ describe('SimultaneousConnections', () => {
         afterEach(async () => {
             await connectionManager1.stop()
             await connectionManager2.stop()
+            await simTransport1.stop()
+            await simTransport2.stop()
         })
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer2
+                targetDescriptor: wsPeerDescriptor2
             }
             const msg2: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer1
+                targetDescriptor: wsPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
@@ -166,17 +179,19 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wsPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wsPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(wsPeerDescriptor2))
+            await waitForCondition(() => connectionManager2.hasConnection(wsPeerDescriptor1))
         })
     })
 
     describe('Websocket 1 server (ConnectionRequests)', () => {
-
+    
+        let simTransport1: SimulatorTransport
+        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
 
-        const wsPeer1: PeerDescriptor = {
+        const wsPeerDescriptor1: PeerDescriptor = {
             nodeId: PeerID.fromString('mock1').value,
             type: NodeType.NODEJS,
             websocket: {
@@ -186,20 +201,26 @@ describe('SimultaneousConnections', () => {
             }
         }
 
-        const wsPeer2: PeerDescriptor = {
+        const wsPeerDescriptor2: PeerDescriptor = {
             nodeId: PeerID.fromString('mock2').value,
             type: NodeType.NODEJS
         }
 
         beforeEach(async () => {
-            connectionManager1 = createConnectionManager(wsPeer1, {
-                transport: simulatorTransport1,
+            simulator = new Simulator()
+            simTransport1 = new SimulatorTransport(wsPeerDescriptor1, simulator)
+            await simTransport1.start()
+            simTransport2 = new SimulatorTransport(wsPeerDescriptor2, simulator)
+            await simTransport2.start()
+
+            connectionManager1 = createConnectionManager(wsPeerDescriptor1, {
+                transport: simTransport1,
                 websocketPortRange: { min: 43432, max: 43432 },
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
-            connectionManager2 = createConnectionManager(wsPeer2, {
-                transport: simulatorTransport2
+            connectionManager2 = createConnectionManager(wsPeerDescriptor2, {
+                transport: simTransport2
             })
             await connectionManager1.start()
             await connectionManager2.start()
@@ -208,16 +229,18 @@ describe('SimultaneousConnections', () => {
         afterEach(async () => {
             await connectionManager1.stop()
             await connectionManager2.stop()
+            await simTransport1.stop()
+            await simTransport2.stop()
         })
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer2
+                targetDescriptor: wsPeerDescriptor2
             }
             const msg2: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer1
+                targetDescriptor: wsPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
@@ -240,32 +263,39 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wsPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wsPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(wsPeerDescriptor2))
+            await waitForCondition(() => connectionManager2.hasConnection(wsPeerDescriptor1))
         })
     })
 
     describe('WebRTC', () => {
 
+        let simTransport1: SimulatorTransport
+        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
 
-        const wrtcPeer1: PeerDescriptor = {
+        const wrtcPeerDescriptor1: PeerDescriptor = {
             nodeId: PeerID.fromString('mock1').value,
             type: NodeType.NODEJS
         }
 
-        const wrtcPeer2: PeerDescriptor = {
+        const wrtcPeerDescriptor2: PeerDescriptor = {
             nodeId: PeerID.fromString('mock2').value,
             type: NodeType.NODEJS
         }
 
         beforeEach(async () => {
-            connectionManager1 = createConnectionManager(wrtcPeer1, {
-                transport: simulatorTransport1,
+            simulator = new Simulator()
+            simTransport1 = new SimulatorTransport(wrtcPeerDescriptor1, simulator)
+            await simTransport1.start()
+            simTransport2 = new SimulatorTransport(wrtcPeerDescriptor2, simulator)
+            await simTransport2.start()
+            connectionManager1 = createConnectionManager(wrtcPeerDescriptor1, {
+                transport: simTransport1,
             })
-            connectionManager2 = createConnectionManager(wrtcPeer2, {
-                transport: simulatorTransport2,
+            connectionManager2 = createConnectionManager(wrtcPeerDescriptor2, {
+                transport: simTransport2,
             })
             await connectionManager1.start()
             await connectionManager2.start()
@@ -274,16 +304,18 @@ describe('SimultaneousConnections', () => {
         afterEach(async () => {
             await connectionManager1.stop()
             await connectionManager2.stop()
+            await simTransport1.stop()
+            await simTransport2.stop()
         })
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
                 ...baseMsg,
-                targetDescriptor: wrtcPeer2
+                targetDescriptor: wrtcPeerDescriptor2
             }
             const msg2: Message = {
                 ...baseMsg,
-                targetDescriptor: wrtcPeer1
+                targetDescriptor: wrtcPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
@@ -306,8 +338,8 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wrtcPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wrtcPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(wrtcPeerDescriptor2))
+            await waitForCondition(() => connectionManager2.hasConnection(wrtcPeerDescriptor1))
         })
     })
 

package/test/integration/Store.test.ts

@@ -42,7 +42,7 @@ describe('Storing data in DHT', () => {
 
     afterEach(async () => {
         await Promise.all(nodes.map((node) => node.stop()))
-    })
+    }, 15000)
 
     it('Storing data works', async () => {
         const storingNodeIndex = 34

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -59,7 +59,7 @@ describe('Storing data in DHT with two peers', () => {
 
     it('Can store on one peer DHT', async () => {
         await otherNode.stop()
-        await waitForCondition(() => entryPoint.getBucketSize() === 0)
+        await waitForCondition(() => entryPoint.getNumberOfNeighbors() === 0)
         const dataKey = createRandomNodeId()
         const storedData = createMockPeerDescriptor()
         const data = Any.pack(storedData, PeerDescriptor)

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -209,4 +209,33 @@ describe('WebRTC Connection Management', () => {
         await disconnectedPromise1
 
     }, 20000)
+
+    it('failed connections are cleaned up', async () => {
+        const msg: Message = {
+            serviceId,
+            messageType: MessageType.RPC,
+            messageId: '1',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+        }
+
+        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
+            manager1.on('disconnected', () => {
+                resolve()
+            })
+        })
+
+        msg.targetDescriptor = {
+            nodeId: new Uint8Array([0, 0, 0, 0, 0]),
+            type: NodeType.NODEJS,
+        }
+        
+        await Promise.allSettled([
+            manager1.send(msg),
+            disconnectedPromise1
+        ])
+        expect(manager1.getConnection(msg.targetDescriptor!)).toBeUndefined()
+    }, 20000)
 })