@streamr/trackerless-network 100.0.0-pretestnet.4 → 100.0.0-rc.0

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

@@ -3,12 +3,12 @@ import { randomEthereumAddress } from '@streamr/test-utils'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { getNodeIdFromPeerDescriptor } from '@streamr/dht'
 
 describe('Full node network with WebSocket connections only', () => {
 
-    const NUM_OF_NODES = 48
+    const NUM_OF_NODES = 32
     const epPeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 15555, tls: false }
     })
@@ -30,8 +30,8 @@ describe('Full node network with WebSocket connections only', () => {
             }
         })
         await entryPoint.start()
-        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
-        entryPoint.getStreamrNode()!.joinStreamPart(streamPartId)
+        entryPoint.getStreamrNode().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+        entryPoint.getStreamrNode().joinStreamPart(streamPartId)
 
         await Promise.all(range(NUM_OF_NODES).map(async (i) => {
             const node = new NetworkStack({
@@ -60,16 +60,16 @@ describe('Full node network with WebSocket connections only', () => {
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
             waitForCondition(() => {
-                return node.getStreamrNode()!.getNeighbors(streamPartId).length >= 4
+                return node.getStreamrNode().getNeighbors(streamPartId).length >= 4
             }
-            , 120000)
+            , 30000)
         ))
-        let numOfMessagesReceived = 0
+        let receivedMessageCount = 0
         const successIds: string[] = []
         nodes.forEach((node) => {
-            node.getStreamrNode()!.on('newMessage', () => {
-                successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode()!.getPeerDescriptor()))
-                numOfMessagesReceived += 1
+            node.getStreamrNode().on('newMessage', () => {
+                successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode().getPeerDescriptor()))
+                receivedMessageCount += 1
             })
         })
 
@@ -78,8 +78,8 @@ describe('Full node network with WebSocket connections only', () => {
             streamPartId,
             randomEthereumAddress()
         )
-        entryPoint.getStreamrNode()!.broadcast(msg)
-        await waitForCondition(() => numOfMessagesReceived === NUM_OF_NODES)
+        entryPoint.getStreamrNode().broadcast(msg)
+        await waitForCondition(() => receivedMessageCount === NUM_OF_NODES)
     }, 220000)
 
 })

package/test/integration/DeliveryRpcRemote.test.ts

@@ -13,24 +13,21 @@ import {
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 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'
 
-const STREAM_PART_ID = StreamPartIDUtils.parse('test-stream#0')
-
 describe('DeliveryRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
     let clientRpc: ListeningRpcCommunicator
     let rpcRemote: DeliveryRpcRemote
 
     const clientNode: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 1, 1]),
+        nodeId: new Uint8Array([1, 1, 1]),
         type: NodeType.NODEJS
     }
     const serverNode: PeerDescriptor = {
-        kademliaId: new Uint8Array([2, 2, 2]),
+        nodeId: new Uint8Array([2, 2, 2]),
         type: NodeType.NODEJS
     }
 
@@ -72,8 +69,8 @@ describe('DeliveryRpcRemote', () => {
         rpcRemote = new DeliveryRpcRemote(
             clientNode,
             serverNode,
-            STREAM_PART_ID,
-            toProtoRpcClient(new DeliveryRpcClient(clientRpc.getRpcClientTransport()))
+            clientRpc,
+            DeliveryRpcClient
         )
     })
 
