@streamr/trackerless-network 0.0.1-tatum.0

package/test/unit/RandomGraphNode.test.ts

@@ -0,0 +1,73 @@
+import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
+import { keyFromPeerDescriptor, PeerDescriptor, PeerID, peerIdFromPeerDescriptor } from '@streamr/dht'
+import { MockTransport } from '../utils/mock/Transport'
+import { createMockRemotePeer, mockConnectionLocker } from '../utils/utils'
+import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
+import { PeerList } from '../../src/logic/PeerList'
+import { MockHandshaker } from '../utils/mock/MockHandshaker'
+import { MockNeighborUpdateManager } from '../utils/mock/MockNeighborUpdateManager'
+import { MockNeighborFinder } from '../utils/mock/MockNeighborFinder'
+import { mockLayer1 } from '../utils/mock/MockLayer1'
+
+describe('RandomGraphNode', () => {
+
+    let randomGraphNode: RandomGraphNode
+    const peerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('random-graph-node').value,
+        type: 0
+    }
+
+    let targetNeighbors: PeerList
+    let nearbyContactPool: PeerList
+    let randomContactPool: PeerList
+
+    beforeEach(async () => {
+        const peerId = peerIdFromPeerDescriptor(peerDescriptor)
+
+        targetNeighbors = new PeerList(peerId, 10)
+        randomContactPool = new PeerList(peerId, 10)
+        nearbyContactPool = new PeerList(peerId, 10)
+
+        randomGraphNode = createRandomGraphNode({
+            targetNeighbors,
+            randomContactPool,
+            nearbyContactPool,
+            P2PTransport: new MockTransport(),
+            ownPeerDescriptor: peerDescriptor,
+            layer1: mockLayer1 as any,
+            connectionLocker: mockConnectionLocker,
+            handshaker: new MockHandshaker(),
+            neighborUpdateManager: new MockNeighborUpdateManager(),
+            neighborFinder: new MockNeighborFinder(),
+            randomGraphId: 'random-graph'
+        })
+        await randomGraphNode.start()
+    })
+
+    afterEach(async () => {
+        await randomGraphNode.stop()
+    })
+
+    it('getTargetNeighborStringIds', () => {
+        const mockRemote = createMockRemotePeer()
+        targetNeighbors.add(mockRemote)
+        const ids = randomGraphNode.getTargetNeighborStringIds()
+        expect(ids[0]).toEqual(keyFromPeerDescriptor(mockRemote.getPeerDescriptor()))
+        targetNeighbors.remove(mockRemote.getPeerDescriptor())
+    })
+
+    it('getNearbyContactPoolIds', () => {
+        const mockRemote = createMockRemotePeer()
+        nearbyContactPool.add(mockRemote)
+        const ids = randomGraphNode.getNearbyContactPoolIds()
+        expect(ids[0]).toEqual(keyFromPeerDescriptor(mockRemote.getPeerDescriptor()))
+    })
+
+    it('getRandomContactPoolIds', () => {
+        const mockRemote = createMockRemotePeer()
+        randomContactPool.add(mockRemote)
+        const ids = randomGraphNode.getRandomContactPoolIds()
+        expect(ids[0]).toEqual(keyFromPeerDescriptor(mockRemote.getPeerDescriptor()))
+    })
+
+})

package/test/unit/StreamEntrypointDiscovery.test.ts

