@streamr/trackerless-network 102.0.0-beta.0 → 102.0.0-beta.2

package/test/integration/Handshakes.test.ts

@@ -1,176 +0,0 @@
-import {
-    ListeningRpcCommunicator,
-    NodeType,
-    PeerDescriptor,
-    Simulator,
-    SimulatorTransport,
-    toNodeId
-} from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { NodeList } from '../../src/logic/NodeList'
-import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
-import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
-import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import {
-    HandshakeRpcClient
-} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-
-describe('Handshakes', () => {
-
-    const peerDescriptor1: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 1, 1]),
-        type: NodeType.NODEJS
-    }
-    const peerDescriptor2: PeerDescriptor = {
-        nodeId: new Uint8Array([2, 1, 1]),
-        type: NodeType.NODEJS
-    }
-    const peerDescriptor3: PeerDescriptor = {
-        nodeId: new Uint8Array([3, 1, 1]),
-        type: NodeType.NODEJS
-    }
-    let rpcCommunicator1: ListeningRpcCommunicator
-    let rpcCommunicator2: ListeningRpcCommunicator
-    let rpcCommunicator3: ListeningRpcCommunicator
-    let neighbors: NodeList
-    let leftNodeView: NodeList
-    let rightNodeView: NodeList
-    let nodeView: NodeList
-    let handshaker: Handshaker
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-
-    const acceptHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
-        const response: StreamPartHandshakeResponse = {
-            requestId: request.requestId,
-            accepted: true
-        }
-        return response
-    }
-
-    const rejectHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
-        const response: StreamPartHandshakeResponse = {
-            requestId: request.requestId,
-            accepted: false
-        }
-        return response
-    }
-
-    const interleavingHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
-        const response: StreamPartHandshakeResponse = {
-            requestId: request.requestId,
-            accepted: true,
-            interleaveTargetDescriptor: peerDescriptor3
-        }
-        return response
-    }
-
-    let simulator: Simulator
-    let simulatorTransport1: SimulatorTransport
-    let simulatorTransport2: SimulatorTransport
-    let simulatorTransport3: SimulatorTransport
-
-    beforeEach(async () => {
-        simulator = new Simulator()
-        simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        await simulatorTransport1.start()
-        simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        await simulatorTransport2.start()
-        simulatorTransport3 = new SimulatorTransport(peerDescriptor3, simulator)
-        await simulatorTransport3.start()
-
-        rpcCommunicator1 = new ListeningRpcCommunicator(streamPartId, simulatorTransport1)
-        rpcCommunicator2 = new ListeningRpcCommunicator(streamPartId, simulatorTransport2)
-        rpcCommunicator3 = new ListeningRpcCommunicator(streamPartId, simulatorTransport3)
-
-        const handshakerNodeId = toNodeId(peerDescriptor2)
-        leftNodeView = new NodeList(handshakerNodeId, 10)
-        rightNodeView = new NodeList(handshakerNodeId, 10)
-        nodeView = new NodeList(handshakerNodeId, 10)
-        neighbors = new NodeList(handshakerNodeId, 4)
-        handshaker = new Handshaker({
-            localPeerDescriptor: peerDescriptor2,
-            streamPartId,
-            nearbyNodeView: nodeView,
-            randomNodeView: nodeView,
-            leftNodeView,
-            rightNodeView,
-            neighbors,
-            rpcCommunicator: rpcCommunicator2,
-            maxNeighborCount: 4,
-            ongoingHandshakes: new Set()
-        })
-
-    })
-
-    afterEach(async () => {
-        rpcCommunicator1.stop()
-        rpcCommunicator2.stop()
-        rpcCommunicator3.stop()
-        await simulatorTransport1.stop()
-        await simulatorTransport2.stop()
-        await simulatorTransport3.stop()
-        simulator.stop()
-    })
-
-    it('Two nodes can handshake', async () => {
-        rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
-        // @ts-expect-error private
-        const res = await handshaker.handshakeWithTarget(
-            new HandshakeRpcRemote(
-                peerDescriptor2,
-                peerDescriptor1,
-                rpcCommunicator2,
-                HandshakeRpcClient
-            )
-        )
-        expect(res).toEqual(true)
-        expect(neighbors.has(toNodeId(peerDescriptor1))).toEqual(true)
-    })
-
-    it('Handshake accepted', async () => {
-        rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
-        // @ts-expect-error private
-        const res = await handshaker.handshakeWithTarget(
-            new HandshakeRpcRemote(
-                peerDescriptor2,
-                peerDescriptor1,
-                rpcCommunicator2,
-                HandshakeRpcClient
-            )
-        )
-        expect(res).toEqual(true)
-        expect(neighbors.has(toNodeId(peerDescriptor1))).toEqual(true)
-    })
-
-    it('Handshake rejected', async () => {
-        rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', rejectHandshake)
-        // @ts-expect-error private
-        const res = await handshaker.handshakeWithTarget(
-            new HandshakeRpcRemote(
-                peerDescriptor2,
-                peerDescriptor1,
-                rpcCommunicator2,
-                HandshakeRpcClient
-            )
-        )
-        expect(res).toEqual(false)
-        expect(neighbors.has(toNodeId(peerDescriptor1))).toEqual(false)
-    })
-
-    it('Handshake with Interleaving', async () => {
-        rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', interleavingHandshake)
-        rpcCommunicator3.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
-        // @ts-expect-error private
-        const res = await handshaker.handshakeWithTarget(
-            new HandshakeRpcRemote(
-                peerDescriptor2,
-                peerDescriptor1,
-                rpcCommunicator2,
-                HandshakeRpcClient
-            )
-        )
-        expect(res).toEqual(true)
-        expect(neighbors.has(toNodeId(peerDescriptor1))).toEqual(true)
-        expect(neighbors.has(toNodeId(peerDescriptor3))).toEqual(true)
-    })
-})