@@ -88,7 +85,7 @@ describe('DeliveryRpcRemote', () => {
     it('sendStreamMessage', async () => {
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            STREAM_PART_ID,
+            StreamPartIDUtils.parse('test-stream#0'),
             randomEthereumAddress()
         )
 
@@ -97,7 +94,7 @@ describe('DeliveryRpcRemote', () => {
     })
 
     it('leaveNotice', async () => {
-        rpcRemote.leaveStreamPartNotice()
+        rpcRemote.leaveStreamPartNotice(StreamPartIDUtils.parse('test#0'), false)
         await waitForCondition(() => recvCounter === 1)
     })
 

package/test/integration/HandshakeRpcRemote.test.ts

@@ -9,11 +9,11 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     HandshakeRpcClient,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('HandshakeRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
@@ -21,11 +21,11 @@ describe('HandshakeRpcRemote', () => {
     let rpcRemote: HandshakeRpcRemote
 
     const clientNode: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 1, 1]),
+        nodeId: new Uint8Array([1, 1, 1]),
         type: NodeType.NODEJS
     }
     const serverNode: PeerDescriptor = {
-        kademliaId: new Uint8Array([2, 2, 2]),
+        nodeId: new Uint8Array([2, 2, 2]),
         type: NodeType.NODEJS
     }
 
@@ -34,7 +34,6 @@ describe('HandshakeRpcRemote', () => {
     let mockConnectionManager2: SimulatorTransport
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         simulator = new Simulator()
         mockConnectionManager1 = new SimulatorTransport(serverNode, simulator)
         await mockConnectionManager1.start()
@@ -60,8 +59,8 @@ describe('HandshakeRpcRemote', () => {
         rpcRemote = new HandshakeRpcRemote(
             clientNode,
             serverNode,
-            'test-stream-part',
-            toProtoRpcClient(new HandshakeRpcClient(clientRpc.getRpcClientTransport()))
+            clientRpc,
+            HandshakeRpcClient
         )
     })
 
@@ -71,11 +70,10 @@ describe('HandshakeRpcRemote', () => {
         await mockConnectionManager1.stop()
         await mockConnectionManager2.stop()
         simulator.stop()
-        Simulator.useFakeTimers(false)
     })
 
     it('handshake', async () => {
-        const result = await rpcRemote.handshake([])
+        const result = await rpcRemote.handshake(StreamPartIDUtils.parse('test#0'), [])
         expect(result.accepted).toEqual(true)
     })
 })

package/test/integration/Handshakes.test.ts

@@ -4,38 +4,38 @@ import {
     PeerDescriptor,
     ListeningRpcCommunicator,
     Simulator,
-    SimulatorTransport
+    SimulatorTransport,
+    getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     HandshakeRpcClient
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../../src/logic/NodeList'
-import { mockConnectionLocker } from '../utils/utils'
 import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Handshakes', () => {
 
     const peerDescriptor1: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 1, 1]),
+        nodeId: new Uint8Array([1, 1, 1]),
         type: NodeType.NODEJS
     }
     const peerDescriptor2: PeerDescriptor = {
-        kademliaId: new Uint8Array([2, 1, 1]),
+        nodeId: new Uint8Array([2, 1, 1]),
         type: NodeType.NODEJS
     }
     const peerDescriptor3: PeerDescriptor = {
-        kademliaId: new Uint8Array([3, 1, 1]),
+        nodeId: new Uint8Array([3, 1, 1]),
         type: NodeType.NODEJS
     }
     let rpcCommunicator1: ListeningRpcCommunicator
     let rpcCommunicator2: ListeningRpcCommunicator
     let rpcCommunicator3: ListeningRpcCommunicator
+    let neighbors: NodeList
+    let leftNodeView: NodeList
+    let rightNodeView: NodeList
     let nodeView: NodeList
-    let targetNeighbors: NodeList
     let handshaker: Handshaker
     const streamPartId = StreamPartIDUtils.parse('stream#0')
 
@@ -70,7 +70,6 @@ describe('Handshakes', () => {
     let simulatorTransport3: SimulatorTransport
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         simulator = new Simulator()
         simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
         await simulatorTransport1.start()
@@ -84,17 +83,21 @@ describe('Handshakes', () => {
         rpcCommunicator3 = new ListeningRpcCommunicator(streamPartId, simulatorTransport3)
 
         const handshakerNodeId = getNodeIdFromPeerDescriptor(peerDescriptor2)
+        leftNodeView = new NodeList(handshakerNodeId, 10)
+        rightNodeView = new NodeList(handshakerNodeId, 10)
         nodeView = new NodeList(handshakerNodeId, 10)
-        targetNeighbors = new NodeList(handshakerNodeId, 4)
+        neighbors = new NodeList(handshakerNodeId, 4)
         handshaker = new Handshaker({
             localPeerDescriptor: peerDescriptor2,
             streamPartId,
             nearbyNodeView: nodeView,
             randomNodeView: nodeView,
-            targetNeighbors,
-            connectionLocker: mockConnectionLocker,
+            leftNodeView,
+            rightNodeView,
+            neighbors,
             rpcCommunicator: rpcCommunicator2,
-            maxNeighborCount: 4
+            maxNeighborCount: 4,
+            ongoingHandshakes: new Set()
         })
 
     })
@@ -107,7 +110,6 @@ describe('Handshakes', () => {
         await simulatorTransport2.stop()
         await simulatorTransport3.stop()
         simulator.stop()
-        Simulator.useFakeTimers(false)
     })
 
     it('Two nodes can handshake', async () => {
@@ -117,12 +119,12 @@ describe('Handshakes', () => {
             new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(true)
-        expect(targetNeighbors.hasNode(peerDescriptor1)).toEqual(true)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(true)
     })
 
     it('Handshake accepted', async () => {
@@ -132,12 +134,12 @@ describe('Handshakes', () => {
             new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(true)
-        expect(targetNeighbors.hasNode(peerDescriptor1)).toEqual(true)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(true)
     })
 
     it('Handshake rejected', async () => {
@@ -147,12 +149,12 @@ describe('Handshakes', () => {
             new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(false)
-        expect(targetNeighbors.hasNode(peerDescriptor1)).toEqual(false)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(false)
     })
 
     it('Handshake with Interleaving', async () => {
@@ -163,12 +165,12 @@ describe('Handshakes', () => {
             new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(true)
-        expect(targetNeighbors.hasNode(peerDescriptor1)).toEqual(true)
-        expect(targetNeighbors.hasNode(peerDescriptor3)).toEqual(true)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(true)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor3))).toEqual(true)
     })
 })

package/test/integration/Inspect.test.ts

@@ -38,7 +38,6 @@ describe('inspect', () => {
     }
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         simulator = new Simulator(LatencyType.REAL)
 
         publisherNode = await initiateNode(publisherDescriptor, simulator)
@@ -65,7 +64,6 @@ describe('inspect', () => {
             inspectorNode.stop(),
             ...inspectedNodes.map((node) => node.stop())
         ])
-        Simulator.useFakeTimers(false)
     })
 
     it('gets successful inspections from all suspects', async () => {

package/test/integration/NeighborUpdateRpcRemote.test.ts

@@ -5,7 +5,6 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { NeighborUpdateRpcRemote } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcRemote'
 import { NeighborUpdate } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import {
@@ -19,11 +18,11 @@ describe('NeighborUpdateRpcRemote', () => {
     let rpcRemote: NeighborUpdateRpcRemote
 
     const clientNode: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 1, 1]),
+        nodeId: new Uint8Array([1, 1, 1]),
         type: NodeType.NODEJS
     }
     const serverNode: PeerDescriptor = {
-        kademliaId: new Uint8Array([2, 2, 2]),
+        nodeId: new Uint8Array([2, 2, 2]),
         type: NodeType.NODEJS
     }
 
@@ -47,7 +46,7 @@ describe('NeighborUpdateRpcRemote', () => {
             'neighborUpdate',
             async (): Promise<NeighborUpdate> => {
                 const node: PeerDescriptor = {
-                    kademliaId: new Uint8Array([4, 2, 4]),
+                    nodeId: new Uint8Array([4, 2, 4]),
                     type: NodeType.NODEJS
                 }
                 const update: NeighborUpdate = {
@@ -63,8 +62,8 @@ describe('NeighborUpdateRpcRemote', () => {
         rpcRemote = new NeighborUpdateRpcRemote(
             clientNode,
             serverNode,
-            'test-stream-part',
-            toProtoRpcClient(new NeighborUpdateRpcClient(clientRpc.getRpcClientTransport()))
+            clientRpc,
+            NeighborUpdateRpcClient
         )
     })
 
@@ -77,7 +76,7 @@ describe('NeighborUpdateRpcRemote', () => {
     })
 
     it('updateNeighbors', async () => {
-        const res = await rpcRemote.updateNeighbors([])
+        const res = await rpcRemote.updateNeighbors(StreamPartIDUtils.parse('test#0'), [])
         expect(res.peerDescriptors.length).toEqual(1)
     })
 })

package/test/integration/NetworkNode.test.ts

@@ -1,13 +1,16 @@
-import { NodeType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
+import { PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
 import {
+    ContentType,
+    EncryptionType,
     MessageID,
-    MessageRef,
+    MessageRef, SignatureType,
     StreamMessage,
     StreamMessageType,
     StreamPartIDUtils
 } from '@streamr/protocol'
 import { EthereumAddress, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
 
@@ -19,18 +22,11 @@ describe('NetworkNode', () => {
     let node1: NetworkNode
     let node2: NetworkNode
 
-    const pd1: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS
-    }
+    const pd1: PeerDescriptor = createMockPeerDescriptor()
 
-    const pd2: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 1, 1]),
-        type: NodeType.NODEJS
-    }
+    const pd2: PeerDescriptor = createMockPeerDescriptor()
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         const simulator = new Simulator()
         transport1 = new SimulatorTransport(pd1, simulator)
         await transport1.start()
@@ -63,7 +59,6 @@ describe('NetworkNode', () => {
             node1.stop(),
             node2.stop()
         ])
-        Simulator.useFakeTimers(false)
     })
 
     it('wait for join + broadcast and subscribe', async () => {
@@ -80,7 +75,10 @@ describe('NetworkNode', () => {
             content: utf8ToBinary(JSON.stringify({
                 hello: 'world'
             })),
+            contentType: ContentType.JSON,
             messageType: StreamMessageType.MESSAGE,
+            encryptionType: EncryptionType.NONE,
+            signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('0x1234'),
         })
 
@@ -95,4 +93,21 @@ describe('NetworkNode', () => {
         await waitForCondition(() => msgCount === 1)
     })
 
+    it('fetchNodeInfo', async () => {
+        await node1.join(STREAM_PART_ID)
+        await node2.join(STREAM_PART_ID)
+        const result1 = await node1.fetchNodeInfo(pd2)
+        const result2 = await node2.fetchNodeInfo(pd1)
+        const result3 = await node1.fetchNodeInfo(node1.getPeerDescriptor())
+        expect(result1.streamPartitions.length).toEqual(1)
+        expect(result2.streamPartitions.length).toEqual(1)
+        expect(result3.streamPartitions.length).toEqual(1)
+        expect(result1.controlLayer.connections.length).toEqual(1)
+        expect(result2.controlLayer.connections.length).toEqual(1)
+        expect(result3.controlLayer.connections.length).toEqual(1)
+        expect(result1.controlLayer.neighbors.length).toEqual(1)
+        expect(result2.controlLayer.neighbors.length).toEqual(1)
+        expect(result3.controlLayer.neighbors.length).toEqual(1)
+    })
+
 })

package/test/integration/NetworkRpc.test.ts

@@ -9,18 +9,17 @@ import { waitForCondition } from '@streamr/utils'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { createStreamMessage } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Simulator } from '@streamr/dht'
+import { DhtCallContext } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
 describe('Network RPC', () => {
-    let rpcCommunicator1: RpcCommunicator
-    let rpcCommunicator2: RpcCommunicator
+    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
+    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
     let client: ProtoRpcClient<DeliveryRpcClient>
     let recvCounter = 0
 
     beforeEach(() => {
-        Simulator.useFakeTimers()
         rpcCommunicator1 = new RpcCommunicator()
         rpcCommunicator2 = new RpcCommunicator()
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
@@ -40,7 +39,6 @@ describe('Network RPC', () => {
     afterEach(() => {
         rpcCommunicator1.stop()
         rpcCommunicator2.stop()
-        Simulator.useFakeTimers(false)
     })
 
     it('sends Data', async () => {

package/test/integration/NetworkStack.test.ts

@@ -34,9 +34,9 @@ describe('NetworkStack', () => {
         })
 
         await stack1.start()
-        stack1.getStreamrNode()!.setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
+        stack1.getStreamrNode().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
         await stack2.start()
-        stack2.getStreamrNode()!.setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
+        stack2.getStreamrNode().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
     })
 
     afterEach(async () => {

package/test/integration/NodeInfoRpc.test.ts

@@ -0,0 +1,104 @@
+import { Simulator, SimulatorTransport, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
+import { NetworkStack } from '../../src/NetworkStack'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { NodeInfoClient } from '../../src/logic/node-info/NodeInfoClient'
+import { NODE_INFO_RPC_SERVICE_ID } from '../../src/logic/node-info/NodeInfoRpcLocal'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { waitForCondition } from '@streamr/utils'
+
+// TODO add Jest utility so that the normalization is not needed (NET-1254)
+const normalizePeerDescriptor = (peerDescriptor: PeerDescriptor) => {
+    return {
+        ...peerDescriptor,
+        nodeId: new Uint8Array(peerDescriptor.nodeId)
+    }
+}
+
+describe('NetworkStack NodeInfoRpc', () => {
+
+    let requesteStack: NetworkStack
+    let otherStack: NetworkStack
+    let nodeInfoClient: NodeInfoClient
+    let requesteeTransport1: SimulatorTransport
+    let otherTransport: SimulatorTransport
+    let requestorTransport: SimulatorTransport
+
+    let simulator: Simulator
+
+    const requesteePeerDescriptor = createMockPeerDescriptor()
+    const otherPeerDescriptor = createMockPeerDescriptor()
+    const requestorPeerDescriptor = createMockPeerDescriptor()
+
+    beforeEach(async () => {
+        simulator = new Simulator()
+        requesteeTransport1 = new SimulatorTransport(requesteePeerDescriptor, simulator)
+        otherTransport = new SimulatorTransport(otherPeerDescriptor, simulator)
+        requestorTransport = new SimulatorTransport(requestorPeerDescriptor, simulator)
+        await requesteeTransport1.start()
+        await otherTransport.start()
+        await requestorTransport.start()
+        requesteStack = new NetworkStack({
+            layer0: {
+                transport: requesteeTransport1,
+                peerDescriptor: requesteePeerDescriptor,
+                entryPoints: [requesteePeerDescriptor]
+            }
+        })
+        otherStack = new NetworkStack({
+            layer0: {
+                transport: otherTransport,
+                peerDescriptor: otherPeerDescriptor,
+                entryPoints: [requesteePeerDescriptor]
+            }
+        })
+        await requesteStack.start()
+        await otherStack.start()
+        nodeInfoClient = new NodeInfoClient(requestorPeerDescriptor, new ListeningRpcCommunicator(NODE_INFO_RPC_SERVICE_ID, requestorTransport))
+    })
+
+    afterEach(async () => {
+        await requesteStack.stop()
+        await otherStack.stop()
+        await requesteeTransport1.stop()
+        await otherTransport.stop()
+        await requestorTransport.stop()
+    })
+
+    it('happy path', async () => {
+        const streamPartId1 = StreamPartIDUtils.parse('stream1#0')
+        const streamPartId2 = StreamPartIDUtils.parse('stream2#0')
+        requesteStack.getStreamrNode().joinStreamPart(streamPartId1)
+        otherStack.getStreamrNode().joinStreamPart(streamPartId1)
+        requesteStack.getStreamrNode().joinStreamPart(streamPartId2)
+        otherStack.getStreamrNode().joinStreamPart(streamPartId2)
+        await waitForCondition(() => 
+            requesteStack.getStreamrNode().getNeighbors(streamPartId1).length === 1 
+            && otherStack.getStreamrNode().getNeighbors(streamPartId1).length === 1
+            && requesteStack.getStreamrNode().getNeighbors(streamPartId2).length === 1
+            && otherStack.getStreamrNode().getNeighbors(streamPartId2).length === 1
+        )
+        const result = await nodeInfoClient.getInfo(requesteePeerDescriptor)
+        expect(result).toMatchObject({
+            peerDescriptor: normalizePeerDescriptor(requesteePeerDescriptor),
+            controlLayer: {
+                neighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
+                connections: [normalizePeerDescriptor(otherPeerDescriptor), normalizePeerDescriptor(requestorPeerDescriptor)]
+            },
+            streamPartitions: [
+                {
+                    id: streamPartId1,
+                    controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
+                    deliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
+                },
+                {
+                    id: streamPartId2,
+                    controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
+                    deliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
+                }
+            ],
+            version: expect.any(String)
+        })
+        expect(result.streamPartitions.length).toEqual(2)
+    })
+
+})

package/test/integration/Propagation.test.ts

@@ -16,8 +16,8 @@ describe('Propagation', () => {
     const NUM_OF_NODES = 256
 
     beforeEach(async () => {
-        totalReceived = 0
         const simulator = new Simulator()
+        totalReceived = 0
         layer1Nodes = []
         randomGraphNodes = []
         const [entryPoint, node1] = await createMockRandomGraphNodeAndDhtNode(entryPointDescriptor, entryPointDescriptor, STREAM_PART_ID, simulator)
@@ -54,11 +54,11 @@ describe('Propagation', () => {
 
     it('All nodes receive messages', async () => {
         await waitForCondition(
-            () => randomGraphNodes.every((node) => node.getTargetNeighborIds().length >= 3), 30000
+            () => randomGraphNodes.every((node) => node.getNeighbors().length >= 3), 30000
         )
         await waitForCondition(() => {
             const avg = randomGraphNodes.reduce((acc, curr) => {
-                return acc + curr.getTargetNeighborIds().length
+                return acc + curr.getNeighbors().length
             }, 0) / randomGraphNodes.length
             return avg >= 4
         }, 20000)