@streamr/trackerless-network 100.2.4-beta.0 → 100.2.5-beta.0

package/test/integration/NetworkNode.test.ts

@@ -37,14 +37,16 @@ describe('NetworkNode', () => {
             layer0: {
                 entryPoints: [pd1],
                 peerDescriptor: pd1,
-                transport: transport1
+                transport: transport1,
+                connectionsView: transport1
             }
         })
         node2 = createNetworkNode({
             layer0: {
                 entryPoints: [pd1],
                 peerDescriptor: pd2,
-                transport: transport2
+                transport: transport2,
+                connectionsView: transport2
             }
         })
 

package/test/integration/NodeInfoRpc.test.ts

@@ -40,6 +40,7 @@ describe('NetworkStack NodeInfoRpc', () => {
         requesteStack = new NetworkStack({
             layer0: {
                 transport: requesteeTransport1,
+                connectionsView: requesteeTransport1,
                 peerDescriptor: requesteePeerDescriptor,
                 entryPoints: [requesteePeerDescriptor]
             }
@@ -47,6 +48,7 @@ describe('NetworkStack NodeInfoRpc', () => {
         otherStack = new NetworkStack({
             layer0: {
                 transport: otherTransport,
+                connectionsView: otherTransport,
                 peerDescriptor: otherPeerDescriptor,
                 entryPoints: [requesteePeerDescriptor]
             }

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

@@ -28,6 +28,7 @@ describe('Joining stream parts on offline nodes', () => {
         entryPoint = new NetworkStack({
             layer0: {
                 transport: entryPointTransport,
+                connectionsView: entryPointTransport,
                 peerDescriptor: entryPointPeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
@@ -36,6 +37,7 @@ describe('Joining stream parts on offline nodes', () => {
         node1 = new NetworkStack({
             layer0: {
                 transport: node1Transport,
+                connectionsView: node1Transport,
                 peerDescriptor: node1PeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
@@ -44,6 +46,7 @@ describe('Joining stream parts on offline nodes', () => {
         node2 = new NetworkStack({
             layer0: {
                 transport: node2Transport,
+                connectionsView: node2Transport,
                 peerDescriptor: node2PeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }

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

@@ -53,6 +53,7 @@ describe('stream without default entrypoints', () => {
         entrypoint = createNetworkNode({
             layer0: {
                 transport: entryPointTransport,
+                connectionsView: entryPointTransport,
                 peerDescriptor: entryPointPeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
@@ -66,6 +67,7 @@ describe('stream without default entrypoints', () => {
                 layer0: {
                     peerDescriptor,
                     transport,
+                    connectionsView: transport,
                     entryPoints: [entryPointPeerDescriptor]
                 }
             })

package/test/integration/streamEntryPointReplacing.test.ts

@@ -27,6 +27,7 @@ describe('Stream Entry Points are replaced when known entry points leave streams
         const node = new NetworkStack({
             layer0: {
                 transport,
+                connectionsView: transport,
                 peerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
@@ -41,6 +42,7 @@ describe('Stream Entry Points are replaced when known entry points leave streams
         layer0EntryPoint = new NetworkStack({
             layer0: {
                 transport: entryPointTransport,
+                connectionsView: entryPointTransport,
                 peerDescriptor: entryPointPeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }

package/test/unit/ContentDeliveryLayerNode.test.ts

@@ -6,7 +6,7 @@ import { MockHandshaker } from '../utils/mock/MockHandshaker'
 import { MockLayer1Node } from '../utils/mock/MockLayer1Node'
 import { MockNeighborFinder } from '../utils/mock/MockNeighborFinder'
 import { MockNeighborUpdateManager } from '../utils/mock/MockNeighborUpdateManager'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor, createMockContentDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { getNodeIdFromPeerDescriptor } from '@streamr/dht'
@@ -65,11 +65,11 @@ describe('ContentDeliveryLayerNode', () => {
         expect(ids[0]).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
     })
 
-    it('Adds Closest Nodes from layer1 contactAdded event to nearbyNodeView', async () => {
+    it('Adds Closest Nodes from layer1 nearbyContactAdded event to nearbyNodeView', async () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
         layer1Node.setClosestContacts([peerDescriptor1, peerDescriptor2])
-        layer1Node.emit('closestContactAdded', peerDescriptor1)
+        layer1Node.emit('nearbyContactAdded', peerDescriptor1)
         await waitForCondition(() => nearbyNodeView.size() === 2)
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
@@ -85,12 +85,12 @@ describe('ContentDeliveryLayerNode', () => {
         expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
     })
 
-    it('Adds Nodes from layer1 KBucket to nearbyNodeView if its size is below nodeViewSize', async () => {
+    it('Adds Nodes from layer1 neighbors to nearbyNodeView if its size is below nodeViewSize', async () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
         layer1Node.addNewRandomPeerToKBucket()
         layer1Node.setClosestContacts([peerDescriptor1, peerDescriptor2])
-        layer1Node.emit('closestContactAdded', peerDescriptor1)
+        layer1Node.emit('nearbyContactAdded', peerDescriptor1)
         await waitForCondition(() => {
             return nearbyNodeView.size() === 3
         }, 20000)

package/test/unit/ContentDeliveryManager.test.ts

@@ -4,7 +4,7 @@ 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 { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor, createStreamMessage, mockConnectionLocker } from '../utils/utils'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 

package/test/unit/ContentDeliveryRpcLocal.test.ts

@@ -3,7 +3,7 @@ import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { ContentDeliveryRpcLocal } from '../../src/logic/ContentDeliveryRpcLocal'
 import { LeaveStreamPartNotice } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
 describe('ContentDeliveryRpcLocal', () => {

package/test/unit/EntrypointDiscovery.test.ts

@@ -1,11 +1,9 @@
 import { PeerDescriptor, areEqualPeerDescriptors } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { wait } from '@streamr/utils'
-import { range } from 'lodash'
 import { EntryPointDiscovery } from '../../src/logic/EntryPointDiscovery'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { DataEntry } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { MockLayer1Node } from '../utils/mock/MockLayer1Node'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
@@ -52,24 +50,11 @@ describe('EntryPointDiscovery', () => {
 
     const fakeDeleteEntryPointData = async (): Promise<void> => {}
 
-    const addNodesToStreamPart = (layer1: MockLayer1Node, count: number) => {
-        range(count).forEach(() => {
-            layer1.addNewRandomPeerToKBucket()
-            layer1.addNewRandomPeerToKBucket()
-            layer1.addNewRandomPeerToKBucket()
-            layer1.addNewRandomPeerToKBucket()
-        })
-    } 
-
-    let layer1Node: MockLayer1Node
-
     beforeEach(() => {
         storeCalled = 0
-        layer1Node = new MockLayer1Node()
         entryPointDiscoveryWithData = new EntryPointDiscovery({
             localPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
-            layer1Node,
             fetchEntryPointData: fakeFetchEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
@@ -78,7 +63,6 @@ describe('EntryPointDiscovery', () => {
         entryPointDiscoveryWithoutData = new EntryPointDiscovery({
             localPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
-            layer1Node,
             fetchEntryPointData: fakeEmptyFetchEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
@@ -90,40 +74,25 @@ describe('EntryPointDiscovery', () => {
         entryPointDiscoveryWithData.destroy()
     })
 
-    it('discoverEntryPointsFromDht has known entrypoints', async () => {
-        const res = await entryPointDiscoveryWithData.discoverEntryPointsFromDht(1)
-        expect(res.entryPointsFromDht).toEqual(false)
-        expect(res.discoveredEntryPoints).toEqual([])
-    })
-
-    it('discoverEntryPointsFromDht does not have known entrypoints', async () => {
-        const res = await entryPointDiscoveryWithData.discoverEntryPointsFromDht(0)
-        expect(res.discoveredEntryPoints.length).toBe(1)
-        expect(areEqualPeerDescriptors(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)
+    it('discoverEntryPoints filters deleted data', async () => {
+        const res = await entryPointDiscoveryWithData.discoverEntryPoints()
+        expect(res.length).toBe(1)
+        expect(areEqualPeerDescriptors(res[0], peerDescriptor)).toBe(true)
     })
 
-    it('discoverEntryPointsfromDht on an empty stream', async () => {
-        const res = await entryPointDiscoveryWithoutData.discoverEntryPointsFromDht(0)
-        expect(res.entryPointsFromDht).toEqual(true)
-        expect(res.discoveredEntryPoints.length).toBe(1)
-        expect(areEqualPeerDescriptors(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)  // localPeerDescriptor
-    })
-
-    it('store on empty stream', async () => {
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
-        expect(storeCalled).toEqual(1)
-        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
+    it('discoverEntryPoints without results', async () => {
+        const res = await entryPointDiscoveryWithoutData.discoverEntryPoints()
+        expect(res.length).toBe(0)
     })
 
     it('store on stream without saturated entrypoint count', async () => {
-        addNodesToStreamPart(layer1Node, 4)
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
+        await entryPointDiscoveryWithData.storeAndKeepLocalNodeAsEntryPoint()
         expect(storeCalled).toEqual(1)
         expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
     })
 
     it('will keep stored until destroyed', async () => {
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
+        await entryPointDiscoveryWithData.storeAndKeepLocalNodeAsEntryPoint()
         expect(storeCalled).toEqual(1)
         expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
         await wait(4500)

package/test/unit/Inspector.test.ts

@@ -1,7 +1,7 @@
 import { ListeningRpcCommunicator, createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { utf8ToBinary } from '@streamr/utils'
 import { Inspector } from '../../src/logic/inspect/Inspector'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor, mockConnectionLocker } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 

package/test/unit/NeighborUpdateRpcLocal.test.ts

@@ -4,7 +4,7 @@ import { NeighborUpdateRpcLocal } from '../../src/logic/neighbor-discovery/Neigh
 import { createMockPeerDescriptor } from '../utils/utils'
 import { NodeList } from '../../src/logic/NodeList'
 import { StreamPartIDUtils } from '@streamr/protocol'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockTransport } from '../utils/mock/MockTransport'
 import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
 import { range } from 'lodash'

package/test/unit/NodeList.test.ts

@@ -13,7 +13,7 @@ import { NodeList } from '../../src/logic/NodeList'
 import { formStreamPartContentDeliveryServiceId } from '../../src/logic/formStreamPartDeliveryServiceId'
 import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockTransport } from '../utils/mock/MockTransport'
 
 const streamPartId = StreamPartIDUtils.parse('stream#0')
 

package/test/unit/StreamPartNetworkSplitAvoidance.test.ts

@@ -0,0 +1,32 @@
+import { MIN_NEIGHBOR_COUNT } from '../../src/logic/StreamPartNetworkSplitAvoidance'
+import { StreamPartNetworkSplitAvoidance } from '../../src/logic/StreamPartNetworkSplitAvoidance'
+import { MockLayer1Node } from '../utils/mock/MockLayer1Node'
+
+describe('StreamPartNetworkSplitAvoidance', () => {
+
+    let avoidance: StreamPartNetworkSplitAvoidance
+    let layer1Node: MockLayer1Node
+    
+    beforeEach(() => {
+        layer1Node = new MockLayer1Node()
+        avoidance = new StreamPartNetworkSplitAvoidance({
+            layer1Node,
+            discoverEntryPoints: async () => { 
+                layer1Node.addNewRandomPeerToKBucket() 
+                return layer1Node.getNeighbors()
+            },
+            exponentialRunOfBaseDelay: 1
+        })
+    })
+
+    afterEach(() => {
+        layer1Node.stop()
+        avoidance.destroy()
+    })
+
+    it('runs avoidance until number of neighbors is above MIN_NEIGHBOR_COUNT', async () => {
+        await avoidance.avoidNetworkSplit()
+        expect(layer1Node.getNeighborCount()).toBeGreaterThan(MIN_NEIGHBOR_COUNT)
+    })
+
+})

package/test/unit/StreamPartReconnect.test.ts

@@ -0,0 +1,30 @@
+import { EntryPointDiscovery } from '../../src/logic/EntryPointDiscovery'
+import { StreamPartReconnect } from '../../src/logic/StreamPartReconnect'
+import { MockLayer1Node } from '../utils/mock/MockLayer1Node'
+import { createFakeEntryPointDiscovery } from '../utils/fake/FakeEntryPointDiscovery'
+import { waitForCondition } from '@streamr/utils'
+
+describe('StreamPartReconnect', () => {
+
+    let entryPointDiscovery: EntryPointDiscovery
+    let layer1Node: MockLayer1Node
+    let streamPartReconnect: StreamPartReconnect
+
+    beforeEach(() => {
+        entryPointDiscovery = createFakeEntryPointDiscovery()
+        layer1Node = new MockLayer1Node()
+        streamPartReconnect = new StreamPartReconnect(layer1Node, entryPointDiscovery)
+    })
+
+    afterEach(() => {
+        streamPartReconnect.destroy()
+    })
+
+    it('Happy path', async () => {
+        await streamPartReconnect.reconnect(1000)
+        expect(streamPartReconnect.isRunning()).toEqual(true)
+        layer1Node.addNewRandomPeerToKBucket()
+        await waitForCondition(() => streamPartReconnect.isRunning() === false)
+    })
+
+})

package/test/unit/TemporaryConnectionRpcLocal.test.ts

@@ -1,6 +1,6 @@
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { TemporaryConnectionRpcLocal } from '../../src/logic/temporary-connection/TemporaryConnectionRpcLocal'
-import { MockTransport } from '../utils/mock/Transport'
+import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { ListeningRpcCommunicator, getDhtAddressFromRaw } from '@streamr/dht'
 

package/test/utils/fake/FakeEntryPointDiscovery.ts

@@ -0,0 +1,29 @@
+import { PeerDescriptor } from '@streamr/dht'
+import { EntryPointDiscovery } from '../../../src/logic/EntryPointDiscovery'
+
+export const createFakeEntryPointDiscovery = (): EntryPointDiscovery => {
+    return new FakeEntryPointDiscovery() as unknown as EntryPointDiscovery
+}
+
+class FakeEntryPointDiscovery {
+
+    private entryPoints: PeerDescriptor[] = []
+
+    setEntryPoints(nodes: PeerDescriptor[]): void {
+        this.entryPoints = nodes
+    } 
+
+    async discoverEntryPoints(): Promise<PeerDescriptor[]> {
+        return this.entryPoints
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async storeAndKeepLocalNodeAsEntryPoint(): Promise<void> {
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    isLocalNodeEntryPoint(): boolean {
+        return true
+    }
+    
+}

package/test/utils/mock/MockConnectionsView.ts

@@ -0,0 +1,18 @@
+import { PeerDescriptor } from '@streamr/dht'
+
+export class MockConnectionsView {
+    // eslint-disable-next-line class-methods-use-this
+    getConnections(): PeerDescriptor[] {
+        return []
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getConnectionCount(): number {
+        return 0
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    hasConnection(): boolean {
+        return false
+    }
+}

package/test/utils/mock/MockLayer0Node.ts

@@ -1,8 +1,9 @@
-import { PeerDescriptor, DataEntry, ITransport } from '@streamr/dht'
+import { PeerDescriptor, DataEntry, ITransport, TransportEvents, ConnectionsView } from '@streamr/dht'
 import { Layer0Node } from '../../../src/logic/Layer0Node'
 import { EventEmitter } from 'eventemitter3'
+import { MockConnectionsView } from './MockConnectionsView'
 
-export class MockLayer0Node extends EventEmitter implements Layer0Node {
+export class MockLayer0Node extends EventEmitter<TransportEvents> implements Layer0Node {
 
     private readonly peerDescriptor: PeerDescriptor
 
@@ -44,18 +45,8 @@ export class MockLayer0Node extends EventEmitter implements Layer0Node {
     }
 
     // eslint-disable-next-line class-methods-use-this
-    getConnections(): PeerDescriptor[] {
-        return []
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getConnectionCount(): number {
-        return 0
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    hasConnection(): boolean {
-        return false
+    getConnectionsView(): ConnectionsView {
+        return new MockConnectionsView()
     }
 
     // eslint-disable-next-line class-methods-use-this

package/test/utils/mock/MockLayer1Node.ts

@@ -1,9 +1,9 @@
 import { PeerDescriptor, RingContacts } from '@streamr/dht'
 import { EventEmitter } from 'eventemitter3'
-import { Layer1Node } from '../../../src/logic/Layer1Node'
+import { Layer1Node, Layer1NodeEvents } from '../../../src/logic/Layer1Node'
 import { createMockPeerDescriptor } from '../utils'
 
-export class MockLayer1Node extends EventEmitter implements Layer1Node {
+export class MockLayer1Node extends EventEmitter<Layer1NodeEvents> implements Layer1Node {
 
     private readonly kbucketPeers: PeerDescriptor[] = []
     private closestContacts: PeerDescriptor[] = []

package/test/utils/mock/{Transport.ts → MockTransport.ts}

@@ -1,7 +1,8 @@
 import { ITransport, PeerDescriptor } from '@streamr/dht'
+import { TransportEvents } from '@streamr/dht'
 import { EventEmitter } from 'eventemitter3'
 
-export class MockTransport extends EventEmitter implements ITransport {
+export class MockTransport extends EventEmitter<TransportEvents> implements ITransport {
 
     // eslint-disable-next-line class-methods-use-this
     async send(): Promise<void> {
@@ -13,21 +14,6 @@ export class MockTransport extends EventEmitter implements ITransport {
         return PeerDescriptor.create()
     }
 
-    // eslint-disable-next-line class-methods-use-this
-    getConnections(): PeerDescriptor[] {
-        return []
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getConnectionCount(): number {
-        return 0
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    hasConnection(): boolean {
-        return false
-    }
-
     // eslint-disable-next-line class-methods-use-this
     stop(): void {
     }

package/test/utils/utils.ts

@@ -47,6 +47,7 @@ export const createMockContentDeliveryLayerNodeAndDhtNode = async (
     await mockCm.start()
     const layer1Node = new DhtNode({
         transport: mockCm,
+        connectionsView: mockCm,
         peerDescriptor: localPeerDescriptor,
         numberOfNodesPerKBucket: 4,
         entryPoints: [entryPointDescriptor],
@@ -134,6 +135,7 @@ export const createNetworkNodeWithSimulator = async (
             peerDescriptor,
             entryPoints,
             transport,
+            connectionsView: transport,
             maxConnections: 25,
             storeHighestTtl: 120000,
             storeMaxTtl: 120000