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

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,8 +1,8 @@
-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'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 
 const logger = new Logger(module)
@@ -11,7 +11,7 @@ describe('Scaling down a Dht network', () => {
     let entryPoint: DhtNode
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
-    const simulator = new Simulator(LatencyType.RANDOM)
+    const simulator = new Simulator(LatencyType.REAL)
     const NUM_NODES = 80
     const MAX_CONNECTIONS = 15
     const K = 2
@@ -49,13 +49,13 @@ 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()) + ', ' 
-                            + keyFromPeerDescriptor(stoppingPeerDescriptor) + ' cleaning up failed')
+                        logger.error(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + ', ' 
+                            + getNodeIdFromPeerDescriptor(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,6 +1,6 @@
-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 { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
@@ -10,7 +10,7 @@ describe('Storing data in DHT', () => {
     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 MAX_CONNECTIONS = 20
     const K = 4
@@ -27,10 +27,7 @@ describe('Storing data in DHT', () => {
             undefined, K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
-        entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
+        entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
         nodes.push(entryPoint)
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`

package/test/integration/StoreAndDelete.test.ts

@@ -1,6 +1,6 @@
-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 { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
@@ -10,7 +10,7 @@ describe('Storing data in DHT', () => {
     let entryPoint: DhtNode
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
-    const simulator = new Simulator(LatencyType.RANDOM)
+    const simulator = new Simulator(LatencyType.REAL)
     const NUM_NODES = 5
     const MAX_CONNECTIONS = 5
     const K = 4
@@ -27,10 +27,7 @@ describe('Storing data in DHT', () => {
             undefined, K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
-        entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
+        entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
         nodes.push(entryPoint)
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`

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)
 })

package/test/integration/{WebRtcConnectionManagement.test.ts → WebrtcConnectionManagement.test.ts}

@@ -1,20 +1,20 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { PeerID } from '../../src/helpers/PeerID'
 import { ConnectionType } from '../../src/connection/IConnection'
 import { ITransport } from '../../src/transport/ITransport'
 import * as Err from '../../src/helpers/errors'
-import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 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()
     })
@@ -200,7 +200,7 @@ describe('WebRTC Connection Management', () => {
 
         msg.targetDescriptor = peerDescriptor2
         manager1.send(msg).catch((e) => {
-            expect(e.code).toEqual('CONNECTION_FAILED')
+            expect(e.code).toEqual('SEND_FAILED')
         })
 
         // @ts-expect-error private field

package/test/integration/{WebRtcConnectorRpc.test.ts → WebrtcConnectorRpc.test.ts}

@@ -1,23 +1,23 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebRtcConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { WebrtcConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import {
     IceCandidate,
     NodeType,
     PeerDescriptor,
     RtcAnswer,
     RtcOffer,
-    WebRtcConnectionRequest
+    WebrtcConnectionRequest
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { generateId } from '../utils/utils'
-import { IWebRtcConnectorRpc } from '../../src/proto/packages/dht/protos/DhtRpc.server'
+import { IWebrtcConnectorRpc } from '../../src/proto/packages/dht/protos/DhtRpc.server'
 import { waitForCondition } from '@streamr/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
 describe('WebRTC rpc messages', () => {
     let rpcCommunicator1: RpcCommunicator
     let rpcCommunicator2: RpcCommunicator
-    let client: ProtoRpcClient<WebRtcConnectorRpcClient>
+    let client: ProtoRpcClient<WebrtcConnectorRpcClient>
 
     let requestConnectionCounter: number
     let rtcOfferCounter: number
@@ -36,7 +36,7 @@ describe('WebRTC rpc messages', () => {
         iceCandidateCounter = 0
 
         rpcCommunicator1 = new RpcCommunicator()
-        const serverFunctions: IWebRtcConnectorRpc = {
+        const serverFunctions: IWebrtcConnectorRpc = {
 
             requestConnection: async (): Promise<Empty> => {
                 requestConnectionCounter += 1
@@ -67,7 +67,7 @@ describe('WebRTC rpc messages', () => {
         rpcCommunicator2.registerRpcNotification(RtcOffer, 'rtcOffer', serverFunctions.rtcOffer)
         rpcCommunicator2.registerRpcNotification(RtcAnswer, 'rtcAnswer', serverFunctions.rtcAnswer)
         rpcCommunicator2.registerRpcNotification(IceCandidate, 'iceCandidate', serverFunctions.iceCandidate)
-        rpcCommunicator2.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
+        rpcCommunicator2.registerRpcNotification(WebrtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
 
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
@@ -77,7 +77,7 @@ describe('WebRTC rpc messages', () => {
             rpcCommunicator1.handleIncomingMessage(message)
         })
 
-        client = toProtoRpcClient(new WebRtcConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
+        client = toProtoRpcClient(new WebrtcConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
     })
 
     afterEach(async () => {
@@ -87,7 +87,6 @@ describe('WebRTC rpc messages', () => {
 
     it('send connectionRequest', async () => {
         client.requestConnection({
-            connectionId: 'connectionRequest'
         },
         { targetDescriptor, notification: true }
         )

package/test/integration/{WebSocket.test.ts → Websocket.test.ts}

@@ -1,26 +1,27 @@
 /* eslint-disable no-console */
 
-import { WebSocketServer } from '../../src/connection/WebSocket/WebSocketServer'
+import { WebsocketServer } from '../../src/connection/websocket/WebsocketServer'
 import { IConnection } from '../../src/connection/IConnection'
-import { ClientWebSocket } from '../../src/connection/WebSocket/ClientWebSocket'
+import { ClientWebsocket } from '../../src/connection/websocket/ClientWebsocket'
 import { Logger } from '@streamr/utils'
 
 const logger = new Logger(module)
 
-describe('WebSocket', () => {
+describe('Websocket', () => {
 
-    const webSocketServer = new WebSocketServer({
-        portRange: { min: 9999, max: 9999 }
+    const websocketServer = new WebsocketServer({
+        portRange: { min: 9977, max: 9977 },
+        enableTls: false
     })
-    const clientWebSocket = new ClientWebSocket()
+    const clientWebsocket = new ClientWebsocket()
 
     beforeAll(async () => {
-        await webSocketServer.start()
+        await websocketServer.start()
     })
 
     it('Happy path', (done) => {
             
-        webSocketServer.on('connected', (serverConnection: IConnection) => {
+        websocketServer.on('connected', (serverConnection: IConnection) => {
             const time = Date.now()
             logger.info('server side sendind msg at ' + time)
             serverConnection.send(Uint8Array.from([1, 2, 3, 4]))
@@ -40,11 +41,11 @@ describe('WebSocket', () => {
             })
         })
         
-        clientWebSocket.on('connected', () => {
+        clientWebsocket.on('connected', () => {
             const time = Date.now()
             logger.info('client side setting listeners at ' + time)
             
-            clientWebSocket.on('data', (bytes: Uint8Array) => {
+            clientWebsocket.on('data', (bytes: Uint8Array) => {
                 const time = Date.now()
                 logger.info('client side receiving message at ' + time)
 
@@ -53,14 +54,14 @@ describe('WebSocket', () => {
                 
                 const time2 = Date.now()
                 logger.info('client side sendind msg at ' + time2)
-                clientWebSocket.send(Uint8Array.from([1, 2, 3, 4]))
+                clientWebsocket.send(Uint8Array.from([1, 2, 3, 4]))
             })
         })
 
-        clientWebSocket.connect('ws://127.0.0.1:9999')
+        clientWebsocket.connect('ws://127.0.0.1:9977')
     })
 
     afterAll(async () => {
-        await webSocketServer.stop()
+        await websocketServer.stop()
     })
 })

package/test/integration/{WebSocketConnectionManagement.test.ts → WebsocketConnectionManagement.test.ts}

@@ -4,24 +4,24 @@ import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
 import { ConnectionType } from '../../src/connection/IConnection'
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/exports'
 import { PeerID } from '../../src/helpers/PeerID'
 import * as Err from '../../src/helpers/errors'
 import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
-const createConfig = (ownPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createOwnPeerDescriptor'>) => {
+const createConfig = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
     return {
         createConnectorFacade: () => new DefaultConnectorFacade({
-            createOwnPeerDescriptor: () => ownPeerDescriptor,
+            createLocalPeerDescriptor: () => localPeerDescriptor,
             ...opts
         }),
         metricsContext: new MetricsContext()
     }
 }
 
-describe('WebSocket Connection Management', () => {
+describe('Websocket Connection Management', () => {
 
     const serviceId = 'test'
     let wsServerManager: ConnectionManager