@streamr/dht 0.0.1-tatum.0

package/test/integration/SimultaneousConnections.test.ts

@@ -0,0 +1,308 @@
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { PeerID } from '../../src/helpers/PeerID'
+import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { waitForCondition } from '@streamr/utils'
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+
+describe('SimultaneousConnections', () => {
+
+    let simulator: Simulator
+    let simulatorTransport1: SimulatorTransport
+    let simulatorTransport2: SimulatorTransport
+
+    const peerDescriptor1 = {
+        kademliaId: PeerID.fromString('mock1').value,
+        type: 0,
+        nodeName: 'mock1'
+    }
+
+    const peerDescriptor2 = {
+        kademliaId: PeerID.fromString('mock2').value,
+        type: 0,
+        nodeName: 'mock2'
+    }
+
+    const baseMsg: Message = {
+        serviceId: 'serviceId',
+        messageType: MessageType.RPC,
+        messageId: '1',
+        body: {
+            oneofKind: 'rpcMessage',
+            rpcMessage: RpcMessage.create()
+        }
+    }
+
+    beforeEach(async () => {
+        simulator = new Simulator()
+        simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
+    })
+
+    afterEach(async () => {
+        await simulatorTransport1.stop()
+        await simulatorTransport2.stop()
+    })
+
+    it('simultanous simulated connection', async () => {
+        const msg1: Message = {
+            ...baseMsg,
+            targetDescriptor: peerDescriptor2
+        }
+        const msg2: Message = {
+            ...baseMsg,
+            targetDescriptor: peerDescriptor1
+        }
+
+        const promise1 = new Promise<void>((resolve, _reject) => {
+            simulatorTransport1.on('message', async (message: Message) => {
+                expect(message.messageType).toBe(MessageType.RPC)
+                resolve()
+            })
+        })
+        const promise2 = new Promise<void>((resolve, _reject) => {
+            simulatorTransport2.on('message', async (message: Message) => {
+                expect(message.messageType).toBe(MessageType.RPC)
+                resolve()
+            })
+        })
+        await Promise.all([
+            promise1,
+            promise2,
+            simulatorTransport1.send(msg1),
+            simulatorTransport2.send(msg2)
+        ])
+        await waitForCondition(() => simulatorTransport2.hasConnection(peerDescriptor1))
+        await waitForCondition(() => simulatorTransport1.hasConnection(peerDescriptor2))
+    })
+
+    describe('Websocket 2 servers', () => {
+
+        let connectionManager1: ConnectionManager
+        let connectionManager2: ConnectionManager
+
+        const wsPeer1: PeerDescriptor = {
+            kademliaId: PeerID.fromString('mock1').value,
+            nodeName: 'mock1WebSocket',
+            type: NodeType.NODEJS,
+            websocket: {
+                ip: '127.0.0.1',
+                port: 43432
+            }
+        }
+
+        const wsPeer2: PeerDescriptor = {
+            kademliaId: PeerID.fromString('mock2').value,
+            nodeName: 'mock2WebSocket',
+            type: NodeType.NODEJS,
+            websocket: {
+                ip: '127.0.0.1',
+                port: 43433
+            }
+        }
+
+        beforeEach(async () => {
+            connectionManager1 = new ConnectionManager({
+                transportLayer: simulatorTransport1,
+                ownPeerDescriptor: wsPeer1,
+                webSocketPort: 43432,
+                entryPoints: [wsPeer1]
+            })
+            connectionManager2 = new ConnectionManager({
+                transportLayer: simulatorTransport2,
+                ownPeerDescriptor: wsPeer2,
+                webSocketPort: 43433,
+                entryPoints: [wsPeer1]
+            })
+            await connectionManager1.start(() => wsPeer1)
+            await connectionManager2.start(() => wsPeer2)
+        })
+
+        afterEach(async () => {
+            await connectionManager1.stop()
+            await connectionManager2.stop()
+        })
+
+        it('Simultaneous Connections', async () => {
+            const msg1: Message = {
+                ...baseMsg,
+                targetDescriptor: wsPeer2
+            }
+            const msg2: Message = {
+                ...baseMsg,
+                targetDescriptor: wsPeer1
+            }
+
+            const promise1 = new Promise<void>((resolve, _reject) => {
+                connectionManager1.on('message', async (message: Message) => {
+                    expect(message.messageType).toBe(MessageType.RPC)
+                    resolve()
+                })
+            })
+            const promise2 = new Promise<void>((resolve, _reject) => {
+                connectionManager2.on('message', async (message: Message) => {
+                    expect(message.messageType).toBe(MessageType.RPC)
+                    resolve()
+                })
+            })
+
+            await Promise.all([
+                promise1,
+                promise2,
+                connectionManager1.send(msg1),
+                connectionManager2.send(msg2)
+            ])
+
+            await waitForCondition(() => connectionManager1.hasConnection(wsPeer2))
+            await waitForCondition(() => connectionManager2.hasConnection(wsPeer1))
+        })
+    })
+
+    describe('Websocket 1 server (ConnectionRequests)', () => {
+
+        let connectionManager1: ConnectionManager
+        let connectionManager2: ConnectionManager
+
+        const wsPeer1: PeerDescriptor = {
+            kademliaId: PeerID.fromString('mock1').value,
+            nodeName: 'mock1WebSocketServer',
+            type: NodeType.NODEJS,
+            websocket: {
+                ip: '127.0.0.1',
+                port: 43432
+            }
+        }
+
+        const wsPeer2: PeerDescriptor = {
+            kademliaId: PeerID.fromString('mock2').value,
+            nodeName: 'mock2WebSocketClient',
+            type: NodeType.NODEJS
+        }
+
+        beforeEach(async () => {
+            connectionManager1 = new ConnectionManager({
+                transportLayer: simulatorTransport1,
+                ownPeerDescriptor: wsPeer1,
+                webSocketPort: 43432,
+                entryPoints: [wsPeer1]
+            })
+            connectionManager2 = new ConnectionManager({
+                transportLayer: simulatorTransport2,
+                ownPeerDescriptor: wsPeer2
+            })
+            await connectionManager1.start(() => wsPeer1)
+            await connectionManager2.start(() => wsPeer2)
+        })
+
+        afterEach(async () => {
+            await connectionManager1.stop()
+            await connectionManager2.stop()
+        })
+
+        it('Simultaneous Connections', async () => {
+            const msg1: Message = {
+                ...baseMsg,
+                targetDescriptor: wsPeer2
+            }
+            const msg2: Message = {
+                ...baseMsg,
+                targetDescriptor: wsPeer1
+            }
+
+            const promise1 = new Promise<void>((resolve, _reject) => {
+                connectionManager1.on('message', async (message: Message) => {
+                    expect(message.messageType).toBe(MessageType.RPC)
+                    resolve()
+                })
+            })
+            const promise2 = new Promise<void>((resolve, _reject) => {
+                connectionManager2.on('message', async (message: Message) => {
+                    expect(message.messageType).toBe(MessageType.RPC)
+                    resolve()
+                })
+            })
+
+            await Promise.all([
+                promise1,
+                promise2,
+                connectionManager1.send(msg1),
+                connectionManager2.send(msg2)
+            ])
+
+            await waitForCondition(() => connectionManager1.hasConnection(wsPeer2))
+            await waitForCondition(() => connectionManager2.hasConnection(wsPeer1))
+        })
+    })
+
+    describe('WebRTC', () => {
+
+        let connectionManager1: ConnectionManager
+        let connectionManager2: ConnectionManager
+
+        const wrtcPeer1: PeerDescriptor = {
+            kademliaId: PeerID.fromString('mock1').value,
+            nodeName: 'mock1WebRTC',
+            type: NodeType.NODEJS
+        }
+
+        const wrtcPeer2: PeerDescriptor = {
+            kademliaId: PeerID.fromString('mock2').value,
+            nodeName: 'mock2WebRTC',
+            type: NodeType.NODEJS
+        }
+
+        beforeEach(async () => {
+            connectionManager1 = new ConnectionManager({
+                transportLayer: simulatorTransport1,
+                ownPeerDescriptor: wrtcPeer1,
+            })
+            connectionManager2 = new ConnectionManager({
+                transportLayer: simulatorTransport2,
+                ownPeerDescriptor: wrtcPeer1,
+            })
+            await connectionManager1.start(() => wrtcPeer1)
+            await connectionManager2.start(() => wrtcPeer2)
+        })
+
+        afterEach(async () => {
+            await connectionManager1.stop()
+            await connectionManager2.stop()
+        })
+
+        it('Simultaneous Connections', async () => {
+            const msg1: Message = {
+                ...baseMsg,
+                targetDescriptor: wrtcPeer2
+            }
+            const msg2: Message = {
+                ...baseMsg,
+                targetDescriptor: wrtcPeer1
+            }
+
+            const promise1 = new Promise<void>((resolve, _reject) => {
+                connectionManager1.on('message', async (message: Message) => {
+                    expect(message.messageType).toBe(MessageType.RPC)
+                    resolve()
+                })
+            })
+            const promise2 = new Promise<void>((resolve, _reject) => {
+                connectionManager2.on('message', async (message: Message) => {
+                    expect(message.messageType).toBe(MessageType.RPC)
+                    resolve()
+                })
+            })
+
+            await Promise.all([
+                promise1,
+                promise2,
+                connectionManager1.send(msg1),
+                connectionManager2.send(msg2)
+            ])
+
+            await waitForCondition(() => connectionManager1.hasConnection(wrtcPeer2))
+            await waitForCondition(() => connectionManager2.hasConnection(wrtcPeer1))
+        })
+    })
+
+})

