@streamr/trackerless-network 0.0.1-tatum.6 → 0.0.1-tatum.7

package/test/integration/Handshakes.test.ts

@@ -13,9 +13,9 @@ import {
 import { NodeList } from '../../src/logic/NodeList'
 import { mockConnectionLocker } from '../utils/utils'
 import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { RemoteHandshaker } from '../../src/logic/neighbor-discovery/RemoteHandshaker'
+import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
 import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Handshakes', () => {
 
@@ -37,9 +37,9 @@ describe('Handshakes', () => {
     let nodeView: NodeList
     let targetNeighbors: NodeList
     let handshaker: Handshaker
-    const randomGraphId = 'handshaker'
+    const streamPartId = StreamPartIDUtils.parse('stream#0')
 
-    const acceptHandshake = async (request: StreamPartHandshakeRequest, _context: ServerCallContext): Promise<StreamPartHandshakeResponse> => {
+    const acceptHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
         const response: StreamPartHandshakeResponse = {
             requestId: request.requestId,
             accepted: true
@@ -47,7 +47,7 @@ describe('Handshakes', () => {
         return response
     }
 
-    const rejectHandshake = async (request: StreamPartHandshakeRequest, _context: ServerCallContext): Promise<StreamPartHandshakeResponse> => {
+    const rejectHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
         const response: StreamPartHandshakeResponse = {
             requestId: request.requestId,
             accepted: false
@@ -55,7 +55,7 @@ describe('Handshakes', () => {
         return response
     }
 
-    const interleavingHandshake = async (request: StreamPartHandshakeRequest, _context: ServerCallContext): Promise<StreamPartHandshakeResponse> => {
+    const interleavingHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
         const response: StreamPartHandshakeResponse = {
             requestId: request.requestId,
             accepted: true,
@@ -69,29 +69,32 @@ describe('Handshakes', () => {
     let simulatorTransport2: SimulatorTransport
     let simulatorTransport3: SimulatorTransport
 
-    beforeEach(() => {
+    beforeEach(async () => {
         Simulator.useFakeTimers()
         simulator = new Simulator()
         simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        await simulatorTransport1.start()
         simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        await simulatorTransport2.start()
         simulatorTransport3 = new SimulatorTransport(peerDescriptor3, simulator)
+        await simulatorTransport3.start()
 
-        rpcCommunicator1 = new ListeningRpcCommunicator(randomGraphId, simulatorTransport1)
-        rpcCommunicator2 = new ListeningRpcCommunicator(randomGraphId, simulatorTransport2)
-        rpcCommunicator3 = new ListeningRpcCommunicator(randomGraphId, simulatorTransport3)
+        rpcCommunicator1 = new ListeningRpcCommunicator(streamPartId, simulatorTransport1)
+        rpcCommunicator2 = new ListeningRpcCommunicator(streamPartId, simulatorTransport2)
+        rpcCommunicator3 = new ListeningRpcCommunicator(streamPartId, simulatorTransport3)
 
         const handshakerNodeId = getNodeIdFromPeerDescriptor(peerDescriptor2)
         nodeView = new NodeList(handshakerNodeId, 10)
         targetNeighbors = new NodeList(handshakerNodeId, 4)
         handshaker = new Handshaker({
             ownPeerDescriptor: peerDescriptor2,
-            randomGraphId,
+            streamPartId,
             nearbyNodeView: nodeView,
             randomNodeView: nodeView,
             targetNeighbors,
             connectionLocker: mockConnectionLocker,
             rpcCommunicator: rpcCommunicator2,
-            N: 4
+            maxNeighborCount: 4
         })
 
     })
@@ -111,10 +114,10 @@ describe('Handshakes', () => {
         rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
         // @ts-expect-error private
         const res = await handshaker.handshakeWithTarget(
-            new RemoteHandshaker(
+            new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                randomGraphId,
+                streamPartId,
                 toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
             )
         )
@@ -126,10 +129,10 @@ describe('Handshakes', () => {
         rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
         // @ts-expect-error private
         const res = await handshaker.handshakeWithTarget(
-            new RemoteHandshaker(
+            new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                randomGraphId,
+                streamPartId,
                 toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
             )
         )
@@ -141,10 +144,10 @@ describe('Handshakes', () => {
         rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', rejectHandshake)
         // @ts-expect-error private
         const res = await handshaker.handshakeWithTarget(
-            new RemoteHandshaker(
+            new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                randomGraphId,
+                streamPartId,
                 toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
             )
         )
@@ -157,10 +160,10 @@ describe('Handshakes', () => {
         rpcCommunicator3.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
         // @ts-expect-error private
         const res = await handshaker.handshakeWithTarget(
-            new RemoteHandshaker(
+            new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                randomGraphId,
+                streamPartId,
                 toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
             )
         )

package/test/integration/Inspect.test.ts

@@ -24,12 +24,13 @@ describe('inspect', () => {
     let publishInterval: NodeJS.Timeout
 
     const initiateNode = async (peerDescriptor: PeerDescriptor, simulator: Simulator): Promise<NetworkStack> => {
-        const transportLayer = new SimulatorTransport(peerDescriptor, simulator)
+        const transport = new SimulatorTransport(peerDescriptor, simulator)
+        await transport.start()
         const node = new NetworkStack({
             layer0: {
                 entryPoints: [publisherDescriptor],
                 peerDescriptor,
-                transportLayer
+                transport
             }
         })
         await node.start()

package/test/integration/{RemoteNeighborUpdateManager.test.ts → NeighborUpdateRpcRemote.test.ts}

@@ -1,4 +1,3 @@
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import {
     ListeningRpcCommunicator,
     NodeType,
@@ -7,16 +6,17 @@ import {
     SimulatorTransport
 } from '@streamr/dht'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { RemoteNeighborUpdateManager } from '../../src/logic/neighbor-discovery/RemoteNeighborUpdateManager'
+import { NeighborUpdateRpcRemote } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcRemote'
 import { NeighborUpdate } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import {
     NeighborUpdateRpcClient,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
-describe('RemoteNeighborUpdateManager', () => {
+describe('NeighborUpdateRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
     let clientRpc: ListeningRpcCommunicator
-    let neighborUpdateRpcClient: RemoteNeighborUpdateManager
+    let rpcRemote: NeighborUpdateRpcRemote
 
     const clientNode: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 1, 1]),
@@ -31,10 +31,12 @@ describe('RemoteNeighborUpdateManager', () => {
     let mockConnectionManager1: SimulatorTransport
     let mockConnectionManager2: SimulatorTransport
 
-    beforeEach(() => {
+    beforeEach(async () => {
         simulator = new Simulator()
         mockConnectionManager1 = new SimulatorTransport(serverNode, simulator)
+        await mockConnectionManager1.start()
         mockConnectionManager2 = new SimulatorTransport(clientNode, simulator)
+        await mockConnectionManager2.start()
 
         mockServerRpc = new ListeningRpcCommunicator('test', mockConnectionManager1)
         clientRpc = new ListeningRpcCommunicator('test', mockConnectionManager2)
@@ -43,13 +45,13 @@ describe('RemoteNeighborUpdateManager', () => {
             NeighborUpdate,
             NeighborUpdate,
             'neighborUpdate',
-            async (_msg: NeighborUpdate, _context: ServerCallContext): Promise<NeighborUpdate> => {
+            async (): Promise<NeighborUpdate> => {
                 const node: PeerDescriptor = {
                     kademliaId: new Uint8Array([4, 2, 4]),
                     type: NodeType.NODEJS
                 }
                 const update: NeighborUpdate = {
-                    randomGraphId: 'testStream',
+                    streamPartId: StreamPartIDUtils.parse('stream#0'),
                     neighborDescriptors: [
                         node
                     ],
@@ -58,10 +60,10 @@ describe('RemoteNeighborUpdateManager', () => {
                 return update
             }
         )
-        neighborUpdateRpcClient = new RemoteNeighborUpdateManager(
+        rpcRemote = new NeighborUpdateRpcRemote(
             clientNode,
             serverNode,
-            'test-stream',
+            'test-stream-part',
             toProtoRpcClient(new NeighborUpdateRpcClient(clientRpc.getRpcClientTransport()))
         )
     })
@@ -75,7 +77,7 @@ describe('RemoteNeighborUpdateManager', () => {
     })
 
     it('updateNeighbors', async () => {
-        const res = await neighborUpdateRpcClient.updateNeighbors([])
+        const res = await rpcRemote.updateNeighbors([])
         expect(res.peerDescriptors.length).toEqual(1)
     })
 })

package/test/integration/NetworkNode.test.ts

@@ -1,14 +1,13 @@
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { NodeType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
 import {
     MessageID,
     MessageRef,
     StreamMessage,
     StreamMessageType,
-    StreamPartIDUtils,
-    toStreamID
+    StreamPartIDUtils
 } from '@streamr/protocol'
-import { EthereumAddress, waitForCondition, hexToBinary, utf8ToBinary } from '@streamr/utils'
+import { EthereumAddress, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
+import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
 
@@ -34,20 +33,22 @@ describe('NetworkNode', () => {
         Simulator.useFakeTimers()
         const simulator = new Simulator()
         transport1 = new SimulatorTransport(pd1, simulator)
+        await transport1.start()
         transport2 = new SimulatorTransport(pd2, simulator)
+        await transport2.start()
 
         node1 = createNetworkNode({
             layer0: {
                 entryPoints: [pd1],
                 peerDescriptor: pd1,
-                transportLayer: transport1
+                transport: transport1
             }
         })
         node2 = createNetworkNode({
             layer0: {
                 entryPoints: [pd1],
                 peerDescriptor: pd2,
-                transportLayer: transport2
+                transport: transport2
             }
         })
 
@@ -68,8 +69,8 @@ describe('NetworkNode', () => {
     it('wait for join + broadcast and subscribe', async () => {
         const streamMessage = new StreamMessage({
             messageId: new MessageID(
-                toStreamID('test'),
-                0,
+                StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+                StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
                 666,
                 0,
                 '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' as EthereumAddress,

package/test/integration/NetworkRpc.test.ts

@@ -1,14 +1,12 @@
 import {
     RpcCommunicator,
-    ProtoCallContext,
     ProtoRpcClient,
     toProtoRpcClient
 } from '@streamr/proto-rpc'
-import { NetworkRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { waitForCondition } from '@streamr/utils'
 import { Empty } from '../../src/proto/google/protobuf/empty'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { createStreamMessage } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { Simulator } from '@streamr/dht'
@@ -18,21 +16,21 @@ import { randomEthereumAddress } from '@streamr/test-utils'
 describe('Network RPC', () => {
     let rpcCommunicator1: RpcCommunicator
     let rpcCommunicator2: RpcCommunicator
-    let client: ProtoRpcClient<NetworkRpcClient>
+    let client: ProtoRpcClient<DeliveryRpcClient>
     let recvCounter = 0
 
     beforeEach(() => {
         Simulator.useFakeTimers()
         rpcCommunicator1 = new RpcCommunicator()
         rpcCommunicator2 = new RpcCommunicator()
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: ProtoCallContext) => {
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
         })
-        client = toProtoRpcClient(new NetworkRpcClient(rpcCommunicator1.getRpcClientTransport()))
+        client = toProtoRpcClient(new DeliveryRpcClient(rpcCommunicator1.getRpcClientTransport()))
         rpcCommunicator2.registerRpcNotification(
             StreamMessage,
             'sendStreamMessage',
-            async (_msg: StreamMessage, _context: ServerCallContext): Promise<Empty> => {
+            async (): Promise<Empty> => {
                 recvCounter += 1
                 return {}
             }

package/test/integration/NetworkStack.test.ts

@@ -6,37 +6,35 @@ import { waitForCondition } from '@streamr/utils'
 import { NetworkStack } from '../../src/NetworkStack'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
+const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
+
 describe('NetworkStack', () => {
 
     let stack1: NetworkStack
     let stack2: NetworkStack
-    const streamPartId = StreamPartIDUtils.parse('stream1#0')
 
     const epDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 32222, tls: false },
-        nodeName: 'entrypoint'
+        websocket: { host: '127.0.0.1', port: 32222, tls: false }
     })
 
     beforeEach(async () => {
         stack1 = new NetworkStack({
             layer0: {
                 peerDescriptor: epDescriptor,
-                entryPoints: [epDescriptor],
-                nodeName: 'entrypoint'
+                entryPoints: [epDescriptor]
             }
         })
         stack2 = new NetworkStack({
             layer0: {
                 websocketPortRange: { min: 32223, max: 32223 },
-                entryPoints: [epDescriptor],
-                nodeName: 'node2'
+                entryPoints: [epDescriptor]
             }
         })
 
         await stack1.start()
-        stack1.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, [epDescriptor])
+        stack1.getStreamrNode()!.setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
         await stack2.start()
-        stack2.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, [epDescriptor])
+        stack2.getStreamrNode()!.setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
     })
 
     afterEach(async () => {
@@ -48,13 +46,13 @@ describe('NetworkStack', () => {
 
     it('Can use NetworkNode pub/sub via NetworkStack', async () => {
         let receivedMessages = 0
-        stack1.getStreamrNode().joinStreamPart(streamPartId)
+        stack1.getStreamrNode().joinStreamPart(STREAM_PART_ID)
         stack1.getStreamrNode().on('newMessage', () => {
             receivedMessages += 1
         })
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            streamPartId,
+            STREAM_PART_ID,
             randomEthereumAddress()
         )
         stack2.getStreamrNode().broadcast(msg)
@@ -63,10 +61,10 @@ describe('NetworkStack', () => {
 
     it('join and wait for neighbors', async () => {
         await Promise.all([
-            stack1.joinStreamPart(streamPartId, { minCount: 1, timeout: 5000 }),
-            stack2.joinStreamPart(streamPartId, { minCount: 1, timeout: 5000 }),
+            stack1.joinStreamPart(STREAM_PART_ID, { minCount: 1, timeout: 5000 }),
+            stack2.joinStreamPart(STREAM_PART_ID, { minCount: 1, timeout: 5000 }),
         ])
-        expect(stack1.getStreamrNode().getNeighbors(streamPartId).length).toBe(1)
-        expect(stack2.getStreamrNode().getNeighbors(streamPartId).length).toBe(1)
+        expect(stack1.getStreamrNode().getNeighbors(STREAM_PART_ID).length).toBe(1)
+        expect(stack2.getStreamrNode().getNeighbors(STREAM_PART_ID).length).toBe(1)
     })
 })

package/test/integration/Propagation.test.ts

@@ -19,7 +19,7 @@ describe('Propagation', () => {
         const simulator = new Simulator()
         dhtNodes = []
         randomGraphNodes = []
-        const [entryPoint, node1] = createMockRandomGraphNodeAndDhtNode(entryPointDescriptor, entryPointDescriptor, STREAM_PART_ID, simulator)
+        const [entryPoint, node1] = await createMockRandomGraphNodeAndDhtNode(entryPointDescriptor, entryPointDescriptor, STREAM_PART_ID, simulator)
         await entryPoint.start()
         await entryPoint.joinDht([entryPointDescriptor])
         await node1.start()
@@ -29,7 +29,7 @@ describe('Propagation', () => {
 
         await Promise.all(range(NUM_OF_NODES).map(async (_i) => {
             const descriptor = createMockPeerDescriptor()
-            const [dht, graph] = createMockRandomGraphNodeAndDhtNode(
+            const [dht, graph] = await createMockRandomGraphNodeAndDhtNode(
                 descriptor,
                 entryPointDescriptor,
                 STREAM_PART_ID,

package/test/integration/RandomGraphNode-Layer1Node-Latencies.test.ts

@@ -24,26 +24,28 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
         const cms: SimulatorTransport[] = range(numOfNodes).map((i) =>
             new SimulatorTransport(peerDescriptors[i], simulator)
         )
+        await entrypointCm.start()
+        await Promise.all(cms.map((cm) => cm.start()))
 
         dhtEntryPoint = new DhtNode({
-            transportLayer: entrypointCm,
+            transport: entrypointCm,
             peerDescriptor: entrypointDescriptor,
             serviceId: streamPartId
         })
         dhtNodes = range(numOfNodes).map((i) => new DhtNode({
-            transportLayer: cms[i],
+            transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))
         graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
-            randomGraphId: streamPartId,
+            streamPartId,
             layer1: dhtNodes[i],
             P2PTransport: cms[i],
             connectionLocker: cms[i],
             ownPeerDescriptor: peerDescriptors[i]
         }))
         entryPointRandomGraphNode = createRandomGraphNode({
-            randomGraphId: streamPartId,
+            streamPartId,
             layer1: dhtEntryPoint,
             P2PTransport: entrypointCm,
             connectionLocker: entrypointCm,
@@ -77,23 +79,23 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
 
     it('happy path 5 nodes', async () => {
         entryPointRandomGraphNode.start()
-        range(4).map((i) => graphNodes[i].start())
+        range(4).forEach((i) => graphNodes[i].start())
         await Promise.all(range(4).map(async (i) => {
             await dhtNodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(range(4).map((i) => {
             return waitForCondition(() => {
                 return graphNodes[i].getTargetNeighborIds().length >= 4
-            }, 10000, 2000)
+            }, 15000, 2000)
         }))
-        range(4).map((i) => {
+        range(4).forEach((i) => {
             expect(graphNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
             expect(graphNodes[i].getTargetNeighborIds().length).toBeGreaterThanOrEqual(4)
         })
         // Check bidirectionality
         const allNodes = graphNodes
         allNodes.push(entryPointRandomGraphNode)
-        range(5).map((i) => {
+        range(5).forEach((i) => {
             const ownNodeId = allNodes[i].getOwnNodeId()
             allNodes[i].getNearbyNodeView().getIds().forEach((nodeId) => {
                 const neighbor = allNodes.find((node) => {

package/test/integration/RandomGraphNode-Layer1Node.test.ts

@@ -1,4 +1,4 @@
-import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, getRandomRegion } from '@streamr/dht'
+import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, getRandomRegion } from '@streamr/dht'
 import { Logger, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
@@ -17,13 +17,11 @@ describe('RandomGraphNode-DhtNode', () => {
 
     const streamPartId = StreamPartIDUtils.parse('stream#0')
     const entrypointDescriptor = createMockPeerDescriptor({
-        nodeName: 'entrypoint',
         region: getRandomRegion()
     })
 
-    const peerDescriptors: PeerDescriptor[] = range(numOfNodes).map((i) => {
+    const peerDescriptors: PeerDescriptor[] = range(numOfNodes).map(() => {
         return createMockPeerDescriptor({
-            nodeName: `node${i}`,
             region: getRandomRegion()
         })
     })
@@ -31,32 +29,34 @@ describe('RandomGraphNode-DhtNode', () => {
 
         Simulator.useFakeTimers()
         const simulator = new Simulator()
-        const entrypointCm = new ConnectionManager({
-            ownPeerDescriptor: entrypointDescriptor,
+        const entrypointCm = new SimulatorTransport(
+            entrypointDescriptor,
             simulator
-        })
+        )
+        await entrypointCm.start()
 
         const cms: ConnectionManager[] = range(numOfNodes).map((i) =>
-            new ConnectionManager({
-                ownPeerDescriptor: peerDescriptors[i],
+            new SimulatorTransport(
+                peerDescriptors[i],
                 simulator
-            })
+            )
         )
+        await Promise.all(cms.map((cm) => cm.start()))
 
         dhtEntryPoint = new DhtNode({
-            transportLayer: entrypointCm,
+            transport: entrypointCm,
             peerDescriptor: entrypointDescriptor,
             serviceId: streamPartId
         })
 
         dhtNodes = range(numOfNodes).map((i) => new DhtNode({
-            transportLayer: cms[i],
+            transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))
 
         graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
-            randomGraphId: streamPartId,
+            streamPartId,
             layer1: dhtNodes[i],
             P2PTransport: cms[i],
             connectionLocker: cms[i],
@@ -65,7 +65,7 @@ describe('RandomGraphNode-DhtNode', () => {
         }))
 
         entryPointRandomGraphNode = createRandomGraphNode({
-            randomGraphId: streamPartId,
+            streamPartId,
             layer1: dhtEntryPoint,
             P2PTransport: entrypointCm,
             connectionLocker: entrypointCm,
@@ -99,13 +99,13 @@ describe('RandomGraphNode-DhtNode', () => {
 
     it('happy path 4 nodes', async () => {
         entryPointRandomGraphNode.start()
-        range(4).map((i) => graphNodes[i].start())
+        range(4).forEach((i) => graphNodes[i].start())
         await Promise.all(range(4).map(async (i) => {
             await dhtNodes[i].joinDht([entrypointDescriptor])
         }))
 
         await waitForCondition(() => range(4).every((i) => graphNodes[i].getTargetNeighborIds().length === 4))
-        range(4).map((i) => {
+        range(4).forEach((i) => {
             expect(graphNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
             expect(graphNodes[i].getTargetNeighborIds().length).toBeGreaterThanOrEqual(4)
         })
@@ -113,7 +113,7 @@ describe('RandomGraphNode-DhtNode', () => {
         // Check bidirectionality
         const allNodes = graphNodes
         allNodes.push(entryPointRandomGraphNode)
-        range(5).map((i) => {
+        range(5).forEach((i) => {
             allNodes[i].getNearbyNodeView().getIds().forEach((nodeId) => {
                 const neighbor = allNodes.find((node) => {
                     return node.getOwnNodeId() === nodeId

package/test/integration/StreamrNode.test.ts

@@ -46,14 +46,16 @@ describe('StreamrNode', () => {
     beforeEach(async () => {
         const simulator = new Simulator()
         transport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        await transport1.start()
         transport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        await transport2.start()
         layer01 = new DhtNode({
-            transportLayer: transport1,
+            transport: transport1,
             peerDescriptor: peerDescriptor1,
             entryPoints: [peerDescriptor1]
         })
         layer02 = new DhtNode({
-            transportLayer: transport2,
+            transport: transport2,
             peerDescriptor: peerDescriptor2,
             entryPoints: [peerDescriptor1]
         })
@@ -126,7 +128,7 @@ describe('StreamrNode', () => {
         ])
     })
 
-    it('leaving streams', async () => {
+    it('leaving stream parts', async () => {
         node1.joinStreamPart(STREAM_PART_ID)
         node2.joinStreamPart(STREAM_PART_ID)
         await Promise.all([