@streamr/trackerless-network 100.0.0-testnet-three.6 → 100.1.0

package/test/integration/ContentDeliveryManager.test.ts

@@ -0,0 +1,135 @@
+import {
+    DhtNode,
+    Simulator,
+    SimulatorTransport
+} from '@streamr/dht'
+import { ContentDeliveryManager, Events } from '../../src/logic/ContentDeliveryManager'
+import { waitForEvent3, waitForCondition } from '@streamr/utils'
+import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { randomEthereumAddress } from '@streamr/test-utils'
+import { Layer0Node } from '../../src/logic/Layer0Node'
+
+describe('ContentDeliveryManager', () => {
+
+    let layer0Node1: Layer0Node
+    let layer0Node2: Layer0Node
+    let transport1: SimulatorTransport
+    let transport2: SimulatorTransport
+    let manager1: ContentDeliveryManager
+    let manager2: ContentDeliveryManager
+
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
+    const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
+
+    const msg = createStreamMessage(
+        JSON.stringify({ hello: 'WORLD' }),
+        STREAM_PART_ID,
+        randomEthereumAddress()
+    )
+
+    afterEach(async () => {
+        await Promise.all([
+            manager1.destroy(),
+            manager2.destroy()
+        ])
+    })
+
+    beforeEach(async () => {
+        const simulator = new Simulator()
+        transport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        await transport1.start()
+        transport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        await transport2.start()
+        layer0Node1 = new DhtNode({
+            transport: transport1,
+            peerDescriptor: peerDescriptor1,
+            entryPoints: [peerDescriptor1]
+        })
+        layer0Node2 = new DhtNode({
+            transport: transport2,
+            peerDescriptor: peerDescriptor2,
+            entryPoints: [peerDescriptor1]
+        })
+        await Promise.all([
+            layer0Node1.start(),
+            layer0Node2.start()
+        ])
+        await Promise.all([
+            layer0Node1.joinDht([peerDescriptor1]),
+            layer0Node2.joinDht([peerDescriptor1])
+        ])
+
+        manager1 = new ContentDeliveryManager({})
+        manager2 = new ContentDeliveryManager({})
+        await manager1.start(layer0Node1, transport1, transport1)
+        manager1.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
+        await manager2.start(layer0Node2, transport2, transport2)
+        manager2.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
+    })
+
+    it('starts', async () => {
+        expect(manager1.getPeerDescriptor()).toEqual(peerDescriptor1)
+        expect(manager2.getPeerDescriptor()).toEqual(peerDescriptor2)
+    })
+
+    it('Joining stream', async () => {
+        manager1.joinStreamPart(STREAM_PART_ID)
+        manager2.joinStreamPart(STREAM_PART_ID)
+        await waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 1)
+        await waitForCondition(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
+        expect(manager1.getNeighbors(STREAM_PART_ID).length).toEqual(1)
+        expect(manager2.getNeighbors(STREAM_PART_ID).length).toEqual(1)
+    })
+
+    it('Publishing after joining and waiting for neighbors', async () => {
+        manager1.joinStreamPart(STREAM_PART_ID)
+        manager2.joinStreamPart(STREAM_PART_ID)
+        await waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 1)
+        await waitForCondition(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
+        await Promise.all([
+            waitForEvent3<Events>(manager1, 'newMessage'),
+            manager2.broadcast(msg)
+        ])
+    })
+
+    it('multi-stream pub/sub', async () => {
+        const streamPartId2 = StreamPartIDUtils.parse('test2#0')
+        manager1.setStreamPartEntryPoints(streamPartId2, [peerDescriptor1])
+        manager2.setStreamPartEntryPoints(streamPartId2, [peerDescriptor1])
+        manager1.joinStreamPart(STREAM_PART_ID)
+        manager1.joinStreamPart(streamPartId2)
+        manager2.joinStreamPart(STREAM_PART_ID)
+        manager2.joinStreamPart(streamPartId2)
+        await Promise.all([
+            waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 1),
+            waitForCondition(() => manager2.getNeighbors(STREAM_PART_ID).length === 1),
+            waitForCondition(() => manager1.getNeighbors(streamPartId2).length === 1),
+            waitForCondition(() => manager2.getNeighbors(streamPartId2).length === 1)
+        ])
+        const msg2 = createStreamMessage(
+            JSON.stringify({ hello: 'WORLD' }),
+            streamPartId2,
+            randomEthereumAddress()
+        )
+        await Promise.all([
+            waitForEvent3<Events>(manager1, 'newMessage'),
+            waitForEvent3<Events>(manager2, 'newMessage'),
+            manager1.broadcast(msg2),
+            manager2.broadcast(msg)
+        ])
+    })
+
+    it('leaving stream parts', async () => {
+        manager1.joinStreamPart(STREAM_PART_ID)
+        manager2.joinStreamPart(STREAM_PART_ID)
+        await Promise.all([
+            waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 1),
+            waitForCondition(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
+        ])
+        await manager2.leaveStreamPart(STREAM_PART_ID)
+        await waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 0)
+    })
+
+})

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