package/test/integration/Inspect.test.ts

@@ -1,89 +0,0 @@
-import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { range } from 'lodash'
-import { NetworkStack } from '../../src/NetworkStack'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('inspect', () => {
-
-    let simulator: Simulator
-
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-    let sequenceNumber: number
-
-    const publisherDescriptor = createMockPeerDescriptor()
-    const inspectorPeerDescriptor = createMockPeerDescriptor()
-
-    const inspectedNodeCount = 12
-
-    let publisherNode: NetworkStack
-    let inspectorNode: NetworkStack
-    let inspectedNodes: NetworkStack[]
-
-    let publishInterval: NodeJS.Timeout
-
-    const initiateNode = async (peerDescriptor: PeerDescriptor, simulator: Simulator): Promise<NetworkStack> => {
-        const transport = new SimulatorTransport(peerDescriptor, simulator)
-        await transport.start()
-        const node = new NetworkStack({
-            layer0: {
-                entryPoints: [publisherDescriptor],
-                peerDescriptor,
-                transport,
-                connectionsView: transport
-            }
-        })
-        await node.start()
-        return node
-    }
-
-    beforeEach(async () => {
-        simulator = new Simulator(LatencyType.REAL)
-
-        publisherNode = await initiateNode(publisherDescriptor, simulator)
-        inspectorNode = await initiateNode(inspectorPeerDescriptor, simulator)
-
-        inspectedNodes = []
-        await Promise.all(range(inspectedNodeCount).map(async () => {
-            const peerDescriptor = createMockPeerDescriptor()
-            const node = await initiateNode(peerDescriptor, simulator)
-            inspectedNodes.push(node)
-        }))
-        await Promise.all([
-            publisherNode.joinStreamPart(streamPartId, { minCount: 4, timeout: 15000 }),
-            inspectorNode.joinStreamPart(streamPartId, { minCount: 4, timeout: 15000 }),
-            ...inspectedNodes.map((node) => node.joinStreamPart(streamPartId, { minCount: 4, timeout: 15000 }))
-        ])
-        sequenceNumber = 0
-    }, 30000)
-
-    afterEach(async () => {
-        clearInterval(publishInterval)
-        await Promise.all([
-            publisherNode.stop(),
-            inspectorNode.stop(),
-            ...inspectedNodes.map((node) => node.stop())
-        ])
-    })
-
-    it('gets successful inspections from all suspects', async () => {
-        publishInterval = setInterval(async () => {
-            const msg = createStreamMessage(
-                JSON.stringify({ hello: 'WORLD' }),
-                streamPartId,
-                randomUserId(),
-                123123,
-                sequenceNumber
-            )
-            publisherNode.getContentDeliveryManager().broadcast(msg)
-            sequenceNumber += 1
-        }, 200)
-
-        for (const node of inspectedNodes) {
-            const result = await inspectorNode.getContentDeliveryManager().inspect(node.getControlLayerNode().getLocalPeerDescriptor(), streamPartId)
-            expect(result).toEqual(true)
-        }
-    }, 25000)
-
-})

package/test/integration/NeighborUpdateRpcRemote.test.ts

