@streamr/dht 100.0.0-testnet-three.1 → 100.0.0-testnet-three.3

package/test/end-to-end/Layer0Webrtc-Layer1.test.ts

@@ -1,5 +1,5 @@
 import { DhtNode } from '../../src/dht/DhtNode'
-import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('Layer 1 on Layer 0 with mocked connections', () => {
@@ -26,22 +26,22 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
         layer0EntryPoint = new DhtNode({ peerDescriptor: entrypointDescriptor, websocketServerEnableTls: false })
 
-        const layer0Node1Id = '11' as DhtAddress
+        const layer0Node1Id = createRandomDhtAddress()
         layer0Node1 = new DhtNode({
             nodeId: layer0Node1Id
         })
 
-        const layer0Node2Id = '22' as DhtAddress
+        const layer0Node2Id = createRandomDhtAddress()
         layer0Node2 = new DhtNode({
             nodeId: layer0Node2Id
         })
 
-        const layer0Node3Id = '33' as DhtAddress
+        const layer0Node3Id = createRandomDhtAddress()
         layer0Node3 = new DhtNode({
             nodeId: layer0Node3Id
         })
 
-        const layer0Node4Id = '44' as DhtAddress
+        const layer0Node4Id = createRandomDhtAddress()
         layer0Node4 = new DhtNode({
             nodeId: layer0Node4Id
         })

package/test/end-to-end/Layer0Webrtc.test.ts

@@ -39,8 +39,6 @@ describe('Layer0 with WebRTC connections', () => {
             node3.start(),
             node4.start()
         ])
-
-        await epDhtNode.joinDht([epPeerDescriptor])
     })
 
     afterEach(async () => {

package/test/unit/PeerManager.test.ts

@@ -15,7 +15,7 @@ describe('PeerManager', () => {
                 return new DhtNodeRpcRemote(undefined as any, peerDescriptor, undefined as any, new MockRpcCommunicator())
             }
         } as any)
-        manager.handleNewPeers(nodeIds.map((n) => ({ nodeId: getRawFromDhtAddress(n), type: NodeType.NODEJS })))
+        manager.addContact(nodeIds.map((n) => ({ nodeId: getRawFromDhtAddress(n), type: NodeType.NODEJS })))
 
         const referenceId = createRandomDhtAddress()
         const excluded = new Set<DhtAddress>(sampleSize(nodeIds, 2)!)

package/test/unit/SortedContactList.test.ts

@@ -118,4 +118,17 @@ describe('SortedContactList', () => {
         list.setActive(item4.getNodeId())
         expect(list.getActiveContacts()).toEqual([item2, item3, item4])
     })
+
+    it('does not emit contactAdded if contact did not fit the structure', () => {
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 2, allowToContainReferenceId: false, emitEvents: true })
+        const onContactAdded = jest.fn()
+        list.on('contactAdded', onContactAdded)
+        list.addContact(item1)
+        list.addContact(item2)
+        expect(onContactAdded).toBeCalledTimes(2)
+        list.addContact(item3)
+        expect(onContactAdded).toBeCalledTimes(2)
+        expect(list.getAllContacts().length).toEqual(2)
+    })
+
 })

package/test/unit/StoreManager.test.ts

@@ -27,7 +27,7 @@ describe('StoreManager', () => {
             localNodeId: DhtAddress,
             closestNeighbors: DhtAddress[],
             replicateData: (request: ReplicateDataRequest) => unknown,
-            setStale: (key: DhtAddress, creator: DhtAddress, stale: boolean) => unknown
+            setAllEntriesAsStale: (key: DhtAddress) => unknown
         ): StoreManager => {
             const getClosestNeighborsTo = () => {
                 return closestNeighbors.map((nodeId) => ({ nodeId: getRawFromDhtAddress(nodeId), type: NodeType.NODEJS }))
@@ -39,7 +39,11 @@ describe('StoreManager', () => {
                 } as any,
                 recursiveOperationManager: undefined as any,
                 localPeerDescriptor: { nodeId: getRawFromDhtAddress(localNodeId), type: NodeType.NODEJS },
-                localDataStore: { values: () => [DATA_ENTRY], setStale } as any,
+                localDataStore: { 
+                    keys: () => [getDhtAddressFromRaw(DATA_ENTRY.key)],
+                    values: () => [DATA_ENTRY],
+                    setAllEntriesAsStale 
+                } as any,
                 serviceId: undefined as any,
                 highestTtl: undefined as any,
                 redundancyFactor: 3,
@@ -52,34 +56,34 @@ describe('StoreManager', () => {
 
             it('new node is within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[0],
                     [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[3], NODES_CLOSEST_TO_DATA[4]],
                     replicateData,
-                    setStale
+                    setAllEntriesAsStale
                 )
-                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[2]), type: NodeType.NODEJS })
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[2]), type: NodeType.NODEJS })
                 await waitForCondition(() => replicateData.mock.calls.length === 1)
                 expect(replicateData).toHaveBeenCalledWith({
                     entry: DATA_ENTRY
                 })
-                expect(setStale).not.toHaveBeenCalled()
+                expect(setAllEntriesAsStale).not.toHaveBeenCalled()
             })
     
             it('new node is not within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[0],
                     [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
                     replicateData,
-                    setStale
+                    setAllEntriesAsStale
                 )
-                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
-                expect(setStale).not.toHaveBeenCalled()
+                expect(setAllEntriesAsStale).not.toHaveBeenCalled()
             })
         })
 
@@ -87,48 +91,47 @@ describe('StoreManager', () => {
 
             it('this node is within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[1],
                     [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
                     replicateData,
-                    setStale
+                    setAllEntriesAsStale
                 )
-                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
-                expect(setStale).not.toHaveBeenCalled()
             })
 
             it('this node is not within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[3],
                     [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2]],
                     replicateData,
-                    setStale
+                    setAllEntriesAsStale
                 )
-                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
-                expect(setStale).toHaveBeenCalledTimes(1)
-                expect(setStale).toHaveBeenCalledWith(getDhtAddressFromRaw(DATA_ENTRY.key), getDhtAddressFromRaw(DATA_ENTRY.creator), true)
+                expect(setAllEntriesAsStale).toHaveBeenCalledTimes(1)
+                expect(setAllEntriesAsStale).toHaveBeenCalledWith(getDhtAddressFromRaw(DATA_ENTRY.key))
             })
 
             it('this node has less than redundancyFactor neighbors', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[3],
                     [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1]],
                     replicateData,
-                    setStale
+                    setAllEntriesAsStale
                 )
-                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
-                expect(setStale).toHaveBeenCalledTimes(0)
+                expect(setAllEntriesAsStale).toHaveBeenCalledTimes(0)
             })
         })
     })