@streamr/trackerless-network 102.0.0-beta.1 → 102.0.0-beta.3

package/test/integration/stream-without-default-entrypoints.test.ts

@@ -1,128 +0,0 @@
-import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { randomUserId } from '@streamr/test-utils'
-import { StreamPartIDUtils, hexToBinary, toUserIdRaw, utf8ToBinary, until } from '@streamr/utils'
-import { range } from 'lodash'
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-import { ContentType, EncryptionType, SignatureType, StreamMessage } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
-
-describe('stream without default entrypoints', () => {
-
-    let entrypoint: NetworkNode
-    let nodes: NetworkNode[]
-    let receivedMessageCount: number
-    const entryPointPeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
-
-    const streamMessage: StreamMessage = {
-        messageId: {
-            streamId: StreamPartIDUtils.getStreamID(STREAM_PART_ID),
-            streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
-            timestamp: 666,
-            sequenceNumber: 0,
-            publisherId: toUserIdRaw(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'),
-    }
-
-    beforeEach(async () => {
-        const simulator = new Simulator(LatencyType.REAL)
-        nodes = []
-        receivedMessageCount = 0
-        const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
-        await entryPointTransport.start()
-        entrypoint = createNetworkNode({
-            layer0: {
-                transport: entryPointTransport,
-                connectionsView: entryPointTransport,
-                peerDescriptor: entryPointPeerDescriptor,
-                entryPoints: [entryPointPeerDescriptor]
-            }
-        })
-        await entrypoint.start()
-        await Promise.all(range(20).map(async () => {
-            const peerDescriptor = createMockPeerDescriptor()
-            const transport = new SimulatorTransport(peerDescriptor, simulator)
-            await transport.start()
-            const node = createNetworkNode({
-                layer0: {
-                    peerDescriptor,
-                    transport,
-                    connectionsView: transport,
-                    entryPoints: [entryPointPeerDescriptor]
-                }
-            })
-            nodes.push(node)
-            await node.start()
-        }))
-    })
-
-    afterEach(async () => {
-        await entrypoint.stop()
-        await Promise.all(nodes.map((node) => node.stop()))
-    })
-
-    it('can join stream without configured entrypoints one by one', async () => {
-        await nodes[0].join(STREAM_PART_ID)
-        nodes[0].addMessageListener((_msg) => {
-            receivedMessageCount += 1
-        })
-        await Promise.all([
-            until(() => receivedMessageCount === 1, 10000),
-            nodes[1].broadcast(streamMessage)
-        ])
-    })
-
-    it('can join without configured entrypoints simultaneously', async () => {
-        nodes[0].addMessageListener((_msg) => {
-            receivedMessageCount += 1
-        })
-        await Promise.all([
-            until(() => receivedMessageCount === 1, 15000),
-            nodes[0].join(STREAM_PART_ID),
-            nodes[1].broadcast(streamMessage),
-        ])
-    })
-
-    it('multiple nodes can join without configured entrypoints simultaneously', async () => {
-        const subscriberCount = 8
-        await Promise.all(range(subscriberCount).map(async (i) => {
-            await nodes[i].join(STREAM_PART_ID, { minCount: 4, timeout: 15000 })
-            nodes[i].addMessageListener(() => {
-                receivedMessageCount += 1
-            })
-        }))
-        const nonjoinedNode = nodes[subscriberCount]
-        await nonjoinedNode.broadcast(streamMessage)
-        await until(() => receivedMessageCount === subscriberCount, 15000)
-    }, 45000)
-
-    it('nodes store themselves as entrypoints on streamPart if number of entrypoints is low', async () => {
-        for (let i = 0; i < 10; i++) {
-            await nodes[i].join(STREAM_PART_ID, { minCount: (i > 0) ? 1 : 0, timeout: 15000 })
-        }
-        await until(async () => {
-            const entryPointData = await nodes[15].stack.getControlLayerNode().fetchDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
-            return entryPointData.length >= 7
-        }, 15000)
-        
-    }, 90000)
-})

package/test/integration/streamEntryPointReplacing.test.ts

@@ -1,97 +0,0 @@
-import { LatencyType, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { range } from 'lodash'
-import { NetworkStack } from '../../src/NetworkStack'
-import { MAX_NODE_COUNT } from '../../src/logic/PeerDescriptorStoreManager'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('Stream Entry Points are replaced when known entry points leave streams', () => {
-    
-    let simulator: Simulator
-    let layer0EntryPoint: NetworkStack
-    const entryPointPeerDescriptor = createMockPeerDescriptor()
-    let initialNodesOnStream: NetworkStack[]
-    let laterNodesOnStream: NetworkStack[]
-    let newNodeInStream: NetworkStack
-
-    const NUM_OF_LATER_NODES = 16
-
-    const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
-
-    const startNode = async () => {
-        const peerDescriptor = createMockPeerDescriptor()
-        const transport = new SimulatorTransport(peerDescriptor, simulator)
-        await transport.start()
-        const node = new NetworkStack({
-            layer0: {
-                transport,
-                connectionsView: transport,
-                peerDescriptor,
-                entryPoints: [entryPointPeerDescriptor]
-            }
-        })
-        await node.start()
-        return node
-    }
-
-    beforeEach(async () => {
-        simulator = new Simulator(LatencyType.REAL)
-        const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
-        layer0EntryPoint = new NetworkStack({
-            layer0: {
-                transport: entryPointTransport,
-                connectionsView: entryPointTransport,
-                peerDescriptor: entryPointPeerDescriptor,
-                entryPoints: [entryPointPeerDescriptor]
-            }
-        })
-        await entryPointTransport.start()
-        await layer0EntryPoint.start()
-
-        initialNodesOnStream = await Promise.all(range(MAX_NODE_COUNT).map(async () => {
-            return await startNode()
-        }))
-
-        laterNodesOnStream = await Promise.all(range(NUM_OF_LATER_NODES).map(async () => {
-            return await startNode()
-        }))
-        newNodeInStream = await startNode()
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            layer0EntryPoint.stop(),
-            ...initialNodesOnStream.map((node) => node.stop()),
-            ...laterNodesOnStream.map((node) => node.stop()),
-            newNodeInStream.stop()
-        ])
-        simulator.stop()
-    })
-
-    // TODO: Investigate why 60 second timeouts are needed
-    it('stream entry points are replaced when nodes leave streams', async () => {
-        await Promise.all(initialNodesOnStream.map((node) => node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 60000 })))
-
-        let receivedMessages = 0
-        for (const node of laterNodesOnStream) {
-            await node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 60000 }) 
-            node.getContentDeliveryManager().on('newMessage', () => {
-                receivedMessages += 1
-            })
-        }
-
-        await Promise.all(initialNodesOnStream.map((node) => node.getContentDeliveryManager().leaveStreamPart(STREAM_PART_ID)))
-        await until(() => 
-            laterNodesOnStream.every((node) => node.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length >= 4), 60000, 1000
-        )
-
-        const msg = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            STREAM_PART_ID,
-            randomUserId()
-        )
-        newNodeInStream.getContentDeliveryManager().broadcast(msg)
-        await until(() => receivedMessages === NUM_OF_LATER_NODES, 30000)
-    }, 200000)
-})

