@streamr/dht 100.0.0-testnet-one.0 → 100.0.0-testnet-one.1

package/test/integration/SimultaneousConnections.test.ts

@@ -20,8 +20,8 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit
 describe('SimultaneousConnections', () => {
 
     let simulator: Simulator
-    let simulatorTransport1: SimulatorTransport
-    let simulatorTransport2: SimulatorTransport
+    let simTransport1: SimulatorTransport
+    let simTransport2: SimulatorTransport
 
     const peerDescriptor1 = {
         nodeId: PeerID.fromString('mock1').value,
@@ -45,15 +45,15 @@ describe('SimultaneousConnections', () => {
 
     beforeEach(async () => {
         simulator = new Simulator()
-        simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        await simulatorTransport1.start()
-        simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        await simulatorTransport2.start()
+        simTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        await simTransport1.start()
+        simTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        await simTransport2.start()
     })
 
     afterEach(async () => {
-        await simulatorTransport1.stop()
-        await simulatorTransport2.stop()
+        await simTransport1.stop()
+        await simTransport2.stop()
     })
 
     it('simultanous simulated connection', async () => {
@@ -67,13 +67,13 @@ describe('SimultaneousConnections', () => {
         }
 
         const promise1 = new Promise<void>((resolve, _reject) => {
-            simulatorTransport1.on('message', async (message: Message) => {
+            simTransport1.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) => {
+            simTransport2.on('message', async (message: Message) => {
                 expect(message.messageType).toBe(MessageType.RPC)
                 resolve()
             })
@@ -81,19 +81,21 @@ describe('SimultaneousConnections', () => {
         await Promise.all([
             promise1,
             promise2,
-            simulatorTransport1.send(msg1),
-            simulatorTransport2.send(msg2)
+            simTransport1.send(msg1),
+            simTransport2.send(msg2)
         ])
-        await waitForCondition(() => simulatorTransport2.hasConnection(peerDescriptor1))
-        await waitForCondition(() => simulatorTransport1.hasConnection(peerDescriptor2))
+        await waitForCondition(() => simTransport2.hasConnection(peerDescriptor1))
+        await waitForCondition(() => simTransport1.hasConnection(peerDescriptor2))
     })
 
     describe('Websocket 2 servers', () => {
 
+        let simTransport1: SimulatorTransport
+        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
-
-        const wsPeer1: PeerDescriptor = {
+        
+        const wsPeerDescriptor1: PeerDescriptor = {
             nodeId: PeerID.fromString('mock1').value,
             type: NodeType.NODEJS,
             websocket: {
@@ -103,7 +105,7 @@ describe('SimultaneousConnections', () => {
             }
         }
 
-        const wsPeer2: PeerDescriptor = {
+        const wsPeerDescriptor2: PeerDescriptor = {
             nodeId: PeerID.fromString('mock2').value,
             type: NodeType.NODEJS,
             websocket: {
@@ -114,17 +116,26 @@ describe('SimultaneousConnections', () => {
         }
 
         beforeEach(async () => {
+            
+            // SimulatorTransport needs to have exatly same peerDescriptor as ConnectionManager
+            // that is why we need to create new SimulatorTransports here
+            simulator = new Simulator()
+            simTransport1 = new SimulatorTransport(wsPeerDescriptor1, simulator)
+            await simTransport1.start()
+            simTransport2 = new SimulatorTransport(wsPeerDescriptor2, simulator)
+            await simTransport2.start()
+            
             const websocketPortRange = { min: 43432, max: 43433 }
-            connectionManager1 = createConnectionManager(wsPeer1, {
-                transport: simulatorTransport1,
+            connectionManager1 = createConnectionManager(wsPeerDescriptor1, {
+                transport: simTransport1,
                 websocketPortRange,
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
-            connectionManager2 = createConnectionManager(wsPeer2, {
-                transport: simulatorTransport2,
+            connectionManager2 = createConnectionManager(wsPeerDescriptor2, {
+                transport: simTransport2,
                 websocketPortRange,
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
             await connectionManager1.start()
@@ -134,16 +145,18 @@ describe('SimultaneousConnections', () => {
         afterEach(async () => {
             await connectionManager1.stop()
             await connectionManager2.stop()
+            await simTransport1.stop()
+            await simTransport2.stop()
         })
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer2
+                targetDescriptor: wsPeerDescriptor2
             }
             const msg2: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer1
+                targetDescriptor: wsPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
@@ -166,17 +179,19 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wsPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wsPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(wsPeerDescriptor2))
+            await waitForCondition(() => connectionManager2.hasConnection(wsPeerDescriptor1))
         })
     })
 
     describe('Websocket 1 server (ConnectionRequests)', () => {
-
+    
+        let simTransport1: SimulatorTransport
+        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
 
-        const wsPeer1: PeerDescriptor = {
+        const wsPeerDescriptor1: PeerDescriptor = {
             nodeId: PeerID.fromString('mock1').value,
             type: NodeType.NODEJS,
             websocket: {
@@ -186,20 +201,26 @@ describe('SimultaneousConnections', () => {
             }
         }
 
-        const wsPeer2: PeerDescriptor = {
+        const wsPeerDescriptor2: PeerDescriptor = {
             nodeId: PeerID.fromString('mock2').value,
             type: NodeType.NODEJS
         }
 
         beforeEach(async () => {
-            connectionManager1 = createConnectionManager(wsPeer1, {
-                transport: simulatorTransport1,
+            simulator = new Simulator()
+            simTransport1 = new SimulatorTransport(wsPeerDescriptor1, simulator)
+            await simTransport1.start()
+            simTransport2 = new SimulatorTransport(wsPeerDescriptor2, simulator)
+            await simTransport2.start()
+
+            connectionManager1 = createConnectionManager(wsPeerDescriptor1, {
+                transport: simTransport1,
                 websocketPortRange: { min: 43432, max: 43432 },
-                entryPoints: [wsPeer1],
+                entryPoints: [wsPeerDescriptor1],
                 websocketServerEnableTls: false
             })
-            connectionManager2 = createConnectionManager(wsPeer2, {
-                transport: simulatorTransport2
+            connectionManager2 = createConnectionManager(wsPeerDescriptor2, {
+                transport: simTransport2
             })
             await connectionManager1.start()
             await connectionManager2.start()
@@ -208,16 +229,18 @@ describe('SimultaneousConnections', () => {
         afterEach(async () => {
             await connectionManager1.stop()
             await connectionManager2.stop()
+            await simTransport1.stop()
+            await simTransport2.stop()
         })
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer2
+                targetDescriptor: wsPeerDescriptor2
             }
             const msg2: Message = {
                 ...baseMsg,
-                targetDescriptor: wsPeer1
+                targetDescriptor: wsPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
@@ -240,32 +263,39 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wsPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wsPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(wsPeerDescriptor2))
+            await waitForCondition(() => connectionManager2.hasConnection(wsPeerDescriptor1))
         })
     })
 
     describe('WebRTC', () => {
 
+        let simTransport1: SimulatorTransport
+        let simTransport2: SimulatorTransport
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
 
-        const wrtcPeer1: PeerDescriptor = {
+        const wrtcPeerDescriptor1: PeerDescriptor = {
             nodeId: PeerID.fromString('mock1').value,
             type: NodeType.NODEJS
         }
 
-        const wrtcPeer2: PeerDescriptor = {
+        const wrtcPeerDescriptor2: PeerDescriptor = {
             nodeId: PeerID.fromString('mock2').value,
             type: NodeType.NODEJS
         }
 
         beforeEach(async () => {
-            connectionManager1 = createConnectionManager(wrtcPeer1, {
-                transport: simulatorTransport1,
+            simulator = new Simulator()
+            simTransport1 = new SimulatorTransport(wrtcPeerDescriptor1, simulator)
+            await simTransport1.start()
+            simTransport2 = new SimulatorTransport(wrtcPeerDescriptor2, simulator)
+            await simTransport2.start()
+            connectionManager1 = createConnectionManager(wrtcPeerDescriptor1, {
+                transport: simTransport1,
             })
-            connectionManager2 = createConnectionManager(wrtcPeer2, {
-                transport: simulatorTransport2,
+            connectionManager2 = createConnectionManager(wrtcPeerDescriptor2, {
+                transport: simTransport2,
             })
             await connectionManager1.start()
             await connectionManager2.start()
@@ -274,16 +304,18 @@ describe('SimultaneousConnections', () => {
         afterEach(async () => {
             await connectionManager1.stop()
             await connectionManager2.stop()
+            await simTransport1.stop()
+            await simTransport2.stop()
         })
 
         it('Simultaneous Connections', async () => {
             const msg1: Message = {
                 ...baseMsg,
-                targetDescriptor: wrtcPeer2
+                targetDescriptor: wrtcPeerDescriptor2
             }
             const msg2: Message = {
                 ...baseMsg,
-                targetDescriptor: wrtcPeer1
+                targetDescriptor: wrtcPeerDescriptor1
             }
 
             const promise1 = new Promise<void>((resolve, _reject) => {
@@ -306,8 +338,8 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(wrtcPeer2))
-            await waitForCondition(() => connectionManager2.hasConnection(wrtcPeer1))
+            await waitForCondition(() => connectionManager1.hasConnection(wrtcPeerDescriptor2))
+            await waitForCondition(() => connectionManager2.hasConnection(wrtcPeerDescriptor1))
         })
     })
 

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -59,7 +59,7 @@ describe('Storing data in DHT with two peers', () => {
 
     it('Can store on one peer DHT', async () => {
         await otherNode.stop()
-        await waitForCondition(() => entryPoint.getBucketSize() === 0)
+        await waitForCondition(() => entryPoint.getNumberOfNeighbors() === 0)
         const dataKey = createRandomNodeId()
         const storedData = createMockPeerDescriptor()
         const data = Any.pack(storedData, PeerDescriptor)

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -26,11 +26,12 @@ describe('Websocket Connection Management', () => {
     const serviceId = 'test'
     let wsServerManager: ConnectionManager
     let noWsServerManager: ConnectionManager
+    let biggerNoWsServerManager: ConnectionManager
 
     const simulator = new Simulator()
 
     const wsServerConnectorPeerDescriptor: PeerDescriptor = {
-        nodeId: PeerID.fromString('peerWithServer').value,
+        nodeId: PeerID.fromString('2').value,
         type: NodeType.NODEJS,
         websocket: {
             host: '127.0.0.1',
@@ -40,12 +41,18 @@ describe('Websocket Connection Management', () => {
     }
 
     const noWsServerConnectorPeerDescriptor: PeerDescriptor = {
-        nodeId: PeerID.fromString('peerWithoutServer').value,
+        nodeId: PeerID.fromString('1').value,
+        type: NodeType.NODEJS,
+    }
+
+    const biggerNoWsServerConnectorPeerDescriptor: PeerDescriptor = {
+        nodeId: PeerID.fromString('3').value,
         type: NodeType.NODEJS,
     }
 
     let connectorTransport1: SimulatorTransport
     let connectorTransport2: SimulatorTransport
+    let connectorTransport3: SimulatorTransport
 
     beforeEach(async () => {
 
@@ -53,6 +60,8 @@ describe('Websocket Connection Management', () => {
         await connectorTransport1.start()
         connectorTransport2 = new SimulatorTransport(noWsServerConnectorPeerDescriptor, simulator)
         await connectorTransport2.start()
+        connectorTransport3 = new SimulatorTransport(biggerNoWsServerConnectorPeerDescriptor, simulator)
+        await connectorTransport3.start()
 
         const config1 = createConfig(wsServerConnectorPeerDescriptor, {
             transport: connectorTransport1,
@@ -62,22 +71,29 @@ describe('Websocket Connection Management', () => {
         const config2 = createConfig(noWsServerConnectorPeerDescriptor, {
             transport: connectorTransport2
         })
+        const config3 = createConfig(biggerNoWsServerConnectorPeerDescriptor, {
+            transport: connectorTransport3
+        })
 
         wsServerManager = new ConnectionManager(config1)
         noWsServerManager = new ConnectionManager(config2)
+        biggerNoWsServerManager = new ConnectionManager(config3)
 
         await wsServerManager.start()
         await noWsServerManager.start()
+        await biggerNoWsServerManager.start()
     })
 
     afterEach(async () => {
         await wsServerManager.stop()
         await noWsServerManager.stop()
+        await biggerNoWsServerManager.stop()
         await connectorTransport1.stop()
         await connectorTransport2.stop()
+        await connectorTransport3.stop()
     })
 
-    it('Can open connections to serverless peer', (done) => {
+    it('Can open connections to serverless peer with smaller peerId', (done) => {
         const dummyMessage: Message = {
             serviceId,
             body: {
@@ -99,6 +115,28 @@ describe('Websocket Connection Management', () => {
         wsServerManager.send(dummyMessage)
     })
 
+    it('Can open connections to serverless peer with bigger peerId', (done) => {
+        const dummyMessage: Message = {
+            serviceId,
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+            messageType: MessageType.RPC,
+            messageId: 'mockerer',
+            targetDescriptor: biggerNoWsServerConnectorPeerDescriptor
+        }
+        biggerNoWsServerManager.on('message', (message: Message) => {
+            expect(message.messageId).toEqual('mockerer')
+            expect(wsServerManager.getConnection(biggerNoWsServerConnectorPeerDescriptor)!.connectionType).toEqual(ConnectionType.WEBSOCKET_SERVER)
+            expect(biggerNoWsServerManager.getConnection(wsServerConnectorPeerDescriptor)!.connectionType).toEqual(ConnectionType.WEBSOCKET_CLIENT)
+
+            done()
+        })
+
+        wsServerManager.send(dummyMessage)
+    })
+
     it('Can open connections to peer with server', async () => {
         const dummyMessage: Message = {
             serviceId,

package/test/integration/WebsocketConnectorRpc.test.ts

@@ -67,16 +67,14 @@ describe('WebsocketConnectorRpc', () => {
         },
         { targetDescriptor: peerDescriptor2 },
         )
-        const res1 = await response1
-        expect(res1.accepted).toEqual(true)
-
+        await response1
+        
         const response2 = client2.requestConnection({
             ip: '127.0.0.1',
             port: 9111
         },
         { targetDescriptor: peerDescriptor1 },
         )
-        const res2 = await response2
-        expect(res2.accepted).toEqual(true)
+        await response2
     })
 })

package/test/unit/SortedContactList.test.ts

@@ -13,7 +13,7 @@ describe('SortedContactList', () => {
     const item4 = createItem(new Uint8Array([0, 0, 0, 4]))
 
     it('compares Ids correctly', async () => {
-        const list = new SortedContactList(item0.getPeerId(), 10)
+        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 10, allowToContainReferenceId: true, emitEvents: false })
         expect(list.compareIds(item0.getPeerId(), item0.getPeerId())).toBe(0)
         expect(list.compareIds(item1.getPeerId(), item1.getPeerId())).toBe(0)
         expect(list.compareIds(item0.getPeerId(), item1.getPeerId())).toBe(-1)
@@ -23,9 +23,9 @@ describe('SortedContactList', () => {
         expect(list.compareIds(item2.getPeerId(), item3.getPeerId())).toBe(-1)
         expect(list.compareIds(item1.getPeerId(), item4.getPeerId())).toBe(-3)
     })
-    
+
     it('orders itself correctly', async () => {
-        const list = new SortedContactList(item0.getPeerId(), 10)
+        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 10, allowToContainReferenceId: true, emitEvents: false })
         list.addContact(item3)
         list.addContact(item2)
         list.addContact(item1)
@@ -35,9 +35,9 @@ describe('SortedContactList', () => {
         expect(contacts[1]).toEqual(item2)
         expect(contacts[2]).toEqual(item3)
     })
-    
+
     it('handles contacted nodes correctly', async () => {
-        const list = new SortedContactList(item0.getPeerId(), 10)
+        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 10, allowToContainReferenceId: false, emitEvents: false })
         list.addContact(item3)
         list.addContact(item2)
         list.addContact(item1)
@@ -49,7 +49,7 @@ describe('SortedContactList', () => {
     })
 
     it('cannot exceed maxSize', async () => {
-        const list = new SortedContactList(item0.getPeerId(), 3)
+        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 3, allowToContainReferenceId: false, emitEvents: true })
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
         list.addContact(item1)
@@ -62,7 +62,7 @@ describe('SortedContactList', () => {
     })
 
     it('removing contacts', async () => {
-        const list = new SortedContactList(item0.getPeerId(), 8)
+        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 8, allowToContainReferenceId: false, emitEvents: true })
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
         list.addContact(item4)
@@ -79,8 +79,13 @@ describe('SortedContactList', () => {
         expect(ret).toEqual(false)
     })
 
-    it('get closes contacts', () => {
-        const list = new SortedContactList(item0.getPeerId(), 8)
+    it('get closest contacts', () => {
+        const list = new SortedContactList({
+            referenceId: item0.getPeerId(), 
+            maxSize: 8, 
+            allowToContainReferenceId: false, 
+            emitEvents: false 
+        })
         list.addContact(item1)
         list.addContact(item3)
         list.addContact(item4)
@@ -90,7 +95,7 @@ describe('SortedContactList', () => {
     })
 
     it('get active contacts', () => {
-        const list = new SortedContactList(item0.getPeerId(), 8)
+        const list = new SortedContactList({ referenceId: item0.getPeerId(), maxSize: 8, allowToContainReferenceId: false, emitEvents: false })
         list.addContact(item1)
         list.addContact(item3)
         list.addContact(item4)