@streamr/dht 100.0.0-testnet-three.6 → 100.0.0

package/test/benchmark/RingCorrectness.test.ts

@@ -0,0 +1,157 @@
+/* eslint-disable no-console */
+import { Simulator } from '../../src/connection/simulator/Simulator'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { createMockRingNode } from '../utils/utils'
+import { execSync } from 'child_process'
+import fs from 'fs'
+import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { Logger } from '@streamr/utils'
+import { getRingIdRawFromPeerDescriptor } from '../../src/dht/contact/ringIdentifiers'
+
+const logger = new Logger(module)
+
+describe('Ring correctness', () => {
+    let entryPoint: DhtNode
+    let nodes: DhtNode[]
+    const simulator = new Simulator()
+
+    const NUM_NODES = 900
+    const nodeIndicesById: Record<DhtAddress, number> = {}
+
+    const regions: Array<number> = []
+    for (let i = 0; i < (NUM_NODES + 1); i++) {
+        regions.push(i)
+    }
+
+    // Shuffle the regions
+    for (let i = regions.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1))
+        const temp = regions[i]
+        regions[i] = regions[j]
+        regions[j] = temp
+    }
+
+    if (!fs.existsSync('test/data/nodeids.json')) {
+        console.log('gound truth data does not exist yet, generating..')
+        execSync('npm run prepare-kademlia-simulation')
+    }
+
+    const dhtIds: Array<{ type: string, data: Array<number> }> = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
+    const groundTruth: Record<string, Array<{ name: string, distance: number, id: { type: string, data: Array<number> } }>>
+        = JSON.parse(fs.readFileSync('test/data/orderedneighbors.json').toString())
+
+    beforeEach(async () => {
+        jest.setTimeout(60000)
+        nodes = []
+        entryPoint = await createMockRingNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[0].data)), regions[0])
+        nodes.push(entryPoint)
+        nodeIndicesById[entryPoint.getNodeId()] = 0
+
+        for (let i = 1; i < NUM_NODES; i++) {
+            const node = await createMockRingNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[i].data)), regions[i + 1])
+            nodeIndicesById[node.getNodeId()] = i
+            nodes.push(node)
+        }
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            entryPoint.stop(),
+            ...nodes.map((node) => node.stop())
+        ])
+    })
+
+    it('Can find correct neighbors', async () => {
+        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
+
+        //await Promise.all(
+        //    nodes.map((node) => node.joinDht([entryPoint.getLocalPeerDescriptor()]))
+        //)
+
+        for (let i = 1; i < NUM_NODES; i++) {
+            // time to join the network
+            const startTimestamp = Date.now()
+            await nodes[i].joinDht([entryPoint.getLocalPeerDescriptor()])
+            const endTimestamp = Date.now()
+            logger.info('Node ' + i + ' joined in ' + (endTimestamp - startTimestamp) + ' ms')
+            const ringStartTimestamp = Date.now()
+            await nodes[i].joinRing()
+            const ringEndTimestamp = Date.now()
+            logger.info('Node ' + i + ' joined ring in ' + (ringEndTimestamp - ringStartTimestamp) + ' ms')
+
+        }
+
+        /*
+        for (let i = 1; i < NUM_NODES; i++) {
+            // time to join the network
+            const ringStartTimestamp = Date.now()
+            await nodes[i].joinRing()
+            const ringEndTimestamp = Date.now()
+            logger.info('Node ' + i + ' joined ring in ' + (ringEndTimestamp - ringStartTimestamp) + ' ms')  
+        }*/
+
+        for (let i = 1; i < NUM_NODES; i++) {
+            logger.info('Node ' + i + ', own region: ' + nodes[i].getLocalPeerDescriptor().region
+                + '. Regions of closest ring peers, left: '
+                + nodes[i].getClosestRingContactsTo(
+                    getRingIdRawFromPeerDescriptor(nodes[i].getLocalPeerDescriptor()), 10).left.map((p) => p.region)
+                + ', right: ' + nodes[i].getClosestRingContactsTo(getRingIdRawFromPeerDescriptor(
+                nodes[i].getLocalPeerDescriptor()), 10).right.map((p) => p.region)
+            )
+        }
+
+        let minimumCorrectNeighbors = Number.MAX_SAFE_INTEGER
+        let sumCorrectNeighbors = 0
+        let sumKbucketSize = 1
+
+        for (let i = nodes.length - 1; i >= 0; i--) {
+            let groundTruthString = 'groundTruthNeighb: '
+            // eslint-disable-next-line @typescript-eslint/prefer-for-of
+            for (let j = 0; j < groundTruth[i + ''].length; j++) {
+                groundTruthString += groundTruth[i + ''][j].name + ','
+            }
+
+            const kademliaNeighbors = nodes[i].getClosestContacts(8).map((p) => getNodeIdFromPeerDescriptor(p))
+
+            let kadString = 'kademliaNeighbors: '
+            kademliaNeighbors.forEach((neighbor) => {
+                kadString += nodeIndicesById[neighbor] + ','
+            })
+
+            let correctNeighbors = 0
+            try {
+                for (let j = 0; j < groundTruth[i + ''].length; j++) {
+                    if (groundTruth[i + ''][j].name != (nodeIndicesById[kademliaNeighbors[j]] + '')) {
+                        break
+                    }
+                    correctNeighbors++
+                }
+            } catch (e) {
+                console.error('Node ' + getNodeIdFromPeerDescriptor(nodes[i].getLocalPeerDescriptor()) + ' had only '
+                    + kademliaNeighbors.length + ' kademlia neighbors')
+            }
+            if (correctNeighbors === 0) {
+                console.log('No correct neighbors found for node ' + i)
+                console.log(groundTruthString)
+                console.log(kadString)
+            }
+            if (correctNeighbors < minimumCorrectNeighbors) {
+                console.log('NEW MIN', i, correctNeighbors)
+                minimumCorrectNeighbors = correctNeighbors
+            }
+
+            if (i > 0) {
+                sumKbucketSize += nodes[i].getNeighborCount()
+                sumCorrectNeighbors += correctNeighbors
+            }
+        }
+
+        const avgKbucketSize = sumKbucketSize / (NUM_NODES - 1)
+        const avgCorrectNeighbors = sumCorrectNeighbors / (NUM_NODES - 1)
+
+        console.log('----------- Simulation results ------------------')
+        console.log('Minimum correct neighbors: ' + minimumCorrectNeighbors)
+        console.log('Average correct neighbors: ' + avgCorrectNeighbors)
+        console.log('Average Kbucket size: ' + avgKbucketSize)
+    }, 240000)
+})

