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

package/test/integration/ConnectionLocking.test.ts

@@ -3,10 +3,11 @@ import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { ITransport } from '../../src/exports'
-import { PeerID } from '../../src/helpers/PeerID'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { ITransport } from '../../src/transport/ITransport'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { getRandomRegion } from '../../dist/src/connection/simulator/pings'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
@@ -20,23 +21,16 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
 
 describe('Connection Locking', () => {
 
-    const mockPeerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('mock1').value,
-        type: NodeType.NODEJS,
+    const mockPeerDescriptor1 = createMockPeerDescriptor({
         region: getRandomRegion()
-    }
-    const mockPeerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('mock2').value,
-        type: NodeType.NODEJS,
+    })
+    const mockPeerDescriptor2 = createMockPeerDescriptor({
         region: getRandomRegion()
-    }
-
+    })
     let mockConnectorTransport1: ConnectionManager
     let mockConnectorTransport2: ConnectionManager
-
     let connectionManager1: ConnectionManager
     let connectionManager2: ConnectionManager
-
     let simulator: Simulator
 
     beforeEach(async () => {
@@ -62,114 +56,126 @@ describe('Connection Locking', () => {
     })
 
     it('can lock connections', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
         ])
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(true)
-        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
+        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
     })
 
     it('Multiple services on the same peer', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(true)
-        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
+        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
     })
 
     it('can unlock connections', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
         ])
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2))
-        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(false)
-        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager2.hasLocalLockedConnection(nodeId2)).toEqual(false)
+        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock')
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(false)
-        await waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1) === false)
-        expect(connectionManager1.hasConnection(mockPeerDescriptor1)).toEqual(false)
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(false)
+        await waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1) === false)
+        expect(connectionManager1.hasConnection(nodeId1)).toEqual(false)
     })
 
     it('unlocking multiple services', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
 
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2))
-        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)).toEqual(false)
+        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(false)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(true)
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock2')
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(false)
-        expect(connectionManager1.hasConnection(mockPeerDescriptor1)).toEqual(false)
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(false)
+        expect(connectionManager1.hasConnection(nodeId1)).toEqual(false)
     })
 
     it('maintains connection if both sides initially lock and then one end unlocks', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
-            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
             connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
         ])
 
-        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2))
-        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1))
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2))
+        expect(connectionManager2.hasLocalLockedConnection(nodeId1))
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
         await waitForCondition(() =>
-            connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)
-            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)
-            && !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)
-            && connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)
+            connectionManager1.hasRemoteLockedConnection(nodeId2)
+            && !connectionManager1.hasLocalLockedConnection(nodeId2)
+            && !connectionManager2.hasRemoteLockedConnection(nodeId1)
+            && connectionManager2.hasLocalLockedConnection(nodeId1)
         )
         
-        expect(connectionManager2.hasConnection(mockPeerDescriptor1)).toEqual(true)
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
+        expect(connectionManager2.hasConnection(nodeId1)).toEqual(true)
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
     })
 
     it('unlocks after graceful disconnect', async () => {
+        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
+        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
-            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
             connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
         ])
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2))
-        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)).toEqual(true)
-        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(true)
+        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
 
         //@ts-expect-error private field
         await connectionManager1.gracefullyDisconnectAsync(mockPeerDescriptor2)
         
         await waitForCondition(() =>
-            !connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)
-            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)
+            !connectionManager1.hasRemoteLockedConnection(nodeId2)
+            && !connectionManager1.hasLocalLockedConnection(nodeId2)
         )
         await waitForCondition(() =>
-            !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)
-            && !connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)
+            !connectionManager2.hasRemoteLockedConnection(nodeId1)
+            && !connectionManager2.hasLocalLockedConnection(nodeId1)
         )
-        await waitForCondition(() => !connectionManager2.hasConnection(mockPeerDescriptor1))
-        await waitForCondition(() => !connectionManager1.hasConnection(mockPeerDescriptor2))
+        await waitForCondition(() => !connectionManager2.hasConnection(nodeId1))
+        await waitForCondition(() => !connectionManager1.hasConnection(nodeId2))
 