@@ -1,82 +0,0 @@
-import {
-    ListeningRpcCommunicator,
-    NodeType,
-    PeerDescriptor,
-    Simulator,
-    SimulatorTransport
-} from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { NeighborUpdateRpcRemote } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcRemote'
-import { NeighborUpdate } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import {
-    NeighborUpdateRpcClient,
-} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-
-describe('NeighborUpdateRpcRemote', () => {
-    let mockServerRpc: ListeningRpcCommunicator
-    let clientRpc: ListeningRpcCommunicator
-    let rpcRemote: NeighborUpdateRpcRemote
-
-    const clientNode: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 1, 1]),
-        type: NodeType.NODEJS
-    }
-    const serverNode: PeerDescriptor = {
-        nodeId: new Uint8Array([2, 2, 2]),
-        type: NodeType.NODEJS
-    }
-
-    let simulator: Simulator
-    let mockConnectionManager1: SimulatorTransport
-    let mockConnectionManager2: SimulatorTransport
-
-    beforeEach(async () => {
-        simulator = new Simulator()
-        mockConnectionManager1 = new SimulatorTransport(serverNode, simulator)
-        await mockConnectionManager1.start()
-        mockConnectionManager2 = new SimulatorTransport(clientNode, simulator)
-        await mockConnectionManager2.start()
-
-        mockServerRpc = new ListeningRpcCommunicator('test', mockConnectionManager1)
-        clientRpc = new ListeningRpcCommunicator('test', mockConnectionManager2)
-
-        mockServerRpc.registerRpcMethod(
-            NeighborUpdate,
-            NeighborUpdate,
-            'neighborUpdate',
-            async (): Promise<NeighborUpdate> => {
-                const node: PeerDescriptor = {
-                    nodeId: new Uint8Array([4, 2, 4]),
-                    type: NodeType.NODEJS
-                }
-                const update: NeighborUpdate = {
-                    streamPartId: StreamPartIDUtils.parse('stream#0'),
-                    neighborDescriptors: [
-                        node
-                    ],
-                    removeMe: false
-                }
-                return update
-            }
-        )
-        rpcRemote = new NeighborUpdateRpcRemote(
-            clientNode,
-            serverNode,
-            clientRpc,
-            NeighborUpdateRpcClient
-        )
-    })
-
-    afterEach(async () => {
-        clientRpc.stop()
-        mockServerRpc.stop()
-        await mockConnectionManager1.stop()
-        await mockConnectionManager2.stop()
-        simulator.stop()
-    })
-
-    it('updateNeighbors', async () => {
-        const res = await rpcRemote.updateNeighbors(StreamPartIDUtils.parse('test#0'), [])
-        expect(res.peerDescriptors.length).toEqual(1)
-    })
-})

package/test/integration/NetworkNode.test.ts

@@ -1,115 +0,0 @@
-import { PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { ContentType, EncryptionType, SignatureType, StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
-
-describe('NetworkNode', () => {
-
-    let transport1: SimulatorTransport
-    let transport2: SimulatorTransport
-
-    let node1: NetworkNode
-    let node2: NetworkNode
-
-    const pd1: PeerDescriptor = createMockPeerDescriptor()
-
-    const pd2: PeerDescriptor = createMockPeerDescriptor()
-
-    beforeEach(async () => {
-        const simulator = new Simulator()
-        transport1 = new SimulatorTransport(pd1, simulator)
-        await transport1.start()
-        transport2 = new SimulatorTransport(pd2, simulator)
-        await transport2.start()
-
-        node1 = createNetworkNode({
-            layer0: {
-                entryPoints: [pd1],
-                peerDescriptor: pd1,
-                transport: transport1,
-                connectionsView: transport1
-            }
-        })
-        node2 = createNetworkNode({
-            layer0: {
-                entryPoints: [pd1],
-                peerDescriptor: pd2,
-                transport: transport2,
-                connectionsView: transport2
-            }
-        })
-
-        await node1.start()
-        node1.setStreamPartEntryPoints(STREAM_PART_ID, [pd1])
-        await node2.start()
-        node2.setStreamPartEntryPoints(STREAM_PART_ID, [pd1])
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            node1.stop(),
-            node2.stop()
-        ])
-    })
-
-    it('wait for join + broadcast and subscribe', async () => {
-        const streamMessage: StreamMessage = {
-            messageId: {
-                streamId: StreamPartIDUtils.getStreamID(STREAM_PART_ID),
-                streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
-                timestamp: 666,
-                sequenceNumber: 0,
-                publisherId: hexToBinary(randomUserId()),
-                messageChainId: 'msgChainId'
-            },
-            previousMessageRef: {
-                timestamp: 665,
-                sequenceNumber: 0
-            },
-            body: {
-                oneofKind: 'contentMessage',
-                contentMessage: {
-                    content: utf8ToBinary(JSON.stringify({
-                        hello: 'world'
-                    })),
-                    contentType: ContentType.JSON,
-                    encryptionType: EncryptionType.NONE,
-                }
-            },
-            signatureType: SignatureType.SECP256K1,
-            signature: hexToBinary('0x1234'),
-        }
-
-        let msgCount = 0
-        await node1.join(STREAM_PART_ID)
-        node1.addMessageListener((msg) => {
-            expect(msg.messageId!.timestamp).toEqual(666)
-            expect(msg.messageId!.sequenceNumber).toEqual(0)
-            msgCount += 1
-        })
-        await node2.broadcast(streamMessage)
-        await waitForCondition(() => msgCount === 1)
-    })
-
-    it('fetchNodeInfo', async () => {
-        await node1.join(STREAM_PART_ID)
-        await node2.join(STREAM_PART_ID)
-        const result1 = await node1.fetchNodeInfo(pd2)
-        const result2 = await node2.fetchNodeInfo(pd1)
-        const result3 = await node1.fetchNodeInfo(node1.getPeerDescriptor())
-        expect(result1.streamPartitions.length).toEqual(1)
-        expect(result2.streamPartitions.length).toEqual(1)
-        expect(result3.streamPartitions.length).toEqual(1)
-        expect(result1.controlLayer.connections.length).toEqual(1)
-        expect(result2.controlLayer.connections.length).toEqual(1)
-        expect(result3.controlLayer.connections.length).toEqual(1)
-        expect(result1.controlLayer.neighbors.length).toEqual(1)
-        expect(result2.controlLayer.neighbors.length).toEqual(1)
-        expect(result3.controlLayer.neighbors.length).toEqual(1)
-    })
-
-})

