@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

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

@@ -1,30 +1,24 @@
-import { binaryToHex } from '@streamr/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('Layer 1 on Layer 0 with mocked connections', () => {
-    const entrypointDescriptor: PeerDescriptor = {
-        kademliaId: new Uint8Array([0]),
-        type: NodeType.NODEJS,
+
+    const entrypointDescriptor = createMockPeerDescriptor({
         websocket: {
             host: '127.0.0.1',
             port: 23232,
             tls: false
         }
-    }
-
+    })
     let layer0EntryPoint: DhtNode
     let layer1Node1: DhtNode
-
     let layer0Node1: DhtNode
     let layer1EntryPoint: DhtNode
-
     let layer0Node2: DhtNode
     let layer1Node2: DhtNode
-
     let layer0Node3: DhtNode
     let layer1Node3: DhtNode
-
     let layer0Node4: DhtNode
     let layer1Node4: DhtNode
 
@@ -32,52 +26,56 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
         layer0EntryPoint = new DhtNode({ peerDescriptor: entrypointDescriptor, websocketServerEnableTls: false })
 
-        const layer0Node1Id = '11'
+        const layer0Node1Id = createRandomDhtAddress()
         layer0Node1 = new DhtNode({
-            peerId: layer0Node1Id
+            nodeId: layer0Node1Id,
+            entryPoints: [entrypointDescriptor]
         })
 
-        const layer0Node2Id = '22'
+        const layer0Node2Id = createRandomDhtAddress()
         layer0Node2 = new DhtNode({
-            peerId: layer0Node2Id
+            nodeId: layer0Node2Id,
+            entryPoints: [entrypointDescriptor]
         })
 
-        const layer0Node3Id = '33'
+        const layer0Node3Id = createRandomDhtAddress()
         layer0Node3 = new DhtNode({
-            peerId: layer0Node3Id
+            nodeId: layer0Node3Id,
+            entryPoints: [entrypointDescriptor]
         })
 
-        const layer0Node4Id = '44'
+        const layer0Node4Id = createRandomDhtAddress()
         layer0Node4 = new DhtNode({
-            peerId: layer0Node4Id
+            nodeId: layer0Node4Id,
+            entryPoints: [entrypointDescriptor]
         })
 
         layer1EntryPoint = new DhtNode({
-            peerId: binaryToHex(entrypointDescriptor.kademliaId),
+            nodeId: getNodeIdFromPeerDescriptor(entrypointDescriptor),
             transport: layer0EntryPoint,
             serviceId: 'layer1'
         })
 
         layer1Node1 = new DhtNode({
-            peerId: layer0Node1Id,
+            nodeId: layer0Node1Id,
             transport: layer0Node1,
             serviceId: 'layer1'
         })
 
         layer1Node2 = new DhtNode({
-            peerId: layer0Node2Id,
+            nodeId: layer0Node2Id,
             transport: layer0Node2,
             serviceId: 'layer1'
         })
 
         layer1Node3 = new DhtNode({
-            peerId: layer0Node3Id,
+            nodeId: layer0Node3Id,
             transport: layer0Node3,
             serviceId: 'layer1'
         })
 
         layer1Node4 = new DhtNode({
-            peerId: layer0Node4Id,
+            nodeId: layer0Node4Id,
             transport: layer0Node4,
             serviceId: 'layer1'
         })
@@ -125,9 +123,9 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         await layer1Node3.joinDht([entrypointDescriptor])
         await layer1Node4.joinDht([entrypointDescriptor])
 
-        expect(layer1Node1.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node2.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node3.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node4.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node1.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
     }, 60000)
 })

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

@@ -2,15 +2,15 @@ import { areEqualBinaries, waitForEvent3 } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { ConnectionType } from '../../src/connection/IConnection'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerID } from '../../src/helpers/PeerID'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { getNodeIdFromPeerDescriptor } from '../../src/exports'
 
 describe('Layer0 with WebRTC connections', () => {
-    const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('entrypoint').value,
-        type: NodeType.NODEJS,
+
+    const epPeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 10029, tls: false }
-    }
+    })
     let epDhtNode: DhtNode
     let node1: DhtNode
     let node2: DhtNode
@@ -39,8 +39,6 @@ describe('Layer0 with WebRTC connections', () => {
             node3.start(),
             node4.start()
         ])
