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

package/test/integration/RandomGraphNode-Layer1Node-Latencies.test.ts

@@ -1,4 +1,4 @@
-import { DhtNode, LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
+import { DhtNode, LatencyType, PeerDescriptor, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
@@ -8,7 +8,7 @@ import { StreamPartIDUtils } from '@streamr/protocol'
 import { Layer1Node } from '../../src/logic/Layer1Node'
 
 describe('RandomGraphNode-DhtNode-Latencies', () => {
-    const numOfNodes = 64
+    const nodeCount = 64
     let layer1Nodes: Layer1Node[]
     let dhtEntryPoint: Layer1Node
     let entryPointRandomGraphNode: RandomGraphNode
@@ -17,12 +17,11 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
     const streamPartId = StreamPartIDUtils.parse('stream#0')
     const entrypointDescriptor = createMockPeerDescriptor()
 
-    const peerDescriptors: PeerDescriptor[] = range(numOfNodes).map(() => createMockPeerDescriptor())
+    const peerDescriptors: PeerDescriptor[] = range(nodeCount).map(() => createMockPeerDescriptor())
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         const simulator = new Simulator(LatencyType.FIXED, 50)
         const entrypointCm = new SimulatorTransport(entrypointDescriptor, simulator)
-        const cms: SimulatorTransport[] = range(numOfNodes).map((i) =>
+        const cms: SimulatorTransport[] = range(nodeCount).map((i) =>
             new SimulatorTransport(peerDescriptors[i], simulator)
         )
         await entrypointCm.start()
@@ -33,24 +32,26 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
             peerDescriptor: entrypointDescriptor,
             serviceId: streamPartId
         })
-        layer1Nodes = range(numOfNodes).map((i) => new DhtNode({
+        layer1Nodes = range(nodeCount).map((i) => new DhtNode({
             transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))
-        graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
+        graphNodes = range(nodeCount).map((i) => createRandomGraphNode({
             streamPartId,
             layer1Node: layer1Nodes[i],
             transport: cms[i],
             connectionLocker: cms[i],
-            localPeerDescriptor: peerDescriptors[i]
+            localPeerDescriptor: peerDescriptors[i],
+            isLocalNodeEntryPoint: () => false
         }))
         entryPointRandomGraphNode = createRandomGraphNode({
             streamPartId,
             layer1Node: dhtEntryPoint,
             transport: entrypointCm,
             connectionLocker: entrypointCm,
-            localPeerDescriptor: entrypointDescriptor
+            localPeerDescriptor: entrypointDescriptor,
+            isLocalNodeEntryPoint: () => false
         })
 
         await dhtEntryPoint.start()
@@ -63,7 +64,6 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
         entryPointRandomGraphNode.stop()
         await Promise.all(layer1Nodes.map((node) => node.stop()))
         await Promise.all(graphNodes.map((node) => node.stop()))
-        Simulator.useFakeTimers(false)
     })
 
     it('happy path single node', async () => {
@@ -72,10 +72,10 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
         await graphNodes[0].start()
         await Promise.all([
             waitForCondition(() => graphNodes[0].getNearbyNodeView().getIds().length === 1),
-            waitForCondition(() => graphNodes[0].getTargetNeighborIds().length === 1)
+            waitForCondition(() => graphNodes[0].getNeighbors().length === 1)
         ])
         expect(graphNodes[0].getNearbyNodeView().getIds().length).toEqual(1)
-        expect(graphNodes[0].getTargetNeighborIds().length).toEqual(1)
+        expect(graphNodes[0].getNeighbors().length).toEqual(1)
     })
 
     it('happy path 5 nodes', async () => {
@@ -84,14 +84,10 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
         await Promise.all(range(4).map(async (i) => {
             await layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
-        await Promise.all(range(4).map((i) => {
-            return waitForCondition(() => {
-                return graphNodes[i].getTargetNeighborIds().length >= 4
-            }, 15000, 2000)
-        }))
+        await waitForCondition(() => range(4).every((i) => graphNodes[i].getNeighbors().length >= 4), 15000, 1000)
         range(4).forEach((i) => {
             expect(graphNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
-            expect(graphNodes[i].getTargetNeighborIds().length).toBeGreaterThanOrEqual(4)
+            expect(graphNodes[i].getNeighbors().length).toBeGreaterThanOrEqual(4)
         })
         // Check bidirectionality
         const allNodes = graphNodes
@@ -102,32 +98,35 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
                 const neighbor = allNodes.find((node) => {
                     return node.getOwnNodeId() === ownNodeId
                 })
-                expect(neighbor!.getTargetNeighborIds()).toContain(nodeId)
+                const neighborIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+                expect(neighborIds).toContain(nodeId)
             })
         })
     }, 60000)
 
     it('happy path 64 nodes', async () => {
-        await Promise.all(range(numOfNodes).map((i) => graphNodes[i].start()))
-        await Promise.all(range(numOfNodes).map((i) => {
+        await Promise.all(range(nodeCount).map((i) => graphNodes[i].start()))
+        await Promise.all(range(nodeCount).map((i) => {
             layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(graphNodes.map((node) =>
-            waitForCondition(() => node.getTargetNeighborIds().length >= 4, 10000)
+            waitForCondition(() => node.getNeighbors().length >= 4, 10000)
         ))
 
         await Promise.all(graphNodes.map((node) =>
-            waitForCondition(() => node.getNumberOfOutgoingHandshakes() === 0)
+            waitForCondition(() => node.getOutgoingHandshakeCount() === 0)
         ))
 
         await waitForCondition(() => {
             let mismatchCounter = 0
             graphNodes.forEach((node) => {
                 const nodeId = node.getOwnNodeId()
-                node.getTargetNeighborIds().forEach((neighborId) => {
+                node.getNeighbors().forEach((neighbor) => {
+                    const neighborId = getNodeIdFromPeerDescriptor(neighbor)
                     if (neighborId !== entryPointRandomGraphNode.getOwnNodeId()) {
                         const neighbor = graphNodes.find((n) => n.getOwnNodeId() === neighborId)
-                        if (!neighbor!.getTargetNeighborIds().includes(nodeId)) {
+                        const neighborIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+                        if (!neighborIds.includes(nodeId)) {
                             mismatchCounter += 1
                         }
                     }

package/test/integration/RandomGraphNode-Layer1Node.test.ts

@@ -1,4 +1,4 @@
-import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, getRandomRegion } from '@streamr/dht'
+import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor, getRandomRegion } from '@streamr/dht'
 import { Logger, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
@@ -10,7 +10,7 @@ import { Layer1Node } from '../../src/logic/Layer1Node'
 const logger = new Logger(module)
 
 describe('RandomGraphNode-DhtNode', () => {
-    const numOfNodes = 64
+    const nodeCount = 64
     let layer1Nodes: Layer1Node[]
     let dhtEntryPoint: Layer1Node
     let entryPointRandomGraphNode: RandomGraphNode
@@ -21,14 +21,12 @@ describe('RandomGraphNode-DhtNode', () => {
         region: getRandomRegion()
     })
 
-    const peerDescriptors: PeerDescriptor[] = range(numOfNodes).map(() => {
+    const peerDescriptors: PeerDescriptor[] = range(nodeCount).map(() => {
         return createMockPeerDescriptor({
             region: getRandomRegion()
         })
     })
     beforeEach(async () => {
-
-        Simulator.useFakeTimers()
         const simulator = new Simulator()
         const entrypointCm = new SimulatorTransport(
             entrypointDescriptor,
@@ -36,7 +34,7 @@ describe('RandomGraphNode-DhtNode', () => {
         )
         await entrypointCm.start()
 
-        const cms: ConnectionManager[] = range(numOfNodes).map((i) =>
+        const cms: ConnectionManager[] = range(nodeCount).map((i) =>
             new SimulatorTransport(
                 peerDescriptors[i],
                 simulator
@@ -50,19 +48,20 @@ describe('RandomGraphNode-DhtNode', () => {
             serviceId: streamPartId
         })
 
-        layer1Nodes = range(numOfNodes).map((i) => new DhtNode({
+        layer1Nodes = range(nodeCount).map((i) => new DhtNode({
             transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))
 
-        graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
+        graphNodes = range(nodeCount).map((i) => createRandomGraphNode({
             streamPartId,
             layer1Node: layer1Nodes[i],
             transport: cms[i],
             connectionLocker: cms[i],
             localPeerDescriptor: peerDescriptors[i],
-            neighborUpdateInterval: 2000
+            neighborUpdateInterval: 2000,
+            isLocalNodeEntryPoint: () => false
         }))
 
         entryPointRandomGraphNode = createRandomGraphNode({
@@ -71,7 +70,8 @@ describe('RandomGraphNode-DhtNode', () => {
             transport: entrypointCm,
             connectionLocker: entrypointCm,
             localPeerDescriptor: entrypointDescriptor,
-            neighborUpdateInterval: 2000
+            neighborUpdateInterval: 2000,
+            isLocalNodeEntryPoint: () => false
         })
 
         await dhtEntryPoint.start()
@@ -84,7 +84,6 @@ describe('RandomGraphNode-DhtNode', () => {
         entryPointRandomGraphNode.stop()
         await Promise.all(layer1Nodes.map((node) => node.stop()))
         await Promise.all(graphNodes.map((node) => node.stop()))
-        Simulator.useFakeTimers(false)
     })
 
     it('happy path single node ', async () => {
@@ -93,9 +92,9 @@ describe('RandomGraphNode-DhtNode', () => {
 
         await graphNodes[0].start()
 
-        await waitForCondition(() => graphNodes[0].getTargetNeighborIds().length === 1)
+        await waitForCondition(() => graphNodes[0].getNeighbors().length === 1)
         expect(graphNodes[0].getNearbyNodeView().getIds().length).toEqual(1)
-        expect(graphNodes[0].getTargetNeighborIds().length).toEqual(1)
+        expect(graphNodes[0].getNeighbors().length).toEqual(1)
     })
 
     it('happy path 4 nodes', async () => {
@@ -105,10 +104,10 @@ describe('RandomGraphNode-DhtNode', () => {
             await layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
 
-        await waitForCondition(() => range(4).every((i) => graphNodes[i].getTargetNeighborIds().length === 4))
+        await waitForCondition(() => range(4).every((i) => graphNodes[i].getNeighbors().length === 4))
         range(4).forEach((i) => {
             expect(graphNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
-            expect(graphNodes[i].getTargetNeighborIds().length).toBeGreaterThanOrEqual(4)
+            expect(graphNodes[i].getNeighbors().length).toBeGreaterThanOrEqual(4)
         })
 
         // Check bidirectionality
@@ -119,36 +118,39 @@ describe('RandomGraphNode-DhtNode', () => {
                 const neighbor = allNodes.find((node) => {
                     return node.getOwnNodeId() === nodeId
                 })
-                expect(neighbor!.getTargetNeighborIds().includes(allNodes[i].getOwnNodeId())).toEqual(true)
+                const neighborIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+                expect(neighborIds.includes(allNodes[i].getOwnNodeId())).toEqual(true)
             })
         })
     }, 10000)
 
     it('happy path 64 nodes', async () => {
-        await Promise.all(range(numOfNodes).map((i) => graphNodes[i].start()))
-        await Promise.all(range(numOfNodes).map((i) => {
+        await Promise.all(range(nodeCount).map((i) => graphNodes[i].start()))
+        await Promise.all(range(nodeCount).map((i) => {
             layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(graphNodes.map((node) =>
-            waitForCondition(() => node.getTargetNeighborIds().length >= 4, 10000)
+            waitForCondition(() => node.getNeighbors().length >= 4, 10000)
         ))
 
         const avg = graphNodes.reduce((acc, curr) => {
-            return acc + curr.getTargetNeighborIds().length
-        }, 0) / numOfNodes
+            return acc + curr.getNeighbors().length
+        }, 0) / nodeCount
 
         logger.info(`AVG Number of neighbors: ${avg}`)
         await Promise.all(graphNodes.map((node) =>
-            waitForCondition(() => node.getNumberOfOutgoingHandshakes() === 0)
+            waitForCondition(() => node.getOutgoingHandshakeCount() === 0)
         ))
         await waitForCondition(() => {
             let mismatchCounter = 0
             graphNodes.forEach((node) => {
                 const nodeId = node.getOwnNodeId()
-                node.getTargetNeighborIds().forEach((neighborId) => {
+                node.getNeighbors().forEach((neighbor) => {
+                    const neighborId = getNodeIdFromPeerDescriptor(neighbor)
                     if (neighborId !== entryPointRandomGraphNode.getOwnNodeId()) {
                         const neighbor = graphNodes.find((n) => n.getOwnNodeId() === neighborId)
-                        if (!neighbor!.getTargetNeighborIds().includes(nodeId)) {
+                        const neighborIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+                        if (!neighborIds.includes(nodeId)) {
                             mismatchCounter += 1
                         }
                     }

package/test/integration/StreamrNode.test.ts

@@ -1,13 +1,7 @@
-import {
-    DhtNode,
-    PeerDescriptor,
-    Simulator,
-    SimulatorTransport,
-    NodeType
-} from '@streamr/dht'
+import { DhtNode, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
 import { StreamrNode, Events } from '../../src/logic/StreamrNode'
 import { waitForEvent3, waitForCondition } from '@streamr/utils'
-import { createStreamMessage } from '../utils/utils'
+import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { Layer0Node } from '../../src/logic/Layer0Node'
@@ -21,14 +15,8 @@ describe('StreamrNode', () => {
     let node1: StreamrNode
     let node2: StreamrNode
 
-    const peerDescriptor1: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS
-    }
-    const peerDescriptor2: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 1, 1]),
-        type: NodeType.NODEJS
-    }
+    const peerDescriptor1: PeerDescriptor = createMockPeerDescriptor()
+    const peerDescriptor2: PeerDescriptor = createMockPeerDescriptor()
     const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
 
     const msg = createStreamMessage(

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

@@ -1,9 +1,9 @@
-import { NodeType, PeerDescriptor, Simulator, SimulatorTransport, LatencyType, getRandomRegion } from '@streamr/dht'
+import { PeerDescriptor, Simulator, SimulatorTransport, LatencyType } from '@streamr/dht'
 import { NetworkStack } from '../../src/NetworkStack'
 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 { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 import { waitForCondition } from '@streamr/utils'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
@@ -11,35 +11,11 @@ const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
 
 describe('Joining stream parts on offline nodes', () => {
 
-    const entryPointPeerDescriptor: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
-
-    const node1PeerDescriptor: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 1, 1]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
-
-    const node2PeerDescriptor: PeerDescriptor = {
-        kademliaId: new Uint8Array([2, 2, 2]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
-
-    const offlineDescriptor1: PeerDescriptor = {
-        kademliaId: new Uint8Array([3, 3, 3]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
-
-    const offlineDescriptor2: PeerDescriptor = {
-        kademliaId: new Uint8Array([4, 4, 4]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
+    const entryPointPeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
+    const node1PeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
+    const node2PeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
+    const offlineDescriptor1: PeerDescriptor = createMockPeerDescriptor()
+    const offlineDescriptor2: PeerDescriptor = createMockPeerDescriptor()
 
     let entryPoint: NetworkStack
     let node1: NetworkStack

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

@@ -1,7 +1,10 @@
-import { LatencyType, NodeType, PeerDescriptor, Simulator, SimulatorTransport, getRandomRegion } from '@streamr/dht'
+import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
 import {
+    ContentType,
+    EncryptionType,
     MessageID,
     MessageRef,
+    SignatureType,
     StreamMessage,
     StreamMessageType,
     StreamPartIDUtils
@@ -18,12 +21,8 @@ describe('stream without default entrypoints', () => {
 
     let entrypoint: NetworkNode
     let nodes: NetworkNode[]
-    let numOfReceivedMessages: number
-    const entryPointPeerDescriptor: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
+    let receivedMessageCount: number
+    const entryPointPeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
 
     const streamMessage = new StreamMessage({
         messageId: new MessageID(
@@ -39,14 +38,16 @@ describe('stream without default entrypoints', () => {
             hello: 'world'
         })),
         messageType: StreamMessageType.MESSAGE,
+        contentType: ContentType.JSON,
+        encryptionType: EncryptionType.NONE,
+        signatureType: SignatureType.SECP256K1,
         signature: hexToBinary('0x1234'),
     })
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         const simulator = new Simulator(LatencyType.REAL)
         nodes = []
-        numOfReceivedMessages = 0
+        receivedMessageCount = 0
         const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
         await entryPointTransport.start()
         entrypoint = createNetworkNode({
@@ -76,43 +77,41 @@ describe('stream without default entrypoints', () => {
     afterEach(async () => {
         await entrypoint.stop()
         await Promise.all(nodes.map((node) => node.stop()))
-        Simulator.useFakeTimers(false)
     })
 
     it('can join stream without configured entrypoints one by one', async () => {
         await nodes[0].join(STREAM_PART_ID)
         nodes[0].addMessageListener((_msg) => {
-            numOfReceivedMessages += 1
+            receivedMessageCount += 1
         })
         await Promise.all([
-            waitForCondition(() => numOfReceivedMessages === 1, 10000),
+            waitForCondition(() => receivedMessageCount === 1, 10000),
             nodes[1].broadcast(streamMessage)
         ])
     })
 
     it('can join without configured entrypoints simultaneously', async () => {
         nodes[0].addMessageListener((_msg) => {
-            numOfReceivedMessages += 1
+            receivedMessageCount += 1
         })
         await Promise.all([
-            waitForCondition(() => numOfReceivedMessages === 1, 15000),
+            waitForCondition(() => receivedMessageCount === 1, 15000),
             nodes[0].join(STREAM_PART_ID),
             nodes[1].broadcast(streamMessage),
         ])
     })
 
     it('multiple nodes can join without configured entrypoints simultaneously', async () => {
-        const numOfSubscribers = 8
-        await Promise.all(range(numOfSubscribers).map(async (i) => {
+        const subscriberCount = 8
+        await Promise.all(range(subscriberCount).map(async (i) => {
             await nodes[i].join(STREAM_PART_ID, { minCount: 4, timeout: 15000 })
-            nodes[i].addMessageListener((_msg) => {
-                numOfReceivedMessages += 1
+            nodes[i].addMessageListener(() => {
+                receivedMessageCount += 1
             })
         }))
-        await Promise.all([
-            waitForCondition(() => numOfReceivedMessages === numOfSubscribers, 15000),
-            nodes[9].broadcast(streamMessage)
-        ])
+        const nonjoinedNode = nodes[subscriberCount]
+        await nonjoinedNode.broadcast(streamMessage)
+        await waitForCondition(() => receivedMessageCount === subscriberCount, 15000)
     }, 45000)
 
     it('nodes store themselves as entrypoints on streamPart if number of entrypoints is low', async () => {
@@ -120,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

@@ -0,0 +1,94 @@
+import { Simulator, SimulatorTransport, LatencyType } from '@streamr/dht'
+import { NetworkStack } from '../../src/NetworkStack'
+import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { ENTRYPOINT_STORE_LIMIT } from '../../src/logic/EntryPointDiscovery'
+import { range } from 'lodash'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { waitForCondition } from '@streamr/utils'
+import { randomEthereumAddress } from '@streamr/test-utils'
+
+describe('Stream Entry Points are replaced when known entry points leave streams', () => {
+    
+    let simulator: Simulator
+    let layer0EntryPoint: NetworkStack
+    const entryPointPeerDescriptor = createMockPeerDescriptor()
+    let initialNodesOnStream: NetworkStack[]
+    let laterNodesOnStream: NetworkStack[]
+    let newNodeInStream: NetworkStack
+
+    const NUM_OF_LATER_NODES = 16
+
+    const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
+
+    const startNode = async () => {
+        const peerDescriptor = createMockPeerDescriptor()
+        const transport = new SimulatorTransport(peerDescriptor, simulator)
+        await transport.start()
+        const node = new NetworkStack({
+            layer0: {
+                transport,
+                peerDescriptor,
+                entryPoints: [entryPointPeerDescriptor]
+            }
+        })
+        await node.start()
+        return node
+    }
+
+    beforeEach(async () => {
+        simulator = new Simulator(LatencyType.REAL)
+        const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
+        layer0EntryPoint = new NetworkStack({
+            layer0: {
+                transport: entryPointTransport,
+                peerDescriptor: entryPointPeerDescriptor,
+                entryPoints: [entryPointPeerDescriptor]
+            }
+        })
+        await entryPointTransport.start()
+        await layer0EntryPoint.start()
+
+        initialNodesOnStream = await Promise.all(range(ENTRYPOINT_STORE_LIMIT).map(async () => {
+            return await startNode()
+        }))
+
+        laterNodesOnStream = await Promise.all(range(NUM_OF_LATER_NODES).map(async () => {
+            return await startNode()
+        }))
+        newNodeInStream = await startNode()
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            layer0EntryPoint.stop(),
+            ...initialNodesOnStream.map((node) => node.stop()),
+            ...laterNodesOnStream.map((node) => node.stop()),
+            newNodeInStream.stop()
+        ])
+        simulator.stop()
+    })
+
+    // TODO: Investigate why 60 second timeouts are needed
+    it('stream entry points are replaced when nodes leave streams', async () => {
+        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: 60000 }) 
+            node.getStreamrNode().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), 60000, 1000)
+
+        const msg = createStreamMessage(
+            JSON.stringify({ hello: 'WORLD' }),
+            STREAM_PART_ID,
+            randomEthereumAddress()
+        )
+        newNodeInStream.getStreamrNode().broadcast(msg)
+        await waitForCondition(() => receivedMessages === NUM_OF_LATER_NODES, 30000)
+    }, 200000)
+})

package/test/unit/DeliveryRpcLocal.test.ts

@@ -50,7 +50,8 @@ describe('DeliveryRpcLocal', () => {
 
     it('Server leaveStreamPartNotice()', async () => {
         const leaveNotice: LeaveStreamPartNotice = {
-            streamPartId: StreamPartIDUtils.parse('stream#0')
+            streamPartId: StreamPartIDUtils.parse('stream#0'),
+            isEntryPoint: false
         }
         await rpcLocal.leaveStreamPartNotice(leaveNotice, { incomingSourceDescriptor: mockSender } as any)
         expect(mockOnLeaveNotice).toHaveBeenCalledTimes(1)