@streamr/dht 102.0.0-beta.1 → 102.0.0-beta.2

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -1,191 +0,0 @@
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { Message, NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { ITransport } from '../../src/transport/ITransport'
-import * as Err from '../../src/helpers/errors'
-import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
-import { MetricsContext } from '@streamr/utils'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
-    return new ConnectionManager({
-        createConnectorFacade: () => new DefaultConnectorFacade({
-            transport,
-            createLocalPeerDescriptor: async () => localPeerDescriptor
-        }),
-        metricsContext: new MetricsContext(),
-        allowIncomingPrivateConnections: false
-    })
-}
-
-describe('WebRTC Connection Management', () => {
-
-    let manager1: ConnectionManager
-    let manager2: ConnectionManager
-    let simulator: Simulator
-    const peerDescriptor1 = createMockPeerDescriptor()
-    const peerDescriptor2 = createMockPeerDescriptor()
-    let connectorTransport1: SimulatorTransport
-    let connectorTransport2: SimulatorTransport
-
-    beforeEach(async () => {
-        simulator = new Simulator(LatencyType.FIXED, 20)
-        connectorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        await connectorTransport1.start()
-        manager1 = createConnectionManager(peerDescriptor1, connectorTransport1)
-        connectorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        await connectorTransport2.start()
-        manager2 = createConnectionManager(peerDescriptor2, connectorTransport2)
-        await manager1.start()
-        await manager2.start()
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            manager1.stop(),
-            manager2.stop(),
-            connectorTransport1.stop(),
-            connectorTransport2.stop()
-        ])
-        simulator.stop()
-    })
-
-    const serviceId = 'dummy'
-
-    // TODO: fix flaky test, ticket NET-911
-    it('Peer1 can open WebRTC Datachannels', (done) => {
-        const dummyMessage: Message = {
-            serviceId: 'unknown',
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            },
-            messageId: 'mockerer'
-        }
-
-        manager2.on('message', (message: Message) => {
-            expect(message.messageId).toEqual('mockerer')
-
-            done()
-        })
-        dummyMessage.targetDescriptor = peerDescriptor2
-        manager1.send(dummyMessage).catch((e) => {
-            throw e
-        })
-    }, 15000)
-
-    it('Peer2 can open WebRTC Datachannel', (done) => {
-        const dummyMessage: Message = {
-            serviceId,
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            }, 
-            messageId: 'mockerer'
-        }
-        manager1.on('message', (message: Message) => {
-            expect(message.messageId).toEqual('mockerer')
-            done()
-        })
-        dummyMessage.targetDescriptor = peerDescriptor1
-        manager2.send(dummyMessage)
-    }, 60000)
-
-    it('Connecting to self throws', async () => {
-        const dummyMessage: Message = {
-            serviceId,
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            },
-            messageId: 'mockerer'
-        }
-        dummyMessage.targetDescriptor = peerDescriptor1
-        await expect(manager1.send(dummyMessage))
-            .rejects
-            .toEqual(new Err.CannotConnectToSelf('Cannot send to self'))
-    })
-
-    it('Connects and disconnects webrtc connections', async () => {
-        const msg: Message = {
-            serviceId,
-            messageId: '1',
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            }
-        }
-
-        const dataPromise = new Promise<void>((resolve, _reject) => {
-            manager2.on('message', async (message: Message) => {
-                expect(message.body.oneofKind).toBe('rpcMessage')
-                resolve()
-            })
-        })
-
-        const connectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('connected', () => {
-                //expect(message.body.oneofKind).toBe('rpcMessage')
-                resolve()
-            })
-        })
-
-        const connectedPromise2 = new Promise<void>((resolve, _reject) => {
-            manager2.on('connected', () => {
-                resolve()
-            })
-        })
-
-        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', () => {
-                resolve()
-            })
-        })
-
-        const disconnectedPromise2 = new Promise<void>((resolve, _reject) => {
-            manager2.on('disconnected', () => {
-                resolve()
-            })
-        })
-
-        msg.targetDescriptor = peerDescriptor2
-        manager1.send(msg).catch((_e) => { })
-
-        await Promise.all([dataPromise, connectedPromise1, connectedPromise2])
-
-        // @ts-expect-error private field
-        manager1.closeConnection(peerDescriptor2)
-
-        await Promise.all([disconnectedPromise1, disconnectedPromise2])
-
-    }, 20000)
-
-    it('failed connections are cleaned up', async () => {
-        const msg: Message = {
-            serviceId,
-            messageId: '1',
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            },
-        }
-
-        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', () => {
-                resolve()
-            })
-        })
-
-        msg.targetDescriptor = {
-            nodeId: new Uint8Array([0, 0, 0, 0, 0]),
-            type: NodeType.NODEJS,
-        }
-        
-        await Promise.allSettled([
-            manager1.send(msg),
-            disconnectedPromise1
-        ])
-    }, 20000)
-})

