@streamr/trackerless-network 0.0.1-tatum.5 → 0.0.1-tatum.6

package/test/unit/StreamPartEntrypointDiscovery.test.ts

@@ -4,18 +4,18 @@ import { wait } from '@streamr/utils'
 import { range } from 'lodash'
 import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { StreamPartEntryPointDiscovery } from '../../src/logic/StreamPartEntryPointDiscovery'
-import { StreamPartDelivery } from '../../src/logic/StreamrNode'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { DataEntry } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { MockLayer1 } from '../utils/mock/MockLayer1'
 import { createMockPeerDescriptor } from '../utils/utils'
 
+const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
+
 describe('StreamPartEntryPointDiscovery', () => {
 
     let entryPointDiscoveryWithData: StreamPartEntryPointDiscovery
     let entryPointDiscoveryWithoutData: StreamPartEntryPointDiscovery
     let storeCalled: number
-    let streamParts = new Map<string, StreamPartDelivery>()
 
     const peerDescriptor = createMockPeerDescriptor({
         nodeName: 'fake'
@@ -42,8 +42,6 @@ describe('StreamPartEntryPointDiscovery', () => {
         deleted: true
     }
 
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-
     const fakeGetEntryPointData = async (_key: Uint8Array): Promise<RecursiveFindResult> => {
         return {
             closestNodes: [peerDescriptor],
@@ -82,12 +80,11 @@ describe('StreamPartEntryPointDiscovery', () => {
 
     beforeEach(() => {
         storeCalled = 0
-        streamParts = new Map()
         layer1 = new MockLayer1(getNodeIdFromPeerDescriptor(peerDescriptor))
-        streamParts.set(streamPartId, { layer1 } as any)
         entryPointDiscoveryWithData = new StreamPartEntryPointDiscovery({
             ownPeerDescriptor: peerDescriptor,
-            streamParts: streamParts,
+            streamPartId: STREAM_PART_ID,
+            layer1,
             getEntryPointData: fakeGetEntryPointData,
             getEntryPointDataViaNode: fakegetEntryPointDataViaNode,
             storeEntryPointData: fakeStoreEntryPointData,
@@ -96,7 +93,8 @@ describe('StreamPartEntryPointDiscovery', () => {
         })
         entryPointDiscoveryWithoutData = new StreamPartEntryPointDiscovery({
             ownPeerDescriptor: peerDescriptor,
-            streamParts: new Map<string, StreamPartDelivery>(),
+            streamPartId: STREAM_PART_ID,
+            layer1,
             getEntryPointData: fakeEmptyGetEntryPointData,
             getEntryPointDataViaNode: fakegetEntryPointDataViaNode,
             storeEntryPointData: fakeStoreEntryPointData,
@@ -110,55 +108,42 @@ describe('StreamPartEntryPointDiscovery', () => {
     })
 
     it('discoverEntryPointsFromDht has known entrypoints', async () => {
-        const res = await entryPointDiscoveryWithData.discoverEntryPointsFromDht(streamPartId, 1)
+        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(streamPartId, 0)
+        const res = await entryPointDiscoveryWithData.discoverEntryPointsFromDht(0)
         expect(res.discoveredEntryPoints.length).toBe(1)
         expect(isSamePeerDescriptor(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)
     })
 
     it('discoverEntryPointsfromDht on an empty stream', async () => {
-        const res = await entryPointDiscoveryWithoutData.discoverEntryPointsFromDht(streamPartId, 0)
+        const res = await entryPointDiscoveryWithoutData.discoverEntryPointsFromDht(0)
         expect(res.entryPointsFromDht).toEqual(true)
         expect(res.discoveredEntryPoints.length).toBe(1)
         expect(isSamePeerDescriptor(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)  // ownPeerDescriptor
     })
 
     it('store on empty stream', async () => {
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(streamPartId, true, 0)
+        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
     })
 
-    it('store on non-empty stream without known entry points', async () => {
-        addNodesToStream(layer1, 4)
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(streamPartId, false, 0)
-        expect(storeCalled).toEqual(0)
-    })
-
     it('store on stream without saturated entrypoint count', async () => {
         addNodesToStream(layer1, 4)
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(streamPartId, true, 0)
+        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
     })
 
-    it('will keep recaching until stream stopped', async () => {
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(streamPartId, true, 0)
+    it('will keep stored until destroyed', async () => {
+        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
         await wait(4500)
-        entryPointDiscoveryWithData.removeSelfAsEntryPoint(streamPartId)
+        await entryPointDiscoveryWithData.destroy()
+        // we have configured cacheInterval to 2 seconds, i.e. after 4.5 seconds it should have been called 2 more items 
         expect(storeCalled).toEqual(3)
     })
 
-    it('will stop recaching is stream is left', async () => {
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(streamPartId, true, 0)
-        expect(storeCalled).toEqual(1)
-        streamParts.delete(streamPartId)
-        await wait(4500)
-        expect(storeCalled).toEqual(1)
-    })
-
 })

package/test/utils/mock/MockLayer1.ts

@@ -1,4 +1,4 @@
-import { DhtPeer, PeerDescriptor, PeerID, PeerIDKey, SortedContactList } from '@streamr/dht'
+import { PeerDescriptor } from '@streamr/dht'
 import { EventEmitter } from 'eventemitter3'
 import { NodeID } from '../../../src/identifiers'
 import { ILayer1 } from '../../../src/logic/ILayer1'
@@ -7,20 +7,18 @@ import { createMockPeerDescriptor } from '../utils'
 export class MockLayer1 extends EventEmitter implements ILayer1 {
     
     private readonly kbucketPeers: PeerDescriptor[] = []
-    private readonly neighborList: SortedContactList<DhtPeer>
 
-    constructor(nodeId: NodeID) {
+    constructor(_nodeId: NodeID) {
         super()
-        this.neighborList = new SortedContactList(PeerID.fromKey(nodeId as string as PeerIDKey), 10)
     }
 
     // eslint-disable-next-line class-methods-use-this
     removeContact(_peerDescriptor: PeerDescriptor, _removeFromOpenInternetPeers?: boolean): void {
-
     }
 
-    getNeighborList(): SortedContactList<DhtPeer> {
-        return this.neighborList
+    // eslint-disable-next-line class-methods-use-this
+    getClosestContacts(_maxCount?: number): PeerDescriptor[] {
+        return []
     }
 
     getKBucketPeers(): PeerDescriptor[] {

package/test/utils/utils.ts

@@ -76,7 +76,6 @@ export const createRandomNodeId = (): NodeID => {
     return randomBytes(10).toString('hex') as NodeID
 }
 
-// TODO use this in tests
 export const createMockPeerDescriptor = (opts?: Omit<Partial<PeerDescriptor>, 'kademliaId' | 'type'>): PeerDescriptor => {
     return {
         ...opts,