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

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,11 +1,11 @@
-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, 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[]
@@ -42,7 +42,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'
@@ -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())
             )
         })
 
@@ -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(keyFromPeerDescriptor(contact.getPeerDescriptor()) + ' ' + keyFromPeerDescriptor(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(keyFromPeerDescriptor(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'
@@ -21,9 +21,9 @@ describe('multiple entry point joining', () => {
             node3 = await createMockConnectionDhtNode('node3', simulator)
 
             entryPoints = [
-                node1.getPeerDescriptor(),
-                node2.getPeerDescriptor(),
-                node3.getPeerDescriptor()
+                node1.getLocalPeerDescriptor(),
+                node2.getLocalPeerDescriptor(),
+                node3.getLocalPeerDescriptor()
             ]
         })
 
@@ -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)

package/test/integration/RouteMessage.test.ts

@@ -4,7 +4,7 @@ import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { Logger, runAndWaitForEvents3, waitForCondition } from '@streamr/utils'
 import { createMockConnectionDhtNode, createWrappedClosestPeersRequest } from '../utils/utils'
 import { PeerID } from '../../src/helpers/PeerID'
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { Simulator } from '../../src/connection/simulator/Simulator'
 import { v4 } from 'uuid'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { RoutingMode } from '../../src/dht/routing/RoutingSession'
@@ -65,7 +65,7 @@ describe('Route Message With Mock Connections', () => {
     }, 10000)
 
     it('Happy path', async () => {
-        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor())
+        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getLocalPeerDescriptor())
         const message: Message = {
             serviceId: 'unknown',
             messageId: v4(),
@@ -74,16 +74,16 @@ describe('Route Message With Mock Connections', () => {
                 oneofKind: 'rpcMessage',
                 rpcMessage: rpcWrapper
             },
-            sourceDescriptor: sourceNode.getPeerDescriptor(),
-            targetDescriptor: destinationNode.getPeerDescriptor()
+            sourceDescriptor: sourceNode.getLocalPeerDescriptor(),
+            targetDescriptor: destinationNode.getLocalPeerDescriptor()
         }
 
         await runAndWaitForEvents3<DhtNodeEvents>([() => {
             sourceNode.router!.doRouteMessage({
                 message,
-                destinationPeer: destinationNode.getPeerDescriptor(),
+                destinationPeer: destinationNode.getLocalPeerDescriptor(),
                 requestId: v4(),
-                sourcePeer: sourceNode.getPeerDescriptor(),
+                sourcePeer: sourceNode.getLocalPeerDescriptor(),
                 reachableThrough: [],
                 routingPath: []
 
@@ -97,7 +97,7 @@ describe('Route Message With Mock Connections', () => {
         destinationNode.on('message', () => {
             receivedMessages += 1
         })
-        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor())
+        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getLocalPeerDescriptor())
 
         for (let i = 0; i < numOfMessages; i++) {
             const message: Message = {
@@ -108,14 +108,14 @@ describe('Route Message With Mock Connections', () => {
                     oneofKind: 'rpcMessage',
                     rpcMessage: rpcWrapper
                 },
-                sourceDescriptor: sourceNode.getPeerDescriptor(),
-                targetDescriptor: destinationNode.getPeerDescriptor()
+                sourceDescriptor: sourceNode.getLocalPeerDescriptor(),
+                targetDescriptor: destinationNode.getLocalPeerDescriptor()
             }
             sourceNode.router!.doRouteMessage({
                 message,
-                destinationPeer: destinationNode.getPeerDescriptor(),
+                destinationPeer: destinationNode.getLocalPeerDescriptor(),
                 requestId: v4(),
-                sourcePeer: sourceNode.getPeerDescriptor(),
+                sourcePeer: sourceNode.getLocalPeerDescriptor(),
                 reachableThrough: [],
                 routingPath: []
             })
@@ -145,7 +145,7 @@ describe('Route Message With Mock Connections', () => {
                 } catch (e) {
                     console.error(e)
                 }
-                if (parseInt(node.getNodeId().toString()) > routerNodes.length || parseInt(node.getNodeId().toString()) < 1) {
+                if (parseInt(node.getNodeId().toString()) > routerNodes.length || parseInt(node.getNodeId().toString()) === 0) {
                     console.error(node.getNodeId().toString())
                 }
             })
@@ -155,7 +155,7 @@ describe('Route Message With Mock Connections', () => {
             routerNodes.map(async (node) =>
                 Promise.all(routerNodes.map(async (receiver) => {
                     if (!node.getNodeId().equals(receiver.getNodeId())) {
-                        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor())
+                        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getLocalPeerDescriptor())
                         const message: Message = {
                             serviceId: 'nonexisting_service',
                             messageId: v4(),
@@ -164,13 +164,13 @@ describe('Route Message With Mock Connections', () => {
                                 oneofKind: 'rpcMessage',
                                 rpcMessage: rpcWrapper
                             },
-                            sourceDescriptor: node.getPeerDescriptor(),
-                            targetDescriptor: destinationNode.getPeerDescriptor()
+                            sourceDescriptor: node.getLocalPeerDescriptor(),
+                            targetDescriptor: destinationNode.getLocalPeerDescriptor()
                         }
                         node.router!.doRouteMessage({
                             message,
-                            destinationPeer: receiver.getPeerDescriptor(),
-                            sourcePeer: node.getPeerDescriptor(),
+                            destinationPeer: receiver.getLocalPeerDescriptor(),
+                            sourcePeer: node.getLocalPeerDescriptor(),
                             requestId: v4(),
                             reachableThrough: [],
                             routingPath: []
@@ -190,7 +190,7 @@ describe('Route Message With Mock Connections', () => {
     }, 90000)
 
     it('Destination receives forwarded message', async () => {
-        const closestPeersRequest = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor())
+        const closestPeersRequest = createWrappedClosestPeersRequest(sourceNode.getLocalPeerDescriptor())
         const closestPeersRequestMessage: Message = {
             serviceId: 'unknown',
             messageId: v4(),
@@ -199,15 +199,15 @@ describe('Route Message With Mock Connections', () => {
                 oneofKind: 'rpcMessage',
                 rpcMessage: closestPeersRequest
             },
-            sourceDescriptor: sourceNode.getPeerDescriptor()!,
-            targetDescriptor: destinationNode.getPeerDescriptor()!
+            sourceDescriptor: sourceNode.getLocalPeerDescriptor()!,
+            targetDescriptor: destinationNode.getLocalPeerDescriptor()!
         }
 
         const routeMessageWrapper: RouteMessageWrapper = {
             message: closestPeersRequestMessage,
-            destinationPeer: destinationNode.getPeerDescriptor(),
+            destinationPeer: destinationNode.getLocalPeerDescriptor(),
             requestId: v4(),
-            sourcePeer: sourceNode.getPeerDescriptor(),
+            sourcePeer: sourceNode.getLocalPeerDescriptor(),
             reachableThrough: [entryPointDescriptor],
             routingPath: []
         }
@@ -229,15 +229,15 @@ describe('Route Message With Mock Connections', () => {
                 oneofKind: 'rpcMessage',
                 rpcMessage
             },
-            sourceDescriptor: sourceNode.getPeerDescriptor()!,
-            targetDescriptor: entryPoint.getPeerDescriptor()!
+            sourceDescriptor: sourceNode.getLocalPeerDescriptor()!,
+            targetDescriptor: entryPoint.getLocalPeerDescriptor()!
         }
 
         const forwardedMessage: RouteMessageWrapper = {
             message: requestMessage,
             requestId: v4(),
-            sourcePeer: sourceNode.getPeerDescriptor(),
-            destinationPeer: entryPoint.getPeerDescriptor()!,
+            sourcePeer: sourceNode.getLocalPeerDescriptor(),
+            destinationPeer: entryPoint.getLocalPeerDescriptor()!,
             reachableThrough: [],
             routingPath: []
         }

package/test/integration/RpcErrors.test.ts

@@ -1,22 +1,22 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { PeerID } from '../../src/helpers/PeerID'
 import { ITransport } from '../../src/transport/ITransport'
 import { v4 } from 'uuid'
-import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { DhtRpcOptions } from '../../src/rpc-protocol/DhtRpcOptions'
 import { ListeningRpcCommunicator } from '../../src/transport/ListeningRpcCommunicator'
 import { ProtoRpcClient, 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 { NodeType, PeerDescriptor, PingRequest, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { MetricsContext } from '@streamr/utils'
 
-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()
     })
@@ -30,8 +30,8 @@ describe('RPC errors', () => {
     let rpcCommunicator1: ListeningRpcCommunicator
     let rpcCommunicator2: ListeningRpcCommunicator
 
-    let client1: ProtoRpcClient<DhtRpcServiceClient>
-    //let client2: ProtoRpcClient<DhtRpcServiceClient>
+    let client1: ProtoRpcClient<DhtNodeRpcClient>
+    //let client2: ProtoRpcClient<DhtNodeRpcClient>
 
     let simulator: Simulator
 
@@ -57,13 +57,13 @@ describe('RPC errors', () => {
         await connectorTransport1.start()
         manager1 = createConnectionManager(peerDescriptor1, connectorTransport1)
         rpcCommunicator1 = new ListeningRpcCommunicator(serviceId, manager1)
-        client1 = toProtoRpcClient(new DhtRpcServiceClient(rpcCommunicator1.getRpcClientTransport()))
+        client1 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator1.getRpcClientTransport()))
 
         connectorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
         await connectorTransport2.start()
         manager2 = createConnectionManager(peerDescriptor2, connectorTransport2)
         rpcCommunicator2 = new ListeningRpcCommunicator(serviceId, manager2)
-        //client2 = toProtoRpcClient(new DhtRpcServiceClient(rpcCommunicator2.getRpcClientTransport()))
+        //client2 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator2.getRpcClientTransport()))
 
         await manager1.start()
         await manager2.start()
@@ -133,7 +133,7 @@ describe('RPC errors', () => {
         
     }, 60000)
 
-    it('Disconnects WebRtcConnection while being connected', async () => {
+    it('Disconnects WebrtcConnection while being connected', async () => {
         
         const rpcMessage: RpcMessage = {
             header: {},

package/test/integration/ScaleDownDht.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 { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
@@ -49,12 +49,12 @@ describe('Scaling down a Dht network', () => {
             const index = Math.floor(Math.random() * randomIndices.length)
             const nodeIndex = randomIndices[index]
             randomIndices.splice(index, 1)
-            const stoppingPeerDescriptor = nodes[nodeIndex].getPeerDescriptor()
+            const stoppingPeerDescriptor = nodes[nodeIndex].getLocalPeerDescriptor()
             await nodes[nodeIndex].stop()
             const nodeIsCleaned = nodes.every((node) =>
                 node.getAllConnectionPeerDescriptors().every((peer) => {
                     if (areEqualPeerDescriptors(peer, stoppingPeerDescriptor)) {
-                        logger.error(keyFromPeerDescriptor(node.getPeerDescriptor()) + ', ' 
+                        logger.error(keyFromPeerDescriptor(node.getLocalPeerDescriptor()) + ', ' 
                             + keyFromPeerDescriptor(stoppingPeerDescriptor) + ' cleaning up failed')
                     }
                     return !areEqualPeerDescriptors(peer, stoppingPeerDescriptor)

package/test/integration/SimultaneousConnections.test.ts

@@ -1,16 +1,16 @@
 import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
-import { Simulator } from '../../src/connection/Simulator/Simulator'
-import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { Simulator } from '../../src/connection/simulator/Simulator'
+import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { PeerID } from '../../src/helpers/PeerID'
 import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
-const createConnectionManager = (ownPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createOwnPeerDescriptor'>) => {
+const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
     return new ConnectionManager({
         createConnectorFacade: () => new DefaultConnectorFacade({
-            createOwnPeerDescriptor: () => ownPeerDescriptor,
+            createLocalPeerDescriptor: () => localPeerDescriptor,
             ...opts
         }),
         metricsContext: new MetricsContext()
@@ -118,12 +118,14 @@ describe('SimultaneousConnections', () => {
             connectionManager1 = createConnectionManager(wsPeer1, {
                 transport: simulatorTransport1,
                 websocketPortRange,
-                entryPoints: [wsPeer1]
+                entryPoints: [wsPeer1],
+                websocketServerEnableTls: false
             })
             connectionManager2 = createConnectionManager(wsPeer2, {
                 transport: simulatorTransport2,
                 websocketPortRange,
-                entryPoints: [wsPeer1]
+                entryPoints: [wsPeer1],
+                websocketServerEnableTls: false
             })
             await connectionManager1.start()
             await connectionManager2.start()
@@ -193,7 +195,8 @@ describe('SimultaneousConnections', () => {
             connectionManager1 = createConnectionManager(wsPeer1, {
                 transport: simulatorTransport1,
                 websocketPortRange: { min: 43432, max: 43432 },
-                entryPoints: [wsPeer1]
+                entryPoints: [wsPeer1],
+                websocketServerEnableTls: false
             })
             connectionManager2 = createConnectionManager(wsPeer2, {
                 transport: simulatorTransport2

package/test/integration/Store.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 { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'

package/test/integration/StoreAndDelete.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 { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -1,6 +1,6 @@
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { Simulator } from '../../src/connection/simulator/Simulator'
 import { PeerID } from '../../src/helpers/PeerID'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
@@ -30,8 +30,8 @@ describe('Storing data in DHT with two peers', () => {
         await entryPoint.start()
         await otherNode.start()
 
-        await entryPoint.joinDht([entryPoint.getPeerDescriptor()])
-        await otherNode.joinDht([entryPoint.getPeerDescriptor()])
+        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
+        await otherNode.joinDht([entryPoint.getLocalPeerDescriptor()])
     })
 
     afterEach(async () => {
@@ -42,30 +42,30 @@ describe('Storing data in DHT with two peers', () => {
 
     it('Node can store on two peer DHT', async () => {
         const dataKey1 = PeerID.fromString('node0-stored-data')
-        const data1 = Any.pack(otherNode.getPeerDescriptor(), PeerDescriptor)
+        const data1 = Any.pack(otherNode.getLocalPeerDescriptor(), PeerDescriptor)
         const dataKey2 = PeerID.fromString('other-node-stored-data')
-        const data2 = Any.pack(entryPoint.getPeerDescriptor(), PeerDescriptor)
+        const data2 = Any.pack(entryPoint.getLocalPeerDescriptor(), PeerDescriptor)
 
         const successfulStorers1 = await otherNode.storeDataToDht(dataKey1.value, data1)
         const successfulStorers2 = await entryPoint.storeDataToDht(dataKey2.value, data2)
-        expect(successfulStorers1[0].kademliaId).toStrictEqual(entryPoint.getPeerDescriptor().kademliaId)
-        expect(successfulStorers2[0].kademliaId).toStrictEqual(otherNode.getPeerDescriptor().kademliaId)
+        expect(successfulStorers1[0].kademliaId).toStrictEqual(entryPoint.getLocalPeerDescriptor().kademliaId)
+        expect(successfulStorers2[0].kademliaId).toStrictEqual(otherNode.getLocalPeerDescriptor().kademliaId)
 
         const foundData1 = await otherNode.getDataFromDht(dataKey1.value)
         const foundData2 = await entryPoint.getDataFromDht(dataKey2.value)
-        expect(areEqualPeerDescriptors(otherNode.getPeerDescriptor(), Any.unpack(foundData1[0]!.data!, PeerDescriptor))).toBeTrue()
-        expect(areEqualPeerDescriptors(entryPoint.getPeerDescriptor(), Any.unpack(foundData2[0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(otherNode.getLocalPeerDescriptor(), Any.unpack(foundData1[0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(entryPoint.getLocalPeerDescriptor(), Any.unpack(foundData2[0]!.data!, PeerDescriptor))).toBeTrue()
     })
 
     it('Can store on one peer DHT', async () => {
         await otherNode.stop()
         await waitForCondition(() => entryPoint.getBucketSize() === 0)
         const dataKey = PeerID.fromString('data-to-store')
-        const data = Any.pack(entryPoint.getPeerDescriptor(), PeerDescriptor)
+        const data = Any.pack(entryPoint.getLocalPeerDescriptor(), PeerDescriptor)
         const successfulStorers = await entryPoint.storeDataToDht(dataKey.value, data)
-        expect(successfulStorers[0].kademliaId).toStrictEqual(entryPoint.getPeerDescriptor().kademliaId)
+        expect(successfulStorers[0].kademliaId).toStrictEqual(entryPoint.getLocalPeerDescriptor().kademliaId)
 
         const foundData = await entryPoint.getDataFromDht(dataKey.value)
-        expect(areEqualPeerDescriptors(entryPoint.getPeerDescriptor(), Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(entryPoint.getLocalPeerDescriptor(), Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
     }, 60000)
 })