package/test/integration/WebrtcConnectorRpc.test.ts

@@ -1,125 +0,0 @@
-import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebrtcConnectorRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
-import {
-    IceCandidate,
-    RtcAnswer,
-    RtcOffer,
-    WebrtcConnectionRequest
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { Empty } from '../../generated/google/protobuf/empty'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { IWebrtcConnectorRpc } from '../../generated/packages/dht/protos/DhtRpc.server'
-import { until } from '@streamr/utils'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
-
-describe('WebRTC rpc messages', () => {
-
-    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
-    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
-    let client: ProtoRpcClient<WebrtcConnectorRpcClient>
-    let requestConnectionCounter: number
-    let rtcOfferCounter: number
-    let rtcAnswerCounter: number
-    let iceCandidateCounter: number
-    const targetDescriptor = createMockPeerDescriptor()
-
-    beforeEach(() => {
-        requestConnectionCounter = 0
-        rtcOfferCounter = 0
-        rtcAnswerCounter = 0
-        iceCandidateCounter = 0
-
-        rpcCommunicator1 = new RpcCommunicator()
-        const serverFunctions: IWebrtcConnectorRpc = {
-
-            requestConnection: async (): Promise<Empty> => {
-                requestConnectionCounter += 1
-                const res: Empty = {}
-                return res
-            },
-
-            rtcOffer: async (): Promise<Empty> => {
-                rtcOfferCounter += 1
-                const res: Empty = {}
-                return res
-            },
-
-            rtcAnswer: async (): Promise<Empty> => {
-                rtcAnswerCounter += 1
-                const res: Empty = {}
-                return res
-            },
-
-            iceCandidate: async (): Promise<Empty> => {
-                iceCandidateCounter += 1
-                const res: Empty = {}
-                return res
-            }
-        }
-
-        rpcCommunicator2 = new RpcCommunicator()
-        rpcCommunicator2.registerRpcNotification(RtcOffer, 'rtcOffer', serverFunctions.rtcOffer)
-        rpcCommunicator2.registerRpcNotification(RtcAnswer, 'rtcAnswer', serverFunctions.rtcAnswer)
-        rpcCommunicator2.registerRpcNotification(IceCandidate, 'iceCandidate', serverFunctions.iceCandidate)
-        rpcCommunicator2.registerRpcNotification(WebrtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
-
-        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
-        })
-
-        rpcCommunicator2.setOutgoingMessageListener(async (message: RpcMessage) => {
-            rpcCommunicator1.handleIncomingMessage(message, new DhtCallContext())
-        })
-
-        client = toProtoRpcClient(new WebrtcConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
-    })
-
-    afterEach(async () => {
-        rpcCommunicator1.stop()
-        rpcCommunicator2.stop()
-    })
-
-    it('send connectionRequest', async () => {
-        client.requestConnection({
-        },
-        { targetDescriptor, notification: true }
-        )
-
-        await until(() => requestConnectionCounter === 1)
-    })
-
-    it('send rtcOffer', async () => {
-        client.rtcOffer({
-            connectionId: 'rtcOffer',
-            description: 'aaaaaa'
-        },
-        { targetDescriptor, notification: true }
-        )
-
-        await until(() => rtcOfferCounter === 1)
-    })
-
-    it('send rtcAnswer', async () => {
-        client.rtcAnswer({
-            connectionId: 'rtcOffer',
-            description: 'aaaaaa'
-        },
-        { targetDescriptor, notification: true }
-        )
-
-        await until(() => rtcAnswerCounter === 1)
-    })
-
-    it('send iceCandidate', async () => {
-        client.iceCandidate({
-            connectionId: 'rtcOffer',
-            candidate: 'aaaaaa',
-            mid: 'asdasdasdasdasd'
-        },
-        { targetDescriptor, notification: true }
-        )
-
-        await until(() => iceCandidateCounter === 1)
-    })
-})

package/test/integration/Websocket.test.ts

@@ -1,65 +0,0 @@
-import { WebsocketServer } from '../../src/connection/websocket/WebsocketServer'
-import { IConnection } from '../../src/connection/IConnection'
-import { WebsocketClientConnection } from '../../src/connection/websocket/NodeWebsocketClientConnection'
-import { Logger } from '@streamr/utils'
-
-const logger = new Logger(module)
-
-describe('Websocket', () => {
-
-    const websocketServer = new WebsocketServer({
-        portRange: { min: 9977, max: 9977 },
-        enableTls: false
-    })
-    const clientWebsocket = new WebsocketClientConnection()
-
-    beforeAll(async () => {
-        await websocketServer.start()
-    })
-
-    it('Happy path', (done) => {
-            
-        websocketServer.on('connected', (serverConnection: IConnection) => {
-            const time = Date.now()
-            logger.info('server side sendind msg at ' + time)
-            serverConnection.send(Uint8Array.from([1, 2, 3, 4]))
-        
-            const time2 = Date.now()
-            logger.info('server side setting listeners at ' + time2)
-            
-            serverConnection.on('data', (bytes: Uint8Array) => {
-                const time = Date.now()
-                logger.info('server side receiving message at ' + time)
-
-                logger.info('server received:' + JSON.stringify(bytes))
-               
-                expect(bytes.toString()).toBe('1,2,3,4')
-                logger.info('calling done()')
-                done()
-            })
-        })
-        
-        clientWebsocket.on('connected', () => {
-            const time = Date.now()
-            logger.info('client side setting listeners at ' + time)
-            
-            clientWebsocket.on('data', (bytes: Uint8Array) => {
-                const time = Date.now()
-                logger.info('client side receiving message at ' + time)
-
-                logger.info('client received: ' + JSON.stringify(bytes))
-                expect(bytes.toString()).toBe('1,2,3,4')
-                
-                const time2 = Date.now()
-                logger.info('client side sendind msg at ' + time2)
-                clientWebsocket.send(Uint8Array.from([1, 2, 3, 4]))
-            })
-        })
-
-        clientWebsocket.connect('ws://127.0.0.1:9977', false)
-    })
-
-    afterAll(async () => {
-        await websocketServer.stop()
-    })
-})

package/test/integration/WebsocketClientConnectorRpc.test.ts

@@ -1,69 +0,0 @@
-import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebsocketClientConnectorRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
-import { createMockPeerDescriptor, mockWebsocketClientConnectorRpc } from '../utils/utils'
-import { WebsocketConnectionRequest } from '../../generated/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { Empty } from '../../generated/google/protobuf/empty'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
-
-describe('WebsocketClientConnectorRpc', () => {
-
-    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
-    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
-    let client1: ProtoRpcClient<WebsocketClientConnectorRpcClient>
-    let client2: ProtoRpcClient<WebsocketClientConnectorRpcClient>
-    const peerDescriptor1 = createMockPeerDescriptor()
-    const peerDescriptor2 = createMockPeerDescriptor()
-
-    beforeEach(() => {
-        rpcCommunicator1 = new RpcCommunicator()
-        rpcCommunicator1.registerRpcMethod(
-            WebsocketConnectionRequest,
-            Empty,
-            'requestConnection',
-            mockWebsocketClientConnectorRpc.requestConnection
-        )
-
-        rpcCommunicator2 = new RpcCommunicator()
-        rpcCommunicator2.registerRpcMethod(
-            WebsocketConnectionRequest,
-            Empty,
-            'requestConnection',
-            mockWebsocketClientConnectorRpc.requestConnection
-        )
-
-        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
-        })
-
-        rpcCommunicator2.setOutgoingMessageListener(async (message: RpcMessage) => {
-            rpcCommunicator1.handleIncomingMessage(message, new DhtCallContext())
-        })
-
-        client1 = toProtoRpcClient(new WebsocketClientConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
-        client2 = toProtoRpcClient(new WebsocketClientConnectorRpcClient(rpcCommunicator2.getRpcClientTransport()))
-    })
-
-    afterEach(async () => {
-        rpcCommunicator1.stop()
-        rpcCommunicator2.stop()
-    })
-
-    it('Happy path', async () => {
-        const response1 = client1.requestConnection({
-            ip: '127.0.0.1',
-            port: 9099
-        },
-        { targetDescriptor: peerDescriptor2 },
-        )
-        await response1
-        
-        const response2 = client2.requestConnection({
-            ip: '127.0.0.1',
-            port: 9111
-        },
-        { targetDescriptor: peerDescriptor1 },
-        )
-        await response2
-    })
-})

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -1,191 +0,0 @@
-import { MetricsContext, until, waitForEvent3 } from '@streamr/utils'
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
-import { Simulator } from '../../src/connection/simulator/Simulator'
-import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import * as Err from '../../src/helpers/errors'
-import { Message, NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { TransportEvents } from '../../src/transport/ITransport'
-import { toNodeId } from '../../src/identifiers'
-
-const SERVICE_ID = 'test'
-
-const createOptions = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeOptions, 'createLocalPeerDescriptor'>) => {
-    return {
-        createConnectorFacade: () => new DefaultConnectorFacade({
-            createLocalPeerDescriptor: async () => localPeerDescriptor,
-            ...opts
-        }),
-        metricsContext: new MetricsContext(),
-        allowIncomingPrivateConnections: false
-    }
-}
-
-describe('Websocket Connection Management', () => {
-
-    let wsServerManager: ConnectionManager
-    let noWsServerManager: ConnectionManager
-    let biggerNoWsServerManager: ConnectionManager
-    const simulator = new Simulator()
-    const wsServerConnectorPeerDescriptor: PeerDescriptor = {
-        nodeId: new Uint8Array([2]),
-        type: NodeType.NODEJS,
-        websocket: {
-            host: '127.0.0.1',
-            port: 12223,
-            tls: false
-        }
-    }
-    const noWsServerConnectorPeerDescriptor: PeerDescriptor = {
-        nodeId: new Uint8Array([1]),
-        type: NodeType.NODEJS,
-    }
-    const biggerNoWsServerConnectorPeerDescriptor: PeerDescriptor = {
-        nodeId: new Uint8Array([3]),
-        type: NodeType.NODEJS,
-    }
-
-    let connectorTransport1: SimulatorTransport
-    let connectorTransport2: SimulatorTransport
-    let connectorTransport3: SimulatorTransport
-
-    beforeEach(async () => {
-
-        connectorTransport1 = new SimulatorTransport(wsServerConnectorPeerDescriptor, simulator)
-        await connectorTransport1.start()
-        connectorTransport2 = new SimulatorTransport(noWsServerConnectorPeerDescriptor, simulator)
-        await connectorTransport2.start()
-        connectorTransport3 = new SimulatorTransport(biggerNoWsServerConnectorPeerDescriptor, simulator)
-        await connectorTransport3.start()
-
-        const options1 = createOptions(wsServerConnectorPeerDescriptor, {
-            transport: connectorTransport1,
-            websocketHost: '127.0.0.1',
-            websocketPortRange: { min: 12223, max: 12223 }
-        })
-        const options2 = createOptions(noWsServerConnectorPeerDescriptor, {
-            transport: connectorTransport2
-        })
-        const options3 = createOptions(biggerNoWsServerConnectorPeerDescriptor, {
-            transport: connectorTransport3
-        })
-
-        wsServerManager = new ConnectionManager(options1)
-        noWsServerManager = new ConnectionManager(options2)
-        biggerNoWsServerManager = new ConnectionManager(options3)
-
-        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 with smaller nodeId', (done) => {
-        const dummyMessage: Message = {
-            serviceId: SERVICE_ID,
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            },
-            messageId: 'mockerer',
-            targetDescriptor: noWsServerConnectorPeerDescriptor
-        }
-        noWsServerManager.on('message', (message: Message) => {
-            expect(message.messageId).toEqual('mockerer')
-
-            done()
-        })
-
-        wsServerManager.send(dummyMessage)
-    })
-
-    it('Can open connections to serverless peer with bigger nodeId', (done) => {
-        const dummyMessage: Message = {
-            serviceId: SERVICE_ID,
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            },
-            messageId: 'mockerer',
-            targetDescriptor: biggerNoWsServerConnectorPeerDescriptor
-        }
-        biggerNoWsServerManager.on('message', (message: Message) => {
-            expect(message.messageId).toEqual('mockerer')
-            done()
-        })
-
-        wsServerManager.send(dummyMessage)
-    })
-
-    it('Failed connection requests are cleaned up', async () => {
-        const dummyMessage: Message = {
-            serviceId: SERVICE_ID,
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            },
-            messageId: 'mockerer',
-            targetDescriptor: {
-                nodeId: new Uint8Array([1, 2, 4]),
-                type: NodeType.NODEJS
-            }
-        }
-
-        await Promise.allSettled([
-            waitForEvent3<TransportEvents>(wsServerManager, 'disconnected', 15000),
-            wsServerManager.send(dummyMessage)
-        ])
-        expect(wsServerManager.hasConnection(toNodeId(dummyMessage.targetDescriptor!))).toBeFalse()
-    }, 20000)
-    
-    it('Can open connections to peer with server', async () => {
-        const dummyMessage: Message = {
-            serviceId: SERVICE_ID,
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            },
-            messageId: 'mockerer',
-            targetDescriptor: wsServerConnectorPeerDescriptor
-        }
-        await noWsServerManager.send(dummyMessage)
-        await until(
-            () => {
-                const nodeId = toNodeId(noWsServerConnectorPeerDescriptor)
-                return wsServerManager.hasConnection(nodeId)
-            }
-        )
-        await until(
-            () => noWsServerManager.hasConnection(toNodeId(wsServerConnectorPeerDescriptor))
-        )
-    })
-
-    it('Connecting to self throws', async () => {
-        const dummyMessage: Message = {
-            serviceId: SERVICE_ID,
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            },
-            messageId: 'mockerer',
-            targetDescriptor: noWsServerConnectorPeerDescriptor
-        }
-        await expect(noWsServerManager.send(dummyMessage))
-            .rejects
-            .toEqual(new Err.CannotConnectToSelf('Cannot send to self'))
-
-        dummyMessage.targetDescriptor = wsServerConnectorPeerDescriptor
-        await expect(wsServerManager.send(dummyMessage))
-            .rejects
-            .toEqual(new Err.CannotConnectToSelf('Cannot send to self'))
-    })
-})