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

package/test/integration/ConnectionManager.test.ts

@@ -1,12 +1,15 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { ConnectivityResponse, Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { PeerID } from '../../src/helpers/PeerID'
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { Simulator } from '../../src/connection/simulator/Simulator'
 import { createPeerDescriptor } from '../../src/dht/DhtNode'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Logger, MetricsContext } from '@streamr/utils'
+import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
 import { SimulatorTransport } from '../../src/exports'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
+import { MarkOptional } from 'ts-essentials'
+import { createRandomKademliaId } from '../../src/helpers/kademliaId'
+import { TransportEvents } from '../../src/transport/ITransport'
 
 const logger = new Logger(module)
 
@@ -37,12 +40,13 @@ describe('ConnectionManager', () => {
     const mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
     const mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)
 
-    let createOwnPeerDescriptor: jest.Mock<PeerDescriptor, [ConnectivityResponse]>
+    let createLocalPeerDescriptor: jest.Mock<PeerDescriptor, [ConnectivityResponse]>
 
-    const createConnectionManager = (opts: Omit<DefaultConnectorFacadeConfig, 'createOwnPeerDescriptor'>) => {
+    const createConnectionManager = (opts: MarkOptional<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
         return new ConnectionManager({
             createConnectorFacade: () => new DefaultConnectorFacade({
-                createOwnPeerDescriptor,
+                createLocalPeerDescriptor,
+                websocketServerEnableTls: false,
                 ...opts
             }),
             metricsContext: new MetricsContext()
@@ -50,7 +54,7 @@ describe('ConnectionManager', () => {
     }
 
     beforeEach(() => {
-        createOwnPeerDescriptor = jest.fn().mockImplementation((response) => createPeerDescriptor(response))
+        createLocalPeerDescriptor = jest.fn().mockImplementation((response) => createPeerDescriptor(response))
     })
 
     beforeAll(async () => {
@@ -59,7 +63,7 @@ describe('ConnectionManager', () => {
         await mockConnectorTransport2.start()
     })
 
-    afterAll(async ()=> {
+    afterAll(async () => {
         await mockTransport.stop()
         await mockConnectorTransport1.stop()
         await mockConnectorTransport2.stop()
@@ -70,12 +74,11 @@ describe('ConnectionManager', () => {
         const connectionManager = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
-            websocketPortRange: { min: 9991, max: 9991 },
+            websocketPortRange: { min: 9991, max: 9991 }
         })
 
         await connectionManager.start()
-        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
 
         await connectionManager.stop()
     })
@@ -103,8 +106,7 @@ describe('ConnectionManager', () => {
         })
 
         await connectionManager1.start()
-        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
 
         const connectionManager2 = createConnectionManager({
             transport: mockConnectorTransport2,
@@ -115,8 +117,7 @@ describe('ConnectionManager', () => {
         })
 
         await connectionManager2.start()
-        expect(createOwnPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[1][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
 
         await connectionManager1.stop()
         await connectionManager2.stop()
@@ -130,20 +131,18 @@ describe('ConnectionManager', () => {
         })
 
         await connectionManager1.start()
-        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
 
         const connectionManager2 = createConnectionManager({
             transport: mockConnectorTransport2,
             websocketPortRange: { min: 9996, max: 9996 },
             entryPoints: [
-                connectionManager1.getPeerDescriptor()
+                connectionManager1.getLocalPeerDescriptor()
             ]
         })
 
         await connectionManager2.start()
-        expect(createOwnPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[1][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
 
         const msg: Message = {
             serviceId,
@@ -174,7 +173,7 @@ describe('ConnectionManager', () => {
             })
         })
 
-        msg.targetDescriptor = connectionManager2.getPeerDescriptor()
+        msg.targetDescriptor = connectionManager2.getLocalPeerDescriptor()
         connectionManager1.send(msg)
 
         await Promise.all([promise, connectedPromise1, connectedPromise2])
@@ -187,18 +186,18 @@ describe('ConnectionManager', () => {
         const connectionManager1 = createConnectionManager({ 
             transport: mockConnectorTransport1,
             websocketHost: '127.0.0.1',
-            websocketPortRange: { min: 9997, max: 9997 }
+            websocketPortRange: { min: 9997, max: 9997 },
         })
 
         await connectionManager1.start()
-        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
 
         const connectionManager2 = createConnectionManager({
             transport: mockConnectorTransport2,
             websocketPortRange: { min: 9999, max: 9999 },
+            websocketServerEnableTls: false,
             entryPoints: [
-                connectionManager1.getPeerDescriptor()
+                connectionManager1.getLocalPeerDescriptor()
             ]
         })
 
@@ -234,13 +233,13 @@ describe('ConnectionManager', () => {
                 resolve()
             })
         })
-        msg.targetDescriptor = connectionManager2.getPeerDescriptor()
+        msg.targetDescriptor = connectionManager2.getLocalPeerDescriptor()
         connectionManager1.send(msg)
 
         await promise
 
         // @ts-expect-error private field
-        connectionManager1.closeConnection(connectionManager2.getPeerDescriptor())
+        connectionManager1.closeConnection(connectionManager2.getLocalPeerDescriptor())
 
         await Promise.all([disconnectedPromise1, disconnectedPromise2])
 
@@ -307,7 +306,7 @@ describe('ConnectionManager', () => {
         await connectionManager4.stop()
     })
 
-    it('Cannot send to own WebSocketServer if kademliaIds do not match', async () => {
+    it('Cannot send to own WebsocketServer if kademliaIds do not match', async () => {
         const connectionManager1 = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
@@ -315,10 +314,9 @@ describe('ConnectionManager', () => {
         })
 
         await connectionManager1.start()
-        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
-        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
         
-        const peerDescriptor = connectionManager1.getPeerDescriptor()
+        const peerDescriptor = connectionManager1.getLocalPeerDescriptor()
         peerDescriptor.kademliaId = new Uint8Array([12, 12, 12, 12])
         const msg: Message = {
             serviceId,
@@ -336,4 +334,83 @@ describe('ConnectionManager', () => {
         
         await connectionManager1.stop()
     })
+
+    it('Cannot send to a WebSocketServer if kademliaIds do not match', async () => {
+
+        const peerDescriptor1 = {
+            kademliaId: createRandomKademliaId(),
+            type: NodeType.NODEJS,
+            websocket: {
+                host: '127.0.0.1',
+                port: 10002,
+                tls: false
+            }
+        }
+
+        const peerDescriptor2 = {
+            kademliaId: createRandomKademliaId(),
+            type: NodeType.NODEJS,
+            websocket: {
+                host: '127.0.0.1',
+                port: 10003,
+                tls: false
+            }
+        }
+        const connectionManager1 = createConnectionManager({
+            transport: mockTransport,
+            websocketHost: '127.0.0.1',
+            websocketPortRange: { min: 10002, max: 10002 },
+            createLocalPeerDescriptor: () => peerDescriptor1 
+        })
+
+        await connectionManager1.start()
+
+        const connectionManager2 = createConnectionManager({
+            transport: mockTransport,
+            websocketHost: '127.0.0.1',
+            websocketPortRange: { min: 10003, max: 10003 },
+            createLocalPeerDescriptor: () => peerDescriptor2
+        })
+
+        await connectionManager2.start()
+
+        const msg: Message = {
+            serviceId,
+            messageType: MessageType.RPC,
+            messageId: '1',
+            targetDescriptor: {
+                // This is not the correct kademliaId of peerDescriptor2
+                kademliaId: new Uint8Array([1, 2, 3, 4]),
+                type: NodeType.NODEJS,
+                websocket: peerDescriptor2.websocket
+            },
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            } 
+        }
+        await Promise.all([
+            waitForEvent3<TransportEvents>(connectionManager1, 'disconnected'),
+            expect(connectionManager1.send(msg))      
+                .rejects
+                .toThrow()
+        ])
+        
+        await connectionManager1.stop()
+        await connectionManager2.stop()
+    }, 10000)
+
+    it('Failed autocertification', async () => {
+        const connectionManager1 = createConnectionManager({
+            transport: mockTransport,
+            websocketHost: '127.0.0.1',
+            autoCertifierUrl: 'https://localhost:12333',
+            websocketServerEnableTls: true,
+            websocketPortRange: { min: 10004, max: 10004 }
+        })
+
+        await connectionManager1.start()
+        expect(connectionManager1.getLocalPeerDescriptor().websocket!.tls).toEqual(false)
+        await connectionManager1.stop()
+    })
 })

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -1,5 +1,5 @@
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
-import { getRandomRegion } from '../../src/connection/Simulator/pings'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
+import { getRandomRegion } from '../../src/connection/simulator/pings'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'

package/test/integration/DhtNodeExternalAPI.test.ts

@@ -1,5 +1,5 @@
 import { DhtNode } from '../../src/dht/DhtNode'
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
@@ -15,7 +15,7 @@ describe('DhtNodeExternalApi', () => {
         simulator = new Simulator(LatencyType.NONE)
         dhtNode1 = await createMockConnectionDhtNode('node1', simulator)
         remote = await createMockConnectionDhtNode('remote', simulator)
-        await dhtNode1.joinDht([dhtNode1.getPeerDescriptor()])
+        await dhtNode1.joinDht([dhtNode1.getLocalPeerDescriptor()])
     })
 
     afterEach(async () => {
@@ -27,26 +27,26 @@ describe('DhtNodeExternalApi', () => {
     })
 
     it('findData happy path', async () => {
-        const data = Any.pack(dhtNode1.getPeerDescriptor(), PeerDescriptor)
+        const data = Any.pack(dhtNode1.getLocalPeerDescriptor(), PeerDescriptor)
         const key = PeerID.fromString('key').value
         await dhtNode1.storeDataToDht(key, data)
 
-        const foundData = await remote.findDataViaPeer(key, dhtNode1.getPeerDescriptor())
-        expect(Any.unpack(foundData[0].data!, PeerDescriptor)).toEqual(dhtNode1.getPeerDescriptor())
+        const foundData = await remote.findDataViaPeer(key, dhtNode1.getLocalPeerDescriptor())
+        expect(Any.unpack(foundData[0].data!, PeerDescriptor)).toEqual(dhtNode1.getLocalPeerDescriptor())
     })
     
     it('findData returns empty array if no data found', async () => {
-        const foundData = await remote.findDataViaPeer(PeerID.fromString('key').value, dhtNode1.getPeerDescriptor())
+        const foundData = await remote.findDataViaPeer(PeerID.fromString('key').value, dhtNode1.getLocalPeerDescriptor())
         expect(foundData).toEqual([])
     })
 
     it('external store data happy path', async () => {
-        const data = Any.pack(dhtNode1.getPeerDescriptor(), PeerDescriptor)
+        const data = Any.pack(dhtNode1.getLocalPeerDescriptor(), PeerDescriptor)
         const key = PeerID.fromString('key').value 
 
-        await remote.storeDataViaPeer(key, data, dhtNode1.getPeerDescriptor())
-        const foundData = await remote.findDataViaPeer(key, dhtNode1.getPeerDescriptor())
-        expect(Any.unpack(foundData[0].data!, PeerDescriptor)).toEqual(dhtNode1.getPeerDescriptor())
+        await remote.storeDataViaPeer(key, data, dhtNode1.getLocalPeerDescriptor())
+        const foundData = await remote.findDataViaPeer(key, dhtNode1.getLocalPeerDescriptor())
+        expect(Any.unpack(foundData[0].data!, PeerDescriptor)).toEqual(dhtNode1.getLocalPeerDescriptor())
     })
   
 })

package/test/integration/{RemoteDhtNode.test.ts → DhtNodeRpcRemote.test.ts}

@@ -1,4 +1,4 @@
-import { RemoteDhtNode } from '../../src/dht/RemoteDhtNode'
+import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
 import { getMockPeers, MockDhtRpc } from '../utils/utils'
 import {
@@ -10,12 +10,12 @@ import {
     PingResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { DhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { generateId } from '../utils/utils'
 
-describe('RemoteDhtNode', () => {
+describe('DhtNodeRpcRemote', () => {
 
-    let remoteDhtNode: RemoteDhtNode
+    let rpcRemote: DhtNodeRpcRemote
     let clientRpcCommunicator: RpcCommunicator
     let serverRpcCommunicator: RpcCommunicator
     const serviceId = 'test'
@@ -39,8 +39,8 @@ describe('RemoteDhtNode', () => {
         serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        const client = toProtoRpcClient(new DhtRpcServiceClient(clientRpcCommunicator.getRpcClientTransport()))
-        remoteDhtNode = new RemoteDhtNode(clientPeerDescriptor, serverPeerDescriptor, client, serviceId)
+        const client = toProtoRpcClient(new DhtNodeRpcClient(clientRpcCommunicator.getRpcClientTransport()))
+        rpcRemote = new DhtNodeRpcRemote(clientPeerDescriptor, serverPeerDescriptor, client, serviceId)
     })
 
     afterEach(() => {
@@ -49,24 +49,24 @@ describe('RemoteDhtNode', () => {
     })
 
     it('Ping happy path', async () => {
-        const active = await remoteDhtNode.ping()
+        const active = await rpcRemote.ping()
         expect(active).toEqual(true)
     })
 
     it('getClosestPeers happy path', async () => {
-        const neighbors = await remoteDhtNode.getClosestPeers(clientPeerDescriptor.kademliaId)
+        const neighbors = await rpcRemote.getClosestPeers(clientPeerDescriptor.kademliaId)
         expect(neighbors.length).toEqual(getMockPeers().length)
     })
 
     it('ping error path', async () => {
         serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', MockDhtRpc.throwPingError)
-        const active = await remoteDhtNode.ping()
+        const active = await rpcRemote.ping()
         expect(active).toEqual(false)
     })
 
     it('getClosestPeers error path', async () => {
         serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.throwGetClosestPeersError)
-        await expect(remoteDhtNode.getClosestPeers(clientPeerDescriptor.kademliaId))
+        await expect(rpcRemote.getClosestPeers(clientPeerDescriptor.kademliaId))
             .rejects.toThrow('Closest peers error')
     })
 

package/test/integration/DhtRpc.test.ts

@@ -1,6 +1,6 @@
 import { getMockPeers, MockDhtRpc } from '../utils/utils'
 import { ProtoRpcClient, RpcCommunicator, RpcError, toProtoRpcClient } from '@streamr/proto-rpc'
-import { DhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { generateId } from '../utils/utils'
 import { ClosestPeersRequest, ClosestPeersResponse, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { wait } from '@streamr/utils'
@@ -9,8 +9,8 @@ import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 describe('DhtRpc', () => {
     let rpcCommunicator1: RpcCommunicator
     let rpcCommunicator2: RpcCommunicator
-    let client1: ProtoRpcClient<DhtRpcServiceClient>
-    let client2: ProtoRpcClient<DhtRpcServiceClient>
+    let client1: ProtoRpcClient<DhtNodeRpcClient>
+    let client2: ProtoRpcClient<DhtNodeRpcClient>
 
     const peerDescriptor1: PeerDescriptor = {
         kademliaId: generateId('peer1'),
@@ -39,8 +39,8 @@ describe('DhtRpc', () => {
 
         rpcCommunicator2.on('outgoingMessage', outgoingListener2)
 
-        client1 = toProtoRpcClient(new DhtRpcServiceClient(rpcCommunicator1.getRpcClientTransport()))
-        client2 = toProtoRpcClient(new DhtRpcServiceClient(rpcCommunicator1.getRpcClientTransport()))
+        client1 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator1.getRpcClientTransport()))
+        client2 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator1.getRpcClientTransport()))
     })
 
     afterEach(async () => {

package/test/integration/{RecursiveFind.test.ts → Find.test.ts}

@@ -1,16 +1,16 @@
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
 import { PeerID } from '../../src/helpers/PeerID'
 import { peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 
-describe('Recursive find correctness', () => {
+describe('Find correctness', () => {
 
     let entryPoint: DhtNode
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
-    const simulator = new Simulator(LatencyType.RANDOM)
+    const simulator = new Simulator(LatencyType.REAL)
     const NUM_NODES = 100
     const K = 2
 
@@ -19,10 +19,7 @@ describe('Recursive find correctness', () => {
         const entryPointId = '0'
         entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, K)
         nodes.push(entryPoint)
-        entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
+        entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`
             const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, K, 20, 60000)
@@ -42,7 +39,7 @@ describe('Recursive find correctness', () => {
 
     it('Entrypoint can find a node from the network (exact match)', async () => {
         const kademliaIdToFind = nodes[45].getNodeId().value
-        const results = await entryPoint.startRecursiveFind(kademliaIdToFind)
+        const results = await entryPoint.startFind(kademliaIdToFind)
         expect(results.closestNodes.length).toBeGreaterThanOrEqual(5)
         expect(PeerID.fromValue(kademliaIdToFind).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
     }, 30000)

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

@@ -1,4 +1,4 @@
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { Simulator } from '../../src/connection/simulator/Simulator'
 import { PeerID } from '../../src/helpers/PeerID'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'

package/test/integration/MigrateData.test.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-console */
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, waitNodesReadyForTesting } from '../utils/utils'
@@ -7,7 +7,7 @@ import { execSync } from 'child_process'
 import fs from 'fs'
 import { Logger } from '@streamr/utils'
 import { PeerID } from '../../src/helpers/PeerID'
-import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import { Contact } from '../../src/dht/contact/Contact'
@@ -83,7 +83,7 @@ describe('Migrating data from node to node in DHT', () => {
         const sortedList = new SortedContactList<Contact>(dataKey, 10000)
 
         nodes.forEach((node) => {
-            sortedList.addContact(new Contact(node.getPeerDescriptor())
+            sortedList.addContact(new Contact(node.getLocalPeerDescriptor())
             )
         })
 
@@ -91,7 +91,7 @@ describe('Migrating data from node to node in DHT', () => {
 
         logger.info('Nodes sorted according to distance to data are: ')
         closest.forEach((contact) => {
-            logger.info(keyFromPeerDescriptor(contact.getPeerDescriptor()))
+            logger.info(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
         })
 
         logger.info('node 0 joining to the DHT')
@@ -114,13 +114,14 @@ describe('Migrating data from node to node in DHT', () => {
                 hasDataMarker = '<-'
             }
 
-            logger.info(keyFromPeerDescriptor(contact.getPeerDescriptor()) + ' ' + keyFromPeerDescriptor(node.getPeerDescriptor()) + hasDataMarker)
+            // eslint-disable-next-line max-len
+            logger.info(peerIdFromPeerDescriptor(contact.getPeerDescriptor()) + ' ' + getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + hasDataMarker)
         })
 
         logger.info(NUM_NODES + ' nodes joining layer0 DHT')
         await Promise.all(
             nodes.map((node) => {
-                if (keyFromPeerDescriptor(node.getPeerDescriptor()) != '0') {
+                if (keyFromPeerDescriptor(node.getLocalPeerDescriptor()) != '0') {
                     node.joinDht([entrypointDescriptor])
                 }
             })
@@ -142,7 +143,7 @@ describe('Migrating data from node to node in DHT', () => {
                 hasDataMarker = '<-'
             }
 
-            logger.info(keyFromPeerDescriptor(node.getPeerDescriptor()) + hasDataMarker)
+            logger.info(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + hasDataMarker)
         })
 
         const closestNode = nodesById.get(PeerID.fromValue(closest[0].getPeerDescriptor().kademliaId).toKey())!

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

@@ -1,5 +1,5 @@
 import { Logger } from '@streamr/utils'
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'

package/test/integration/MultipleEntryPointJoining.test.ts

@@ -1,4 +1,4 @@
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
@@ -14,16 +14,16 @@ describe('multiple entry point joining', () => {
         let entryPoints: PeerDescriptor[]
         
         beforeEach(async () => {
-            simulator = new Simulator(LatencyType.RANDOM)
+            simulator = new Simulator(LatencyType.REAL)
 
             node1 = await createMockConnectionDhtNode('node1', simulator)
             node2 = await createMockConnectionDhtNode('node2', simulator)
             node3 = await createMockConnectionDhtNode('node3', simulator)
 
             entryPoints = [
-                node1.getPeerDescriptor(),
-                node2.getPeerDescriptor(),
-                node3.getPeerDescriptor()
+                node1.getLocalPeerDescriptor(),
+                node2.getLocalPeerDescriptor(),
+                node3.getLocalPeerDescriptor()
             ]
         })
 
@@ -67,7 +67,7 @@ describe('multiple entry point joining', () => {
         let entryPoints: PeerDescriptor[]
         
         beforeEach(async () => {
-            simulator = new Simulator(LatencyType.RANDOM)
+            simulator = new Simulator(LatencyType.REAL)
             
             entryPoint1 = await createMockConnectionDhtNode('entryPoint1', simulator)
             entryPoint2 = await createMockConnectionDhtNode('entryPoint2', simulator)
@@ -76,8 +76,8 @@ describe('multiple entry point joining', () => {
             node2 = await createMockConnectionDhtNode('node2', simulator)
 
             entryPoints = [
-                entryPoint1.getPeerDescriptor(),
-                entryPoint2.getPeerDescriptor(),
+                entryPoint1.getLocalPeerDescriptor(),
+                entryPoint2.getLocalPeerDescriptor(),
             ]
 
             await entryPoint1.joinDht(entryPoints)