@@ -0,0 +1,152 @@
+import { StreamEntryPointDiscovery } from '../../src/logic/StreamEntryPointDiscovery'
+import { PeerDescriptor, RecursiveFindResult, PeerID } from '@streamr/dht'
+import { StreamObject } from '../../src/logic/StreamrNode'
+import { DataEntry } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Any } from '../../src/proto/google/protobuf/any'
+import { wait } from '@streamr/utils'
+
+describe('StreamEntryPointDiscovery', () => {
+
+    let streamEntryPointDiscoveryWithData: StreamEntryPointDiscovery
+    let streamEntryPointDiscoveryWithoutData: StreamEntryPointDiscovery
+    let storeCalled: number
+    let streams = new Map<string, StreamObject>()
+
+    const peerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('fake').value,
+        type: 0,
+        nodeName: 'fake'
+    }
+
+    const deletedPeerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('deleted').value,
+        type: 0,
+        nodeName: 'deleted'
+    }
+
+    const fakeData: DataEntry = {
+        data: Any.pack(peerDescriptor, PeerDescriptor),
+        ttl: 1000,
+        storer: peerDescriptor,
+        kademliaId: Uint8Array.from([1, 2, 3]),
+        stale: false,
+        deleted: false
+    }
+
+    const fakeDeletedData: DataEntry = {
+        data: Any.pack(deletedPeerDescriptor, PeerDescriptor),
+        ttl: 1000,
+        storer: deletedPeerDescriptor,
+        kademliaId: Uint8Array.from([1, 2, 3]),
+        stale: false,
+        deleted: true
+    }
+
+    const stream = 'stream#0'
+
+    const fakeGetEntryPointData = async (_key: Uint8Array): Promise<RecursiveFindResult> => {
+        return {
+            closestNodes: [peerDescriptor],
+            dataEntries: [fakeData, fakeDeletedData]
+        }
+    }
+
+    const fakeGetEntryPointDataViaPeer = async (_key: Uint8Array, _peer: PeerDescriptor): Promise<DataEntry[]> => {
+        return [fakeData]
+    }
+
+    const fakeStoreEntryPointData = async (_key: Uint8Array, _data: Any): Promise<PeerDescriptor[]> => {
+        storeCalled++
+        return [peerDescriptor]
+    }
+
+    const fakeEmptyGetEntryPointData = async (_key: Uint8Array): Promise<RecursiveFindResult> => {
+        return {
+            closestNodes: [],
+            dataEntries: []
+        }
+    }
+
+    const fakeDeleteEntryPointData = async (_key: Uint8Array): Promise<void> => {}
+
+    beforeEach(() => {
+        storeCalled = 0
+        streams = new Map()
+        streams.set(stream, {} as any)
+        streamEntryPointDiscoveryWithData = new StreamEntryPointDiscovery({
+            ownPeerDescriptor: peerDescriptor,
+            streams,
+            getEntryPointData: fakeGetEntryPointData,
+            getEntryPointDataViaPeer: fakeGetEntryPointDataViaPeer,
+            storeEntryPointData: fakeStoreEntryPointData,
+            deleteEntryPointData: fakeDeleteEntryPointData,
+            cacheInterval: 2000
+        })
+        streamEntryPointDiscoveryWithoutData = new StreamEntryPointDiscovery({
+            ownPeerDescriptor: peerDescriptor,
+            streams: new Map<string, StreamObject>(),
+            getEntryPointData: fakeEmptyGetEntryPointData,
+            getEntryPointDataViaPeer: fakeGetEntryPointDataViaPeer,
+            storeEntryPointData: fakeStoreEntryPointData,
+            deleteEntryPointData: fakeDeleteEntryPointData,
+            cacheInterval: 2000
+        })
+    })
+
+    afterEach(() => {
+        streamEntryPointDiscoveryWithData.destroy()
+    })
+
+    it('discoverEntryPointsFromDht has known entrypoints', async () => {
+        const res = await streamEntryPointDiscoveryWithData.discoverEntryPointsFromDht(stream, 1)
+        expect(res.joiningEmptyStream).toEqual(false)
+        expect(res.entryPointsFromDht).toEqual(false)
+        expect(res.discoveredEntryPoints).toEqual([])
+    })
+
+    it('discoverEntryPointsFromDht does not have known entrypoints', async () => {
+        const res = await streamEntryPointDiscoveryWithData.discoverEntryPointsFromDht(stream, 0)
+        expect(res.joiningEmptyStream).toEqual(false)
+        expect(res.entryPointsFromDht).toEqual(true)
+        expect(res.discoveredEntryPoints).toEqual([peerDescriptor])
+    })
+
+    it('discoverEntryPointsfromDht on an empty stream', async () => {
+        const res = await streamEntryPointDiscoveryWithoutData.discoverEntryPointsFromDht(stream, 0)
+        expect(res.joiningEmptyStream).toEqual(true)
+        expect(res.entryPointsFromDht).toEqual(true)
+        expect(res.discoveredEntryPoints).toEqual([peerDescriptor]) // ownPeerDescriptor
+    })
+
+    it('store on empty stream', async () => {
+        await streamEntryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(stream, true, true, 0)
+        expect(storeCalled).toEqual(1)
+    })
+
+    it('store on non-empty stream without known entry points', async () => {
+        await streamEntryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(stream, false, false, 0)
+        expect(storeCalled).toEqual(0)
+    })
+
+    it('store on stream without saturated entrypoint count', async () => {
+        await streamEntryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(stream, false, true, 0)
+        expect(storeCalled).toEqual(1)
+    })
+
+    it('will keep recaching until stream stopped', async () => {
+        await streamEntryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(stream, true, true, 0)
+        expect(storeCalled).toEqual(1)
+        await wait(4500)
+        streamEntryPointDiscoveryWithData.removeSelfAsEntryPoint(stream)
+        expect(storeCalled).toEqual(3)
+    })
+
+    it('will stop recaching is stream is left', async () => {
+        await streamEntryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(stream, true, true, 0)
+        expect(storeCalled).toEqual(1)
+        streams.delete(stream)
+        await wait(4500)
+        expect(storeCalled).toEqual(1)
+    })
+
+})