-        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(false)
-        expect(connectionManager2.hasConnection(mockPeerDescriptor1)).toEqual(false)
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(false)
+        expect(connectionManager2.hasConnection(nodeId1)).toEqual(false)
     }, 10000)
 })

package/test/integration/ConnectionManager.test.ts

@@ -1,45 +1,32 @@
+import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
+import { MarkOptional } from 'ts-essentials'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { ConnectivityResponse, Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID } from '../../src/helpers/PeerID'
+import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
 import { Simulator } from '../../src/connection/simulator/Simulator'
-import { createPeerDescriptor } from '../../src/dht/DhtNode'
+import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
+import { createPeerDescriptor } from '../../src/helpers/createPeerDescriptor'
+import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+import { ConnectivityResponse, Message, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
-import { SimulatorTransport } from '../../src/exports'
-import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
-import { MarkOptional } from 'ts-essentials'
-import { createRandomKademliaId } from '../../src/helpers/kademliaId'
 import { TransportEvents } from '../../src/transport/ITransport'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { getRandomRegion } from '../../src/connection/simulator/pings'
+
+const SERVICE_ID = 'demo'
 
 const logger = new Logger(module)
 
 // TODO: refactor this test file to use beforeEach and AfterEach for proper teardown
 describe('ConnectionManager', () => {
-    const serviceId = 'demo'
 
-    const mockPeerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('tester1').value,
-        type: NodeType.NODEJS
-    }
-    const mockPeerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('tester2').value,
-        type: NodeType.NODEJS
-    }
-
-    const mockPeerDescriptor3: PeerDescriptor = {
-        kademliaId: PeerID.fromString('tester3').value,
-        type: NodeType.NODEJS
-    }
-    const mockPeerDescriptor4: PeerDescriptor = {
-        kademliaId: PeerID.fromString('tester4').value,
-        type: NodeType.NODEJS
-    }
+    const mockPeerDescriptor1 = createMockPeerDescriptor()
+    const mockPeerDescriptor2 = createMockPeerDescriptor()
+    const mockPeerDescriptor3 = createMockPeerDescriptor()
+    const mockPeerDescriptor4 = createMockPeerDescriptor()
     const simulator = new Simulator()
-
     const mockTransport = new SimulatorTransport(mockPeerDescriptor1, simulator)
     const mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
     const mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)