package/test/types/global.d.ts

@@ -1 +0,0 @@
-import '@streamr/test-utils/customMatcherTypes'

package/test/unit/ContentDeliveryLayerNode.test.ts

@@ -1,112 +0,0 @@
-import { toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
-import { NodeList } from '../../src/logic/NodeList'
-import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
-import { MockDiscoveryLayerNode } from '../utils/mock/MockDiscoveryLayerNode'
-import { MockHandshaker } from '../utils/mock/MockHandshaker'
-import { MockNeighborFinder } from '../utils/mock/MockNeighborFinder'
-import { MockNeighborUpdateManager } from '../utils/mock/MockNeighborUpdateManager'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockContentDeliveryRpcRemote, createMockPeerDescriptor, mockConnectionLocker } from '../utils/utils'
-
-describe('ContentDeliveryLayerNode', () => {
-
-    let contentDeliveryLayerNode: ContentDeliveryLayerNode
-    const peerDescriptor = createMockPeerDescriptor()
-
-    let neighbors: NodeList
-    let nearbyNodeView: NodeList
-    let randomNodeView: NodeList
-
-    let discoveryLayerNode: MockDiscoveryLayerNode
-
-    beforeEach(async () => {
-        const nodeId = toNodeId(peerDescriptor)
-
-        neighbors = new NodeList(nodeId, 10)
-        randomNodeView = new NodeList(nodeId, 10)
-        nearbyNodeView = new NodeList(nodeId, 10)
-        discoveryLayerNode = new MockDiscoveryLayerNode()
-
-        contentDeliveryLayerNode = createContentDeliveryLayerNode({
-            neighbors,
-            randomNodeView,
-            nearbyNodeView,
-            transport: new MockTransport(),
-            localPeerDescriptor: peerDescriptor,
-            discoveryLayerNode,
-            connectionLocker: mockConnectionLocker,
-            handshaker: new MockHandshaker() as any,
-            neighborUpdateManager: new MockNeighborUpdateManager() as any,
-            neighborFinder: new MockNeighborFinder() as any,
-            streamPartId: StreamPartIDUtils.parse('stream#0'),
-            isLocalNodeEntryPoint: () => false
-        })
-        await contentDeliveryLayerNode.start()
-    })
-
-    afterEach(() => {
-        contentDeliveryLayerNode.stop()
-    })
-
-    it('getNeighbors', () => {
-        const mockRemote = createMockContentDeliveryRpcRemote()
-        neighbors.add(mockRemote)
-        const result = contentDeliveryLayerNode.getNeighbors()
-        expect(toNodeId(result[0])).toEqual(toNodeId(mockRemote.getPeerDescriptor()))
-    })
-
-    it('getNearbyNodeView', () => {
-        const mockRemote = createMockContentDeliveryRpcRemote()
-        nearbyNodeView.add(mockRemote)
-        const ids = contentDeliveryLayerNode.getNearbyNodeView().getIds()
-        expect(ids[0]).toEqual(toNodeId(mockRemote.getPeerDescriptor()))
-    })
-
-    it('Adds Closest Nodes from layer1 nearbyContactAdded event to nearbyNodeView', async () => {
-        const peerDescriptor1 = createMockPeerDescriptor()
-        const peerDescriptor2 = createMockPeerDescriptor()
-        discoveryLayerNode.setClosestContacts([peerDescriptor1, peerDescriptor2])
-        discoveryLayerNode.emit('nearbyContactAdded', peerDescriptor1)
-        await until(() => nearbyNodeView.size() === 2)
-        expect(nearbyNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
-    })
-
-    it('Adds Random Nodes from layer1 randomContactAdded event to randomNodeView', async () => {
-        const peerDescriptor1 = createMockPeerDescriptor()
-        const peerDescriptor2 = createMockPeerDescriptor()
-        discoveryLayerNode.setRandomContacts([peerDescriptor1, peerDescriptor2])
-        discoveryLayerNode.emit('randomContactAdded', peerDescriptor1)
-        await until(() => randomNodeView.size() === 2)
-        expect(randomNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
-        expect(randomNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
-    })
-
-    it('Adds Nodes from layer1 neighbors to nearbyNodeView if its size is below nodeViewSize', async () => {
-        const peerDescriptor1 = createMockPeerDescriptor()
-        const peerDescriptor2 = createMockPeerDescriptor()
-        discoveryLayerNode.addNewRandomPeerToKBucket()
-        discoveryLayerNode.setClosestContacts([peerDescriptor1, peerDescriptor2])
-        discoveryLayerNode.emit('nearbyContactAdded', peerDescriptor1)
-        await until(() => {
-            return nearbyNodeView.size() === 3
-        }, 20000)
-        expect(nearbyNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
-    }, 25000)
-
-    it('getInfo', () => {
-        const nodeWithRtt = createMockContentDeliveryRpcRemote()
-        neighbors.add(nodeWithRtt)
-        const nodeWithoutRtt = createMockContentDeliveryRpcRemote()
-        neighbors.add(nodeWithoutRtt)
-        nodeWithRtt.setRtt(100)
-        const info = contentDeliveryLayerNode.getInfos()
-        expect(info[0].rtt).toEqual(100)
-        expect(info[0].peerDescriptor).toEqual(nodeWithRtt.getPeerDescriptor())
-        expect(info[1].rtt).toBeUndefined()
-        expect(info[1].peerDescriptor).toEqual(nodeWithoutRtt.getPeerDescriptor())
-    })
-})

package/test/unit/ContentDeliveryManager.test.ts

@@ -1,96 +0,0 @@
-import { areEqualPeerDescriptors } from '@streamr/dht'
-import { StreamPartIDUtils, until } from '@streamr/utils'
-import { ContentDeliveryManager } from '../../src/logic/ContentDeliveryManager'
-import { ProxyDirection } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { MockControlLayerNode } from '../utils/mock/MockControlLayerNode'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor, createStreamMessage, mockConnectionLocker } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('ContentDeliveryManager', () => {
-
-    let manager: ContentDeliveryManager
-    const peerDescriptor = createMockPeerDescriptor()
-
-    beforeEach(async () => {
-        manager = new ContentDeliveryManager({})
-        const mockLayer0 = new MockControlLayerNode(peerDescriptor)
-        await manager.start(mockLayer0, new MockTransport(), mockConnectionLocker)
-    })
-
-    afterEach(async () => {
-        await manager.destroy()
-    })
-
-    it('PeerDescriptor is correct', () => {
-        // TODO could use toEqualPeerDescriptor from dht package if we export that custom matcher
-        expect(areEqualPeerDescriptors(peerDescriptor, manager.getPeerDescriptor())).toBe(true)
-    })
-
-    describe('join and leave', () => {
-
-        const streamPartId = StreamPartIDUtils.parse('stream#0')
-        const message = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            streamPartId,
-            randomUserId()
-        )
-
-        beforeEach(async () => {
-            manager.setStreamPartEntryPoints(streamPartId, [manager.getPeerDescriptor()])
-        })
-
-        it('can join stream part', async () => {
-            manager.joinStreamPart(streamPartId)
-            expect(manager.hasStreamPart(streamPartId)).toEqual(true)
-        })
-
-        it('can leave stream part', async () => {
-            manager.joinStreamPart(streamPartId)
-            expect(manager.hasStreamPart(streamPartId)).toEqual(true)
-            await manager.leaveStreamPart(streamPartId)
-            expect(manager.hasStreamPart(streamPartId)).toEqual(false)
-        })
-
-        it('broadcast joins stream', async () => {
-            manager.broadcast(message)
-            await until(() => manager.hasStreamPart(streamPartId))
-        })
-    })
-
-    describe('proxied stream', () => {
-        it('happy path', async () => {
-            const streamPartId = StreamPartIDUtils.parse('stream#0')
-            const proxy = createMockPeerDescriptor()
-            const userId = randomUserId()
-            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
-            await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
-        })
-
-        it('empty node list', async () => {
-            const streamPartId = StreamPartIDUtils.parse('stream#0')
-            const proxy = createMockPeerDescriptor()
-            const userId = randomUserId()
-            await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
-            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
-            await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
-        })
-
-        it('connection count to 0', async () => {
-            const streamPartId = StreamPartIDUtils.parse('stream#0')
-            const proxy = createMockPeerDescriptor()
-            const userId = randomUserId()
-            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId, 0)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
-            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
-            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId, 0)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
-        })
-    })
-})