package/test/integration/NetworkRpc.test.ts

@@ -1,52 +0,0 @@
-import { DhtCallContext } from '@streamr/dht'
-import {
-    ProtoRpcClient,
-    RpcCommunicator,
-    toProtoRpcClient
-} from '@streamr/proto-rpc'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
-import { Empty } from '../../src/proto/google/protobuf/empty'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('Network RPC', () => {
-    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
-    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
-    let client: ProtoRpcClient<ContentDeliveryRpcClient>
-    let recvCounter = 0
-
-    beforeEach(() => {
-        rpcCommunicator1 = new RpcCommunicator()
-        rpcCommunicator2 = new RpcCommunicator()
-        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
-        })
-        client = toProtoRpcClient(new ContentDeliveryRpcClient(rpcCommunicator1.getRpcClientTransport()))
-        rpcCommunicator2.registerRpcNotification(
-            StreamMessage,
-            'sendStreamMessage',
-            async (): Promise<Empty> => {
-                recvCounter += 1
-                return {}
-            }
-        )
-    })
-
-    afterEach(() => {
-        rpcCommunicator1.stop()
-        rpcCommunicator2.stop()
-    })
-
-    it('sends Data', async () => {
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            StreamPartIDUtils.parse('testStream#0'),
-            randomUserId()
-        )
-        await client.sendStreamMessage(msg)
-        await waitForCondition(() => recvCounter === 1)
-    })
-})

package/test/integration/NetworkStack.test.ts

@@ -1,72 +0,0 @@
-import {
-    StreamPartIDUtils,
-    waitForCondition
-} from '@streamr/utils'
-import { NetworkStack } from '../../src/NetworkStack'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
-
-describe('NetworkStack', () => {
-
-    let stack1: NetworkStack
-    let stack2: NetworkStack
-
-    const epDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 32222, tls: false }
-    })
-
-    beforeEach(async () => {
-        stack1 = new NetworkStack({
-            layer0: {
-                peerDescriptor: epDescriptor,
-                entryPoints: [epDescriptor],
-                websocketServerEnableTls: false
-            }
-        })
-        stack2 = new NetworkStack({
-            layer0: {
-                websocketPortRange: { min: 32223, max: 32223 },
-                entryPoints: [epDescriptor],
-                websocketServerEnableTls: false
-            }
-        })
-
-        await stack1.start()
-        stack1.getContentDeliveryManager().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
-        await stack2.start()
-        stack2.getContentDeliveryManager().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            stack1.stop(),
-            stack2.stop()
-        ])
-    })
-
-    it('Can use NetworkNode pub/sub via NetworkStack', async () => {
-        let receivedMessages = 0
-        stack1.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        stack1.getContentDeliveryManager().on('newMessage', () => {
-            receivedMessages += 1
-        })
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            STREAM_PART_ID,
-            randomUserId()
-        )
-        stack2.getContentDeliveryManager().broadcast(msg)
-        await waitForCondition(() => receivedMessages === 1)
-    })
-
-    it('join and wait for neighbors', async () => {
-        await Promise.all([
-            stack1.joinStreamPart(STREAM_PART_ID, { minCount: 1, timeout: 5000 }),
-            stack2.joinStreamPart(STREAM_PART_ID, { minCount: 1, timeout: 5000 }),
-        ])
-        expect(stack1.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length).toBe(1)
-        expect(stack2.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length).toBe(1)
-    })
-})