-
     let createLocalPeerDescriptor: jest.Mock<PeerDescriptor, [ConnectivityResponse]>
 
     const createConnectionManager = (opts: MarkOptional<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
@@ -54,7 +41,7 @@ describe('ConnectionManager', () => {
     }
 
     beforeEach(() => {
-        createLocalPeerDescriptor = jest.fn().mockImplementation((response) => createPeerDescriptor(response))
+        createLocalPeerDescriptor = jest.fn().mockImplementation((response) => createPeerDescriptor(response, getRandomRegion()))
     })
 
     beforeAll(async () => {
@@ -85,12 +72,13 @@ describe('ConnectionManager', () => {
 
     it('Throws an async exception if fails to connect to entrypoints', async () => {
 
+        const entryPoint = createMockPeerDescriptor({
+            websocket: { host: '127.0.0.1', port: 12345, tls: false }
+        })
         const connectionManager = createConnectionManager({
             transport: mockTransport,
             websocketPortRange: { min: 9992, max: 9992 },
-            entryPoints: [
-                { kademliaId: Uint8Array.from([1, 2, 3]), type: NodeType.NODEJS, websocket: { host: '127.0.0.1', port: 12345, tls: false } }
-            ]
+            entryPoints: [entryPoint]
         })
 
         await expect(connectionManager.start()).rejects.toThrow('Failed to connect to the entrypoints')
@@ -108,12 +96,13 @@ describe('ConnectionManager', () => {
         await connectionManager1.start()
         expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
 
+        const entryPoint = createMockPeerDescriptor({
+            websocket: { host: '127.0.0.1', port: 9993, tls: false } 
+        })
         const connectionManager2 = createConnectionManager({
             transport: mockConnectorTransport2,
             websocketPortRange: { min: 9994, max: 9994 },
-            entryPoints: [
-                { kademliaId: Uint8Array.from([1, 2, 3]), type: NodeType.NODEJS, websocket: { host: '127.0.0.1', port: 9993, tls: false } }
-            ]
+            entryPoints: [entryPoint]
         })
 
         await connectionManager2.start()
@@ -145,8 +134,7 @@ describe('ConnectionManager', () => {
         expect(createLocalPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
 
         const msg: Message = {
-            serviceId,
-            messageType: MessageType.RPC,
+            serviceId: SERVICE_ID,
             messageId: '1',
             body: {
                 oneofKind: 'rpcMessage',
@@ -156,7 +144,7 @@ describe('ConnectionManager', () => {
 
         const promise = new Promise<void>((resolve, _reject) => {
             connectionManager2.on('message', async (message: Message) => {
-                expect(message.messageType).toBe(MessageType.RPC)
+                expect(message.body.oneofKind).toBe('rpcMessage')
                 resolve()
             })
         })
@@ -204,8 +192,7 @@ describe('ConnectionManager', () => {
         await connectionManager2.start()
 
         const msg: Message = {
-            serviceId,
-            messageType: MessageType.RPC,
+            serviceId: SERVICE_ID,
             messageId: '1',
             body: {
                 oneofKind: 'rpcMessage',
@@ -229,7 +216,7 @@ describe('ConnectionManager', () => {
 
         const promise = new Promise<void>((resolve, _reject) => {
             connectionManager2.on('message', async (message: Message) => {
-                expect(message.messageType).toBe(MessageType.RPC)
+                expect(message.body.oneofKind).toBe('rpcMessage')
                 resolve()
             })
         })
@@ -255,8 +242,7 @@ describe('ConnectionManager', () => {
         await connectionManager4.start()
 
         const msg: Message = {
-            serviceId,
-            messageType: MessageType.RPC,
+            serviceId: SERVICE_ID,
             messageId: '1',
             body: {
                 oneofKind: 'rpcMessage',
@@ -266,7 +252,7 @@ describe('ConnectionManager', () => {
 
         const dataPromise = new Promise<void>((resolve, _reject) => {
             connectionManager4.on('message', async (message: Message) => {
-                expect(message.messageType).toBe(MessageType.RPC)
+                expect(message.body.oneofKind).toBe('rpcMessage')
                 resolve()
             })
         })
@@ -304,9 +290,10 @@ describe('ConnectionManager', () => {
         await Promise.all([disconnectedPromise1, disconnectedPromise2])
         await connectionManager3.stop()
         await connectionManager4.stop()
+        simulator2.stop()
     })
 
-    it('Cannot send to own WebsocketServer if kademliaIds do not match', async () => {
+    it('Cannot send to own WebsocketServer if nodeIds do not match', async () => {
         const connectionManager1 = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
@@ -317,10 +304,9 @@ describe('ConnectionManager', () => {
         expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
         
         const peerDescriptor = connectionManager1.getLocalPeerDescriptor()
-        peerDescriptor.kademliaId = new Uint8Array([12, 12, 12, 12])
+        peerDescriptor.nodeId = new Uint8Array([12, 12, 12, 12])
         const msg: Message = {
-            serviceId,
-            messageType: MessageType.RPC,
+            serviceId: SERVICE_ID,
             messageId: '1',
             targetDescriptor: peerDescriptor,
             body: {
@@ -335,27 +321,22 @@ describe('ConnectionManager', () => {
         await connectionManager1.stop()
     })
 
-    it('Cannot send to a WebSocketServer if kademliaIds do not match', async () => {
+    it('Cannot send to a WebSocketServer if nodeIds do not match', async () => {
 
-        const peerDescriptor1 = {
-            kademliaId: createRandomKademliaId(),
-            type: NodeType.NODEJS,
+        const peerDescriptor1 = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 10002,
                 tls: false
             }
-        }
-
-        const peerDescriptor2 = {
-            kademliaId: createRandomKademliaId(),
-            type: NodeType.NODEJS,
+        })
+        const peerDescriptor2 = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 10003,
                 tls: false
             }
-        }
+        })
         const connectionManager1 = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
@@ -375,12 +356,11 @@ describe('ConnectionManager', () => {
         await connectionManager2.start()
 
         const msg: Message = {
-            serviceId,
-            messageType: MessageType.RPC,
+            serviceId: SERVICE_ID,
             messageId: '1',
             targetDescriptor: {
-                // This is not the correct kademliaId of peerDescriptor2
-                kademliaId: new Uint8Array([1, 2, 3, 4]),
+                // This is not the correct nodeId of peerDescriptor2
+                nodeId: getRawFromDhtAddress(createRandomDhtAddress()),
                 type: NodeType.NODEJS,
                 websocket: peerDescriptor2.websocket
             },
@@ -404,7 +384,7 @@ describe('ConnectionManager', () => {
         const connectionManager1 = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
-            autoCertifierUrl: 'https://localhost:12333',
+            autoCertifierUrl: 'https://127.0.0.1:12333',
             websocketServerEnableTls: true,
             websocketPortRange: { min: 10004, max: 10004 }
         })

package/test/integration/ConnectivityChecking.test.ts

@@ -0,0 +1,52 @@
+import { MetricsContext } from '@streamr/utils'
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
+import { MockTransport } from '../utils/mock/Transport'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { sendConnectivityRequest } from '../../src/connection/connectivityChecker'
+import { LOCAL_PROTOCOL_VERSION } from '../../src/helpers/version'
+
+describe('ConnectivityChecking', () => {
+
+    let server: ConnectionManager
+    const PORT = 15000
+    const HOST = '127.0.0.1'
+
+    beforeEach(async () => {
+        server = new ConnectionManager({
+            createConnectorFacade: () => new DefaultConnectorFacade({
+                createLocalPeerDescriptor: () => {
+                    return {
+                        ...createMockPeerDescriptor(),
+                        websocket: {
+                            host: HOST,
+                            port: PORT,
+                            tls: false
+                        }
+                    }
+                },
+                websocketHost: HOST,
+                websocketPortRange: { min: PORT, max: PORT },
+                websocketServerEnableTls: false,
+                transport: new MockTransport()
+            }),
+            metricsContext: new MetricsContext()
+        })
+        await server.start()
+    })
+
+    afterEach(async () => {
+        await server.stop()
+    })
+
+    it('connectivityCheck with compatible version', async () => {
+        const request = {
+            host: HOST,
+            port: PORT,
+            tls: false,
+            selfSigned: false
+        }
+        const response = await sendConnectivityRequest(request, server.getLocalPeerDescriptor())
+        expect(response.version).toEqual(LOCAL_PROTOCOL_VERSION)
+    })
+})

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -1,34 +1,30 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createMockConnectionDhtNode } from '../utils/utils'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { createMockConnectionDhtNode, createMockPeerDescriptor } from '../utils/utils'
 
 const NUM_OF_NODES_PER_KBUCKET = 8
 
 const runTest = async (latencyType: LatencyType) => {
     const simulator = new Simulator(latencyType)
-    const entryPointId = '0'
-    const entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, NUM_OF_NODES_PER_KBUCKET)
-    const entrypointDescriptor = {
-        kademliaId: entryPoint.getNodeId().value,
-        type: NodeType.NODEJS,
+    const entrypointDescriptor = createMockPeerDescriptor({
         region: getRandomRegion()
-    }
+    })
+    const entryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(entrypointDescriptor.nodeId), NUM_OF_NODES_PER_KBUCKET)
     const nodes: DhtNode[] = []
     for (let i = 1; i < 100; i++) {
-        const nodeId = `${i}`
-        const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, NUM_OF_NODES_PER_KBUCKET)
+        const node = await createMockConnectionDhtNode(simulator, undefined, NUM_OF_NODES_PER_KBUCKET)
         nodes.push(node)
     }
 
     await entryPoint.joinDht([entrypointDescriptor])
     await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
     nodes.forEach((node) => {
-        expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+        expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         expect(node.getClosestContacts().length).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
     })
-    expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+    expect(entryPoint.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
 
     await Promise.all([
         entryPoint.stop(),

package/test/integration/DhtNodeExternalAPI.test.ts

@@ -1,9 +1,8 @@
-import { DhtNode } from '../../src/dht/DhtNode'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { createRandomDhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
 import { createMockConnectionDhtNode } from '../utils/utils'
-import { Any } from '../../src/proto/google/protobuf/any'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID } from '../../src/helpers/PeerID'
 
 describe('DhtNodeExternalApi', () => {
 
@@ -13,8 +12,8 @@ describe('DhtNodeExternalApi', () => {
 
     beforeEach(async () => {
         simulator = new Simulator(LatencyType.NONE)
-        dhtNode1 = await createMockConnectionDhtNode('node1', simulator)
-        remote = await createMockConnectionDhtNode('remote', simulator)
+        dhtNode1 = await createMockConnectionDhtNode(simulator)
+        remote = await createMockConnectionDhtNode(simulator)
         await dhtNode1.joinDht([dhtNode1.getLocalPeerDescriptor()])
     })
 
@@ -26,27 +25,24 @@ describe('DhtNodeExternalApi', () => {
         simulator.stop()
     })
 
-    it('findData happy path', async () => {
-        const data = Any.pack(dhtNode1.getLocalPeerDescriptor(), PeerDescriptor)
-        const key = PeerID.fromString('key').value
-        await dhtNode1.storeDataToDht(key, data)
-
-        const foundData = await remote.findDataViaPeer(key, dhtNode1.getLocalPeerDescriptor())
-        expect(Any.unpack(foundData[0].data!, PeerDescriptor)).toEqual(dhtNode1.getLocalPeerDescriptor())
+    it('fetch data happy path', async () => {
+        const entry = createMockDataEntry()
+        await dhtNode1.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
+        const foundData = await remote.fetchDataFromDhtViaPeer(getDhtAddressFromRaw(entry.key), dhtNode1.getLocalPeerDescriptor())
+        expectEqualData(foundData[0], entry)
     })
     
-    it('findData returns empty array if no data found', async () => {
-        const foundData = await remote.findDataViaPeer(PeerID.fromString('key').value, dhtNode1.getLocalPeerDescriptor())
+    it('fetch data returns empty array if no data found', async () => {
+        const foundData = await remote.fetchDataFromDhtViaPeer(createRandomDhtAddress(), dhtNode1.getLocalPeerDescriptor())
         expect(foundData).toEqual([])
     })
 
     it('external store data happy path', async () => {
-        const data = Any.pack(dhtNode1.getLocalPeerDescriptor(), PeerDescriptor)
-        const key = PeerID.fromString('key').value 
-
-        await remote.storeDataViaPeer(key, data, dhtNode1.getLocalPeerDescriptor())
-        const foundData = await remote.findDataViaPeer(key, dhtNode1.getLocalPeerDescriptor())
-        expect(Any.unpack(foundData[0].data!, PeerDescriptor)).toEqual(dhtNode1.getLocalPeerDescriptor())
+        const entry = createMockDataEntry()
+        await remote.storeDataToDhtViaPeer(getDhtAddressFromRaw(entry.key), entry.data!, dhtNode1.getLocalPeerDescriptor())
+        const foundData = await remote.fetchDataFromDhtViaPeer(getDhtAddressFromRaw(entry.key), dhtNode1.getLocalPeerDescriptor())
+        expectEqualData(foundData[0], entry)
+        expect(getDhtAddressFromRaw(foundData[0].creator)).toEqual(getNodeIdFromPeerDescriptor(remote.getLocalPeerDescriptor()))
     })
   
 })