@@ -5,8 +5,8 @@ import {
     SimulatorTransport,
     NodeType
 } from '@streamr/dht'
-import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
-import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
+import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import {
     LeaveStreamPartNotice,
     StreamMessage
@@ -17,10 +17,10 @@ import { createStreamMessage } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
-describe('DeliveryRpcRemote', () => {
+describe('ContentDeliveryRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
     let clientRpc: ListeningRpcCommunicator
-    let rpcRemote: DeliveryRpcRemote
+    let rpcRemote: ContentDeliveryRpcRemote
 
     const clientNode: PeerDescriptor = {
         nodeId: new Uint8Array([1, 1, 1]),
@@ -66,11 +66,11 @@ describe('DeliveryRpcRemote', () => {
             }
         )
 
-        rpcRemote = new DeliveryRpcRemote(
+        rpcRemote = new ContentDeliveryRpcRemote(
             clientNode,
             serverNode,
             clientRpc,
-            DeliveryRpcClient
+            ContentDeliveryRpcClient
         )
     })
 

package/test/integration/Handshakes.test.ts

@@ -11,7 +11,6 @@ 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 { StreamPartIDUtils } from '@streamr/protocol'
@@ -33,8 +32,10 @@ describe('Handshakes', () => {
     let rpcCommunicator1: ListeningRpcCommunicator
     let rpcCommunicator2: ListeningRpcCommunicator
     let rpcCommunicator3: ListeningRpcCommunicator
-    let nodeView: NodeList
     let neighbors: NodeList
+    let leftNodeView: NodeList
+    let rightNodeView: NodeList
+    let nodeView: NodeList
     let handshaker: Handshaker
     const streamPartId = StreamPartIDUtils.parse('stream#0')
 
@@ -82,6 +83,8 @@ 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)
         neighbors = new NodeList(handshakerNodeId, 4)
         handshaker = new Handshaker({
@@ -89,8 +92,9 @@ describe('Handshakes', () => {
             streamPartId,
             nearbyNodeView: nodeView,
             randomNodeView: nodeView,
+            leftNodeView,
+            rightNodeView,
             neighbors,
-            connectionLocker: mockConnectionLocker,
             rpcCommunicator: rpcCommunicator2,
             maxNeighborCount: 4,
             ongoingHandshakes: new Set()

package/test/integration/Inspect.test.ts

@@ -75,12 +75,12 @@ describe('inspect', () => {
                 123123,
                 sequenceNumber
             )
-            publisherNode.getStreamrNode().broadcast(msg)
+            publisherNode.getContentDeliveryManager().broadcast(msg)
             sequenceNumber += 1
         }, 200)
 
         for (const node of inspectedNodes) {
-            const result = await inspectorNode.getStreamrNode().inspect(node.getLayer0Node().getLocalPeerDescriptor(), streamPartId)
+            const result = await inspectorNode.getContentDeliveryManager().inspect(node.getLayer0Node().getLocalPeerDescriptor(), streamPartId)
             expect(result).toEqual(true)
         }
     }, 25000)

package/test/integration/NetworkRpc.test.ts

@@ -3,7 +3,7 @@ import {
     ProtoRpcClient,
     toProtoRpcClient
 } from '@streamr/proto-rpc'
-import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { waitForCondition } from '@streamr/utils'
 import { Empty } from '../../src/proto/google/protobuf/empty'
@@ -16,7 +16,7 @@ import { randomEthereumAddress } from '@streamr/test-utils'
 describe('Network RPC', () => {
     let rpcCommunicator1: RpcCommunicator<DhtCallContext>
     let rpcCommunicator2: RpcCommunicator<DhtCallContext>
-    let client: ProtoRpcClient<DeliveryRpcClient>
+    let client: ProtoRpcClient<ContentDeliveryRpcClient>
     let recvCounter = 0
 
     beforeEach(() => {
@@ -25,7 +25,7 @@ describe('Network RPC', () => {
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
         })
-        client = toProtoRpcClient(new DeliveryRpcClient(rpcCommunicator1.getRpcClientTransport()))
+        client = toProtoRpcClient(new ContentDeliveryRpcClient(rpcCommunicator1.getRpcClientTransport()))
         rpcCommunicator2.registerRpcNotification(
             StreamMessage,
             'sendStreamMessage',

package/test/integration/NetworkStack.test.ts

@@ -34,9 +34,9 @@ describe('NetworkStack', () => {
         })
 
         await stack1.start()
-        stack1.getStreamrNode().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
+        stack1.getContentDeliveryManager().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
         await stack2.start()
-        stack2.getStreamrNode().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
+        stack2.getContentDeliveryManager().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
     })
 
     afterEach(async () => {
@@ -48,8 +48,8 @@ describe('NetworkStack', () => {
 
     it('Can use NetworkNode pub/sub via NetworkStack', async () => {
         let receivedMessages = 0
-        stack1.getStreamrNode().joinStreamPart(STREAM_PART_ID)
-        stack1.getStreamrNode().on('newMessage', () => {
+        stack1.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
+        stack1.getContentDeliveryManager().on('newMessage', () => {
             receivedMessages += 1
         })
         const msg = createStreamMessage(
@@ -57,7 +57,7 @@ describe('NetworkStack', () => {
             STREAM_PART_ID,
             randomEthereumAddress()
         )
-        stack2.getStreamrNode().broadcast(msg)
+        stack2.getContentDeliveryManager().broadcast(msg)
         await waitForCondition(() => receivedMessages === 1)
     })
 
@@ -66,7 +66,7 @@ describe('NetworkStack', () => {
             stack1.joinStreamPart(STREAM_PART_ID, { minCount: 1, timeout: 5000 }),
             stack2.joinStreamPart(STREAM_PART_ID, { minCount: 1, timeout: 5000 }),
         ])
-        expect(stack1.getStreamrNode().getNeighbors(STREAM_PART_ID).length).toBe(1)
-        expect(stack2.getStreamrNode().getNeighbors(STREAM_PART_ID).length).toBe(1)
+        expect(stack1.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length).toBe(1)
+        expect(stack2.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length).toBe(1)
     })
 })

package/test/integration/NodeInfoRpc.test.ts

@@ -67,15 +67,15 @@ describe('NetworkStack NodeInfoRpc', () => {
     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)
+        requesteStack.getContentDeliveryManager().joinStreamPart(streamPartId1)
+        otherStack.getContentDeliveryManager().joinStreamPart(streamPartId1)
+        requesteStack.getContentDeliveryManager().joinStreamPart(streamPartId2)
+        otherStack.getContentDeliveryManager().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
+            requesteStack.getContentDeliveryManager().getNeighbors(streamPartId1).length === 1 
+            && otherStack.getContentDeliveryManager().getNeighbors(streamPartId1).length === 1
+            && requesteStack.getContentDeliveryManager().getNeighbors(streamPartId2).length === 1
+            && otherStack.getContentDeliveryManager().getNeighbors(streamPartId2).length === 1
         )
         const result = await nodeInfoClient.getInfo(requesteePeerDescriptor)
         expect(result).toMatchObject({
@@ -88,12 +88,12 @@ describe('NetworkStack NodeInfoRpc', () => {
                 {
                     id: streamPartId1,
                     controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
-                    deliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
+                    contentDeliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
                 },
                 {
                     id: streamPartId2,
                     controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
-                    deliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
+                    contentDeliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
                 }
             ],
             version: expect.any(String)

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

@@ -70,10 +70,10 @@ describe('Joining stream parts on offline nodes', () => {
         await entryPoint.getLayer0Node().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor1, PeerDescriptor))
         await entryPoint.getLayer0Node().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor2, PeerDescriptor))
         
-        node1.getStreamrNode().joinStreamPart(STREAM_PART_ID)
-        node1.getStreamrNode().on('newMessage', () => { messageReceived = true })
+        node1.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
+        node1.getContentDeliveryManager().on('newMessage', () => { messageReceived = true })
         const msg = createStreamMessage(JSON.stringify({ hello: 'WORLD' }), STREAM_PART_ID, randomEthereumAddress())
-        node2.getStreamrNode().broadcast(msg)
+        node2.getContentDeliveryManager().broadcast(msg)
         await waitForCondition(() => messageReceived, 40000)
     }, 60000)
 

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

@@ -119,7 +119,7 @@ describe('stream without default entrypoints', () => {
             await nodes[i].join(STREAM_PART_ID, { minCount: (i > 0) ? 1 : 0, timeout: 15000 })
         }
         await waitForCondition(async () => {
-            const entryPointData = await nodes[15].stack.getLayer0Node().getDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
+            const entryPointData = await nodes[15].stack.getLayer0Node().fetchDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
             return entryPointData.length >= 7
         }, 15000)
         

package/test/integration/streamEntryPointReplacing.test.ts

@@ -68,27 +68,29 @@ describe('Stream Entry Points are replaced when known entry points leave streams
         simulator.stop()
     })
 
+    // TODO: Investigate why 60 second timeouts are needed
     it('stream entry points are replaced when nodes leave streams', async () => {
-        // TODO: Investigate why CI needs more than 15 seconds to find 4 neighbors for the stream.
-        await Promise.all(initialNodesOnStream.map((node) => node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 30000 })))
+        await Promise.all(initialNodesOnStream.map((node) => node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 60000 })))
 
         let receivedMessages = 0
         for (const node of laterNodesOnStream) {
-            await node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 30000 }) 
-            node.getStreamrNode().on('newMessage', () => {
+            await node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 60000 }) 
+            node.getContentDeliveryManager().on('newMessage', () => {
                 receivedMessages += 1
             })
         }
 
-        await Promise.all(initialNodesOnStream.map((node) => node.getStreamrNode().leaveStreamPart(STREAM_PART_ID)))
-        await waitForCondition(() => laterNodesOnStream.every((node) => node.getStreamrNode().getNeighbors(STREAM_PART_ID).length >= 4), 30000, 1000)
+        await Promise.all(initialNodesOnStream.map((node) => node.getContentDeliveryManager().leaveStreamPart(STREAM_PART_ID)))
+        await waitForCondition(() => 
+            laterNodesOnStream.every((node) => node.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length >= 4), 60000, 1000
+        )
 
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
             STREAM_PART_ID,
             randomEthereumAddress()
         )
-        newNodeInStream.getStreamrNode().broadcast(msg)
-        await waitForCondition(() => receivedMessages === NUM_OF_LATER_NODES, 15000)
+        newNodeInStream.getContentDeliveryManager().broadcast(msg)
+        await waitForCondition(() => receivedMessages === NUM_OF_LATER_NODES, 30000)
     }, 200000)
 })

package/test/unit/ContentDeliveryManager.test.ts

@@ -0,0 +1,96 @@
+import { areEqualPeerDescriptors } from '@streamr/dht'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { randomEthereumAddress } from '@streamr/test-utils'
+import { waitForCondition } from '@streamr/utils'
+import { ContentDeliveryManager } from '../../src/logic/ContentDeliveryManager'
+import { MockLayer0Node } from '../utils/mock/MockLayer0Node'
+import { MockTransport } from '../utils/mock/Transport'
+import { createMockPeerDescriptor, createStreamMessage, mockConnectionLocker } from '../utils/utils'
+import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+
+describe('ContentDeliveryManager', () => {
+
+    let manager: ContentDeliveryManager
+    const peerDescriptor = createMockPeerDescriptor()
+
+    beforeEach(async () => {
+        manager = new ContentDeliveryManager({})
+        const mockLayer0 = new MockLayer0Node(peerDescriptor)
+        await manager.start(mockLayer0, new MockTransport(), mockConnectionLocker)
+    })
+
+    afterEach(async () => {
+        await manager.destroy()
+    })
+
+    it('PeerDescriptor is correct', () => {
+        expect(areEqualPeerDescriptors(peerDescriptor, manager.getPeerDescriptor()))
+    })
+
+    describe('join and leave', () => {
+
+        const streamPartId = StreamPartIDUtils.parse('stream#0')
+        const message = createStreamMessage(
+            JSON.stringify({ hello: 'WORLD' }),
+            streamPartId,
+            randomEthereumAddress()
+        )
+
+        beforeEach(async () => {
+            manager.setStreamPartEntryPoints(streamPartId, [manager.getPeerDescriptor()])
+        })
+
+        it('can join stream part', async () => {
+            manager.joinStreamPart(streamPartId)
+            expect(manager.hasStreamPart(streamPartId)).toEqual(true)
+        })
+
+        it('can leave stream part', async () => {
+            manager.joinStreamPart(streamPartId)
+            expect(manager.hasStreamPart(streamPartId)).toEqual(true)
+            await manager.leaveStreamPart(streamPartId)
+            expect(manager.hasStreamPart(streamPartId)).toEqual(false)
+        })
+
+        it('broadcast joins stream', async () => {
+            manager.broadcast(message)
+            await waitForCondition(() => manager.hasStreamPart(streamPartId))
+        })
+    })
+
+    describe('proxied stream', () => {
+        it('happy path', async () => {
+            const streamPartId = StreamPartIDUtils.parse('stream#0')
+            const proxy = createMockPeerDescriptor()
+            const userId = randomEthereumAddress()
+            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
+            expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
+            await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
+            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
+        })
+
+        it('empty node list', async () => {
+            const streamPartId = StreamPartIDUtils.parse('stream#0')
+            const proxy = createMockPeerDescriptor()
+            const userId = randomEthereumAddress()
+            await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
+            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
+            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
+            expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
+            await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
+            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
+        })
+
+        it('connection count to 0', async () => {
+            const streamPartId = StreamPartIDUtils.parse('stream#0')
+            const proxy = createMockPeerDescriptor()
+            const userId = randomEthereumAddress()
+            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId, 0)
+            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
+            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
+            expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
+            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId, 0)
+            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
+        })
+    })
+})

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

@@ -1,14 +1,14 @@
 import { ListeningRpcCommunicator } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
-import { DeliveryRpcLocal } from '../../src/logic/DeliveryRpcLocal'
+import { ContentDeliveryRpcLocal } from '../../src/logic/ContentDeliveryRpcLocal'
 import { LeaveStreamPartNotice } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { MockTransport } from '../utils/mock/Transport'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
-describe('DeliveryRpcLocal', () => {
+describe('ContentDeliveryRpcLocal', () => {
 
-    let rpcLocal: DeliveryRpcLocal
+    let rpcLocal: ContentDeliveryRpcLocal
     const peerDescriptor = createMockPeerDescriptor()
 
     const mockSender = createMockPeerDescriptor()
@@ -30,7 +30,7 @@ describe('DeliveryRpcLocal', () => {
         mockOnLeaveNotice = jest.fn((_m) => {})
         mockMarkForInspection = jest.fn((_m) => {})
 
-        rpcLocal = new DeliveryRpcLocal({
+        rpcLocal = new ContentDeliveryRpcLocal({
             markAndCheckDuplicate: mockDuplicateCheck,
             broadcast: mockBroadcast,
             onLeaveNotice: mockOnLeaveNotice,

package/test/unit/EntrypointDiscovery.test.ts

@@ -37,7 +37,7 @@ describe('EntryPointDiscovery', () => {
         deleted: true
     }
 
-    const fakeGetEntryPointData = async (): Promise<DataEntry[]> => {
+    const fakeFetchEntryPointData = async (): Promise<DataEntry[]> => {
         return [fakeData, fakeDeletedData]
     }
 
@@ -46,7 +46,7 @@ describe('EntryPointDiscovery', () => {
         return [peerDescriptor]
     }
 
-    const fakeEmptyGetEntryPointData = async (): Promise<DataEntry[]> => {
+    const fakeEmptyFetchEntryPointData = async (): Promise<DataEntry[]> => {
         return []
     }
 
@@ -70,7 +70,7 @@ describe('EntryPointDiscovery', () => {
             localPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
             layer1Node,
-            getEntryPointData: fakeGetEntryPointData,
+            fetchEntryPointData: fakeFetchEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
             storeInterval: 2000
@@ -79,7 +79,7 @@ describe('EntryPointDiscovery', () => {
             localPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
             layer1Node,
-            getEntryPointData: fakeEmptyGetEntryPointData,
+            fetchEntryPointData: fakeEmptyFetchEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
             storeInterval: 2000

package/test/unit/HandshakeRpcLocal.test.ts

@@ -2,7 +2,7 @@ import { DhtAddress, NodeType, getNodeIdFromPeerDescriptor, getRawFromDhtAddress
 import { NodeList } from '../../src/logic/NodeList'
 import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
 import { InterleaveRequest, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor, createMockHandshakeRpcRemote, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, createMockHandshakeRpcRemote, createMockContentDeliveryRpcRemote } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
@@ -26,11 +26,10 @@ describe('HandshakeRpcLocal', () => {
 
         rpcLocal = new HandshakeRpcLocal({
             streamPartId: STREAM_PART_ID,
-            connectionLocker: mockConnectionLocker,
             ongoingHandshakes,
             ongoingInterleaves,
             createRpcRemote: (_p) => createMockHandshakeRpcRemote(),
-            createDeliveryRpcRemote: (_p) => createMockDeliveryRpcRemote(),
+            createContentDeliveryRpcRemote: (_p) => createMockContentDeliveryRpcRemote(),
             handshakeWithInterleaving: async (_p, _t) => {
                 handshakeWithInterleaving()
                 return true
@@ -54,10 +53,10 @@ describe('HandshakeRpcLocal', () => {
     })
 
     it('handshake interleave', async () => {
-        neighbors.add(createMockDeliveryRpcRemote())
-        neighbors.add(createMockDeliveryRpcRemote())
-        neighbors.add(createMockDeliveryRpcRemote())
-        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
         const req = StreamPartHandshakeRequest.create({
             streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
@@ -111,10 +110,10 @@ describe('HandshakeRpcLocal', () => {
     })
 
     it('rejects handshakes if interleaving to the requestor is ongoing', async () => {
-        neighbors.add(createMockDeliveryRpcRemote())
-        neighbors.add(createMockDeliveryRpcRemote())
-        neighbors.add(createMockDeliveryRpcRemote())
-        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
         const requestor = createMockPeerDescriptor()
         ongoingInterleaves.add(getNodeIdFromPeerDescriptor(requestor))
         const req = StreamPartHandshakeRequest.create({
@@ -131,10 +130,10 @@ describe('HandshakeRpcLocal', () => {
         const interleavingPeer1 = createMockPeerDescriptor()
         const interleavingPeer2 = createMockPeerDescriptor()
         const interleavingPeer3 = createMockPeerDescriptor()
-        neighbors.add(createMockDeliveryRpcRemote(interleavingPeer1))
-        neighbors.add(createMockDeliveryRpcRemote(interleavingPeer2))
-        neighbors.add(createMockDeliveryRpcRemote(interleavingPeer3))
-        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote(interleavingPeer1))
+        neighbors.add(createMockContentDeliveryRpcRemote(interleavingPeer2))
+        neighbors.add(createMockContentDeliveryRpcRemote(interleavingPeer3))
+        neighbors.add(createMockContentDeliveryRpcRemote())
         ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer1))
         ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer2))
         ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer3))
@@ -149,4 +148,21 @@ describe('HandshakeRpcLocal', () => {
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(0)
     })
 
+    it('rejects handshakes if the requestor has more than maxNeighborCount neighbors', async () => {
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        neighbors.add(createMockContentDeliveryRpcRemote())
+        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)
+    })
+
 })