package/test/unit/ContentDeliveryRpcLocal.test.ts

@@ -1,60 +0,0 @@
-import { ListeningRpcCommunicator } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { ContentDeliveryRpcLocal } from '../../src/logic/ContentDeliveryRpcLocal'
-import { LeaveStreamPartNotice } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('ContentDeliveryRpcLocal', () => {
-
-    let rpcLocal: ContentDeliveryRpcLocal
-    const peerDescriptor = createMockPeerDescriptor()
-
-    const mockSender = createMockPeerDescriptor()
-
-    const message = createStreamMessage(
-        JSON.stringify({ hello: 'WORLD' }),
-        StreamPartIDUtils.parse('random-graph#0'),
-        randomUserId()
-    )
-
-    let mockBroadcast: jest.Mock
-    let mockDuplicateCheck: jest.Mock
-    let mockOnLeaveNotice: jest.Mock
-    let mockMarkForInspection: jest.Mock
-
-    beforeEach(async () => {
-        mockDuplicateCheck = jest.fn((_c, _p) => true)
-        mockBroadcast = jest.fn((_m, _p) => {})
-        mockOnLeaveNotice = jest.fn((_m) => {})
-        mockMarkForInspection = jest.fn((_m) => {})
-
-        rpcLocal = new ContentDeliveryRpcLocal({
-            markAndCheckDuplicate: mockDuplicateCheck,
-            broadcast: mockBroadcast,
-            onLeaveNotice: mockOnLeaveNotice,
-            markForInspection: mockMarkForInspection,
-            localPeerDescriptor: peerDescriptor,
-            streamPartId: StreamPartIDUtils.parse('stream#0'),
-            rpcCommunicator: new ListeningRpcCommunicator('random-graph-node', new MockTransport())
-        })
-    })
-    
-    it('Server sendStreamMessage()', async () => {
-        await rpcLocal.sendStreamMessage(message, { incomingSourceDescriptor: mockSender } as any)
-        expect(mockDuplicateCheck).toHaveBeenCalledTimes(1)
-        expect(mockBroadcast).toHaveBeenCalledTimes(1)
-        expect(mockMarkForInspection).toHaveBeenCalledTimes(1)
-    })
-
-    it('Server leaveStreamPartNotice()', async () => {
-        const leaveNotice: LeaveStreamPartNotice = {
-            streamPartId: StreamPartIDUtils.parse('stream#0'),
-            isEntryPoint: false
-        }
-        await rpcLocal.leaveStreamPartNotice(leaveNotice, { incomingSourceDescriptor: mockSender } as any)
-        expect(mockOnLeaveNotice).toHaveBeenCalledTimes(1)
-    })
-
-})