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

package/test/end-to-end/inspect.test.ts

@@ -1,9 +1,11 @@
-import { MessageID, MessageRef, StreamMessage, StreamMessageType, toStreamID, toStreamPartID } from '@streamr/protocol'
+import { MessageID, MessageRef, StreamMessage, StreamMessageType, StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { createMockPeerDescriptor } from '../utils/utils'
 
+const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
+
 describe('inspect', () => {
 
     const publisherDescriptor = createMockPeerDescriptor({
@@ -30,8 +32,6 @@ describe('inspect', () => {
         }
     })
 
-    const streamPartId = toStreamPartID(toStreamID('stream'), 0)
-
     let publisherNode: NetworkNode
 
     let inspectedNode: NetworkNode
@@ -40,8 +40,8 @@ describe('inspect', () => {
 
     const message = new StreamMessage({ 
         messageId: new MessageID(
-            toStreamID('stream'),
-            0,
+            StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+            StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
             666,
             0,
             randomEthereumAddress(),
@@ -81,14 +81,14 @@ describe('inspect', () => {
         await inspectedNode.start()
         await inspectorNode.start()
 
-        publisherNode.stack.getStreamrNode()!.joinStreamPart(streamPartId)
-        inspectedNode.stack.getStreamrNode()!.joinStreamPart(streamPartId)
-        inspectorNode.stack.getStreamrNode()!.joinStreamPart(streamPartId)
+        publisherNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
+        inspectedNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
+        inspectorNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
 
         await waitForCondition(() => 
-            publisherNode.stack.getStreamrNode().getNeighbors(streamPartId).length === 2 
-            && inspectedNode.stack.getStreamrNode().getNeighbors(streamPartId).length === 2 
-            && inspectorNode.stack.getStreamrNode().getNeighbors(streamPartId).length === 2
+            publisherNode.stack.getStreamrNode().getNeighbors(STREAM_PART_ID).length === 2 
+            && inspectedNode.stack.getStreamrNode().getNeighbors(STREAM_PART_ID).length === 2 
+            && inspectorNode.stack.getStreamrNode().getNeighbors(STREAM_PART_ID).length === 2
         )
     }, 30000)
 
@@ -104,7 +104,7 @@ describe('inspect', () => {
         setTimeout(async () => {
             await publisherNode.broadcast(message)
         }, 250)
-        const success = await inspectorNode.inspect(inspectedDescriptor, streamPartId)
+        const success = await inspectorNode.inspect(inspectedDescriptor, STREAM_PART_ID)
         expect(success).toBe(true)
     })
 

package/test/end-to-end/proxy-and-full-node.test.ts

@@ -29,7 +29,6 @@ const createMessage = (streamPartId: StreamPartID): StreamMessage => {
 describe('proxy and full node', () => {
 
     const proxyNodeDescriptor = createMockPeerDescriptor({
-        nodeName: 'proxyNode',
         websocket: { host: '127.0.0.1', port: 23135, tls: false }
     })
     const proxiedNodeDescriptor = createMockPeerDescriptor()
@@ -72,7 +71,7 @@ describe('proxy and full node', () => {
         await proxiedNode.stop()
     })
 
-    it('proxied node can act as full node on another stream', async () => {
+    it('proxied node can act as full node on another stream part', async () => {
         await proxiedNode.setProxies(proxiedStreamPart, [proxyNodeDescriptor], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 1)
         expect(proxiedNode.stack.getLayer0DhtNode().hasJoined()).toBe(false)
 
@@ -88,23 +87,23 @@ describe('proxy and full node', () => {
             proxiedNode.broadcast(createMessage(proxiedStreamPart))
         ])
 
-        expect(proxiedNode.stack.getStreamrNode().getStream(proxiedStreamPart)!.proxied).toBe(true)
-        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamPart1)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(proxiedStreamPart)!.proxied).toBe(true)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart1)!.proxied).toBe(false)
     })
 
-    it('proxied node can act as full node on multiple streams', async () => {
+    it('proxied node can act as full node on multiple stream parts', async () => {
         await proxiedNode.setProxies(proxiedStreamPart, [proxyNodeDescriptor], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 1)
         expect(proxiedNode.stack.getLayer0DhtNode().hasJoined()).toBe(false)
 
         await Promise.all([
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === 'regular-stream1'),
+                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart1)),
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === 'regular-stream2'),
+                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart2)),
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === 'regular-stream3'),
+                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart3)),
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === 'regular-stream4'),
+                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart4)),
             proxiedNode.broadcast(createMessage(regularStreamPart1)),
             proxiedNode.broadcast(createMessage(regularStreamPart2)),
             proxiedNode.broadcast(createMessage(regularStreamPart3)),
@@ -118,11 +117,11 @@ describe('proxy and full node', () => {
             proxiedNode.broadcast(createMessage(proxiedStreamPart))
         ])
 
-        expect(proxiedNode.stack.getStreamrNode().getStream(proxiedStreamPart)!.proxied).toBe(true)
-        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamPart1)!.proxied).toBe(false)
-        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamPart2)!.proxied).toBe(false)
-        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamPart3)!.proxied).toBe(false)
-        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamPart4)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(proxiedStreamPart)!.proxied).toBe(true)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart1)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart2)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart3)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart4)!.proxied).toBe(false)
     })
 
 })

