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

package/test/benchmark/first-message.ts

@@ -31,7 +31,7 @@ const prepareLayer0 = async () => {
         region: getRandomRegion()
     })
     layer0Ep = peerDescriptor
-    const entryPoint = createNetworkNodeWithSimulator(peerDescriptor, simulator, [peerDescriptor])
+    const entryPoint = await createNetworkNodeWithSimulator(peerDescriptor, simulator, [peerDescriptor])
     await entryPoint.start()    
     nodes.push(entryPoint)
 
@@ -44,7 +44,7 @@ const prepareStream = async (streamId: string) => {
         region: getRandomRegion()
     })
     const streamPartId = toStreamPartID(toStreamID(streamId), 0)
-    const streamPublisher = createNetworkNodeWithSimulator(peerDescriptor, simulator, [layer0Ep])
+    const streamPublisher = await createNetworkNodeWithSimulator(peerDescriptor, simulator, [layer0Ep])
     await streamPublisher.start()
     streamPublisher.join(streamPartId)
     nodes.push(streamPublisher)
@@ -76,7 +76,7 @@ const measureJoiningTime = async () => {
                 0,
                 i,
                 Math.floor(Math.random() * 20000),
-                'node' as any,
+                '2222' as any,
                 'msgChainId'
             ),
             prevMsgRef: null,
@@ -90,7 +90,11 @@ const measureJoiningTime = async () => {
     }, 1000)
     // get random node from network to use as entrypoint
     const randomNode = nodes[Math.floor(Math.random() * nodes.length)]
-    const streamSubscriber = createNetworkNodeWithSimulator(peerDescriptor, simulator, [randomNode.stack.getLayer0Node().getLocalPeerDescriptor()])
+    const streamSubscriber = await createNetworkNodeWithSimulator(
+        peerDescriptor,
+        simulator,
+        [randomNode.stack.getLayer0Node().getLocalPeerDescriptor()]
+    )
     currentNode = streamSubscriber
     const start = performance.now()
     await streamSubscriber.start()
