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

package/test/integration/SimultaneousConnections.test.ts

@@ -1,4 +1,4 @@
-import { MetricsContext, waitForCondition } from '@streamr/utils'
+import { MetricsContext, until } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
@@ -79,8 +79,8 @@ describe('SimultaneousConnections', () => {
             simTransport1.send(msg1),
             simTransport2.send(msg2)
         ])
-        await waitForCondition(() => simTransport2.hasConnection(toNodeId(peerDescriptor1)))
-        await waitForCondition(() => simTransport1.hasConnection(toNodeId(peerDescriptor2)))
+        await until(() => simTransport2.hasConnection(toNodeId(peerDescriptor1)))
+        await until(() => simTransport1.hasConnection(toNodeId(peerDescriptor2)))
     })
 
     describe('Websocket 2 servers', () => {
@@ -160,8 +160,8 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(toNodeId(wsPeerDescriptor2)))
-            await waitForCondition(() => connectionManager2.hasConnection(toNodeId(wsPeerDescriptor1)))
+            await until(() => connectionManager1.hasConnection(toNodeId(wsPeerDescriptor2)))
+            await until(() => connectionManager2.hasConnection(toNodeId(wsPeerDescriptor1)))
         })
     })
 
@@ -240,8 +240,8 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(toNodeId(wsPeerDescriptor2)))
-            await waitForCondition(() => connectionManager2.hasConnection(toNodeId(wsPeerDescriptor1)))
+            await until(() => connectionManager1.hasConnection(toNodeId(wsPeerDescriptor2)))
+            await until(() => connectionManager2.hasConnection(toNodeId(wsPeerDescriptor1)))
         })
     })
 
@@ -308,8 +308,8 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(toNodeId(wrtcPeerDescriptor2)))
-            await waitForCondition(() => connectionManager2.hasConnection(toNodeId(wrtcPeerDescriptor1)))
+            await until(() => connectionManager1.hasConnection(toNodeId(wrtcPeerDescriptor2)))
+            await until(() => connectionManager2.hasConnection(toNodeId(wrtcPeerDescriptor1)))
         })
     })
 

package/test/integration/StoreOnDhtWithThreeNodes.test.ts

