@streamr/trackerless-network 100.0.0-testnet-one.4 → 100.0.0-testnet-two.0

package/test/unit/HandshakeRpcLocal.test.ts

@@ -3,7 +3,7 @@ import { hexToBinary } from '@streamr/utils'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { NodeList } from '../../src/logic/NodeList'
 import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
-import { InterleaveNotice, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { InterleaveRequest, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor, createMockHandshakeRpcRemote, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
@@ -17,18 +17,20 @@ describe('HandshakeRpcLocal', () => {
 
     let targetNeighbors: NodeList
     let ongoingHandshakes: Set<NodeID>
+    let ongoingInterleaves: Set<NodeID>
     let handshakeWithInterleaving: jest.Mock
 
     beforeEach(() => {
         targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), 10)
         ongoingHandshakes = new Set()
-
+        ongoingInterleaves = new Set()
         handshakeWithInterleaving = jest.fn()
 
         rpcLocal = new HandshakeRpcLocal({
             streamPartId: STREAM_PART_ID,
             connectionLocker: mockConnectionLocker,
             ongoingHandshakes,
+            ongoingInterleaves,
             createRpcRemote: (_p) => createMockHandshakeRpcRemote(),
             createDeliveryRpcRemote: (_p) => createMockDeliveryRpcRemote(),
             handshakeWithInterleaving: async (_p, _t) => {
@@ -85,31 +87,67 @@ describe('HandshakeRpcLocal', () => {
     })
 
     it('handshakeWithInterleaving success', async () => {
-        const req: InterleaveNotice = {
-            streamPartId: STREAM_PART_ID,
+        const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
                 nodeId: hexToBinary('0x2222'),
                 type: NodeType.NODEJS
             }
-
         }
-        await rpcLocal.interleaveNotice(req, {
+        await rpcLocal.interleaveRequest(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
     })
 
     it('handshakeWithInterleaving success', async () => {
-        const req: InterleaveNotice = {
-            streamPartId: StreamPartIDUtils.parse('other-stream#0'),
+        const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
                 nodeId: hexToBinary('0x2222'),
                 type: NodeType.NODEJS
             }
         }
-        await rpcLocal.interleaveNotice(req, {
+        await rpcLocal.interleaveRequest(req, {
+            incomingSourceDescriptor: createMockPeerDescriptor()
+        } as any)
+        expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
+    })
+
+    it('rejects handshakes if interleaving to the requestor is ongoing', async () => {
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        const requestor = createMockPeerDescriptor()
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(requestor))
+        const req = StreamPartHandshakeRequest.create({
+            streamPartId: STREAM_PART_ID,
+            requestId: 'requestId'
+        })
+        const res = await rpcLocal.handshake(req, {
+            incomingSourceDescriptor: requestor
+        } as any)
+        expect(res.accepted).toEqual(false)
+    })
+
+    it('Rejects if interleaving is required and too many interleaving requests are ongoing', async () => {
+        const interleavingPeer1 = createMockPeerDescriptor()
+        const interleavingPeer2 = createMockPeerDescriptor()
+        const interleavingPeer3 = createMockPeerDescriptor()
+        targetNeighbors.add(createMockDeliveryRpcRemote(interleavingPeer1))
+        targetNeighbors.add(createMockDeliveryRpcRemote(interleavingPeer2))
+        targetNeighbors.add(createMockDeliveryRpcRemote(interleavingPeer3))
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer1))
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer2))
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer3))
+        const req = StreamPartHandshakeRequest.create({
+            streamPartId: STREAM_PART_ID,
+            requestId: 'requestId'
+        })
+        const res = await rpcLocal.handshake(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
+        expect(res.accepted).toEqual(false)
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(0)
     })
 

package/test/unit/NodeList.test.ts

@@ -1,20 +1,19 @@
-import { NodeList } from '../../src/logic/NodeList'
-import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
 import {
-    PeerDescriptor,
     ListeningRpcCommunicator,
+    NodeType,
+    PeerDescriptor,
     Simulator,
     SimulatorTransport,
-    NodeType,
 } from '@streamr/dht'
-import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { binaryToHex } from '@streamr/utils'
 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 { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
+import { NodeList } from '../../src/logic/NodeList'
 import { formStreamPartDeliveryServiceId } from '../../src/logic/formStreamPartDeliveryServiceId'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { createMockPeerDescriptor, createRandomNodeId } from '../utils/utils'
 
 const streamPartId = StreamPartIDUtils.parse('stream#0')
 
@@ -36,14 +35,13 @@ describe('NodeList', () => {
         const mockTransport = new SimulatorTransport(peerDescriptor, simulator)
         await mockTransport.start()
         const mockCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(streamPartId), mockTransport)
-        const mockClient = mockCommunicator.getRpcClientTransport()
-        
         mockTransports.push(mockTransport)
         return new DeliveryRpcRemote(
             createMockPeerDescriptor(),
             peerDescriptor,
             streamPartId,
-            toProtoRpcClient(new DeliveryRpcClient(mockClient))
+            mockCommunicator,
+            DeliveryRpcClient
         )
     }
 

package/test/unit/ProxyConnectionRpcRemote.test.ts

@@ -1,30 +1,38 @@
+import { RpcCommunicator } from '@streamr/proto-rpc'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary } from '@streamr/utils'
 import { ProxyConnectionRpcRemote } from '../../src/logic/proxy/ProxyConnectionRpcRemote'
-import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyConnectionRequest, ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyConnectionRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('ProxyConnectionRpcRemote', () => {
 
-    it('happy path', () => {
-        const client = {
-            requestConnection: jest.fn()
-        }
+    it('happy path', async () => {
+        const onOutgoingMessage = jest.fn()
+        const rpcCommunicator = new RpcCommunicator()
+        rpcCommunicator.setOutgoingMessageListener(onOutgoingMessage)
         const clientPeerDescriptor = createMockPeerDescriptor()
         const serverPeerDescriptor = createMockPeerDescriptor()
         const rpcRemote = new ProxyConnectionRpcRemote(
             clientPeerDescriptor,
             serverPeerDescriptor,
             StreamPartIDUtils.parse('stream#0'),
-            client
+            rpcCommunicator,
+            ProxyConnectionRpcClient
         )
+
         const userId = randomEthereumAddress()
-        rpcRemote.requestConnection(ProxyDirection.PUBLISH, userId)
-        expect(client.requestConnection).toBeCalledWith({
+        await rpcRemote.requestConnection(ProxyDirection.PUBLISH, userId)
+
+        const [rpcMessage, _, callContext] = onOutgoingMessage.mock.calls[0]
+        const request = ProxyConnectionRequest.fromBinary(rpcMessage.body.value)
+        expect(request).toEqual({
             direction: ProxyDirection.PUBLISH,
-            userId: hexToBinary(userId)
-        }, {
+            userId: Uint8Array.from(hexToBinary(userId))
+        })
+        expect(callContext).toMatchObject({
             sourceDescriptor: clientPeerDescriptor,
             targetDescriptor: serverPeerDescriptor,
             timeout: 5000

package/test/unit/RandomGraphNode.test.ts

@@ -38,10 +38,12 @@ describe('RandomGraphNode', () => {
             localPeerDescriptor: peerDescriptor,
             layer1Node,
             connectionLocker: mockConnectionLocker,
-            handshaker: new MockHandshaker(),
-            neighborUpdateManager: new MockNeighborUpdateManager(),
-            neighborFinder: new MockNeighborFinder(),
-            streamPartId: StreamPartIDUtils.parse('stream#0')
+            handshaker: new MockHandshaker() as any,
+            neighborUpdateManager: new MockNeighborUpdateManager() as any,
+            neighborFinder: new MockNeighborFinder() as any,
+            streamPartId: StreamPartIDUtils.parse('stream#0'),
+            isLocalNodeEntryPoint: () => false
+
         })
         await randomGraphNode.start()
     })

package/test/utils/mock/MockHandshaker.ts

@@ -1,7 +1,8 @@
+import { Methods } from '@streamr/test-utils'
 import { NodeID } from '../../../src/identifiers'
-import { IHandshaker } from '../../../src/logic/neighbor-discovery/Handshaker'
+import { Handshaker } from '../../../src/logic/neighbor-discovery/Handshaker'
 
-export class MockHandshaker implements IHandshaker {
+export class MockHandshaker implements Methods<Handshaker> {
 
     // eslint-disable-next-line class-methods-use-this
     getOngoingHandshakes(): Set<NodeID> {

package/test/utils/mock/MockNeighborFinder.ts

@@ -1,6 +1,7 @@
-import { INeighborFinder } from '../../../src/logic/neighbor-discovery/NeighborFinder'
+import { Methods } from '@streamr/test-utils'
+import { NeighborFinder } from '../../../src/logic/neighbor-discovery/NeighborFinder'
 
-export class MockNeighborFinder implements INeighborFinder {
+export class MockNeighborFinder implements Methods<NeighborFinder> {
 
     // eslint-disable-next-line class-methods-use-this
     start(): void {

package/test/utils/mock/MockNeighborUpdateManager.ts

@@ -1,7 +1,8 @@
-import { INeighborUpdateManager } from '../../../src/logic/neighbor-discovery/NeighborUpdateManager'
+import { Methods } from '@streamr/test-utils'
+import { NeighborUpdateManager } from '../../../src/logic/neighbor-discovery/NeighborUpdateManager'
 import { NeighborUpdate } from '../../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 
-export class MockNeighborUpdateManager implements INeighborUpdateManager {
+export class MockNeighborUpdateManager implements Methods<NeighborUpdateManager> {
 
     // eslint-disable-next-line class-methods-use-this
     async start(): Promise<void> {

package/test/utils/utils.ts

@@ -16,6 +16,8 @@ import { EthereumAddress, hexToBinary, utf8ToBinary } from '@streamr/utils'
 import { StreamPartID, StreamPartIDUtils } from '@streamr/protocol'
 import { NodeID } from '../../src/identifiers'
 import { Layer1Node } from '../../src/logic/Layer1Node'
+import { DeliveryRpcClient, HandshakeRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { RpcCommunicator } from '@streamr/proto-rpc'
 
 export const mockConnectionLocker: ConnectionLocker = {
     lockConnection: () => {},
@@ -45,7 +47,8 @@ export const createMockRandomGraphNodeAndDhtNode = async (
         layer1Node,
         connectionLocker: mockCm,
         localPeerDescriptor,
-        rpcRequestTimeout: 5000
+        rpcRequestTimeout: 5000,
+        isLocalNodeEntryPoint: () => false
     })
     return [layer1Node, randomGraphNode]
 }
@@ -90,7 +93,13 @@ export const createMockPeerDescriptor = (opts?: Omit<Partial<PeerDescriptor>, 'n
 }
 
 export const createMockDeliveryRpcRemote = (remotePeerDescriptor?: PeerDescriptor): DeliveryRpcRemote => {
-    return new DeliveryRpcRemote(createMockPeerDescriptor(), remotePeerDescriptor ?? createMockPeerDescriptor(), 'mock', {} as any)
+    return new DeliveryRpcRemote(
+        createMockPeerDescriptor(),
+        remotePeerDescriptor ?? createMockPeerDescriptor(),
+        'mock',
+        new RpcCommunicator(),
+        DeliveryRpcClient
+    )
 }
 
 export const createMockHandshakeRpcRemote = (): HandshakeRpcRemote => {
@@ -98,19 +107,18 @@ export const createMockHandshakeRpcRemote = (): HandshakeRpcRemote => {
         createMockPeerDescriptor(),
         createMockPeerDescriptor(), 
         'mock',
-        {
-            handshake: async () => {},
-            interleaveNotice: async () => {}
-        } as any
+        new RpcCommunicator(),
+        HandshakeRpcClient
     )
 }
 
-export const createNetworkNodeWithSimulator = (
+export const createNetworkNodeWithSimulator = async (
     peerDescriptor: PeerDescriptor,
     simulator: Simulator,
     entryPoints: PeerDescriptor[]
-): NetworkNode => {
+): Promise<NetworkNode> => {
     const transport = new SimulatorTransport(peerDescriptor, simulator)
+    await transport.start()
     return createNetworkNode({
         layer0: {
             peerDescriptor,