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

package/test/unit/EntrypointDiscovery.test.ts

@@ -0,0 +1,132 @@
+import { PeerDescriptor, areEqualPeerDescriptors } from '@streamr/dht'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { wait } from '@streamr/utils'
+import { range } from 'lodash'
+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'
+import { createMockPeerDescriptor } from '../utils/utils'
+
+const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
+
+describe('EntryPointDiscovery', () => {
+
+    let entryPointDiscoveryWithData: EntryPointDiscovery
+    let entryPointDiscoveryWithoutData: EntryPointDiscovery
+    let storeCalled: number
+
+    const peerDescriptor = createMockPeerDescriptor()
+    const deletedPeerDescriptor = createMockPeerDescriptor()
+
+    const fakeData: DataEntry = {
+        data: Any.pack(peerDescriptor, PeerDescriptor),
+        ttl: 1000,
+        storer: peerDescriptor,
+        kademliaId: Uint8Array.from([1, 2, 3]),
+        stale: false,
+        deleted: false
+    }
+
+    const fakeDeletedData: DataEntry = {
+        data: Any.pack(deletedPeerDescriptor, PeerDescriptor),
+        ttl: 1000,
+        storer: deletedPeerDescriptor,
+        kademliaId: Uint8Array.from([1, 2, 3]),
+        stale: false,
+        deleted: true
+    }
+
+    const fakeGetEntryPointData = async (): Promise<DataEntry[]> => {
+        return [fakeData, fakeDeletedData]
+    }
+
+    const fakeStoreEntryPointData = async (): Promise<PeerDescriptor[]> => {
+        storeCalled++
+        return [peerDescriptor]
+    }
+
+    const fakeEmptyGetEntryPointData = async (): Promise<DataEntry[]> => {
+        return []
+    }
+
+    const fakeDeleteEntryPointData = async (): Promise<void> => {}
+
+    const addNodesToStreamPart = (layer1: MockLayer1, count: number) => {
+        range(count).forEach(() => {
+            layer1.addNewRandomPeerToKBucket()
+            layer1.addNewRandomPeerToKBucket()
+            layer1.addNewRandomPeerToKBucket()
+            layer1.addNewRandomPeerToKBucket()
+        })
+    } 
+
+    let layer1: MockLayer1
+
+    beforeEach(() => {
+        storeCalled = 0
+        layer1 = new MockLayer1()
+        entryPointDiscoveryWithData = new EntryPointDiscovery({
+            ownPeerDescriptor: peerDescriptor,
+            streamPartId: STREAM_PART_ID,
+            layer1,
+            getEntryPointData: fakeGetEntryPointData,
+            storeEntryPointData: fakeStoreEntryPointData,
+            deleteEntryPointData: fakeDeleteEntryPointData,
+            storeInterval: 2000
+        })
+        entryPointDiscoveryWithoutData = new EntryPointDiscovery({
+            ownPeerDescriptor: peerDescriptor,
+            streamPartId: STREAM_PART_ID,
+            layer1,
+            getEntryPointData: fakeEmptyGetEntryPointData,
+            storeEntryPointData: fakeStoreEntryPointData,
+            deleteEntryPointData: fakeDeleteEntryPointData,
+            storeInterval: 2000
+        })
+    })
+
+    afterEach(() => {
+        entryPointDiscoveryWithData.destroy()
+    })
+
+    it('discoverEntryPointsFromDht has known entrypoints', async () => {
+        const res = await entryPointDiscoveryWithData.discoverEntryPointsFromDht(1)
+        expect(res.entryPointsFromDht).toEqual(false)
+        expect(res.discoveredEntryPoints).toEqual([])
+    })
+
+    it('discoverEntryPointsFromDht does not have known entrypoints', async () => {
+        const res = await entryPointDiscoveryWithData.discoverEntryPointsFromDht(0)
+        expect(res.discoveredEntryPoints.length).toBe(1)
+        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(areEqualPeerDescriptors(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)  // ownPeerDescriptor
+    })
+
+    it('store on empty stream', async () => {
+        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
+        expect(storeCalled).toEqual(1)
+    })
+
+    it('store on stream without saturated entrypoint count', async () => {
+        addNodesToStreamPart(layer1, 4)
+        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
+        expect(storeCalled).toEqual(1)
+    })
+
+    it('will keep stored until destroyed', async () => {
+        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
+        expect(storeCalled).toEqual(1)
+        await wait(4500)
+        await entryPointDiscoveryWithData.destroy()
+        // 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)
     })
 })

package/test/unit/NodeList.test.ts

@@ -1,5 +1,5 @@
 import { NodeList } from '../../src/logic/NodeList'
-import { RemoteRandomGraphNode } from '../../src/logic/RemoteRandomGraphNode'
+import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
 import {
     PeerDescriptor,
     ListeningRpcCommunicator,
@@ -7,12 +7,16 @@ import {
     SimulatorTransport,
     NodeType,
 } from '@streamr/dht'
-import { NetworkRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { expect } from 'expect'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { createMockPeerDescriptor, createRandomNodeId } from '../utils/utils'
 import { binaryToHex } from '@streamr/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { formStreamPartDeliveryServiceId } from '../../src/logic/formStreamPartDeliveryServiceId'
+
+const streamPartId = StreamPartIDUtils.parse('stream#0')
 
 describe('NodeList', () => {
 
@@ -24,31 +28,36 @@ describe('NodeList', () => {
         new Uint8Array([1, 1, 5])
     ]
     const ownId = createRandomNodeId()
-    const graphId = 'test'
     let nodeList: NodeList
     let simulator: Simulator
     let mockTransports: SimulatorTransport[]
 
-    const createRemoteGraphNode = (peerDescriptor: PeerDescriptor) => {
+    const createRemoteGraphNode = async (peerDescriptor: PeerDescriptor) => {
         const mockTransport = new SimulatorTransport(peerDescriptor, simulator)
-        const mockCommunicator = new ListeningRpcCommunicator(`layer2-${ graphId }`, mockTransport)
+        await mockTransport.start()
+        const mockCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(streamPartId), mockTransport)
         const mockClient = mockCommunicator.getRpcClientTransport()
         
         mockTransports.push(mockTransport)
-        return new RemoteRandomGraphNode(createMockPeerDescriptor(), peerDescriptor, graphId, toProtoRpcClient(new NetworkRpcClient(mockClient)))
+        return new DeliveryRpcRemote(
+            createMockPeerDescriptor(),
+            peerDescriptor,
+            streamPartId,
+            toProtoRpcClient(new DeliveryRpcClient(mockClient))
+        )
     }
 
-    beforeEach(() => {
+    beforeEach(async () => {
         simulator = new Simulator()
         mockTransports = []
         nodeList = new NodeList(ownId, 6)
-        ids.forEach((id) => {
+        for (const id of ids) {
             const peerDescriptor: PeerDescriptor = {
                 kademliaId: id,
                 type: NodeType.NODEJS
             }
-            nodeList.add(createRemoteGraphNode(peerDescriptor))
-        })
+            nodeList.add(await createRemoteGraphNode(peerDescriptor))
+        }
     })
 
     afterEach(async ()=> {
@@ -59,12 +68,12 @@ describe('NodeList', () => {
         simulator.stop()
     })
 
-    it('add', () => {
+    it('add', async () => {
         const newDescriptor = {
             kademliaId: new Uint8Array([1, 2, 3]),
             type: NodeType.NODEJS
         }
-        const newNode = createRemoteGraphNode(newDescriptor)
+        const newNode = await createRemoteGraphNode(newDescriptor)
         nodeList.add(newNode)
         expect(nodeList.hasNode(newDescriptor)).toEqual(true)
 
@@ -72,7 +81,7 @@ describe('NodeList', () => {
             kademliaId: new Uint8Array([1, 2, 4]),
             type: NodeType.NODEJS
         }
-        const newNode2 = createRemoteGraphNode(newDescriptor2)
+        const newNode2 = await createRemoteGraphNode(newDescriptor2)
         nodeList.add(newNode2)
         expect(nodeList.hasNode(newDescriptor2)).toEqual(false)
     })

package/test/unit/{RemoteProxyServer.test.ts → ProxyConnectionRpcRemote.test.ts}

@@ -1,11 +1,11 @@
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary } from '@streamr/utils'
-import { RemoteProxyServer } from '../../src/logic/proxy/RemoteProxyServer'
+import { ProxyConnectionRpcRemote } from '../../src/logic/proxy/ProxyConnectionRpcRemote'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
-describe('RemoteProxyServer', () => {
+describe('ProxyConnectionRpcRemote', () => {
 
     it('happy path', () => {
         const client = {
@@ -13,14 +13,14 @@ describe('RemoteProxyServer', () => {
         }
         const clientPeerDescriptor = createMockPeerDescriptor()
         const serverPeerDescriptor = createMockPeerDescriptor()
-        const server = new RemoteProxyServer(
+        const rpcRemote = new ProxyConnectionRpcRemote(
             clientPeerDescriptor,
             serverPeerDescriptor,
             StreamPartIDUtils.parse('stream#0'),
             client
         )
         const userId = randomEthereumAddress()
-        server.requestConnection(ProxyDirection.PUBLISH, userId)
+        rpcRemote.requestConnection(ProxyDirection.PUBLISH, userId)
         expect(client.requestConnection).toBeCalledWith({
             direction: ProxyDirection.PUBLISH,
             userId: hexToBinary(userId)

package/test/unit/RandomGraphNode.test.ts

@@ -8,7 +8,8 @@ import { MockLayer1 } from '../utils/mock/MockLayer1'
 import { MockNeighborFinder } from '../utils/mock/MockNeighborFinder'
 import { MockNeighborUpdateManager } from '../utils/mock/MockNeighborUpdateManager'
 import { MockTransport } from '../utils/mock/Transport'
-import { createMockPeerDescriptor, createMockRemoteNode, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('RandomGraphNode', () => {
 
@@ -26,7 +27,7 @@ describe('RandomGraphNode', () => {
         targetNeighbors = new NodeList(nodeId, 10)
         randomNodeView = new NodeList(nodeId, 10)
         nearbyNodeView = new NodeList(nodeId, 10)
-        layer1 = new MockLayer1(nodeId)
+        layer1 = new MockLayer1()
 
         randomGraphNode = createRandomGraphNode({
             targetNeighbors,
@@ -39,7 +40,7 @@ describe('RandomGraphNode', () => {
             handshaker: new MockHandshaker(),
             neighborUpdateManager: new MockNeighborUpdateManager(),
             neighborFinder: new MockNeighborFinder(),
-            randomGraphId: 'random-graph'
+            streamPartId: StreamPartIDUtils.parse('stream#0')
         })
         await randomGraphNode.start()
     })
@@ -49,7 +50,7 @@ describe('RandomGraphNode', () => {
     })
 
     it('getTargetNeighborIds', () => {
-        const mockRemote = createMockRemoteNode()
+        const mockRemote = createMockDeliveryRpcRemote()
         targetNeighbors.add(mockRemote)
         const ids = randomGraphNode.getTargetNeighborIds()
         expect(ids[0]).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
@@ -57,7 +58,7 @@ describe('RandomGraphNode', () => {
     })
 
     it('getNearbyNodeView', () => {
-        const mockRemote = createMockRemoteNode()
+        const mockRemote = createMockDeliveryRpcRemote()
         nearbyNodeView.add(mockRemote)
         const ids = randomGraphNode.getNearbyNodeView().getIds()
         expect(ids[0]).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
@@ -68,8 +69,8 @@ describe('RandomGraphNode', () => {
         const peerDescriptor2 = createMockPeerDescriptor()
         layer1.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => nearbyNodeView.size() === 2)
-        expect(nearbyNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
+        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
     })
 
     it('Adds Random Nodes from layer1 newRandomContact event to randomNodeView', async () => {
@@ -77,8 +78,8 @@ describe('RandomGraphNode', () => {
         const peerDescriptor2 = createMockPeerDescriptor()
         layer1.emit('newRandomContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => randomNodeView.size() === 2)
-        expect(randomNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(randomNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
+        expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
     })
 
     it('Adds Nodes from layer1 KBucket to nearbyNodeView if its size is below nodeViewSize', async () => {
@@ -87,8 +88,8 @@ describe('RandomGraphNode', () => {
         layer1.addNewRandomPeerToKBucket()
         layer1.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => nearbyNodeView.size() === 3)
-        expect(nearbyNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
+        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
     })
 
 })

package/test/unit/StreamMessageTranslator.test.ts

@@ -3,26 +3,27 @@ import {
     MessageID,
     StreamMessage as OldStreamMessage,
     StreamMessageType as OldStreamMessageType,
-    StreamPartIDUtils,
-    toStreamID
+    StreamPartIDUtils
 } from '@streamr/protocol'
 import { binaryToHex, binaryToUtf8, hexToBinary, toEthereumAddress, utf8ToBinary } from '@streamr/utils'
 import { StreamMessageTranslator } from '../../src/logic/protocol-integration/stream-message/StreamMessageTranslator'
 import { StreamMessageType } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createStreamMessage } from '../utils/utils'
 
+const STREAM_PART_ID = StreamPartIDUtils.parse('TEST#0')
+
 describe('StreamMessageTranslator', () => {
 
     const publisherId = toEthereumAddress('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
     const signature = hexToBinary('0x1234')
     const protobufMsg = createStreamMessage(
         JSON.stringify({ hello: 'WORLD' }),
-        StreamPartIDUtils.parse('TEST#0'),
+        STREAM_PART_ID,
         publisherId
     )
     const messageId = new MessageID(
-        toStreamID('TEST'),
-        0,
+        StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+        StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
         Date.now(),
         0,
         publisherId,
@@ -39,10 +40,10 @@ describe('StreamMessageTranslator', () => {
 
     it('translates old protocol to protobuf', () => {
         const translated = StreamMessageTranslator.toProtobuf(oldProtocolMsg)
+        expect(translated.messageId!.streamId).toEqual(StreamPartIDUtils.getStreamID(STREAM_PART_ID))
+        expect(translated.messageId!.streamPartition).toEqual(StreamPartIDUtils.getStreamPartition(STREAM_PART_ID))
         expect(translated.messageId!.timestamp).toBeGreaterThanOrEqual(0)
         expect(translated.messageId!.sequenceNumber).toEqual(0)
-        expect(translated.messageId!.streamId).toEqual('TEST')
-        expect(translated.messageId!.streamPartition).toEqual(0)
         expect(binaryToHex(translated.messageId!.publisherId, true)).toEqual('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
         expect(translated.previousMessageRef).toEqual(undefined)
         expect(translated.messageType).toEqual(StreamMessageType.MESSAGE)
@@ -53,10 +54,10 @@ describe('StreamMessageTranslator', () => {
 
     it('translates protobuf to old protocol', () => {
         const translated = StreamMessageTranslator.toClientProtocol(protobufMsg)
+        expect(translated.messageId.streamId).toEqual(StreamPartIDUtils.getStreamID(STREAM_PART_ID))
+        expect(translated.messageId.streamPartition).toEqual(StreamPartIDUtils.getStreamPartition(STREAM_PART_ID))
         expect(translated.messageId.timestamp).toBeGreaterThanOrEqual(0)
         expect(translated.messageId.sequenceNumber).toEqual(0)
-        expect(translated.messageId.streamId).toEqual('TEST')
-        expect(translated.messageId.streamPartition).toEqual(0)
         expect(translated.getPublisherId()).toEqual('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
         expect(translated.prevMsgRef).toEqual(null)
         expect(translated.messageType).toEqual(OldStreamMessageType.MESSAGE)