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

package/test/integration/joining-streams-on-offline-peers.test.ts

@@ -1,42 +1,38 @@
 import { NodeType, PeerDescriptor, Simulator, SimulatorTransport, LatencyType } from '@streamr/dht'
 import { NetworkStack } from '../../src/NetworkStack'
-import { streamPartIdToDataKey } from '../../src/logic/StreamPartEntryPointDiscovery'
+import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { createStreamMessage } from '../utils/utils'
 import { waitForCondition } from '@streamr/utils'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
-describe('Joining streams on offline nodes', () => {
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
+const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
+
+describe('Joining stream parts on offline nodes', () => {
 
     const entryPointPeerDescriptor: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 2, 3]),
-        nodeName: 'entrypoint',
         type: NodeType.NODEJS
     }
 
     const node1PeerDescriptor: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 1, 1]),
-        nodeName: 'node1',
         type: NodeType.NODEJS
     }
 
     const node2PeerDescriptor: PeerDescriptor = {
         kademliaId: new Uint8Array([2, 2, 2]),
-        nodeName: 'node2',
         type: NodeType.NODEJS
     }
 
     const offlineDescriptor1: PeerDescriptor = {
         kademliaId: new Uint8Array([3, 3, 3]),
-        nodeName: 'offline',
         type: NodeType.NODEJS
     }
 
     const offlineDescriptor2: PeerDescriptor = {
         kademliaId: new Uint8Array([4, 4, 4]),
-        nodeName: 'offline',
         type: NodeType.NODEJS
     }
 