-
-        await epDhtNode.joinDht([epPeerDescriptor])
     })
 
     afterEach(async () => {
@@ -61,18 +59,19 @@ describe('Layer0 with WebRTC connections', () => {
                 'connected',
                 20000,
                 (peerDescriptor: PeerDescriptor) => {
-                    return areEqualBinaries(peerDescriptor.kademliaId, node1.getLocalPeerDescriptor().kademliaId)
+                    return areEqualBinaries(peerDescriptor.nodeId, node1.getLocalPeerDescriptor().nodeId)
                 }
             ),
             node2.joinDht([epPeerDescriptor]),
             node1.joinDht([epPeerDescriptor])
         ])
-
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
-        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getLocalPeerDescriptor())!.connectionType)
+        const nodeId1 = getNodeIdFromPeerDescriptor(node1.getLocalPeerDescriptor())
+        const nodeId2 = getNodeIdFromPeerDescriptor(node2.getLocalPeerDescriptor())
+        expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).getConnection(nodeId2)!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
-        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getLocalPeerDescriptor())!.connectionType)
+        expect((node2.getTransport() as ConnectionManager).getConnection(nodeId1)!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
 
     }, 60000)
@@ -84,12 +83,13 @@ describe('Layer0 with WebRTC connections', () => {
             node3.joinDht([epPeerDescriptor]),
             node4.joinDht([epPeerDescriptor])
         ])
-
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
-        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getLocalPeerDescriptor())!.connectionType)
+        const nodeId1 = getNodeIdFromPeerDescriptor(node1.getLocalPeerDescriptor())
+        const nodeId2 = getNodeIdFromPeerDescriptor(node2.getLocalPeerDescriptor())
+        expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).getConnection(nodeId2)!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
-        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getLocalPeerDescriptor())!.connectionType)
+        expect((node2.getTransport() as ConnectionManager).getConnection(nodeId1)!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
     })
 })

package/test/end-to-end/Layer1-Scale-WebSocket.test.ts

@@ -1,29 +1,21 @@
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID } from '../../src/helpers/PeerID'
+import { createMockPeerDescriptor } from '../utils/utils'
 
+const STREAM_ID = 'stream'
+const NUM_OF_NODES = 16
 const NUM_OF_NODES_PER_KBUCKET = 8
+const WEBSOCKET_PORT_RANGE = { min: 62200, max: 62200 + NUM_OF_NODES }
 
 describe('Layer1 Scale', () => {
-    const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('entrypoint').value,
-        type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 43225, tls: false }
-    }
-
-    const STREAM_ID = 'stream'
-
-    const NUM_OF_NODES = 16
 
+    const epPeerDescriptor = createMockPeerDescriptor({
+        websocket: { host: '127.0.0.1', port: 43225, tls: false }
+    })
     let layer0Nodes: DhtNode[]
-
     let layer1Nodes: DhtNode[]
-
     let epLayer0Node: DhtNode
     let epLayer1Node: DhtNode
 