package/test/benchmark/hybrid-network-simulation/RingContactList.test.ts

@@ -0,0 +1,72 @@
+import { ConnectivityResponse, PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
+import { createPeerDescriptor } from '../../../src/helpers/createPeerDescriptor'
+import { NatType } from '../../../src/connection/ConnectionManager'
+import { ipv4ToNumber, Logger } from '@streamr/utils'
+import { RingContactList } from '../../../src/dht/contact/RingContactList'
+import { getRingIdRawFromPeerDescriptor } from '../../../src/dht/contact/ringIdentifiers'
+import { getRandomRegion } from '../../../src/connection/simulator/pings'
+
+const logger = new Logger(module)
+
+function ipv4ToString(ip: number): string {
+    return [
+        (ip >>> 24) & 0xFF,
+        (ip >>> 16) & 0xFF,
+        (ip >>> 8) & 0xFF,
+        ip & 0xFF
+    ].join('.')
+}
+
+class MockNode {
+    private readonly peerDescriptor: PeerDescriptor
+
+    constructor(_region: number, ipAddress: string) {
+
+        const connectivityResponse: ConnectivityResponse = {
+            host: 'localhost',
+            natType: NatType.UNKNOWN,
+            ipAddress: ipv4ToNumber(ipAddress),
+            version: '0.0.0'
+
+        }
+        this.peerDescriptor = createPeerDescriptor(connectivityResponse, getRandomRegion())
+        logger.info(ipv4ToString(this.peerDescriptor.ipAddress!))
+    }
+
+    public getPeerDescriptor(): PeerDescriptor {
+        return this.peerDescriptor
+    }
+}
+
+// populate with mock ip addresses
+const mockData: Array< [number, string] > = [
+    [0, '5.2.4.2'],
+    [0, '6.23.2.4'],
+    [0, '7.2.4.2'],
+    [0, '8.23.2.4'],
+    [0, '9.3.2.4'],
+    [0, '10.3.2.4'],
+    [0, '24.23.2.4'],
+    [0, '31.23.2.4'],
+    [0, '33.2.4.2'],
+    [0, '35.3.2.4'],
+    [0, '37.23.2.4'],
+    [0, '39.2.4.2'],
+    [0, '42.3.2.4'],
+    [0, '46.2.4.2'],
+    [0, '48.3.2.4'],
+    [0, '50.23.2.4']
+]
+
+const mockNodes: MockNode[] = mockData.map(([region, ipAddress]) => new MockNode(region, ipAddress))
+const referenceNode = mockNodes[5]
+const ringContactList: RingContactList<MockNode> = new RingContactList<MockNode>(
+    getRingIdRawFromPeerDescriptor(referenceNode.getPeerDescriptor()),
+    false
+)
+
+mockNodes.forEach((node) => ringContactList.addContact(node))
+
+ringContactList.getClosestContacts().left.forEach((node) => logger.info(ipv4ToString(node.getPeerDescriptor().ipAddress!)))
+logger.info('reference node: ' + ipv4ToString(referenceNode.getPeerDescriptor().ipAddress!))
+ringContactList.getClosestContacts().right.forEach((node) => logger.info(ipv4ToString(node.getPeerDescriptor().ipAddress!)))

package/test/data/generateGroundTruthData.ts

@@ -3,8 +3,8 @@ import crypto from 'crypto'
 import KBucket from 'k-bucket'
 import { DhtAddressRaw } from '../../src/identifiers'
 
-const ID_LENGTH = 8
-const NUM_NODES = 2000
+const ID_LENGTH = 20
+const NUM_NODES = 900
 const NUM_NEAREST = 10
 
 const generateId = function(): DhtAddressRaw {

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

@@ -1,7 +1,7 @@
 import LeakDetector from 'jest-leak-detector'
 import { waitForCondition } from '@streamr/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { Message, MessageType } 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'
@@ -48,7 +48,6 @@ describe('memory leak', () => {
         const msg: Message = {
             serviceId: 'mock-service-id',
             targetDescriptor: receiver.getLocalPeerDescriptor(),
-            messageType: MessageType.RPC,
             messageId: 'mock-message-id',
             body: {
                 oneofKind: 'rpcMessage',

package/test/integration/ConnectionManager.test.ts

@@ -6,10 +6,12 @@ import { Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { createPeerDescriptor } from '../../src/helpers/createPeerDescriptor'
 import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
-import { ConnectivityResponse, Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { ConnectivityResponse, Message, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { TransportEvents } from '../../src/transport/ITransport'
 import { createMockPeerDescriptor } from '../utils/utils'
+import { getRandomRegion } from '../../src/connection/simulator/pings'
+import { range } from 'lodash'
 
 const SERVICE_ID = 'demo'
 
@@ -40,7 +42,7 @@ describe('ConnectionManager', () => {
     }
 
     beforeEach(() => {
-        createLocalPeerDescriptor = jest.fn().mockImplementation((response) => createPeerDescriptor(response))
+        createLocalPeerDescriptor = jest.fn().mockImplementation((response) => createPeerDescriptor(response, getRandomRegion()))
     })
 
     beforeAll(async () => {
@@ -85,6 +87,27 @@ describe('ConnectionManager', () => {
         await connectionManager.stop()
     }, 15000)
 
+    it('Succesfully connectivityChecks if at least one entry point is online', async () => {
+        // Create offline PeerDescriptors
+        const entryPoints = range(4).map((i) => {
+            return createMockPeerDescriptor({
+                websocket: { host: '127.0.0.1', port: 12345 + i, tls: false }
+            })
+        })
+        entryPoints.push(createMockPeerDescriptor({
+            websocket: { host: '127.0.0.1', port: 9998, tls: false }
+        }))
+        const connectionManager = createConnectionManager({
+            transport: mockTransport,
+            websocketPortRange: { min: 9998, max: 9998 },
+            entryPoints
+        })
+        await connectionManager.start()
+        expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
+
+        await connectionManager.stop()
+    }, 20000)
+
     it('Can probe connectivity in open internet', async () => {
         const connectionManager1 = createConnectionManager({
             transport: mockTransport,
@@ -134,7 +157,6 @@ describe('ConnectionManager', () => {
 
         const msg: Message = {
             serviceId: SERVICE_ID,
-            messageType: MessageType.RPC,
             messageId: '1',
             body: {
                 oneofKind: 'rpcMessage',
@@ -144,7 +166,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()
             })
         })
@@ -193,7 +215,6 @@ describe('ConnectionManager', () => {
 
         const msg: Message = {
             serviceId: SERVICE_ID,
-            messageType: MessageType.RPC,
             messageId: '1',
             body: {
                 oneofKind: 'rpcMessage',
@@ -217,7 +238,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()
             })
         })
@@ -244,7 +265,6 @@ describe('ConnectionManager', () => {
 
         const msg: Message = {
             serviceId: SERVICE_ID,
-            messageType: MessageType.RPC,
             messageId: '1',
             body: {
                 oneofKind: 'rpcMessage',
@@ -254,7 +274,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()
             })
         })
@@ -309,7 +329,6 @@ describe('ConnectionManager', () => {
         peerDescriptor.nodeId = new Uint8Array([12, 12, 12, 12])
         const msg: Message = {
             serviceId: SERVICE_ID,
-            messageType: MessageType.RPC,
             messageId: '1',
             targetDescriptor: peerDescriptor,
             body: {
@@ -360,7 +379,6 @@ describe('ConnectionManager', () => {
 
         const msg: Message = {
             serviceId: SERVICE_ID,
-            messageType: MessageType.RPC,
             messageId: '1',
             targetDescriptor: {
                 // This is not the correct nodeId of peerDescriptor2

package/test/integration/ConnectivityChecking.test.ts

@@ -4,7 +4,7 @@ import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { MockTransport } from '../utils/mock/Transport'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { sendConnectivityRequest } from '../../src/connection/connectivityChecker'
-import { version } from '../../package.json'
+import { LOCAL_PROTOCOL_VERSION } from '../../src/helpers/version'
 
 describe('ConnectivityChecking', () => {
 
@@ -46,19 +46,7 @@ describe('ConnectivityChecking', () => {
             tls: false,
             selfSigned: false
         }
-        const response = await sendConnectivityRequest(request, server.getLocalPeerDescriptor(), version)
-        expect(response.version).toEqual(version)
+        const response = await sendConnectivityRequest(request, server.getLocalPeerDescriptor())
+        expect(response.version).toEqual(LOCAL_PROTOCOL_VERSION)
     })
-
-    it('connectivityCheck with incompatible version', async () => {
-        const request = {
-            host: HOST,
-            port: PORT,
-            tls: false,
-            selfSigned: false
-        }
-        await expect(sendConnectivityRequest(request, server.getLocalPeerDescriptor(), '0.0.1'))
-            .toReject()
-    })
-
 })

package/test/integration/DhtNodeExternalAPI.test.ts

@@ -25,22 +25,22 @@ describe('DhtNodeExternalApi', () => {
         simulator.stop()
     })
 
-    it('findData happy path', async () => {
+    it('fetch data happy path', async () => {
         const entry = createMockDataEntry()
         await dhtNode1.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
-        const foundData = await remote.findDataViaPeer(getDhtAddressFromRaw(entry.key), dhtNode1.getLocalPeerDescriptor())
+        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(createRandomDhtAddress(), 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 entry = createMockDataEntry()
-        await remote.storeDataViaPeer(getDhtAddressFromRaw(entry.key), entry.data!, dhtNode1.getLocalPeerDescriptor())
-        const foundData = await remote.findDataViaPeer(getDhtAddressFromRaw(entry.key), dhtNode1.getLocalPeerDescriptor())
+        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()))
     })

package/test/integration/Find.test.ts

@@ -1,6 +1,6 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerDescriptor, RecursiveOperation } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
 import { getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
 
@@ -37,9 +37,9 @@ describe('Find correctness', () => {
 
     it('Entrypoint can find a node from the network (exact match)', async () => {
         const targetId = getRawFromDhtAddress(nodes[45].getNodeId())
-        const results = await entryPoint.executeRecursiveOperation(getDhtAddressFromRaw(targetId), RecursiveOperation.FIND_NODE)
-        expect(results.closestNodes.length).toBeGreaterThanOrEqual(5)
-        expect(getDhtAddressFromRaw(targetId)).toEqual(getNodeIdFromPeerDescriptor(results.closestNodes[0]))
+        const closestNodes = await entryPoint.findClosestNodesFromDht(getDhtAddressFromRaw(targetId))
+        expect(closestNodes.length).toBeGreaterThanOrEqual(5)
+        expect(getDhtAddressFromRaw(targetId)).toEqual(getNodeIdFromPeerDescriptor(closestNodes[0]))
     }, 30000)
 
 })

package/test/integration/Layer1-scale.test.ts

@@ -159,7 +159,6 @@ describe('Layer1', () => {
     //                 const message: Message = {
     //                     serviceId: 'service',
     //                     messageId: v4(),
-    //                     messageType: MessageType.RPC,
     //                     body: {
     //                         oneofKind: 'rpcMessage',
     //                         rpcMessage: rpcWrapper

package/test/integration/ReplicateData.test.ts

@@ -99,7 +99,7 @@ describe('Replicate data from node to node in DHT', () => {
         }))
 
         const randomNonStoppedNode = sample(nodes.filter((n) => !stoppedNodeIds.includes(n.getNodeId())))!
-        const data = await randomNonStoppedNode.getDataFromDht(getDhtAddressFromRaw(DATA.key))
+        const data = await randomNonStoppedNode.fetchDataFromDht(getDhtAddressFromRaw(DATA.key))
         expect(data).toHaveLength(1)
         expectEqualData(data[0], DATA)
     }, 180000)

package/test/integration/RouteMessage.test.ts

@@ -1,5 +1,5 @@
 import { DhtNode, Events as DhtNodeEvents } from '../../src/dht/DhtNode'
-import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { Logger, runAndWaitForEvents3, waitForCondition } from '@streamr/utils'
 import { createMockConnectionDhtNode, createWrappedClosestPeersRequest } from '../utils/utils'
@@ -64,7 +64,6 @@ describe('Route Message With Mock Connections', () => {
         const message: Message = {
             serviceId: 'unknown',
             messageId: v4(),
-            messageType: MessageType.RPC,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: rpcWrapper
@@ -98,7 +97,6 @@ describe('Route Message With Mock Connections', () => {
             const message: Message = {
                 serviceId: 'unknown',
                 messageId: v4(),
-                messageType: MessageType.RPC,
                 body: {
                     oneofKind: 'rpcMessage',
                     rpcMessage: rpcWrapper
@@ -136,7 +134,6 @@ describe('Route Message With Mock Connections', () => {
                         const message: Message = {
                             serviceId: 'nonexisting_service',
                             messageId: v4(),
-                            messageType: MessageType.RPC,
                             body: {
                                 oneofKind: 'rpcMessage',
                                 rpcMessage: rpcWrapper
@@ -171,7 +168,6 @@ describe('Route Message With Mock Connections', () => {
         const closestPeersRequestMessage: Message = {
             serviceId: 'unknown',
             messageId: v4(),
-            messageType: MessageType.RPC,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: closestPeersRequest
@@ -202,7 +198,6 @@ describe('Route Message With Mock Connections', () => {
         const requestMessage: Message = {
             serviceId: 'layer0',
             messageId: v4(),
-            messageType: MessageType.RPC,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage

package/test/integration/RouterRpcRemote.test.ts

@@ -1,6 +1,6 @@
 import { RpcCommunicator } from '@streamr/proto-rpc'
 import { RouterRpcRemote } from '../../src/dht/routing/RouterRpcRemote'
-import { Message, MessageType, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RouterRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { createMockPeerDescriptor, createWrappedClosestPeersRequest, mockRouterRpc } from '../utils/utils'
@@ -34,7 +34,6 @@ describe('RemoteRouter', () => {
         const routed: Message = {
             serviceId: SERVICE_ID,
             messageId: 'routed',
-            messageType: MessageType.RPC,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: rpcWrapper
@@ -58,7 +57,6 @@ describe('RemoteRouter', () => {
         const routed: Message = {
             serviceId: SERVICE_ID,
             messageId: 'routed',
-            messageType: MessageType.RPC,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: rpcWrapper

package/test/integration/SimultaneousConnections.test.ts

@@ -3,7 +3,7 @@ import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { Message, MessageType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
@@ -12,7 +12,6 @@ import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const BASE_MESSAGE: Message = {
     serviceId: 'serviceId',
-    messageType: MessageType.RPC,
     messageId: '1',
     body: {
         oneofKind: 'rpcMessage',
@@ -63,13 +62,13 @@ describe('SimultaneousConnections', () => {
 
         const promise1 = new Promise<void>((resolve, _reject) => {
             simTransport1.on('message', async (message: Message) => {
-                expect(message.messageType).toBe(MessageType.RPC)
+                expect(message.body.oneofKind).toBe('rpcMessage')
                 resolve()
             })
         })
         const promise2 = new Promise<void>((resolve, _reject) => {
             simTransport2.on('message', async (message: Message) => {
-                expect(message.messageType).toBe(MessageType.RPC)
+                expect(message.body.oneofKind).toBe('rpcMessage')
                 resolve()
             })
         })
@@ -142,13 +141,13 @@ describe('SimultaneousConnections', () => {
 
             const promise1 = new Promise<void>((resolve, _reject) => {
                 connectionManager1.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
             const promise2 = new Promise<void>((resolve, _reject) => {
                 connectionManager2.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
@@ -222,13 +221,13 @@ describe('SimultaneousConnections', () => {
 
             const promise1 = new Promise<void>((resolve, _reject) => {
                 connectionManager1.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
             const promise2 = new Promise<void>((resolve, _reject) => {
                 connectionManager2.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
@@ -290,13 +289,13 @@ describe('SimultaneousConnections', () => {
 
             const promise1 = new Promise<void>((resolve, _reject) => {
                 connectionManager1.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })
             const promise2 = new Promise<void>((resolve, _reject) => {
                 connectionManager2.on('message', async (message: Message) => {
-                    expect(message.messageType).toBe(MessageType.RPC)
+                    expect(message.body.oneofKind).toBe('rpcMessage')
                     resolve()
                 })
             })

package/test/integration/Store.test.ts

@@ -59,7 +59,7 @@ describe('Storing data in DHT', () => {
         )
         expect(successfulStorers.length).toBeGreaterThan(4)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(getDhtAddressFromRaw(entry.key))
+        const results = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
         results.forEach((result) => {
             expectEqualData(result, entry)
         })
@@ -76,7 +76,7 @@ describe('Storing data in DHT', () => {
         )
         expect(successfulStorers.length).toBeGreaterThan(4)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(getDhtAddressFromRaw(entry.key))
+        const results = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
         results.forEach((result) => {
             expectEqualData(result, entry)
             expect(getDhtAddressFromRaw(result.creator)).toEqual(getNodeIdFromPeerDescriptor(requestor))