@@ -50,28 +46,30 @@ describe('Joining streams on offline nodes', () => {
         const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
         entryPoint = new NetworkStack({
             layer0: {
-                transportLayer: entryPointTransport,
+                transport: entryPointTransport,
                 peerDescriptor: entryPointPeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
         })
-
+        const node1Transport = new SimulatorTransport(node1PeerDescriptor, simulator)
         node1 = new NetworkStack({
             layer0: {
-                transportLayer: new SimulatorTransport(node1PeerDescriptor, simulator),
+                transport: node1Transport,
                 peerDescriptor: node1PeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
         })
-
+        const node2Transport = new SimulatorTransport(node2PeerDescriptor, simulator)
         node2 = new NetworkStack({
             layer0: {
-                transportLayer: new SimulatorTransport(node2PeerDescriptor, simulator),
+                transport: node2Transport,
                 peerDescriptor: node2PeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
         })
-
+        await entryPointTransport.start()
+        await node1Transport.start()
+        await node2Transport.start()
         await entryPoint.start()
         await node1.start()
         await node2.start()
@@ -88,12 +86,12 @@ describe('Joining streams on offline nodes', () => {
         let messageReceived = false
 
         // store offline peer descriptors to DHT
-        await entryPoint.getLayer0DhtNode().storeDataToDht(streamPartIdToDataKey(streamPartId), Any.pack(offlineDescriptor1, PeerDescriptor))
-        await entryPoint.getLayer0DhtNode().storeDataToDht(streamPartIdToDataKey(streamPartId), Any.pack(offlineDescriptor2, PeerDescriptor))
+        await entryPoint.getLayer0DhtNode().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor1, PeerDescriptor))
+        await entryPoint.getLayer0DhtNode().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor2, PeerDescriptor))
         
-        node1.getStreamrNode().joinStreamPart(streamPartId)
+        node1.getStreamrNode().joinStreamPart(STREAM_PART_ID)
         node1.getStreamrNode().on('newMessage', () => { messageReceived = true })
-        const msg = createStreamMessage(JSON.stringify({ hello: 'WORLD' }), streamPartId, randomEthereumAddress())
+        const msg = createStreamMessage(JSON.stringify({ hello: 'WORLD' }), STREAM_PART_ID, randomEthereumAddress())
         node2.getStreamrNode().broadcast(msg)
         await waitForCondition(() => messageReceived, 40000)
     }, 60000)

package/test/integration/stream-without-default-entrypoints.test.ts

@@ -4,13 +4,12 @@ import {
     MessageRef,
     StreamMessage,
     StreamMessageType,
-    StreamPartIDUtils,
-    toStreamID
+    StreamPartIDUtils
 } from '@streamr/protocol'
 import { EthereumAddress, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { streamPartIdToDataKey } from '../../src/logic/StreamPartEntryPointDiscovery'
+import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
@@ -22,14 +21,13 @@ describe('stream without default entrypoints', () => {
     let numOfReceivedMessages: number
     const entryPointPeerDescriptor: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 2, 3]),
-        nodeName: 'entrypoint',
         type: NodeType.NODEJS
     }
 
     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,
@@ -49,23 +47,23 @@ describe('stream without default entrypoints', () => {
         nodes = []
         numOfReceivedMessages = 0
         const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
+        await entryPointTransport.start()
         entrypoint = createNetworkNode({
             layer0: {
-                transportLayer: entryPointTransport,
+                transport: entryPointTransport,
                 peerDescriptor: entryPointPeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
         })
         await entrypoint.start()
-        await Promise.all(range(20).map(async (i) => {
-            const peerDescriptor = createMockPeerDescriptor({
-                nodeName: `${i}`
-            })
+        await Promise.all(range(20).map(async () => {
+            const peerDescriptor = createMockPeerDescriptor()
             const transport = new SimulatorTransport(peerDescriptor, simulator)
+            await transport.start()
             const node = createNetworkNode({
                 layer0: {
                     peerDescriptor,
-                    transportLayer: transport,
+                    transport,
                     entryPoints: [entryPointPeerDescriptor]
                 }
             })
@@ -122,7 +120,7 @@ describe('stream without default entrypoints', () => {
         }
         await waitForCondition(async () => {
             const entryPointData = await nodes[15].stack.getLayer0DhtNode().getDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
-            return entryPointData.dataEntries!.length >= 7
+            return entryPointData.length >= 7
         }, 15000)
         
     }, 90000)

package/test/unit/{StreamNodeServer.test.ts → DeliveryRpcLocal.test.ts}

@@ -1,14 +1,14 @@
 import { ListeningRpcCommunicator } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
-import { StreamNodeServer } from '../../src/logic/StreamNodeServer'
+import { DeliveryRpcLocal } from '../../src/logic/DeliveryRpcLocal'
 import { LeaveStreamPartNotice } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { MockTransport } from '../utils/mock/Transport'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
-describe('StreamNodeServer', () => {
+describe('DeliveryRpcLocal', () => {
 
-    let streamNodeServer: StreamNodeServer
+    let rpcLocal: DeliveryRpcLocal
     const peerDescriptor = createMockPeerDescriptor()
 
     const mockSender = createMockPeerDescriptor()
@@ -30,19 +30,19 @@ describe('StreamNodeServer', () => {
         mockOnLeaveNotice = jest.fn((_m) => {})
         mockMarkForInspection = jest.fn((_m) => {})
 
-        streamNodeServer = new StreamNodeServer({
+        rpcLocal = new DeliveryRpcLocal({
             markAndCheckDuplicate: mockDuplicateCheck,
             broadcast: mockBroadcast,
             onLeaveNotice: mockOnLeaveNotice,
             markForInspection: mockMarkForInspection,
             ownPeerDescriptor: peerDescriptor,
-            randomGraphId: 'random-graph',
+            streamPartId: StreamPartIDUtils.parse('stream#0'),
             rpcCommunicator: new ListeningRpcCommunicator('random-graph-node', new MockTransport())
         })
     })
     
     it('Server sendStreamMessage()', async () => {
-        await streamNodeServer.sendStreamMessage(message, { incomingSourceDescriptor: mockSender } as any)
+        await rpcLocal.sendStreamMessage(message, { incomingSourceDescriptor: mockSender } as any)
         expect(mockDuplicateCheck).toHaveBeenCalledTimes(1)
         expect(mockBroadcast).toHaveBeenCalledTimes(1)
         expect(mockMarkForInspection).toHaveBeenCalledTimes(1)
@@ -50,9 +50,9 @@ describe('StreamNodeServer', () => {
 
     it('Server leaveStreamPartNotice()', async () => {
         const leaveNotice: LeaveStreamPartNotice = {
-            randomGraphId: 'random-graph'
+            streamPartId: StreamPartIDUtils.parse('stream#0')
         }
-        await streamNodeServer.leaveStreamPartNotice(leaveNotice, { incomingSourceDescriptor: mockSender } as any)
+        await rpcLocal.leaveStreamPartNotice(leaveNotice, { incomingSourceDescriptor: mockSender } as any)
         expect(mockOnLeaveNotice).toHaveBeenCalledTimes(1)
     })
 

package/test/unit/{StreamPartEntrypointDiscovery.test.ts → EntrypointDiscovery.test.ts}

@@ -1,9 +1,8 @@
-import { PeerDescriptor, RecursiveFindResult, isSamePeerDescriptor } from '@streamr/dht'
+import { PeerDescriptor, areEqualPeerDescriptors } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { wait } from '@streamr/utils'
 import { range } from 'lodash'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
-import { StreamPartEntryPointDiscovery } from '../../src/logic/StreamPartEntryPointDiscovery'
+import { EntryPointDiscovery } from '../../src/logic/EntryPointDiscovery'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { DataEntry } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { MockLayer1 } from '../utils/mock/MockLayer1'
@@ -11,18 +10,14 @@ import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
 
-describe('StreamPartEntryPointDiscovery', () => {
+describe('EntryPointDiscovery', () => {
 
-    let entryPointDiscoveryWithData: StreamPartEntryPointDiscovery
-    let entryPointDiscoveryWithoutData: StreamPartEntryPointDiscovery
+    let entryPointDiscoveryWithData: EntryPointDiscovery
+    let entryPointDiscoveryWithoutData: EntryPointDiscovery
     let storeCalled: number
 
-    const peerDescriptor = createMockPeerDescriptor({
-        nodeName: 'fake'
-    })
-    const deletedPeerDescriptor = createMockPeerDescriptor({
-        nodeName: 'deleted'
-    })
+    const peerDescriptor = createMockPeerDescriptor()
+    const deletedPeerDescriptor = createMockPeerDescriptor()
 
     const fakeData: DataEntry = {
         data: Any.pack(peerDescriptor, PeerDescriptor),
@@ -42,32 +37,22 @@ describe('StreamPartEntryPointDiscovery', () => {
         deleted: true
     }
 
-    const fakeGetEntryPointData = async (_key: Uint8Array): Promise<RecursiveFindResult> => {
-        return {
-            closestNodes: [peerDescriptor],
-            dataEntries: [fakeData, fakeDeletedData]
-        }
-    }
-
-    const fakegetEntryPointDataViaNode = async (_key: Uint8Array, _node: PeerDescriptor): Promise<DataEntry[]> => {
-        return [fakeData]
+    const fakeGetEntryPointData = async (): Promise<DataEntry[]> => {
+        return [fakeData, fakeDeletedData]
     }
 
-    const fakeStoreEntryPointData = async (_key: Uint8Array, _data: Any): Promise<PeerDescriptor[]> => {
+    const fakeStoreEntryPointData = async (): Promise<PeerDescriptor[]> => {
         storeCalled++
         return [peerDescriptor]
     }
 
-    const fakeEmptyGetEntryPointData = async (_key: Uint8Array): Promise<RecursiveFindResult> => {
-        return {
-            closestNodes: [],
-            dataEntries: []
-        }
+    const fakeEmptyGetEntryPointData = async (): Promise<DataEntry[]> => {
+        return []
     }
 
-    const fakeDeleteEntryPointData = async (_key: Uint8Array): Promise<void> => {}
+    const fakeDeleteEntryPointData = async (): Promise<void> => {}
 
-    const addNodesToStream = (layer1: MockLayer1, count: number) => {
+    const addNodesToStreamPart = (layer1: MockLayer1, count: number) => {
         range(count).forEach(() => {
             layer1.addNewRandomPeerToKBucket()
             layer1.addNewRandomPeerToKBucket()
@@ -80,26 +65,24 @@ describe('StreamPartEntryPointDiscovery', () => {
 
     beforeEach(() => {
         storeCalled = 0
-        layer1 = new MockLayer1(getNodeIdFromPeerDescriptor(peerDescriptor))
-        entryPointDiscoveryWithData = new StreamPartEntryPointDiscovery({
+        layer1 = new MockLayer1()
+        entryPointDiscoveryWithData = new EntryPointDiscovery({
             ownPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
             layer1,
             getEntryPointData: fakeGetEntryPointData,
-            getEntryPointDataViaNode: fakegetEntryPointDataViaNode,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
-            cacheInterval: 2000
+            storeInterval: 2000
         })
-        entryPointDiscoveryWithoutData = new StreamPartEntryPointDiscovery({
+        entryPointDiscoveryWithoutData = new EntryPointDiscovery({
             ownPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
             layer1,
             getEntryPointData: fakeEmptyGetEntryPointData,
-            getEntryPointDataViaNode: fakegetEntryPointDataViaNode,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
-            cacheInterval: 2000
+            storeInterval: 2000
         })
     })
 
@@ -116,14 +99,14 @@ describe('StreamPartEntryPointDiscovery', () => {
     it('discoverEntryPointsFromDht does not have known entrypoints', async () => {
         const res = await entryPointDiscoveryWithData.discoverEntryPointsFromDht(0)
         expect(res.discoveredEntryPoints.length).toBe(1)
-        expect(isSamePeerDescriptor(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)
+        expect(areEqualPeerDescriptors(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)
     })
 
     it('discoverEntryPointsfromDht on an empty stream', async () => {
         const res = await entryPointDiscoveryWithoutData.discoverEntryPointsFromDht(0)
         expect(res.entryPointsFromDht).toEqual(true)
         expect(res.discoveredEntryPoints.length).toBe(1)
-        expect(isSamePeerDescriptor(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)  // ownPeerDescriptor
+        expect(areEqualPeerDescriptors(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)  // ownPeerDescriptor
     })
 
     it('store on empty stream', async () => {
@@ -132,7 +115,7 @@ describe('StreamPartEntryPointDiscovery', () => {
     })
 
     it('store on stream without saturated entrypoint count', async () => {
-        addNodesToStream(layer1, 4)
+        addNodesToStreamPart(layer1, 4)
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
     })
@@ -142,7 +125,7 @@ describe('StreamPartEntryPointDiscovery', () => {
         expect(storeCalled).toEqual(1)
         await wait(4500)
         await entryPointDiscoveryWithData.destroy()
-        // we have configured cacheInterval to 2 seconds, i.e. after 4.5 seconds it should have been called 2 more items 
+        // we have configured storeInterval to 2 seconds, i.e. after 4.5 seconds it should have been called 2 more items 
         expect(storeCalled).toEqual(3)
     })
 

package/test/unit/{HandshakerServer.test.ts → HandshakeRpcLocal.test.ts}

@@ -2,13 +2,16 @@ import { NodeType } from '@streamr/dht'
 import { hexToBinary } from '@streamr/utils'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { NodeList } from '../../src/logic/NodeList'
-import { HandshakerServer } from '../../src/logic/neighbor-discovery/HandshakerServer'
+import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
 import { InterleaveNotice, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor, createMockRemoteHandshaker, createMockRemoteNode, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, createMockHandshakeRpcRemote, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
-describe('HandshakerServer', () => {
+const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
 
-    let handshakerServer: HandshakerServer
+describe('HandshakeRpcLocal', () => {
+
+    let rpcLocal: HandshakeRpcLocal
 
     const ownPeerDescriptor = createMockPeerDescriptor()
 
@@ -22,28 +25,27 @@ describe('HandshakerServer', () => {
 
         handshakeWithInterleaving = jest.fn()
 
-        handshakerServer = new HandshakerServer({
-            randomGraphId: 'random-graph',
-            ownPeerDescriptor,
+        rpcLocal = new HandshakeRpcLocal({
+            streamPartId: STREAM_PART_ID,
             connectionLocker: mockConnectionLocker,
             ongoingHandshakes,
-            createRemoteHandshaker: (_p) => createMockRemoteHandshaker(),
-            createRemoteNode: (_p) => createMockRemoteNode(),
+            createRpcRemote: (_p) => createMockHandshakeRpcRemote(),
+            createDeliveryRpcRemote: (_p) => createMockDeliveryRpcRemote(),
             handshakeWithInterleaving: async (_p, _t) => {
                 handshakeWithInterleaving()
                 return true
             },
             targetNeighbors,
-            N: 4
+            maxNeighborCount: 4
         })
     })
 
     it('handshake', async () => {
         const req = StreamPartHandshakeRequest.create({
-            randomGraphId: 'random-graph',
+            streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
         })
-        const res = await handshakerServer.handshake(req, {
+        const res = await rpcLocal.handshake(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(res.accepted).toEqual(true)
@@ -52,15 +54,15 @@ describe('HandshakerServer', () => {
     })
 
     it('handshake interleave', async () => {
-        targetNeighbors.add(createMockRemoteNode())
-        targetNeighbors.add(createMockRemoteNode())
-        targetNeighbors.add(createMockRemoteNode())
-        targetNeighbors.add(createMockRemoteNode())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
         const req = StreamPartHandshakeRequest.create({
-            randomGraphId: 'random-graph',
+            streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
         })
-        const res = await handshakerServer.handshake(req, {
+        const res = await rpcLocal.handshake(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(res.accepted).toEqual(true)
@@ -73,10 +75,10 @@ describe('HandshakerServer', () => {
         ongoingHandshakes.add('0x4444' as NodeID)
         ongoingHandshakes.add('0x5555' as NodeID)
         const req = StreamPartHandshakeRequest.create({
-            randomGraphId: 'random-graph',
+            streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
         })
-        const res = await handshakerServer.handshake(req, {
+        const res = await rpcLocal.handshake(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(res.accepted).toEqual(false)
@@ -84,14 +86,14 @@ describe('HandshakerServer', () => {
 
     it('handshakeWithInterleaving success', async () => {
         const req: InterleaveNotice = {
-            randomGraphId: 'random-graph',
+            streamPartId: STREAM_PART_ID,
             interleaveTargetDescriptor: {
                 kademliaId: hexToBinary('0x2222'),
                 type: NodeType.NODEJS
             }
 
         }
-        await handshakerServer.interleaveNotice(req, {
+        await rpcLocal.interleaveNotice(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
@@ -99,13 +101,13 @@ describe('HandshakerServer', () => {
 
     it('handshakeWithInterleaving success', async () => {
         const req: InterleaveNotice = {
-            randomGraphId: 'wrong-random-graph',
+            streamPartId: StreamPartIDUtils.parse('other-stream#0'),
             interleaveTargetDescriptor: {
                 kademliaId: hexToBinary('0x2222'),
                 type: NodeType.NODEJS
             }
         }
-        await handshakerServer.interleaveNotice(req, {
+        await rpcLocal.interleaveNotice(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(0)

package/test/unit/Handshaker.test.ts

@@ -3,15 +3,16 @@ import { range } from 'lodash'
 import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { NodeList } from '../../src/logic/NodeList'
 import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
-import { createMockPeerDescriptor, createMockRemoteNode, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Handshaker', () => {
 
     let handshaker: Handshaker
     const peerDescriptor = createMockPeerDescriptor()
 
-    const N = 4
-    const stream = 'stream#0'
+    const maxNeighborCount = 4
+    const streamPartId = StreamPartIDUtils.parse('stream#0')
 
     let targetNeighbors: NodeList
     let nearbyNodeView: NodeList
@@ -20,10 +21,11 @@ describe('Handshaker', () => {
     let simulator: Simulator
     let simulatorTransport: SimulatorTransport
     
-    beforeEach(() => {
+    beforeEach(async () => {
         simulator = new Simulator()
         simulatorTransport = new SimulatorTransport(peerDescriptor, simulator)
-        const rpcCommunicator = new ListeningRpcCommunicator(stream, simulatorTransport)
+        await simulatorTransport.start()
+        const rpcCommunicator = new ListeningRpcCommunicator(streamPartId, simulatorTransport)
 
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         targetNeighbors = new NodeList(nodeId, 10)
@@ -32,13 +34,13 @@ describe('Handshaker', () => {
 
         handshaker = new Handshaker({
             ownPeerDescriptor: peerDescriptor,
-            randomGraphId: stream,
+            streamPartId,
             connectionLocker: mockConnectionLocker,
             targetNeighbors,
             nearbyNodeView,
             randomNodeView,
             rpcCommunicator,
-            N
+            maxNeighborCount
         })
     })
 
@@ -53,7 +55,7 @@ describe('Handshaker', () => {
     })
 
     it('attemptHandshakesOnContact with known nodes that cannot be connected to', async () => {
-        range(2).forEach(() => nearbyNodeView.add(createMockRemoteNode()))
+        range(2).forEach(() => nearbyNodeView.add(createMockDeliveryRpcRemote()))
         const res = await handshaker.attemptHandshakesOnContacts([])
         expect(res.length).toEqual(2)
     })

package/test/unit/Inspector.test.ts

@@ -1,9 +1,10 @@
-import { ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
+import { ListeningRpcCommunicator } from '@streamr/dht'
 import { utf8ToBinary } from '@streamr/utils'
 import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { Inspector } from '../../src/logic/inspect/Inspector'
 import { MockTransport } from '../utils/mock/Transport'
 import { createMockPeerDescriptor, createRandomNodeId, mockConnectionLocker } from '../utils/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Inspector', () => {
     
@@ -28,10 +29,10 @@ describe('Inspector', () => {
         mockConnect = jest.fn(() => {})
         inspector = new Inspector({
             ownPeerDescriptor: inspectorDescriptor,
-            graphId: 'test',
+            streamPartId: StreamPartIDUtils.parse('stream#0'),
             rpcCommunicator: new ListeningRpcCommunicator('inspector', new MockTransport()),
             connectionLocker: mockConnectionLocker,
-            openInspectConnection: async (_peerDescriptor: PeerDescriptor, _lockId: string) => mockConnect()
+            openInspectConnection: async () => mockConnect()
         })
     })
 

package/test/unit/NeighborFinder.test.ts

@@ -3,7 +3,7 @@ import { NodeList } from '../../src/logic/NodeList'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { expect } from 'expect'
-import { createMockRemoteNode, createRandomNodeId } from '../utils/utils'
+import { createMockDeliveryRpcRemote, createRandomNodeId } from '../utils/utils'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 describe('NeighborFinder', () => {
@@ -13,12 +13,12 @@ describe('NeighborFinder', () => {
     let nearbyNodeView: NodeList
     let neighborFinder: NeighborFinder
 
-    const N = 4
+    const minCount = 4
 
     beforeEach(() => {
         targetNeighbors = new NodeList(nodeId, 15)
         nearbyNodeView = new NodeList(nodeId, 30)
-        range(30).forEach(() => nearbyNodeView.add(createMockRemoteNode()))
+        range(30).forEach(() => nearbyNodeView.add(createMockDeliveryRpcRemote()))
         const mockDoFindNeighbors = async (excluded: NodeID[]) => {
             const target = nearbyNodeView.getRandom(excluded)
             if (Math.random() < 0.5) {
@@ -32,7 +32,7 @@ describe('NeighborFinder', () => {
             targetNeighbors,
             nearbyNodeView,
             doFindNeighbors: (excluded) => mockDoFindNeighbors(excluded),
-            N
+            minCount
         })
     })
 
@@ -42,7 +42,7 @@ describe('NeighborFinder', () => {
 
     it('Finds target number of nodes', async () => {
         neighborFinder.start()
-        await waitForCondition(() => targetNeighbors.size() >= N, 10000)
+        await waitForCondition(() => targetNeighbors.size() >= minCount, 10000)
         expect(neighborFinder.isRunning()).toEqual(false)
     })
 })