package/test/end-to-end/proxy-connections.test.ts

@@ -1,19 +1,19 @@
-import { MessageID, MessageRef, StreamMessage, StreamMessageType, toStreamID, toStreamPartID } from '@streamr/protocol'
+import { MessageID, MessageRef, StreamMessage, StreamMessageType, StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary, utf8ToBinary, wait, waitForCondition, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { NodeID } from '../../src/identifiers'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
-import { ProxyStreamConnectionClient } from '../../src/logic/proxy/ProxyStreamConnectionClient'
+import { ProxyClient } from '../../src/logic/proxy/ProxyClient'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const PROXIED_NODE_USER_ID = randomEthereumAddress()
-const STREAM_PART_ID = toStreamPartID(toStreamID('proxy-test'), 0)
+const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
 const MESSAGE = new StreamMessage({
     messageId: new MessageID(
-        toStreamID('proxy-test'),
-        0,
+        StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+        StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
         666,
         0,
         randomEthereumAddress(),
@@ -34,24 +34,22 @@ describe('Proxy connections', () => {
     let proxiedNode: NetworkNode
 
     const hasConnectionFromProxy = (proxyNode: NetworkNode): boolean => {
-        const delivery = proxyNode.stack.getStreamrNode()!.getStream(STREAM_PART_ID)
+        const delivery = proxyNode.stack.getStreamrNode()!.getStreamPartDelivery(STREAM_PART_ID)
         return (delivery !== undefined)
             ? ((delivery as { node: RandomGraphNode }).node).hasProxyConnection(proxiedNode.getNodeId())
             : false
     }
     
     const hasConnectionToProxy = (proxyNodeId: NodeID, direction: ProxyDirection): boolean => {
-        const client = (proxiedNode.stack.getStreamrNode()!.getStream(STREAM_PART_ID) as { client: ProxyStreamConnectionClient }).client
+        const client = (proxiedNode.stack.getStreamrNode()!.getStreamPartDelivery(STREAM_PART_ID) as { client: ProxyClient }).client
         return client.hasConnection(proxyNodeId, direction)
     }
 
     beforeEach(async () => {
         const proxyNodeDescriptor1 = createMockPeerDescriptor({
-            nodeName: 'proxyNode',
             websocket: { host: '127.0.0.1', port: 23132, tls: false }
         })
         const proxyNodeDescriptor2 = createMockPeerDescriptor({
-            nodeName: 'proxyNode',
             websocket: { host: '127.0.0.1', port: 23133, tls: false }
         })
         const proxiedNodeDescriptor = createMockPeerDescriptor()
@@ -191,7 +189,7 @@ describe('Proxy connections', () => {
         expect(hasConnectionFromProxy(proxyNode1)).toBe(true)
     }, 30000)
 
-    it('cannot join on proxy publish streams', async () => {
+    it('can\'t join proxied stream part', async () => {
         await proxiedNode.setProxies(
             STREAM_PART_ID,
             [proxyNode1.getPeerDescriptor()],
@@ -201,7 +199,7 @@ describe('Proxy connections', () => {
         await expect(proxiedNode.join(STREAM_PART_ID)).rejects.toThrow('Cannot join')
     })
 
-    it('connect publish on proxy subscribe streams', async () => {
+    it('can\'t broadcast to subscribe-only proxied stream part', async () => {
         await proxiedNode.setProxies(
             STREAM_PART_ID,
             [proxyNode1.getPeerDescriptor()],

package/test/end-to-end/proxy-key-exchange.test.ts

@@ -12,9 +12,10 @@ import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
+const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
+
 describe('proxy group key exchange', () => {
     const proxyNodeDescriptor = createMockPeerDescriptor({
-        nodeName: 'proxyNode',
         websocket: { host: '127.0.0.1', port: 23134, tls: false }
     })
     const publisherDescriptor = createMockPeerDescriptor()
@@ -23,8 +24,6 @@ describe('proxy group key exchange', () => {
     const publisherUserId = toEthereumAddress('0x823A026e226EB47980c88616e01E1D3305Ef8Ecb')
     const subscriberUserId = toEthereumAddress('0x73E6183bf9b79D30533bEC7B28e982e9Af649B23')
 
-    const streamPartId = StreamPartIDUtils.parse('proxy-test#0')
-
     let proxyNode: NetworkNode
     let publisher: NetworkNode
     let subscriber: NetworkNode
@@ -40,8 +39,8 @@ describe('proxy group key exchange', () => {
             }
         })
         await proxyNode.start()
-        proxyNode.setStreamPartEntryPoints(streamPartId, [proxyNodeDescriptor])
-        proxyNode.stack.getStreamrNode()!.joinStreamPart(streamPartId)
+        proxyNode.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor])
+        proxyNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
         publisher = createNetworkNode({
             layer0: {
                 entryPoints: [publisherDescriptor],
@@ -66,8 +65,8 @@ describe('proxy group key exchange', () => {
     })
     
     it('happy path request', async () => {
-        await publisher.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
-        await subscriber.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
+        await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
+        await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
 
         const requestContent = utf8ToBinary(new GroupKeyRequest({
             recipient: publisherUserId,
@@ -79,8 +78,8 @@ describe('proxy group key exchange', () => {
         }).serialize())
         const request = new StreamMessage({
             messageId: new MessageID(
-                StreamPartIDUtils.getStreamID(streamPartId),
-                StreamPartIDUtils.getStreamPartition(streamPartId),
+                StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+                StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
                 Date.now(),
                 0,
                 subscriberUserId,
@@ -99,8 +98,8 @@ describe('proxy group key exchange', () => {
     })
 
     it('happy path response', async () => {
-        await publisher.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
-        await subscriber.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
+        await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
+        await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
 
         const responseContent = utf8ToBinary(new GroupKeyResponse({
             recipient: publisherUserId,
@@ -109,8 +108,8 @@ describe('proxy group key exchange', () => {
         }).serialize())
         const response = new StreamMessage({
             messageId: new MessageID(
-                StreamPartIDUtils.getStreamID(streamPartId),
-                StreamPartIDUtils.getStreamPartition(streamPartId),
+                StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+                StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
                 Date.now(),
                 0,
                 publisherUserId,

package/test/end-to-end/random-graph-with-real-connections.test.ts

@@ -14,7 +14,7 @@ describe('random graph with real connections', () => {
         websocket: { host: '127.0.0.1', port: 12221, tls: false }
     }
 
-    const randomGraphId = StreamPartIDUtils.parse('random-graph#0')
+    const streamPartId = StreamPartIDUtils.parse('random-graph#0')
     let epDhtNode: DhtNode
     let dhtNode1: DhtNode
     let dhtNode2: DhtNode
@@ -41,7 +41,7 @@ describe('random graph with real connections', () => {
 
         randomGraphNode1 = createRandomGraphNode(
             {
-                randomGraphId,
+                streamPartId,
                 layer1: epDhtNode,
                 P2PTransport: epDhtNode.getTransport(),
                 connectionLocker: epDhtNode.getTransport() as ConnectionManager,
@@ -49,28 +49,28 @@ describe('random graph with real connections', () => {
             }
         )
         randomGraphNode2 = createRandomGraphNode({
-            randomGraphId,
+            streamPartId,
             layer1: dhtNode1,
             P2PTransport: dhtNode1.getTransport(),
             connectionLocker: dhtNode1.getTransport() as ConnectionManager,
             ownPeerDescriptor: dhtNode1.getPeerDescriptor()
         })
         randomGraphNode3 = createRandomGraphNode({
-            randomGraphId,
+            streamPartId,
             layer1: dhtNode2,
             P2PTransport: dhtNode2.getTransport(),
             connectionLocker: dhtNode2.getTransport() as ConnectionManager,
             ownPeerDescriptor: dhtNode2.getPeerDescriptor()
         })
         randomGraphNode4 = createRandomGraphNode({
-            randomGraphId,
+            streamPartId,
             layer1: dhtNode3,
             P2PTransport: dhtNode3.getTransport(),
             connectionLocker: dhtNode3.getTransport() as ConnectionManager,
             ownPeerDescriptor: dhtNode3.getPeerDescriptor()
         })
         randomGraphNode5 = createRandomGraphNode({
-            randomGraphId,
+            streamPartId,
             layer1: dhtNode4,
             P2PTransport: dhtNode4.getTransport(),
             connectionLocker: dhtNode4.getTransport() as ConnectionManager,
@@ -144,7 +144,7 @@ describe('random graph with real connections', () => {
 
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            randomGraphId,
+            streamPartId,
             randomEthereumAddress()
         )
         randomGraphNode1.broadcast(msg)

package/test/end-to-end/webrtc-full-node-network.test.ts

@@ -16,7 +16,7 @@ describe('Full node network with WebRTC connections', () => {
         region: getRandomRegion()
     })
 
-    const randomGraphId = StreamPartIDUtils.parse('webrtc-network#0')
+    const streamPartId = StreamPartIDUtils.parse('webrtc-network#0')
 
     let entryPoint: NetworkStack
 
@@ -33,8 +33,8 @@ describe('Full node network with WebRTC connections', () => {
             }
         })
         await entryPoint.start()
-        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
-        entryPoint.getStreamrNode()!.joinStreamPart(randomGraphId)
+        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+        entryPoint.getStreamrNode()!.joinStreamPart(streamPartId)
 
         await Promise.all(range(NUM_OF_NODES).map(async () => {
             const peerDescriptor = createMockPeerDescriptor()
@@ -46,8 +46,8 @@ describe('Full node network with WebRTC connections', () => {
             })
             nodes.push(node)
             await node.start()
-            node.getStreamrNode().setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
-            node.getStreamrNode().joinStreamPart(randomGraphId)
+            node.getStreamrNode().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+            node.getStreamrNode().joinStreamPart(streamPartId)
         }))
 
     }, 90000)
@@ -62,13 +62,13 @@ describe('Full node network with WebRTC connections', () => {
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
             waitForCondition(() => {
-                return node.getStreamrNode()!.getNeighbors(randomGraphId).length >= 3
+                return node.getStreamrNode()!.getNeighbors(streamPartId).length >= 3
             }
             , 120000)
         ))
         let numOfMessagesReceived = 0
         const successIds: string[] = []
-        nodes.map((node) => {
+        nodes.forEach((node) => {
             node.getStreamrNode()!.on('newMessage', () => {
                 successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode()!.getPeerDescriptor()))
                 numOfMessagesReceived += 1
@@ -76,7 +76,7 @@ describe('Full node network with WebRTC connections', () => {
         })
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            randomGraphId,
+            streamPartId,
             randomEthereumAddress()
         )
         entryPoint.getStreamrNode()!.broadcast(msg)

package/test/end-to-end/websocket-full-node-network.test.ts

@@ -10,10 +10,9 @@ describe('Full node network with WebSocket connections only', () => {
 
     const NUM_OF_NODES = 48
     const epPeerDescriptor = createMockPeerDescriptor({
-        nodeName: 'entrypoint',
         websocket: { host: '127.0.0.1', port: 15555, tls: false }
     })
-    const randomGraphId = StreamPartIDUtils.parse('websocket-network#0')
+    const streamPartId = StreamPartIDUtils.parse('websocket-network#0')
 
     let entryPoint: NetworkStack
 
@@ -30,22 +29,21 @@ describe('Full node network with WebSocket connections only', () => {
             }
         })
         await entryPoint.start()
-        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
-        entryPoint.getStreamrNode()!.joinStreamPart(randomGraphId)
+        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+        entryPoint.getStreamrNode()!.joinStreamPart(streamPartId)
 
         await Promise.all(range(NUM_OF_NODES).map(async (i) => {
             const node = new NetworkStack({
                 layer0: {
                     entryPoints: [epPeerDescriptor],
                     websocketPortRange: { min: 15556 + i, max: 15556 + i },
-                    nodeName: `${i}`,
                     numberOfNodesPerKBucket: 4
                 }
             })
             nodes.push(node)
             await node.start()
-            node.getStreamrNode().setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
-            node.getStreamrNode().joinStreamPart(randomGraphId)
+            node.getStreamrNode().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+            node.getStreamrNode().joinStreamPart(streamPartId)
         }))
 
     }, 120000)
@@ -60,13 +58,13 @@ describe('Full node network with WebSocket connections only', () => {
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
             waitForCondition(() => {
-                return node.getStreamrNode()!.getNeighbors(randomGraphId).length >= 4
+                return node.getStreamrNode()!.getNeighbors(streamPartId).length >= 4
             }
             , 120000)
         ))
         let numOfMessagesReceived = 0
         const successIds: string[] = []
-        nodes.map((node) => {
+        nodes.forEach((node) => {
             node.getStreamrNode()!.on('newMessage', () => {
                 successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode()!.getPeerDescriptor()))
                 numOfMessagesReceived += 1
@@ -75,7 +73,7 @@ describe('Full node network with WebSocket connections only', () => {
 
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            randomGraphId,
+            streamPartId,
             randomEthereumAddress()
         )
         entryPoint.getStreamrNode()!.broadcast(msg)

package/test/integration/{RemoteRandomGraphNode.test.ts → DeliveryRpcRemote.test.ts}

@@ -5,24 +5,25 @@ import {
     SimulatorTransport,
     NodeType
 } from '@streamr/dht'
-import { RemoteRandomGraphNode } from '../../src/logic/RemoteRandomGraphNode'
-import { NetworkRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import {
     LeaveStreamPartNotice,
     StreamMessage
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { waitForCondition } from '@streamr/utils'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { createStreamMessage } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
-describe('RemoteRandomGraphNode', () => {
+const STREAM_PART_ID = StreamPartIDUtils.parse('test-stream#0')
+
+describe('DeliveryRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
     let clientRpc: ListeningRpcCommunicator
-    let remoteRandomGraphNode: RemoteRandomGraphNode
+    let rpcRemote: DeliveryRpcRemote
 
     const clientNode: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 1, 1]),
@@ -39,11 +40,13 @@ describe('RemoteRandomGraphNode', () => {
     let mockConnectionManager1: SimulatorTransport
     let mockConnectionManager2: SimulatorTransport
 
-    beforeEach(() => {
+    beforeEach(async () => {
         recvCounter = 0
         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)
@@ -51,7 +54,7 @@ describe('RemoteRandomGraphNode', () => {
         mockServerRpc.registerRpcNotification(
             StreamMessage,
             'sendStreamMessage',
-            async (_msg: StreamMessage, _context: ServerCallContext): Promise<Empty> => {
+            async (): Promise<Empty> => {
                 recvCounter += 1
                 return Empty
             }
@@ -60,17 +63,17 @@ describe('RemoteRandomGraphNode', () => {
         mockServerRpc.registerRpcNotification(
             LeaveStreamPartNotice,
             'leaveStreamPartNotice',
-            async (_msg: LeaveStreamPartNotice, _context: ServerCallContext): Promise<Empty> => {
+            async (): Promise<Empty> => {
                 recvCounter += 1
                 return Empty
             }
         )
 
-        remoteRandomGraphNode = new RemoteRandomGraphNode(
+        rpcRemote = new DeliveryRpcRemote(
             clientNode,
             serverNode,
-            'test-stream',
-            toProtoRpcClient(new NetworkRpcClient(clientRpc.getRpcClientTransport()))
+            STREAM_PART_ID,
+            toProtoRpcClient(new DeliveryRpcClient(clientRpc.getRpcClientTransport()))
         )
     })
 
@@ -85,16 +88,16 @@ describe('RemoteRandomGraphNode', () => {
     it('sendStreamMessage', async () => {
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            StreamPartIDUtils.parse('test-stream#0'),
+            STREAM_PART_ID,
             randomEthereumAddress()
         )
 
-        await remoteRandomGraphNode.sendStreamMessage(msg)
+        await rpcRemote.sendStreamMessage(msg)
         await waitForCondition(() => recvCounter === 1)
     })
 
     it('leaveNotice', async () => {
-        remoteRandomGraphNode.leaveStreamPartNotice()
+        rpcRemote.leaveStreamPartNotice()
         await waitForCondition(() => recvCounter === 1)
     })
 

package/test/integration/{RemoteHandshaker.test.ts → HandshakeRpcRemote.test.ts}

@@ -2,7 +2,6 @@ import {
     StreamPartHandshakeRequest,
     StreamPartHandshakeResponse
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import {
     ListeningRpcCommunicator,
     NodeType,
@@ -14,12 +13,12 @@ import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     HandshakeRpcClient,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { RemoteHandshaker } from '../../src/logic/neighbor-discovery/RemoteHandshaker'
+import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
 
-describe('RemoteHandshaker', () => {
+describe('HandshakeRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
     let clientRpc: ListeningRpcCommunicator
-    let remoteHandshaker: RemoteHandshaker
+    let rpcRemote: HandshakeRpcRemote
 
     const clientNode: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 1, 1]),
@@ -34,11 +33,13 @@ describe('RemoteHandshaker', () => {
     let mockConnectionManager1: SimulatorTransport
     let mockConnectionManager2: SimulatorTransport
 
-    beforeEach(() => {
+    beforeEach(async () => {
         Simulator.useFakeTimers()
         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)
@@ -47,7 +48,7 @@ describe('RemoteHandshaker', () => {
             StreamPartHandshakeRequest,
             StreamPartHandshakeResponse,
             'handshake',
-            async (msg: StreamPartHandshakeRequest, _context: ServerCallContext): Promise<StreamPartHandshakeResponse> => {
+            async (msg: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
                 const res: StreamPartHandshakeResponse = {
                     requestId: msg.requestId,
                     accepted: true
@@ -56,10 +57,10 @@ describe('RemoteHandshaker', () => {
             }
         )
 
-        remoteHandshaker = new RemoteHandshaker(
+        rpcRemote = new HandshakeRpcRemote(
             clientNode,
             serverNode,
-            'test-stream',
+            'test-stream-part',
             toProtoRpcClient(new HandshakeRpcClient(clientRpc.getRpcClientTransport()))
         )
     })
@@ -74,7 +75,7 @@ describe('RemoteHandshaker', () => {
     })
 
     it('handshake', async () => {
-        const result = await remoteHandshaker.handshake([])
+        const result = await rpcRemote.handshake([])
         expect(result.accepted).toEqual(true)
     })
 })