@streamr/dht 0.0.1-tatum.6 → 0.0.1-tatum.8

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

@@ -1,4 +1,4 @@
-import { DhtPeer } from '../../src/dht/DhtPeer'
+import { RemoteDhtNode } from '../../src/dht/RemoteDhtNode'
 import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
 import { getMockPeers, MockDhtRpc } from '../utils/utils'
 import {
@@ -12,16 +12,15 @@ import {
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { DhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { generateId } from '../utils/utils'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
-describe('DhtPeer', () => {
+describe('RemoteDhtNode', () => {
 
-    let dhtPeer: DhtPeer
+    let remoteDhtNode: RemoteDhtNode
     let clientRpcCommunicator: RpcCommunicator
     let serverRpcCommunicator: RpcCommunicator
     const serviceId = 'test'
     const clientPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('dhtPeer'),
+        kademliaId: generateId('client'),
         type: NodeType.NODEJS
     }
     const serverPeerDescriptor: PeerDescriptor = {
@@ -34,14 +33,14 @@ describe('DhtPeer', () => {
         serverRpcCommunicator = new RpcCommunicator()
         serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
         serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', MockDhtRpc.ping)
-        clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             serverRpcCommunicator.handleIncomingMessage(message)
         })
-        serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
         const client = toProtoRpcClient(new DhtRpcServiceClient(clientRpcCommunicator.getRpcClientTransport()))
-        dhtPeer = new DhtPeer(clientPeerDescriptor, serverPeerDescriptor, client, serviceId)
+        remoteDhtNode = new RemoteDhtNode(clientPeerDescriptor, serverPeerDescriptor, client, serviceId)
     })
 
     afterEach(() => {
@@ -50,24 +49,24 @@ describe('DhtPeer', () => {
     })
 
     it('Ping happy path', async () => {
-        const active = await dhtPeer.ping()
+        const active = await remoteDhtNode.ping()
         expect(active).toEqual(true)
     })
 
     it('getClosestPeers happy path', async () => {
-        const neighbors = await dhtPeer.getClosestPeers(clientPeerDescriptor.kademliaId)
+        const neighbors = await remoteDhtNode.getClosestPeers(clientPeerDescriptor.kademliaId)
         expect(neighbors.length).toEqual(getMockPeers().length)
     })
 
     it('ping error path', async () => {
         serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', MockDhtRpc.throwPingError)
-        const active = await dhtPeer.ping()
+        const active = await remoteDhtNode.ping()
         expect(active).toEqual(false)
     })
 
     it('getClosestPeers error path', async () => {
         serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.throwGetClosestPeersError)
-        await expect(dhtPeer.getClosestPeers(clientPeerDescriptor.kademliaId))
+        await expect(remoteDhtNode.getClosestPeers(clientPeerDescriptor.kademliaId))
             .rejects.toThrow('Closest peers error')
     })
 

package/test/integration/RouteMessage.test.ts

@@ -6,7 +6,6 @@ import { createMockConnectionDhtNode, createWrappedClosestPeersRequest } from '.
 import { PeerID } from '../../src/helpers/PeerID'
 import { Simulator } from '../../src/connection/Simulator/Simulator'
 import { v4 } from 'uuid'
-import { UUID } from '../../src/helpers/UUID'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { RoutingMode } from '../../src/dht/routing/RoutingSession'
 
@@ -34,7 +33,6 @@ describe('Route Message With Mock Connections', () => {
 
         entryPointDescriptor = {
             kademliaId: entryPoint.getNodeId().value,
-            nodeName: 'entrypoint',
             type: NodeType.NODEJS
         }
 
@@ -67,7 +65,7 @@ describe('Route Message With Mock Connections', () => {
     }, 10000)
 
     it('Happy path', async () => {
-        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor(), destinationNode.getPeerDescriptor())
+        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor())
         const message: Message = {
             serviceId: 'unknown',
             messageId: v4(),
@@ -96,10 +94,10 @@ describe('Route Message With Mock Connections', () => {
     it('Receives multiple messages', async () => {
         const numOfMessages = 20
         let receivedMessages = 0
-        destinationNode.on('message', (_message: Message) => {
+        destinationNode.on('message', () => {
             receivedMessages += 1
         })
-        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor(), destinationNode.getPeerDescriptor())
+        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor())
 
         for (let i = 0; i < numOfMessages; i++) {
             const message: Message = {
@@ -137,7 +135,7 @@ describe('Route Message With Mock Connections', () => {
         }
 
         const numsOfReceivedMessages: Record<string, number> = {}
-        routerNodes.map((node) => {
+        routerNodes.forEach((node) => {
             numsOfReceivedMessages[node.getNodeId().toKey()] = 0
             node.on('message', (msg: Message) => {
                 numsOfReceivedMessages[node.getNodeId().toKey()] = numsOfReceivedMessages[node.getNodeId().toKey()] + 1
@@ -157,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(), destinationNode.getPeerDescriptor())
+                        const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor())
                         const message: Message = {
                             serviceId: 'nonexisting_service',
                             messageId: v4(),
@@ -192,7 +190,7 @@ describe('Route Message With Mock Connections', () => {
     }, 90000)
 
     it('Destination receives forwarded message', async () => {
-        const closestPeersRequest = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor(), destinationNode.getPeerDescriptor())
+        const closestPeersRequest = createWrappedClosestPeersRequest(sourceNode.getPeerDescriptor())
         const closestPeersRequestMessage: Message = {
             serviceId: 'unknown',
             messageId: v4(),
@@ -208,7 +206,7 @@ describe('Route Message With Mock Connections', () => {
         const routeMessageWrapper: RouteMessageWrapper = {
             message: closestPeersRequestMessage,
             destinationPeer: destinationNode.getPeerDescriptor(),
-            requestId: new UUID().toString(),
+            requestId: v4(),
             sourcePeer: sourceNode.getPeerDescriptor(),
             reachableThrough: [entryPointDescriptor],
             routingPath: []

package/test/integration/{RemoteRouter.test.ts → RouterRpcRemote.test.ts}

@@ -1,19 +1,18 @@
 import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { RemoteRouter } from '../../src/dht/routing/RemoteRouter'
+import { RouterRpcRemote } from '../../src/dht/routing/RouterRpcRemote'
 import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RoutingServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { RouterRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
-import { createWrappedClosestPeersRequest, generateId, MockRoutingService } from '../utils/utils'
+import { createWrappedClosestPeersRequest, generateId, mockRouterRpc } from '../utils/utils'
 
 describe('RemoteRouter', () => {
 
-    let remoteRouter: RemoteRouter
+    let remoteRouter: RouterRpcRemote
     let clientRpcCommunicator: RpcCommunicator
     let serverRpcCommunicator: RpcCommunicator
     const serviceId = 'test'
     const clientPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('dhtPeer'),
+        kademliaId: generateId('client'),
         type: NodeType.NODEJS
     }
     const serverPeerDescriptor: PeerDescriptor = {
@@ -24,19 +23,19 @@ describe('RemoteRouter', () => {
     beforeEach(() => {
         clientRpcCommunicator = new RpcCommunicator()
         serverRpcCommunicator = new RpcCommunicator()
-        serverRpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'routeMessage', MockRoutingService.routeMessage)
-        clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        serverRpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'routeMessage', mockRouterRpc.routeMessage)
+        clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             serverRpcCommunicator.handleIncomingMessage(message)
         })
-        serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        const client = toProtoRpcClient(new RoutingServiceClient(clientRpcCommunicator.getRpcClientTransport()))
-        remoteRouter = new RemoteRouter(clientPeerDescriptor, serverPeerDescriptor, serviceId, client)
+        const client = toProtoRpcClient(new RouterRpcClient(clientRpcCommunicator.getRpcClientTransport()))
+        remoteRouter = new RouterRpcRemote(clientPeerDescriptor, serverPeerDescriptor, serviceId, client)
     })
 
     it('routeMessage happy path', async () => {
-        const rpcWrapper = createWrappedClosestPeersRequest(clientPeerDescriptor, serverPeerDescriptor)
+        const rpcWrapper = createWrappedClosestPeersRequest(clientPeerDescriptor)
         const routed: Message = {
             serviceId,
             messageId: 'routed',
@@ -58,8 +57,8 @@ describe('RemoteRouter', () => {
     })
 
     it('routeMessage error path', async () => {
-        serverRpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'routeMessage', MockRoutingService.throwRouteMessageError)
-        const rpcWrapper = createWrappedClosestPeersRequest(clientPeerDescriptor, serverPeerDescriptor)
+        serverRpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'routeMessage', mockRouterRpc.throwRouteMessageError)
+        const rpcWrapper = createWrappedClosestPeersRequest(clientPeerDescriptor)
         const routed: Message = {
             serviceId,
             messageId: 'routed',

package/test/integration/RpcErrors.test.ts

@@ -3,11 +3,24 @@ 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 { DhtRpcOptions, ListeningRpcCommunicator, SimulatorTransport } from '../../src/exports'
+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 { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 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) => {
+    return new ConnectionManager({
+        createConnectorFacade: () => new DefaultConnectorFacade({
+            transport,
+            createOwnPeerDescriptor: () => ownPeerDescriptor
+        }),
+        metricsContext: new MetricsContext()
+    })
+}
 
 describe('RPC errors', () => {
 
@@ -32,8 +45,8 @@ describe('RPC errors', () => {
         type: NodeType.NODEJS,
     }
 
-    let connectorTransport1: ITransport
-    let connectorTransport2: ITransport
+    let connectorTransport1: SimulatorTransport
+    let connectorTransport2: SimulatorTransport
 
     const serviceId = 'test'
 
@@ -41,17 +54,19 @@ describe('RPC errors', () => {
 
         simulator = new Simulator(LatencyType.FIXED, 50)
         connectorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        manager1 = new ConnectionManager({ transportLayer: connectorTransport1 })
+        await connectorTransport1.start()
+        manager1 = createConnectionManager(peerDescriptor1, connectorTransport1)
         rpcCommunicator1 = new ListeningRpcCommunicator(serviceId, manager1)
         client1 = toProtoRpcClient(new DhtRpcServiceClient(rpcCommunicator1.getRpcClientTransport()))
 
         connectorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        manager2 = new ConnectionManager({ transportLayer: connectorTransport2 })
+        await connectorTransport2.start()
+        manager2 = createConnectionManager(peerDescriptor2, connectorTransport2)
         rpcCommunicator2 = new ListeningRpcCommunicator(serviceId, manager2)
         //client2 = toProtoRpcClient(new DhtRpcServiceClient(rpcCommunicator2.getRpcClientTransport()))
 
-        await manager1.start((_msg) => peerDescriptor1)
-        await manager2.start((_msg) => peerDescriptor2)
+        await manager1.start()
+        await manager2.start()
 
     })
 
@@ -64,7 +79,7 @@ describe('RPC errors', () => {
     })
 
     it('Can make a RPC call over WebRTC', async () => {
-        const ping = async (request: PingRequest, _context: ServerCallContext):
+        const ping = async (request: PingRequest):
             Promise<PingResponse> => {
             const response: PingResponse = {
                 requestId: request.requestId
@@ -134,7 +149,7 @@ describe('RPC errors', () => {
         }
 
         const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            manager1.on('disconnected', () => {
                 //expect(message.messageType).toBe(MessageType.RPC)
                 resolve()
             })

package/test/integration/ScaleDownDht.test.ts

@@ -2,7 +2,7 @@ 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 { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 
 const logger = new Logger(module)
@@ -20,18 +20,17 @@ describe('Scaling down a Dht network', () => {
         nodes = []
         const entryPointId = '0'
         entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
-            undefined, K, entryPointId, MAX_CONNECTIONS)
+            undefined, K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
 
         entrypointDescriptor = {
             kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            nodeName: entryPointId
+            type: NodeType.NODEJS
         }
 
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, K, nodeId, MAX_CONNECTIONS)
+            const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, K, MAX_CONNECTIONS)
             nodes.push(node)
         }
         await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
@@ -54,10 +53,11 @@ describe('Scaling down a Dht network', () => {
             await nodes[nodeIndex].stop()
             const nodeIsCleaned = nodes.every((node) =>
                 node.getAllConnectionPeerDescriptors().every((peer) => {
-                    if (isSamePeerDescriptor(peer, stoppingPeerDescriptor)) {
-                        logger.error(' ' + node.getPeerDescriptor().nodeName + ', ' + stoppingPeerDescriptor.nodeName + ' cleaning up failed')
+                    if (areEqualPeerDescriptors(peer, stoppingPeerDescriptor)) {
+                        logger.error(keyFromPeerDescriptor(node.getPeerDescriptor()) + ', ' 
+                            + keyFromPeerDescriptor(stoppingPeerDescriptor) + ' cleaning up failed')
                     }
-                    return !isSamePeerDescriptor(peer, stoppingPeerDescriptor)
+                    return !areEqualPeerDescriptors(peer, stoppingPeerDescriptor)
                 })
             )
             expect(nodeIsCleaned).toEqual(true)

package/test/integration/SimultaneousConnections.test.ts

@@ -1,10 +1,21 @@
+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 { 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'
-import { waitForCondition } from '@streamr/utils'
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
+
+const createConnectionManager = (ownPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createOwnPeerDescriptor'>) => {
+    return new ConnectionManager({
+        createConnectorFacade: () => new DefaultConnectorFacade({
+            createOwnPeerDescriptor: () => ownPeerDescriptor,
+            ...opts
+        }),
+        metricsContext: new MetricsContext()
+    })
+}
 
 describe('SimultaneousConnections', () => {
 
@@ -14,14 +25,12 @@ describe('SimultaneousConnections', () => {
 
     const peerDescriptor1 = {
         kademliaId: PeerID.fromString('mock1').value,
-        type: NodeType.NODEJS,
-        nodeName: 'mock1'
+        type: NodeType.NODEJS
     }
 
     const peerDescriptor2 = {
         kademliaId: PeerID.fromString('mock2').value,
-        type: NodeType.NODEJS,
-        nodeName: 'mock2'
+        type: NodeType.NODEJS
     }
 
     const baseMsg: Message = {
@@ -37,7 +46,9 @@ describe('SimultaneousConnections', () => {
     beforeEach(async () => {
         simulator = new Simulator()
         simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        await simulatorTransport1.start()
         simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        await simulatorTransport2.start()
     })
 
     afterEach(async () => {
@@ -84,7 +95,6 @@ describe('SimultaneousConnections', () => {
 
         const wsPeer1: PeerDescriptor = {
             kademliaId: PeerID.fromString('mock1').value,
-            nodeName: 'mock1WebSocket',
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
@@ -95,7 +105,6 @@ describe('SimultaneousConnections', () => {
 
         const wsPeer2: PeerDescriptor = {
             kademliaId: PeerID.fromString('mock2').value,
-            nodeName: 'mock2WebSocket',
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
@@ -106,20 +115,18 @@ describe('SimultaneousConnections', () => {
 
         beforeEach(async () => {
             const websocketPortRange = { min: 43432, max: 43433 }
-            connectionManager1 = new ConnectionManager({
-                transportLayer: simulatorTransport1,
-                ownPeerDescriptor: wsPeer1,
+            connectionManager1 = createConnectionManager(wsPeer1, {
+                transport: simulatorTransport1,
                 websocketPortRange,
                 entryPoints: [wsPeer1]
             })
-            connectionManager2 = new ConnectionManager({
-                transportLayer: simulatorTransport2,
-                ownPeerDescriptor: wsPeer2,
+            connectionManager2 = createConnectionManager(wsPeer2, {
+                transport: simulatorTransport2,
                 websocketPortRange,
                 entryPoints: [wsPeer1]
             })
-            await connectionManager1.start(() => wsPeer1)
-            await connectionManager2.start(() => wsPeer2)
+            await connectionManager1.start()
+            await connectionManager2.start()
         })
 
         afterEach(async () => {
@@ -169,7 +176,6 @@ describe('SimultaneousConnections', () => {
 
         const wsPeer1: PeerDescriptor = {
             kademliaId: PeerID.fromString('mock1').value,
-            nodeName: 'mock1WebSocketServer',
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
@@ -180,23 +186,20 @@ describe('SimultaneousConnections', () => {
 
         const wsPeer2: PeerDescriptor = {
             kademliaId: PeerID.fromString('mock2').value,
-            nodeName: 'mock2WebSocketClient',
             type: NodeType.NODEJS
         }
 
         beforeEach(async () => {
-            connectionManager1 = new ConnectionManager({
-                transportLayer: simulatorTransport1,
-                ownPeerDescriptor: wsPeer1,
+            connectionManager1 = createConnectionManager(wsPeer1, {
+                transport: simulatorTransport1,
                 websocketPortRange: { min: 43432, max: 43432 },
                 entryPoints: [wsPeer1]
             })
-            connectionManager2 = new ConnectionManager({
-                transportLayer: simulatorTransport2,
-                ownPeerDescriptor: wsPeer2
+            connectionManager2 = createConnectionManager(wsPeer2, {
+                transport: simulatorTransport2
             })
-            await connectionManager1.start(() => wsPeer1)
-            await connectionManager2.start(() => wsPeer2)
+            await connectionManager1.start()
+            await connectionManager2.start()
         })
 
         afterEach(async () => {
@@ -246,27 +249,23 @@ describe('SimultaneousConnections', () => {
 
         const wrtcPeer1: PeerDescriptor = {
             kademliaId: PeerID.fromString('mock1').value,
-            nodeName: 'mock1WebRTC',
             type: NodeType.NODEJS
         }
 
         const wrtcPeer2: PeerDescriptor = {
             kademliaId: PeerID.fromString('mock2').value,
-            nodeName: 'mock2WebRTC',
             type: NodeType.NODEJS
         }
 
         beforeEach(async () => {
-            connectionManager1 = new ConnectionManager({
-                transportLayer: simulatorTransport1,
-                ownPeerDescriptor: wrtcPeer1,
+            connectionManager1 = createConnectionManager(wrtcPeer1, {
+                transport: simulatorTransport1,
             })
-            connectionManager2 = new ConnectionManager({
-                transportLayer: simulatorTransport2,
-                ownPeerDescriptor: wrtcPeer1,
+            connectionManager2 = createConnectionManager(wrtcPeer2, {
+                transport: simulatorTransport2,
             })
-            await connectionManager1.start(() => wrtcPeer1)
-            await connectionManager2.start(() => wrtcPeer2)
+            await connectionManager1.start()
+            await connectionManager2.start()
         })
 
         afterEach(async () => {

package/test/integration/Store.test.ts

@@ -2,7 +2,8 @@ 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 { isSamePeerDescriptor, PeerID } from '../../src/exports'
+import { PeerID } from '../../src/helpers/PeerID'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Any } from '../../src/proto/google/protobuf/any'
 
 describe('Storing data in DHT', () => {
@@ -23,19 +24,18 @@ describe('Storing data in DHT', () => {
         nodes = []
         const entryPointId = '0'
         entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
-            undefined, K, entryPointId, MAX_CONNECTIONS)
+            undefined, K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
         entrypointDescriptor = {
             kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            nodeName: entryPointId
+            type: NodeType.NODEJS
         }
         nodes.push(entryPoint)
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`
             const node = await createMockConnectionDhtNode(nodeId, simulator, 
-                undefined, K, nodeId, MAX_CONNECTIONS, 60000)
+                undefined, K, MAX_CONNECTIONS, 60000)
             nodeIndicesById[node.getNodeId().toKey()] = i
             nodes.push(node)
         }
@@ -55,8 +55,7 @@ describe('Storing data in DHT', () => {
         expect(successfulStorers.length).toBeGreaterThan(4)
     }, 90000)
 
-    // TODO: flaky test, fix in NET-1027
-    it.skip('Storing and getting data works', async () => {
+    it('Storing and getting data works', async () => {
         const storingNode = getRandomNode()
         const dataKey = PeerID.fromString('3232323e12r31r3')
         const data = Any.pack(entrypointDescriptor, PeerDescriptor)
@@ -65,9 +64,9 @@ describe('Storing data in DHT', () => {
 
         const fetchingNode = getRandomNode()
         const results = await fetchingNode.getDataFromDht(dataKey.value)
-        results.dataEntries!.forEach((entry) => {
+        results.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(isSamePeerDescriptor(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
         })
     }, 90000)
 })

package/test/integration/StoreAndDelete.test.ts

@@ -2,7 +2,8 @@ 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 { isSamePeerDescriptor, PeerID } from '../../src/exports'
+import { PeerID } from '../../src/helpers/PeerID'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Any } from '../../src/proto/google/protobuf/any'
 
 describe('Storing data in DHT', () => {
@@ -23,19 +24,18 @@ describe('Storing data in DHT', () => {
         nodes = []
         const entryPointId = '0'
         entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
-            undefined, K, entryPointId, MAX_CONNECTIONS)
+            undefined, K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
         entrypointDescriptor = {
             kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            nodeName: entryPointId
+            type: NodeType.NODEJS
         }
         nodes.push(entryPoint)
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`
             const node = await createMockConnectionDhtNode(nodeId, simulator, 
-                undefined, K, nodeId, MAX_CONNECTIONS, 60000)
+                undefined, K, MAX_CONNECTIONS, 60000)
             nodeIndicesById[node.getNodeId().toKey()] = i
             nodes.push(node)
         }
@@ -57,10 +57,10 @@ describe('Storing data in DHT', () => {
 
         const fetchingNode = getRandomNode()
         const results = await fetchingNode.getDataFromDht(dataKey.value)
-        results.dataEntries!.forEach((entry) => {
+        results.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
             expect(entry.deleted).toBeTrue()
-            expect(isSamePeerDescriptor(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
         })
     }, 90000)
 
@@ -74,20 +74,20 @@ describe('Storing data in DHT', () => {
 
         const fetchingNode = getRandomNode()
         const results1 = await fetchingNode.getDataFromDht(dataKey.value)
-        results1.dataEntries!.forEach((entry) => {
+        results1.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
             expect(entry.deleted).toBeTrue()
-            expect(isSamePeerDescriptor(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
         })
 
         const successfulStorers2 = await storingNode.storeDataToDht(dataKey.value, data)
         expect(successfulStorers2.length).toBeGreaterThan(4)
 
         const results2 = await fetchingNode.getDataFromDht(dataKey.value)
-        results2.dataEntries!.forEach((entry) => {
+        results2.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
             expect(entry.deleted).toBeFalse()
-            expect(isSamePeerDescriptor(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
         })
     }, 90000)
 })