package/test/unit/StreamMessageTranslator.test.ts

@@ -0,0 +1,67 @@
+import { createStreamMessage } from '../utils/utils'
+import { ContentMessage, StreamMessageType } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { StreamMessageTranslator } from '../../src/logic/protocol-integration/stream-message/StreamMessageTranslator'
+import {
+    EncryptionType,
+    MessageID,
+    StreamID,
+    StreamMessage as OldStreamMessage,
+    StreamMessageType as OldStreamMessageType
+} from '@streamr/protocol'
+import { EthereumAddress } from '@streamr/utils'
+
+describe('StreamMessageTranslator', () => {
+
+    const content: ContentMessage = {
+        body: JSON.stringify({ hello: 'WORLD' })
+    }
+    const protobufMsg = createStreamMessage(content, 'TEST', 'publisher')
+
+    const messageId = new MessageID(
+        'TEST' as StreamID,
+        0,
+        Date.now(),
+        0,
+        'publisher' as EthereumAddress,
+        'test',
+    )
+
+    const oldProtocolMsg = new OldStreamMessage({
+        messageId,
+        prevMsgRef: null,
+        content: { hello: 'WORLD' },
+        messageType: OldStreamMessageType.MESSAGE,
+        encryptionType: EncryptionType.NONE,
+        signature: 'signature',
+    })
+
+    it('translates old protocol to protobuf', () => {
+        const translated = StreamMessageTranslator.toProtobuf(oldProtocolMsg)
+        expect(translated.messageRef!.timestamp).toBeGreaterThanOrEqual(0)
+        expect(translated.messageRef!.sequenceNumber).toEqual(0)
+        expect(translated.messageRef!.streamId).toEqual('TEST')
+        expect(translated.messageRef!.streamPartition).toEqual(0)
+        expect(translated.messageRef!.publisherId).toEqual('publisher')
+        expect(translated.previousMessageRef).toEqual(undefined)
+        expect(translated.messageType).toEqual(StreamMessageType.MESSAGE)
+        expect(translated.groupKeyId).toEqual(undefined)
+        expect(translated.signature).toEqual('signature')
+        expect(JSON.parse(ContentMessage.fromBinary(translated.content).body)).toEqual({ hello: 'WORLD' })
+
+    })
+
+    it('translates protobuf to old protocol', () => {
+        const translated = StreamMessageTranslator.toClientProtocol(protobufMsg)
+        expect(translated.messageId.timestamp).toBeGreaterThanOrEqual(0)
+        expect(translated.messageId.sequenceNumber).toEqual(0)
+        expect(translated.messageId.streamId).toEqual('TEST')
+        expect(translated.messageId.streamPartition).toEqual(0)
+        expect(translated.getPublisherId()).toEqual('publisher')
+        expect(translated.prevMsgRef).toEqual(null)
+        expect(translated.messageType).toEqual(OldStreamMessageType.MESSAGE)
+        expect(translated.contentType).toEqual(0)
+        expect(translated.groupKeyId).toEqual(null)
+        expect(translated.signature).toEqual('signature')
+        expect(translated.getParsedContent()).toEqual({ hello: 'WORLD' })
+    })
+})

package/test/unit/StreamNodeServer.test.ts