@@ -109,7 +113,6 @@ const measureJoiningTime = async () => {
 }
 
 const run = async () => {
-    Simulator.useFakeTimers()
     await prepareLayer0()
     for (let i = 0; i < 20; i++) {
         await prepareStream(`stream-${i}`)
@@ -124,7 +127,6 @@ const run = async () => {
     }
     fs.closeSync(logFile)
     await shutdownNetwork()
-    Simulator.useFakeTimers(false)
 } 
 
 // eslint-disable-next-line promise/catch-or-return, promise/always-return

package/test/end-to-end/random-graph-with-real-connections.test.ts

@@ -50,7 +50,8 @@ describe('random graph with real connections', () => {
                 layer1Node: epDhtNode,
                 transport: epDhtNode.getTransport(),
                 connectionLocker: epDhtNode.getTransport() as ConnectionManager,
-                localPeerDescriptor: epPeerDescriptor
+                localPeerDescriptor: epPeerDescriptor,
+                isLocalNodeEntryPoint: () => false
             }
         )
         randomGraphNode2 = createRandomGraphNode({
@@ -58,28 +59,32 @@ describe('random graph with real connections', () => {
             layer1Node: dhtNode1,
             transport: dhtNode1.getTransport(),
             connectionLocker: dhtNode1.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode1.getLocalPeerDescriptor()
+            localPeerDescriptor: dhtNode1.getLocalPeerDescriptor(),
+            isLocalNodeEntryPoint: () => false
         })
         randomGraphNode3 = createRandomGraphNode({
             streamPartId,
             layer1Node: dhtNode2,
             transport: dhtNode2.getTransport(),
             connectionLocker: dhtNode2.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode2.getLocalPeerDescriptor()
+            localPeerDescriptor: dhtNode2.getLocalPeerDescriptor(),
+            isLocalNodeEntryPoint: () => false
         })
         randomGraphNode4 = createRandomGraphNode({
             streamPartId,
             layer1Node: dhtNode3,
             transport: dhtNode3.getTransport(),
             connectionLocker: dhtNode3.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode3.getLocalPeerDescriptor()
+            localPeerDescriptor: dhtNode3.getLocalPeerDescriptor(),
+            isLocalNodeEntryPoint: () => false
         })
         randomGraphNode5 = createRandomGraphNode({
             streamPartId,
             layer1Node: dhtNode4,
             transport: dhtNode4.getTransport(),
             connectionLocker: dhtNode4.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode4.getLocalPeerDescriptor()
+            localPeerDescriptor: dhtNode4.getLocalPeerDescriptor(),
+            isLocalNodeEntryPoint: () => false
         })
         await epDhtNode.joinDht([epPeerDescriptor])
         await Promise.all([

package/test/end-to-end/webrtc-full-node-network.test.ts

@@ -65,7 +65,7 @@ describe('Full node network with WebRTC connections', () => {
             waitForCondition(() => {
                 return node.getStreamrNode()!.getNeighbors(streamPartId).length >= 3
             }
-            , 120000)
+            , 30000)
         ))
         let numOfMessagesReceived = 0
         const successIds: string[] = []

package/test/end-to-end/websocket-full-node-network.test.ts

@@ -8,7 +8,7 @@ import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
 describe('Full node network with WebSocket connections only', () => {
 
-    const NUM_OF_NODES = 48
+    const NUM_OF_NODES = 32
     const epPeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 15555, tls: false }
     })
@@ -62,7 +62,7 @@ describe('Full node network with WebSocket connections only', () => {
             waitForCondition(() => {
                 return node.getStreamrNode()!.getNeighbors(streamPartId).length >= 4
             }
-            , 120000)
+            , 30000)
         ))
         let numOfMessagesReceived = 0
         const successIds: string[] = []

package/test/integration/DeliveryRpcRemote.test.ts

@@ -13,7 +13,6 @@ import {
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { waitForCondition } from '@streamr/utils'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { createStreamMessage } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
@@ -73,7 +72,8 @@ describe('DeliveryRpcRemote', () => {
             clientNode,
             serverNode,
             STREAM_PART_ID,
-            toProtoRpcClient(new DeliveryRpcClient(clientRpc.getRpcClientTransport()))
+            clientRpc,
+            DeliveryRpcClient
         )
     })
 
@@ -97,7 +97,7 @@ describe('DeliveryRpcRemote', () => {
     })
 
     it('leaveNotice', async () => {
-        rpcRemote.leaveStreamPartNotice()
+        rpcRemote.leaveStreamPartNotice(false)
         await waitForCondition(() => recvCounter === 1)
     })
 

package/test/integration/HandshakeRpcRemote.test.ts

@@ -9,7 +9,6 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     HandshakeRpcClient,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
@@ -34,7 +33,6 @@ describe('HandshakeRpcRemote', () => {
     let mockConnectionManager2: SimulatorTransport
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         simulator = new Simulator()
         mockConnectionManager1 = new SimulatorTransport(serverNode, simulator)
         await mockConnectionManager1.start()
@@ -61,7 +59,8 @@ describe('HandshakeRpcRemote', () => {
             clientNode,
             serverNode,
             'test-stream-part',
-            toProtoRpcClient(new HandshakeRpcClient(clientRpc.getRpcClientTransport()))
+            clientRpc,
+            HandshakeRpcClient
         )
     })
 
@@ -71,7 +70,6 @@ describe('HandshakeRpcRemote', () => {
         await mockConnectionManager1.stop()
         await mockConnectionManager2.stop()
         simulator.stop()
-        Simulator.useFakeTimers(false)
     })
 
     it('handshake', async () => {

package/test/integration/Handshakes.test.ts

@@ -6,7 +6,6 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     HandshakeRpcClient
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
@@ -70,7 +69,6 @@ describe('Handshakes', () => {
     let simulatorTransport3: SimulatorTransport
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         simulator = new Simulator()
         simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
         await simulatorTransport1.start()
@@ -107,7 +105,6 @@ describe('Handshakes', () => {
         await simulatorTransport2.stop()
         await simulatorTransport3.stop()
         simulator.stop()
-        Simulator.useFakeTimers(false)
     })
 
     it('Two nodes can handshake', async () => {
@@ -118,7 +115,8 @@ describe('Handshakes', () => {
                 peerDescriptor2,
                 peerDescriptor1,
                 streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(true)
@@ -133,7 +131,8 @@ describe('Handshakes', () => {
                 peerDescriptor2,
                 peerDescriptor1,
                 streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(true)
@@ -148,7 +147,8 @@ describe('Handshakes', () => {
                 peerDescriptor2,
                 peerDescriptor1,
                 streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(false)
@@ -164,7 +164,8 @@ describe('Handshakes', () => {
                 peerDescriptor2,
                 peerDescriptor1,
                 streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(true)

package/test/integration/Inspect.test.ts

@@ -38,7 +38,6 @@ describe('inspect', () => {
     }
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         simulator = new Simulator(LatencyType.REAL)
 
         publisherNode = await initiateNode(publisherDescriptor, simulator)
@@ -65,7 +64,6 @@ describe('inspect', () => {
             inspectorNode.stop(),
             ...inspectedNodes.map((node) => node.stop())
         ])
-        Simulator.useFakeTimers(false)
     })
 
     it('gets successful inspections from all suspects', async () => {

package/test/integration/NeighborUpdateRpcRemote.test.ts

@@ -5,7 +5,6 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { NeighborUpdateRpcRemote } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcRemote'
 import { NeighborUpdate } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import {
@@ -64,7 +63,8 @@ describe('NeighborUpdateRpcRemote', () => {
             clientNode,
             serverNode,
             'test-stream-part',
-            toProtoRpcClient(new NeighborUpdateRpcClient(clientRpc.getRpcClientTransport()))
+            clientRpc,
+            NeighborUpdateRpcClient
         )
     })
 

package/test/integration/NetworkNode.test.ts

@@ -30,7 +30,6 @@ describe('NetworkNode', () => {
     }
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         const simulator = new Simulator()
         transport1 = new SimulatorTransport(pd1, simulator)
         await transport1.start()
@@ -63,7 +62,6 @@ describe('NetworkNode', () => {
             node1.stop(),
             node2.stop()
         ])
-        Simulator.useFakeTimers(false)
     })
 
     it('wait for join + broadcast and subscribe', async () => {

package/test/integration/NetworkRpc.test.ts

@@ -9,7 +9,6 @@ import { waitForCondition } from '@streamr/utils'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { createStreamMessage } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Simulator } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
@@ -20,7 +19,6 @@ describe('Network RPC', () => {
     let recvCounter = 0
 
     beforeEach(() => {
-        Simulator.useFakeTimers()
         rpcCommunicator1 = new RpcCommunicator()
         rpcCommunicator2 = new RpcCommunicator()
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
@@ -40,7 +38,6 @@ describe('Network RPC', () => {
     afterEach(() => {
         rpcCommunicator1.stop()
         rpcCommunicator2.stop()
-        Simulator.useFakeTimers(false)
     })
 
     it('sends Data', async () => {

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

@@ -19,7 +19,6 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
 
     const peerDescriptors: PeerDescriptor[] = range(numOfNodes).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) =>
@@ -43,14 +42,16 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
             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 () => {

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

@@ -27,8 +27,6 @@ describe('RandomGraphNode-DhtNode', () => {
         })
     })
     beforeEach(async () => {
-
-        Simulator.useFakeTimers()
         const simulator = new Simulator()
         const entrypointCm = new SimulatorTransport(
             entrypointDescriptor,
@@ -62,7 +60,8 @@ describe('RandomGraphNode-DhtNode', () => {
             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 () => {

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

@@ -43,7 +43,6 @@ describe('stream without default entrypoints', () => {
     })
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         const simulator = new Simulator(LatencyType.REAL)
         nodes = []
         numOfReceivedMessages = 0
@@ -76,7 +75,6 @@ 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 () => {
@@ -105,14 +103,13 @@ describe('stream without default entrypoints', () => {
         const numOfSubscribers = 8
         await Promise.all(range(numOfSubscribers).map(async (i) => {
             await nodes[i].join(STREAM_PART_ID, { minCount: 4, timeout: 15000 })
-            nodes[i].addMessageListener((_msg) => {
+            nodes[i].addMessageListener(() => {
                 numOfReceivedMessages += 1
             })
         }))
-        await Promise.all([
-            waitForCondition(() => numOfReceivedMessages === numOfSubscribers, 15000),
-            nodes[9].broadcast(streamMessage)
-        ])
+        const nonjoinedNode = nodes[numOfSubscribers]
+        await nonjoinedNode.broadcast(streamMessage)
+        await waitForCondition(() => numOfReceivedMessages === numOfSubscribers, 15000)
     }, 45000)
 
     it('nodes store themselves as entrypoints on streamPart if number of entrypoints is low', async () => {

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()
+    })
+
+    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 })))
+
+        let receivedMessages = 0
+        for (const node of laterNodesOnStream) {
+            await node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 30000 }) 
+            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), 30000, 1000)
+
+        const msg = createStreamMessage(
+            JSON.stringify({ hello: 'WORLD' }),
+            STREAM_PART_ID,
+            randomEthereumAddress()
+        )
+        newNodeInStream.getStreamrNode().broadcast(msg)
+        await waitForCondition(() => receivedMessages === NUM_OF_LATER_NODES, 15000)
+    }, 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)

package/test/unit/EntrypointDiscovery.test.ts

@@ -22,7 +22,7 @@ describe('EntryPointDiscovery', () => {
     const fakeData: DataEntry = {
         key: Uint8Array.from([1, 2, 3]),
         data: Any.pack(peerDescriptor, PeerDescriptor),
-        creator: peerDescriptor,
+        creator: peerDescriptor.nodeId,
         ttl: 1000,
         stale: false,
         deleted: false
@@ -31,7 +31,7 @@ describe('EntryPointDiscovery', () => {
     const fakeDeletedData: DataEntry = {
         key: Uint8Array.from([1, 2, 3]),
         data: Any.pack(deletedPeerDescriptor, PeerDescriptor),
-        creator: deletedPeerDescriptor,
+        creator: deletedPeerDescriptor.nodeId,
         ttl: 1000,
         stale: false,
         deleted: true
@@ -112,17 +112,20 @@ describe('EntryPointDiscovery', () => {
     it('store on empty stream', async () => {
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
+        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
     })
 
     it('store on stream without saturated entrypoint count', async () => {
         addNodesToStreamPart(layer1Node, 4)
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
+        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
     })
 
     it('will keep stored until destroyed', async () => {
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
+        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
         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