@@ -34,7 +34,7 @@ describe('Storing data in DHT with two peers', () => {
         await entryPoint.stop()
         await node1.stop()
         await node2.stop()
-        simulator?.stop()
+        simulator!.stop()
     })
 
     it('Node can store on three peer DHT', async () => {

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -1,7 +1,7 @@
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { Simulator } from '../../src/connection/simulator/Simulator'
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
 import { toDhtAddress } from '../../src/identifiers'
 
@@ -26,7 +26,7 @@ describe('Storing data in DHT with two peers', () => {
     afterEach(async () => {
         await entryPoint.stop()
         await otherNode.stop()
-        simulator?.stop()
+        simulator!.stop()
     })
 
     it('Node can store on two peer DHT', async () => {
@@ -42,7 +42,7 @@ describe('Storing data in DHT with two peers', () => {
 
     it('Can store on one peer DHT', async () => {
         await otherNode.stop()
-        await waitForCondition(() => entryPoint.getNeighborCount() === 0)
+        await until(() => entryPoint.getNeighborCount() === 0)
         const storedData = createMockDataEntry()
         await entryPoint.storeDataToDht(toDhtAddress(storedData.key), storedData.data!)
         const foundData = await entryPoint.fetchDataFromDht(toDhtAddress(storedData.key))

package/test/integration/StoreRpcRemote.test.ts

@@ -45,7 +45,7 @@ describe('StoreRpcRemote', () => {
 
     it('storeData rejects', async () => {
         serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.throwStoreDataError)
-        await expect(rpcRemote.storeData(request)).rejects.toThrowError(
+        await expect(rpcRemote.storeData(request)).rejects.toThrow(
             'Could not store data to'
             + ` ${toNodeId(serverPeerDescriptor)} from ${toNodeId(clientPeerDescriptor)}`
             + ' Error: Mock'

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -162,34 +162,6 @@ describe('WebRTC Connection Management', () => {
 
     }, 20000)
 
-    it('Disconnects webrtcconnection while being connected', async () => {
-        const msg: Message = {
-            serviceId,
-            messageId: '1',
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            },
-        }
-
-        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', () => {
-                resolve()
-            })
-        })
-
-        msg.targetDescriptor = peerDescriptor2
-        manager1.send(msg).catch((e) => {
-            expect(e.code).toEqual('SEND_FAILED')
-        })
-
-        // @ts-expect-error private field
-        manager1.closeConnection(peerDescriptor2)
-
-        await disconnectedPromise1
-
-    }, 20000)
-
     it('failed connections are cleaned up', async () => {
         const msg: Message = {
             serviceId,

package/test/integration/WebrtcConnectorRpc.test.ts

@@ -9,7 +9,7 @@ import {
 import { Empty } from '../../generated/google/protobuf/empty'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { IWebrtcConnectorRpc } from '../../generated/packages/dht/protos/DhtRpc.server'
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
@@ -86,7 +86,7 @@ describe('WebRTC rpc messages', () => {
         { targetDescriptor, notification: true }
         )
 
-        await waitForCondition(() => requestConnectionCounter === 1)
+        await until(() => requestConnectionCounter === 1)
     })
 
     it('send rtcOffer', async () => {
@@ -97,7 +97,7 @@ describe('WebRTC rpc messages', () => {
         { targetDescriptor, notification: true }
         )
 
-        await waitForCondition(() => rtcOfferCounter === 1)
+        await until(() => rtcOfferCounter === 1)
     })
 
     it('send rtcAnswer', async () => {
@@ -108,7 +108,7 @@ describe('WebRTC rpc messages', () => {
         { targetDescriptor, notification: true }
         )
 
-        await waitForCondition(() => rtcAnswerCounter === 1)
+        await until(() => rtcAnswerCounter === 1)
     })
 
     it('send iceCandidate', async () => {
@@ -120,6 +120,6 @@ describe('WebRTC rpc messages', () => {
         { targetDescriptor, notification: true }
         )
 
-        await waitForCondition(() => iceCandidateCounter === 1)
+        await until(() => iceCandidateCounter === 1)
     })
 })

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -1,4 +1,4 @@
-import { MetricsContext, waitForCondition, waitForEvent3 } from '@streamr/utils'
+import { MetricsContext, until, waitForEvent3 } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
 import { Simulator } from '../../src/connection/simulator/Simulator'
@@ -158,13 +158,13 @@ describe('Websocket Connection Management', () => {
             targetDescriptor: wsServerConnectorPeerDescriptor
         }
         await noWsServerManager.send(dummyMessage)
-        await waitForCondition(
+        await until(
             () => {
                 const nodeId = toNodeId(noWsServerConnectorPeerDescriptor)
                 return wsServerManager.hasConnection(nodeId)
             }
         )
-        await waitForCondition(
+        await until(
             () => noWsServerManager.hasConnection(toNodeId(wsServerConnectorPeerDescriptor))
         )
     })

package/test/integration/rpc-connections-over-webrtc.test.ts

@@ -51,7 +51,6 @@ describe('RPC connections over WebRTC', () => {
         await connectorTransport2.start()
         manager2 = createConnectionManager(peerDescriptor2, connectorTransport2)
         rpcCommunicator2 = new ListeningRpcCommunicator(SERVICE_ID, manager2)
-        //client2 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator2.getRpcClientTransport()))
 
         await manager1.start()
         await manager2.start()
@@ -88,7 +87,7 @@ describe('RPC connections over WebRTC', () => {
         const response = await client1.ping(request, options)
 
         expect(response.requestId).toEqual(request.requestId)
-    }, 60000)
+    })
 
     it('Throws an exception if RPC method is not defined', async () => {
 
@@ -102,57 +101,23 @@ describe('RPC connections over WebRTC', () => {
 
         await expect(client1.ping(request, options))
             .rejects.toThrow('Server does not implement method ping')
-    }, 60000)
-
-    /*
-    
-    TODO enable these tests (NET-1177)
+    })
 
-    it.only('Throws a client-side exception if WebRTC connection fails', async () => {
+    it('Throws a client-side exception if WebRTC connection fails', async () => {
 
         const request: PingRequest = {
             requestId: v4()
         }
         const options: DhtRpcOptions = {
             sourceDescriptor: peerDescriptor1,
-            targetDescriptor: peerDescriptor2
+            targetDescriptor: peerDescriptor2,
+            timeout: 10000
         }
-        await connectorTransport1.stop()
         await manager2.stop()
         
-        const result = await client1.ping(request, options)
-        
-    }, 60000)
-
-    it('Disconnects WebrtcConnection while being connected', async () => {
-        
-        const rpcMessage: RpcMessage = {
-            header: {},
-            body: new Uint8Array(10),
-            requestId: v4()
-        }
-
-        const msg: Message = {
-            serviceId,
-            messageId: '1',
-            body: RpcMessage.toBinary(rpcMessage)
-        }
+        await expect(client1.ping(request, options))
+            .rejects.toThrow('Peer disconnected')
 
-        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', () => {
-                //expect(message.body.oneofKind).toBe('rpcMessage')
-                resolve()
-            })
-        })
-
-        msg.targetDescriptor = peerDescriptor2
-        manager1.send(msg).catch((e) => {
-            expect(e.code).toEqual('CONNECTION_FAILED')
-        })
-        
-        manager1.disconnect(peerDescriptor2!, undefined, 100)
-        await disconnectedPromise1
+    }, 10000)
 
-    }, 20000)
-    */
 })

package/test/unit/AutoCertifierClientFacade.test.ts

@@ -42,17 +42,17 @@ describe('AutoCertifierClientFacade', () => {
 
     it('start', async () => {
         await client.start()
-        expect(setHost).toBeCalled()
-        expect(updateCertificate).toBeCalled()
+        expect(setHost).toHaveBeenCalled()
+        expect(updateCertificate).toHaveBeenCalled()
     })
 
     it('updated events are processed', async () => {
         await client.start()
-        expect(setHost).toBeCalledTimes(1)
-        expect(updateCertificate).toBeCalledTimes(1);
+        expect(setHost).toHaveBeenCalledTimes(1)
+        expect(updateCertificate).toHaveBeenCalledTimes(1);
         (mockClient as MockAutoCertifierClient).emitUpdateSubdomain()
-        expect(setHost).toBeCalledTimes(2)
-        expect(updateCertificate).toBeCalledTimes(2)
+        expect(setHost).toHaveBeenCalledTimes(2)
+        expect(updateCertificate).toHaveBeenCalledTimes(2)
     })
 
 })

package/test/unit/Handshaker.test.ts

@@ -104,7 +104,7 @@ describe('Handshaker', () => {
         })
 
         it('onHandshakeFailed unsupported version', () => {
-            handshaker.emit('handshakeFailed', HandshakeError.UNSUPPORTED_VERSION)
+            handshaker.emit('handshakeFailed', HandshakeError.UNSUPPORTED_PROTOCOL_VERSION)
             expect(mockOnHandshakeCompleted).not.toHaveBeenCalled()
             expect(mockPendingConnectionClose).toHaveBeenCalledTimes(1)
         })

package/test/unit/ListeningRpcCommunicator.test.ts

@@ -1,4 +1,4 @@
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { ListeningRpcCommunicator } from '../../src/transport/ListeningRpcCommunicator'
 import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -44,9 +44,9 @@ describe('ListeningRpcCommunicator', () => {
             RpcMessage.create(),
             { targetDescriptor: peerDescriptor }, createDeferredPromises()
         )
-        await waitForCondition(() => rpcCommunicator.getRequestIds(() => true).length > 0)
+        await until(() => rpcCommunicator.getRequestIds(() => true).length > 0)
         transport.emit('disconnected', peerDescriptor, false)
-        await waitForCondition(() => rpcCommunicator.getRequestIds(() => true).length === 0)
+        await until(() => rpcCommunicator.getRequestIds(() => true).length === 0)
     }, 10000)
 
 })

package/test/unit/PeerManager.test.ts

@@ -1,4 +1,4 @@
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { range, sample, sampleSize } from 'lodash'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { PeerManager } from '../../src/dht/PeerManager'
@@ -64,7 +64,7 @@ describe('PeerManager', () => {
         expect(manager.getNeighborCount()).toBe(0)
         manager.addContact(failureContact)
         const closesSuccessContact = getClosestNodes(toNodeId(localPeerDescriptor), successContacts)[0]
-        await waitForCondition(() => {
+        await until(() => {
             const neighborNodeIds = manager.getNeighbors().map((n) => n.getNodeId())
             return neighborNodeIds.includes(toNodeId(closesSuccessContact))
         })

package/test/unit/RecursiveOperationSession.test.ts

@@ -1,4 +1,4 @@
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { range } from 'lodash'
 import { RecursiveOperationSession } from '../../src/dht/recursive-operation/RecursiveOperationSession'
 import { RecursiveOperationSessionRpcRemote } from '../../src/dht/recursive-operation/RecursiveOperationSessionRpcRemote'
@@ -59,7 +59,7 @@ describe('RecursiveOperationSession', () => {
 
         // TODO now waits for the 4s timeout, could setup test so that it completes by receiving
         // all data it wants
-        await waitForCondition(() => onCompleted.mock.calls.length > 0)
+        await until(() => onCompleted.mock.calls.length > 0)
         const result = session.getResults()
         // TODO assert peer descriptors
         expect(result.closestNodes).toHaveLength(6)

package/test/unit/RoutingSession.test.ts

@@ -76,4 +76,11 @@ describe('RoutingSession', () => {
         expect(session.updateAndGetRoutablePeers().length).toBe(0)
     })
 
+    it('recalculates Routing Table if it is empty', () => {
+        connections.set(toNodeId(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
+        expect(session.updateAndGetRoutablePeers().length).toBe(1)
+        routingTablesCache.onNodeDisconnected(toNodeId(mockPeerDescriptor2))
+        expect(session.updateAndGetRoutablePeers().length).toBe(1)
+    })
+
 })

package/test/unit/SortedContactList.test.ts

@@ -38,7 +38,7 @@ describe('SortedContactList', () => {
         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(onContactRemoved).toHaveBeenCalledWith(item4)
         expect(list.getContact(item4.getNodeId())).toBeFalsy()
     })
 
@@ -106,9 +106,9 @@ describe('SortedContactList', () => {
         list.on('contactAdded', onContactAdded)
         list.addContact(item1)
         list.addContact(item2)
-        expect(onContactAdded).toBeCalledTimes(2)
+        expect(onContactAdded).toHaveBeenCalledTimes(2)
         list.addContact(item3)
-        expect(onContactAdded).toBeCalledTimes(2)
+        expect(onContactAdded).toHaveBeenCalledTimes(2)
         expect(list.getClosestContacts().length).toEqual(2)
     })
 

package/test/unit/StoreManager.test.ts

@@ -1,4 +1,4 @@
-import { wait, waitForCondition } from '@streamr/utils'
+import { wait, until } from '@streamr/utils'
 import { range, without } from 'lodash'
 import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
 import { StoreManager } from '../../src/dht/store/StoreManager'
@@ -67,7 +67,7 @@ describe('StoreManager', () => {
                     setAllEntriesAsStale
                 )
                 manager.onContactAdded(getNodeCloseToData(2))
-                await waitForCondition(() => replicateData.mock.calls.length === 1)
+                await until(() => replicateData.mock.calls.length === 1)
                 expect(replicateData).toHaveBeenCalledWith({
                     entry: DATA_ENTRY
                 }, true)

package/test/unit/connectivityRequestHandler.test.ts

@@ -1,4 +1,4 @@
-import { ipv4ToNumber, waitForCondition } from '@streamr/utils'
+import { ipv4ToNumber, until } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { once } from 'events'
 import { Server as HttpServer, createServer as createHttpServer } from 'http'
@@ -48,7 +48,7 @@ describe('connectivityRequestHandler', () => {
         }
         connection.emit('data', Message.toBinary(request))
 
-        await waitForCondition(() => connection.send.mock.calls.length > 0)
+        await until(() => connection.send.mock.calls.length > 0)
 
         const receivedMessage = Message.fromBinary(connection.send.mock.calls[0][0])
         expect(receivedMessage).toEqual({
@@ -62,7 +62,7 @@ describe('connectivityRequestHandler', () => {
                         tls: false
                     },
                     ipAddress: ipv4ToNumber(HOST),
-                    version: LOCAL_PROTOCOL_VERSION
+                    protocolVersion: LOCAL_PROTOCOL_VERSION
                 },
                 oneofKind: 'connectivityResponse'
             },
@@ -83,7 +83,7 @@ describe('connectivityRequestHandler', () => {
         }
         connection.emit('data', Message.toBinary(request))
 
-        await waitForCondition(() => connection.send.mock.calls.length > 0)
+        await until(() => connection.send.mock.calls.length > 0)
 
         const receivedMessage = Message.fromBinary(connection.send.mock.calls[0][0])
         expect(receivedMessage).toEqual({
@@ -92,7 +92,7 @@ describe('connectivityRequestHandler', () => {
                     host: HOST,
                     natType: 'unknown',
                     ipAddress: ipv4ToNumber(HOST),
-                    version: LOCAL_PROTOCOL_VERSION
+                    protocolVersion: LOCAL_PROTOCOL_VERSION
                 },
                 oneofKind: 'connectivityResponse'
             },

package/test/unit/customMatchers.test.ts

@@ -13,4 +13,22 @@ describe('custom matchers', () => {
     it('no match', () => {
         expect(createMockPeerDescriptor()).not.toEqualPeerDescriptor(createMockPeerDescriptor())
     })
+
+    describe('error message', () => {
+
+        it('normal', () => {
+            const actual = createMockPeerDescriptor()
+            const expected = createMockPeerDescriptor()
+            expect(() => {
+                expect(actual).toEqualPeerDescriptor(expected)
+            }).toThrow('PeerDescriptor nodeId values don\'t match')
+        })
+
+        it('inverse', () => {
+            const peerDescriptor = createMockPeerDescriptor()
+            expect(() => {
+                expect(peerDescriptor).not.toEqualPeerDescriptor(peerDescriptor)
+            }).toThrow('PeerDescriptors are equal')
+        })
+    })
 })

package/test/unit/getClosestNodes.test.ts

@@ -10,7 +10,7 @@ describe('getClosestNodes', () => {
     it('happy path', () => {
         const peerDescriptors = range(10).map(() => createMockPeerDescriptor())
         const referenceId = randomDhtAddress()
-        const excluded = new Set<DhtAddress>(sampleSize(peerDescriptors.map((n) => toNodeId(n), 2)))
+        const excluded = new Set<DhtAddress>(sampleSize(peerDescriptors.map((n) => toNodeId(n)), 2))
 
         const actual = getClosestNodes(
             referenceId,

package/test/unit/version.test.ts

@@ -1,18 +1,18 @@
-import { isMaybeSupportedVersion } from '../../src/helpers/version'
+import { isMaybeSupportedProtocolVersion } from '../../src/helpers/version'
 
 describe('version', () => {
 
     it('supported', () => {
-        expect(isMaybeSupportedVersion('1.0')).toBe(true)
-        expect(isMaybeSupportedVersion('1.1')).toBe(true)
-        expect(isMaybeSupportedVersion('2.0')).toBe(true)
-        expect(isMaybeSupportedVersion('3.5')).toBe(true)
+        expect(isMaybeSupportedProtocolVersion('1.0')).toBe(true)
+        expect(isMaybeSupportedProtocolVersion('1.1')).toBe(true)
+        expect(isMaybeSupportedProtocolVersion('2.0')).toBe(true)
+        expect(isMaybeSupportedProtocolVersion('3.5')).toBe(true)
     })
 
     it('not supported', () => {
-        expect(isMaybeSupportedVersion('')).toBe(false)
-        expect(isMaybeSupportedVersion('100.0.0-testnet-three.3')).toBe(false)
-        expect(isMaybeSupportedVersion('0.0')).toBe(false)
-        expect(isMaybeSupportedVersion('0.1')).toBe(false)
+        expect(isMaybeSupportedProtocolVersion('')).toBe(false)
+        expect(isMaybeSupportedProtocolVersion('100.0.0-testnet-three.3')).toBe(false)
+        expect(isMaybeSupportedProtocolVersion('0.0')).toBe(false)
+        expect(isMaybeSupportedProtocolVersion('0.1')).toBe(false)
     })
 })

package/test/utils/customMatchers.ts

@@ -15,8 +15,8 @@ declare global {
     }
 }
 
-const formErrorMessage = (description: string, expected: string | number | undefined, actual: string | number | undefined): string => {
-    return `${description}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(actual)}`
+const formErrorMessage = (field: keyof PeerDescriptor, expected: string | number | undefined, actual: string | number | undefined): string => {
+    return `PeerDescriptor ${field} values don't match:\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(actual)}`
 }
 
 const toEqualPeerDescriptor = (
@@ -32,7 +32,7 @@ const toEqualPeerDescriptor = (
         messages.push(formErrorMessage('type', typeNames[expected.type], typeNames[actual.type]))
     }
     expectEqualConnectivityMethod('udp', expected.udp, actual.udp, messages)
-    expectEqualConnectivityMethod('tpc', expected.tcp, actual.tcp, messages)
+    expectEqualConnectivityMethod('tcp', expected.tcp, actual.tcp, messages)
     expectEqualConnectivityMethod('websocket', expected.websocket, actual.websocket, messages)
     if (expected.region !== actual.region) {
         messages.push(formErrorMessage('region', expected?.region, actual?.region))
@@ -45,13 +45,13 @@ const toEqualPeerDescriptor = (
     } else {
         return {
             pass: true,
-            message: () => `Expected not to throw ${printReceived('StreamrClientError')}`
+            message: () => 'PeerDescriptors are equal'
         }
     }
 }
 
 const expectEqualConnectivityMethod = (
-    description: string,
+    field: keyof PeerDescriptor,
     method1: ConnectivityMethod | undefined,
     method2: ConnectivityMethod | undefined,
     messages: string[]
@@ -62,7 +62,7 @@ const expectEqualConnectivityMethod = (
             : undefined
     }
     if (!isEqual(method1, method2)) {
-        messages.push(formErrorMessage(description, toOutput(method1), toOutput(method2)))
+        messages.push(formErrorMessage(field, toOutput(method1), toOutput(method2)))
     }
 }
 

package/test/utils/topology.ts

@@ -59,7 +59,6 @@ export const createTestTopology = (nodeCount: number, minNeighorCount: number):
             }
         }
     }
-    // eslint-disable-next-line no-constant-condition
     while (true) {
         const partitions = getTopologyPartitions(topology)
         if (partitions.length === 1) {

package/test/utils/utils.ts

@@ -25,7 +25,7 @@ import { v4 } from 'uuid'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
 import { Empty } from '../../generated/google/protobuf/empty'
 import { Any } from '../../generated/google/protobuf/any'
-import { wait, waitForCondition } from '@streamr/utils'
+import { wait, until } from '@streamr/utils'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { DhtAddress, randomDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
 
@@ -258,7 +258,7 @@ export const waitForStableTopology = async (nodes: DhtNode[], maxConnectionCount
     await Promise.all(connectionManagers.map(async (connectionManager) => {
         connectionManager.garbageCollectConnections(maxConnectionCount, MAX_IDLE_TIME)
         try {
-            await waitForCondition(() => connectionManager.getConnections().length <= maxConnectionCount, waitTime)
+            await until(() => connectionManager.getConnections().length <= maxConnectionCount, waitTime)
         } catch {
             // the topology is very likely stable, but we can't be sure (maybe the node has more than maxConnectionCount
             // locked connections and therefore it is ok to that garbage collector was not able to remove any of those

package/.eslintignore

@@ -1,5 +0,0 @@
-node_modules/**
-coverage/**
-dist/**
-.idea/**
-generated/**

package/.eslintrc

@@ -1,3 +0,0 @@
-{
-    "extends": "../../.eslintrc.js"
-}