@@ -0,0 +1,63 @@
+import { ListeningRpcCommunicator, PeerDescriptor, PeerID } from '@streamr/dht'
+import { StreamNodeServer } from '../../src/logic/StreamNodeServer'
+import { ContentMessage, LeaveStreamNotice } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { MockTransport } from '../utils/mock/Transport'
+import { createStreamMessage } from '../utils/utils'
+
+describe('StreamNodeServer', () => {
+
+    let streamNodeServer: StreamNodeServer
+    const peerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('random-graph-node').value,
+        type: 0
+    }
+
+    const mockSender: PeerDescriptor = {
+        kademliaId: PeerID.fromString('mock-sender').value,
+        type: 0
+    }
+
+    const content: ContentMessage = {
+        body: JSON.stringify({ hello: 'WORLD' })
+    }
+    const message = createStreamMessage(content, 'random-graph', 'publisher')
+
+    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) => {})
+
+        streamNodeServer = new StreamNodeServer({
+            markAndCheckDuplicate: mockDuplicateCheck,
+            broadcast: mockBroadcast,
+            onLeaveNotice: mockOnLeaveNotice,
+            markForInspection: mockMarkForInspection,
+            ownPeerDescriptor: peerDescriptor,
+            randomGraphId: 'random-graph',
+            rpcCommunicator: new ListeningRpcCommunicator('random-graph-node', new MockTransport())
+        })
+    })
+    
+    it('Server sendData()', async () => {
+        await streamNodeServer.sendData(message, { incomingSourceDescriptor: mockSender } as any)
+        expect(mockDuplicateCheck).toHaveBeenCalledTimes(1)
+        expect(mockBroadcast).toHaveBeenCalledTimes(1)
+        expect(mockMarkForInspection).toHaveBeenCalledTimes(1)
+    })
+
+    it('Server leaveStreamNotice()', async () => {
+        const leaveNotice: LeaveStreamNotice = {
+            senderId: 'sender',
+            randomGraphId: 'random-graph'
+        }
+        await streamNodeServer.leaveStreamNotice(leaveNotice, { incomingSourceDescriptor: mockSender } as any)
+        expect(mockOnLeaveNotice).toHaveBeenCalledTimes(1)
+    })
+
+})

package/test/unit/StreamrNode.test.ts

@@ -0,0 +1,74 @@
+import { StreamrNode } from '../../src/logic/StreamrNode'
+import { MockLayer0 } from '../utils/mock/MockLayer0'
+import { isSamePeerDescriptor, PeerDescriptor, PeerID } from '@streamr/dht'
+import { createStreamMessage, mockConnectionLocker } from '../utils/utils'
+import { MockTransport } from '../utils/mock/Transport'
+import { ContentMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { waitForCondition } from '@streamr/utils'
+
+describe('StreamrNode', () => {
+
+    let node: StreamrNode
+    const peerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('streamr-node').value,
+        type: 0
+    }
+    const stream = 'stream'
+    const content: ContentMessage = {
+        body: JSON.stringify({ hello: 'WORLD' })
+    }
+    const message = createStreamMessage(content, stream, 'publisher')
+
+    beforeEach(async () => {
+        node = new StreamrNode({})
+        const mockLayer0 = new MockLayer0(peerDescriptor)
+        await node.start(mockLayer0, new MockTransport(), mockConnectionLocker)
+        node.setStreamPartEntryPoints(stream, [peerDescriptor])
+    })
+
+    afterEach(async () => {
+        await node.destroy()
+    })
+
+    it('PeerDescriptor is correct', () => {
+        expect(isSamePeerDescriptor(peerDescriptor, node.getPeerDescriptor()))
+    })
+
+    it('can join streams', async () => {
+        await node.joinStream(stream)
+        expect(node.hasStream(stream)).toEqual(true)
+    })
+
+    it('can leave streams', async () => {
+        await node.joinStream(stream)
+        expect(node.hasStream(stream)).toEqual(true)
+        node.leaveStream(stream)
+        expect(node.hasStream(stream)).toEqual(false)
+    })
+
+    it('subscribe and wait for join', async () => {
+        await node.waitForJoinAndSubscribe(stream)
+        expect(node.hasStream(stream)).toEqual(true)
+    })
+
+    it('publish and wait for join', async () => {
+        await node.waitForJoinAndPublish(stream, message)
+        expect(node.hasStream(stream)).toEqual(true)
+    })
+
+    it('subscribe joins stream', async () => {
+        node.subscribeToStream(stream)
+        await waitForCondition(() => node.hasStream(stream))
+    })
+
+    it('publish joins stream', async () => {
+        await node.publishToStream(stream, message)
+        await waitForCondition(() => node.hasStream(stream))
+    })
+
+    it('can unsubscribe', async () => {
+        await node.joinStream(stream)
+        await node.unsubscribeFromStream(stream)
+    })
+
+})