package/test/integration/Store.test.ts

@@ -0,0 +1,72 @@
+import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
+import { isSamePeerDescriptor, PeerID } from '../../src/exports'
+import { Any } from '../../src/proto/google/protobuf/any'
+
+describe('Storing data in DHT', () => {
+    let entryPoint: DhtNode
+    let nodes: DhtNode[]
+    let entrypointDescriptor: PeerDescriptor
+    const simulator = new Simulator(LatencyType.RANDOM)
+    const NUM_NODES = 100
+    const MAX_CONNECTIONS = 20
+    const K = 4
+    const nodeIndicesById: Record<string, number> = {}
+
+    const getRandomNode = () => {
+        return nodes[Math.floor(Math.random() * nodes.length)]
+    }
+
+    beforeEach(async () => {
+        nodes = []
+        const entryPointId = '0'
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
+            undefined, K, entryPointId, MAX_CONNECTIONS)
+        nodes.push(entryPoint)
+        nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
+        entrypointDescriptor = {
+            kademliaId: entryPoint.getNodeId().value,
+            type: NodeType.NODEJS,
+            nodeName: entryPointId
+        }
+        nodes.push(entryPoint)
+        for (let i = 1; i < NUM_NODES; i++) {
+            const nodeId = `${i}`
+            const node = await createMockConnectionDhtNode(nodeId, simulator, 
+                undefined, K, nodeId, MAX_CONNECTIONS, 60000)
+            nodeIndicesById[node.getNodeId().toKey()] = i
+            nodes.push(node)
+        }
+        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
+        await waitConnectionManagersReadyForTesting(nodes.map((node) => node.connectionManager!), MAX_CONNECTIONS)
+    }, 90000)
+
+    afterEach(async () => {
+        await Promise.all(nodes.map((node) => node.stop()))
+    })
+
+    it('Storing data works', async () => {
+        const storingNodeIndex = 34
+        const dataKey = PeerID.fromString('3232323e12r31r3')
+        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
+        const successfulStorers = await nodes[storingNodeIndex].storeDataToDht(dataKey.value, data)
+        expect(successfulStorers.length).toBeGreaterThan(4)
+    }, 90000)
+
+    it('Storing and getting data works', async () => {
+        const storingNode = getRandomNode()
+        const dataKey = PeerID.fromString('3232323e12r31r3')
+        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
+        const successfulStorers = await storingNode.storeDataToDht(dataKey.value, data)
+        expect(successfulStorers.length).toBeGreaterThan(4)
+
+        const fetchingNode = getRandomNode()
+        const results = await fetchingNode.getDataFromDht(dataKey.value)
+        results.dataEntries!.forEach((entry) => {
+            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
+            expect(isSamePeerDescriptor(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+        })
+    }, 90000)
+})

package/test/integration/StoreAndDelete.test.ts

@@ -0,0 +1,93 @@
+import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
+import { isSamePeerDescriptor, PeerID } from '../../src/exports'
+import { Any } from '../../src/proto/google/protobuf/any'
+
+describe('Storing data in DHT', () => {
+    let entryPoint: DhtNode
+    let nodes: DhtNode[]
+    let entrypointDescriptor: PeerDescriptor
+    const simulator = new Simulator(LatencyType.RANDOM)
+    const NUM_NODES = 5
+    const MAX_CONNECTIONS = 5
+    const K = 4
+    const nodeIndicesById: Record<string, number> = {}
+
+    const getRandomNode = () => {
+        return nodes[Math.floor(Math.random() * nodes.length)]
+    }
+
+    beforeEach(async () => {
+        nodes = []
+        const entryPointId = '0'
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
+            undefined, K, entryPointId, MAX_CONNECTIONS)
+        nodes.push(entryPoint)
+        nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
+        entrypointDescriptor = {
+            kademliaId: entryPoint.getNodeId().value,
+            type: NodeType.NODEJS,
+            nodeName: entryPointId
+        }
+        nodes.push(entryPoint)
+        for (let i = 1; i < NUM_NODES; i++) {
+            const nodeId = `${i}`
+            const node = await createMockConnectionDhtNode(nodeId, simulator, 
+                undefined, K, nodeId, MAX_CONNECTIONS, 60000)
+            nodeIndicesById[node.getNodeId().toKey()] = i
+            nodes.push(node)
+        }
+        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
+        await waitConnectionManagersReadyForTesting(nodes.map((node) => node.connectionManager!), MAX_CONNECTIONS)
+    }, 90000)
+
+    afterEach(async () => {
+        await Promise.all(nodes.map((node) => node.stop()))
+    })
+
+    it('Data can be deleted', async () => {
+        const storingNode = getRandomNode()
+        const dataKey = PeerID.fromString('3232323e12r31r3')
+        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
+        const successfulStorers = await storingNode.storeDataToDht(dataKey.value, data)
+        expect(successfulStorers.length).toBeGreaterThan(4)
+        await storingNode.deleteDataFromDht(dataKey.value)
+
+        const fetchingNode = getRandomNode()
+        const results = await fetchingNode.getDataFromDht(dataKey.value)
+        results.dataEntries!.forEach((entry) => {
+            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
+            expect(entry.deleted).toBeTrue()
+            expect(isSamePeerDescriptor(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+        })
+    }, 90000)
+
+    it('Data can be deleted and re-stored', async () => {
+        const storingNode = getRandomNode()
+        const dataKey = PeerID.fromString('3232323e12r31r3')
+        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
+        const successfulStorers1 = await storingNode.storeDataToDht(dataKey.value, data)
+        expect(successfulStorers1.length).toBeGreaterThan(4)
+        await storingNode.deleteDataFromDht(dataKey.value)
+
+        const fetchingNode = getRandomNode()
+        const results1 = await fetchingNode.getDataFromDht(dataKey.value)
+        results1.dataEntries!.forEach((entry) => {
+            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
+            expect(entry.deleted).toBeTrue()
+            expect(isSamePeerDescriptor(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+        })
+
+        const successfulStorers2 = await storingNode.storeDataToDht(dataKey.value, data)
+        expect(successfulStorers2.length).toBeGreaterThan(4)
+
+        const results2 = await fetchingNode.getDataFromDht(dataKey.value)
+        results2.dataEntries!.forEach((entry) => {
+            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
+            expect(entry.deleted).toBeFalse()
+            expect(isSamePeerDescriptor(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+        })
+    }, 90000)
+})

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -0,0 +1,71 @@
+import { createMockConnectionDhtNode } from '../utils/utils'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { PeerID } from '../../src/helpers/PeerID'
+import { Any } from '../../src/proto/google/protobuf/any'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { waitForCondition } from '@streamr/utils'
+
+describe('Storing data in DHT with two peers', () => {
+
+    let entryPoint: DhtNode
+    let otherNode: DhtNode
+
+    let simulator: Simulator | undefined
+
+    beforeEach(async () => {
+        simulator = new Simulator()
+        const entryPointId = 'node0'
+        const otherNodeId = 'other-node'
+        entryPoint = await createMockConnectionDhtNode(
+            entryPointId,
+            simulator,
+        )
+        otherNode = await createMockConnectionDhtNode(
+            otherNodeId,
+            simulator
+        )
+
+        await entryPoint.start()
+        await otherNode.start()
+
+        await entryPoint.joinDht([entryPoint.getPeerDescriptor()])
+        await otherNode.joinDht([entryPoint.getPeerDescriptor()])
+    })
+
+    afterEach(async () => {
+        await entryPoint.stop()
+        await otherNode.stop()
+        simulator?.stop()
+    })
+
+    it('Node can store on two peer DHT', async () => {
+        const dataKey1 = PeerID.fromString('node0-stored-data')
+        const data1 = Any.pack(otherNode.getPeerDescriptor(), PeerDescriptor)
+        const dataKey2 = PeerID.fromString('other-node-stored-data')
+        const data2 = Any.pack(entryPoint.getPeerDescriptor(), PeerDescriptor)
+
+        const successfulStorers1 = await otherNode.storeDataToDht(dataKey1.value, data1)
+        const successfulStorers2 = await entryPoint.storeDataToDht(dataKey2.value, data2)
+        expect(successfulStorers1[0].nodeName).toEqual(entryPoint.getPeerDescriptor().nodeName)
+        expect(successfulStorers2[0].nodeName).toEqual(otherNode.getPeerDescriptor().nodeName)
+
+        const foundData1 = await otherNode.getDataFromDht(dataKey1.value)
+        const foundData2 = await entryPoint.getDataFromDht(dataKey2.value)
+        expect(isSamePeerDescriptor(otherNode.getPeerDescriptor(), Any.unpack(foundData1.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(isSamePeerDescriptor(entryPoint.getPeerDescriptor(), Any.unpack(foundData2.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
+    })
+
+    it('Can store on one peer DHT', async () => {
+        await otherNode.stop()
+        await waitForCondition(() => entryPoint.getBucketSize() === 0)
+        const dataKey = PeerID.fromString('data-to-store')
+        const data = Any.pack(entryPoint.getPeerDescriptor(), PeerDescriptor)
+        const successfulStorers = await entryPoint.storeDataToDht(dataKey.value, data)
+        expect(successfulStorers[0].nodeName).toEqual(entryPoint.getPeerDescriptor().nodeName)
+
+        const foundData = await entryPoint.getDataFromDht(dataKey.value)
+        expect(isSamePeerDescriptor(entryPoint.getPeerDescriptor(), Any.unpack(foundData.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
+    }, 60000)
+})