-    const websocketPortRange = { min: 62200, max: 62200 + NUM_OF_NODES }
-
     beforeEach(async () => {
         epLayer0Node = new DhtNode({
             peerDescriptor: epPeerDescriptor,
@@ -41,7 +33,7 @@ describe('Layer1 Scale', () => {
 
         for (let i = 0; i < NUM_OF_NODES; i++) {
             const node = new DhtNode({ 
-                websocketPortRange,
+                websocketPortRange: WEBSOCKET_PORT_RANGE,
                 entryPoints: [epPeerDescriptor],
                 websocketServerEnableTls: false,
                 numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
@@ -75,10 +67,10 @@ describe('Layer1 Scale', () => {
     // TODO: fix flaky test in NET-1021
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
+            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node ) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

package/test/end-to-end/Layer1-Scale-Webrtc.test.ts

@@ -1,24 +1,17 @@
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID } from '../../src/helpers/PeerID'
+import { createMockPeerDescriptor } from '../utils/utils'
 
+const STREAM_ID = 'stream'
+const NUM_OF_NODES = 16
 const NUM_OF_NODES_PER_KBUCKET = 8
 
 describe('Layer1 Scale', () => {
-    const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('0').value,
-        type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 43228, tls: false }
-    }
-
-    const STREAM_ID = 'stream'
-
-    const NUM_OF_NODES = 16
 
+    const epPeerDescriptor = createMockPeerDescriptor({
+        websocket: { host: '127.0.0.1', port: 43228, tls: false }
+    })
     let layer0Nodes: DhtNode[]
-
     let layer1Nodes: DhtNode[]
-
     let epLayer0Node: DhtNode
     let epLayer1Node: DhtNode
 
@@ -65,10 +58,10 @@ describe('Layer1 Scale', () => {
 
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
+            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

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

@@ -21,7 +21,7 @@ describe('Failed autocertification', () => {
             entryPoints: [entryPointPeerDescriptor],
             websocketServerEnableTls: true,
             autoCertifierConfigFile: os.tmpdir() + '/failedAutoCertificationConfigFile.json',
-            autoCertifierUrl: 'http://localhost:44444'
+            autoCertifierUrl: 'http://127.0.0.1:44444'
         })
 
         node = new DhtNode({
@@ -46,7 +46,7 @@ describe('Failed autocertification', () => {
         const failedAutocertificationPeerDescriptor = failedAutocertificationNode.getLocalPeerDescriptor()
         expect(failedAutocertificationPeerDescriptor.websocket!.tls).toBe(false)
         await failedAutocertificationNode.joinDht([entryPointPeerDescriptor])
-        expect(failedAutocertificationNode.getBucketSize()).toEqual(2)
+        expect(failedAutocertificationNode.getNeighborCount()).toEqual(2)
     })
 
 })

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

@@ -1,16 +1,15 @@
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { PeerID } from '../../src/helpers/PeerID'
 import { waitForCondition } from '@streamr/utils'
-import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { areEqualPeerDescriptors } from '../../src/identifiers'
 
 describe('Websocket IConnection Requests', () => {
-    const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('3').value,
-        type: NodeType.NODEJS,
+
+    const epPeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 10021, tls: false }
-    }
+    })
     let epDhtNode: DhtNode
     let node1: DhtNode
     let node2: DhtNode
@@ -63,8 +62,8 @@ describe('Websocket IConnection Requests', () => {
 
         await waitForCondition(() => { return (connected1 && connected2) })
 
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getNodeId())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getNodeId())).toEqual(true)
 
     }, 10000)
 })

package/test/end-to-end/memory-leak.test.ts

@@ -1,59 +1,53 @@
 import LeakDetector from 'jest-leak-detector'
-import { binaryToHex, waitForCondition } from '@streamr/utils'
-import { randomBytes } from 'crypto'
+import { waitForCondition } from '@streamr/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { Message, MessageType, NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const MESSAGE_ID = 'mock-message-id'
 
 describe('memory leak', () => {
 
     it('send message', async () => {
-        const entryPointDescriptor = {
-            kademliaId: randomBytes(10),
-            type: NodeType.NODEJS,
+        const entryPointDescriptor = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 11224,
                 tls: false
             }
-        }
+        })
         let entryPoint: DhtNode | undefined = new DhtNode({
-            peerId: binaryToHex(entryPointDescriptor.kademliaId),
+            nodeId: getNodeIdFromPeerDescriptor(entryPointDescriptor),
             websocketHost: entryPointDescriptor.websocket!.host,
             websocketPortRange: {
-                min: entryPointDescriptor.websocket.port,
-                max: entryPointDescriptor.websocket.port
+                min: entryPointDescriptor.websocket!.port,
+                max: entryPointDescriptor.websocket!.port
             },
             entryPoints: [entryPointDescriptor],
             websocketServerEnableTls: false
         })
         await entryPoint.start()
         await entryPoint.joinDht([entryPointDescriptor])
-        let sender: DhtNode | undefined = new DhtNode({})
-        let receiver: DhtNode | undefined = new DhtNode({})
-        /*TODO should this work? await Promise.all([
-            async () => {
+        let sender: DhtNode | undefined = new DhtNode({ entryPoints: [entryPointDescriptor] })
+        let receiver: DhtNode | undefined = new DhtNode({ entryPoints: [entryPointDescriptor] })
+        await Promise.all([
+            (async () => {
                 await sender.start()
                 await sender.joinDht([entryPointDescriptor])
-            },
-            async () => {
+            })(),
+            (async () => {
                 await receiver.start()
                 await receiver.joinDht([entryPointDescriptor])
-            }
-        ])*/
-        await sender.start()
-        await sender.joinDht([entryPointDescriptor])
-        await receiver.start()
-        await receiver.joinDht([entryPointDescriptor])
+            })()
+        ])
 
         let receivedMessage: Message | undefined = undefined
         receiver.on('message', (msg: Message) => receivedMessage = msg)
         const msg: Message = {
             serviceId: 'mock-service-id',
             targetDescriptor: receiver.getLocalPeerDescriptor(),
-            messageType: MessageType.RPC,
             messageId: 'mock-message-id',
             body: {
                 oneofKind: 'rpcMessage',
@@ -72,6 +66,7 @@ describe('memory leak', () => {
 
         const detector1 = new LeakDetector(entryPoint)
         entryPoint = undefined
+        await detector1.isLeaking()
         expect(await detector1.isLeaking()).toBe(false)
 
         const detector2 = new LeakDetector(sender)
@@ -81,5 +76,5 @@ describe('memory leak', () => {
         const detector3 = new LeakDetector(receiver)
         receiver = undefined
         expect(await detector3.isLeaking()).toBe(false)
-    })
+    }, 10000)
 })