package/test/utils/mock/MockHandshaker.ts

@@ -0,0 +1,15 @@
+import { IHandshaker } from '../../../src/logic/neighbor-discovery/Handshaker'
+
+export class MockHandshaker implements IHandshaker {
+
+    // eslint-disable-next-line class-methods-use-this
+    getOngoingHandshakes(): Set<string> {
+        return new Set()
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async attemptHandshakesOnContacts(excludedIds: string[]): Promise<string[]> {
+        return excludedIds
+    }
+
+}

package/test/utils/mock/MockLayer0.ts

@@ -0,0 +1,71 @@
+import { PeerDescriptor, peerIdFromPeerDescriptor, PeerID, RecursiveFindResult, Message, DataEntry } from '@streamr/dht'
+import { ILayer0 } from '../../../src/logic/ILayer0'
+import { Any } from '../../../src/proto/google/protobuf/any'
+import { EventEmitter } from 'eventemitter3'
+
+export class MockLayer0 extends EventEmitter implements ILayer0 {
+
+    private readonly peerDescriptor: PeerDescriptor
+
+    constructor(peerDescriptor: PeerDescriptor) {
+        super()
+        this.peerDescriptor = peerDescriptor
+    }
+
+    getPeerDescriptor(): PeerDescriptor {
+        return this.peerDescriptor
+    }
+
+    getNodeId(): PeerID {
+        return peerIdFromPeerDescriptor(this.peerDescriptor)
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async getDataFromDht(_key: Uint8Array): Promise<RecursiveFindResult> {
+        return {
+            closestNodes: [],
+            dataEntries: []
+        }
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async findDataViaPeer(_key: Uint8Array): Promise<DataEntry[]> {
+        return []
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async deleteDataFromDht(_key: Uint8Array): Promise<void> {
+        
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async storeDataToDht(_key: Uint8Array, _data: Any): Promise<PeerDescriptor[]> {
+        return []
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async send(_message: Message, _doNotConnect?: boolean): Promise<void> {
+        return
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getKnownEntryPoints(): PeerDescriptor[] {
+        return []
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    isJoinOngoing(): boolean {
+        return false
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getAllConnectionPeerDescriptors(): PeerDescriptor[] {
+        return []
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async stop(): Promise<void> {
+
+    }
+
+}

package/test/utils/mock/MockLayer1.ts

@@ -0,0 +1,6 @@
+export const mockLayer1 = {
+    on: (): void => {},
+    once: (): void => {},
+    off: (): void => {},
+    getNeighborList: (): any => { return { getClosestContacts: () => [] }},
+}

package/test/utils/mock/MockNeighborFinder.ts

@@ -0,0 +1,19 @@
+import { INeighborFinder } from '../../../src/logic/neighbor-discovery/NeighborFinder'
+
+export class MockNeighborFinder implements INeighborFinder {
+
+    // eslint-disable-next-line class-methods-use-this
+    start(_excluded?: string[]): void {
+
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    stop(): void {
+
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    isRunning(): boolean {
+        return false
+    }
+}

package/test/utils/mock/MockNeighborUpdateManager.ts

@@ -0,0 +1,21 @@
+import { INeighborUpdateManager } from '../../../src/logic/neighbor-discovery/NeighborUpdateManager'
+import { NeighborUpdate } from '../../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+
+export class MockNeighborUpdateManager implements INeighborUpdateManager {
+
+    // eslint-disable-next-line class-methods-use-this
+    async start(): Promise<void> {
+
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    stop(): void {
+
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async neighborUpdate(_request: NeighborUpdate, _context: ServerCallContext): Promise<NeighborUpdate> {
+        return NeighborUpdate.create()
+    }
+}

package/test/utils/mock/Transport.ts

@@ -0,0 +1,25 @@
+import { ITransport, Message, PeerDescriptor } from '@streamr/dht'
+import { EventEmitter } from 'eventemitter3'
+
+export class MockTransport extends EventEmitter implements ITransport {
+
+    // eslint-disable-next-line class-methods-use-this
+    async send(_msg: Message, _doNotConnect?: boolean): Promise<void> {
+
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getPeerDescriptor(): PeerDescriptor {
+        return PeerDescriptor.create()
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getAllConnectionPeerDescriptors(): PeerDescriptor[] {
+        return []
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    stop(): void {
+
+    }
+}