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

package/test/unit/PeerDescriptorStoreManager.test.ts

@@ -1,103 +0,0 @@
-import { PeerDescriptor, areEqualPeerDescriptors, randomDhtAddress } from '@streamr/dht'
-import { wait } from '@streamr/utils'
-import { PeerDescriptorStoreManager } from '../../src/logic/PeerDescriptorStoreManager'
-import { Any } from '../../generated/google/protobuf/any'
-import { DataEntry } from '../../generated/packages/dht/protos/DhtRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const KEY = randomDhtAddress()
-
-describe('PeerDescriptorStoreManager', () => {
-
-    let withData: PeerDescriptorStoreManager
-    let withoutData: PeerDescriptorStoreManager
-    let storeCalled: number
-
-    const peerDescriptor = createMockPeerDescriptor()
-    const deletedPeerDescriptor = createMockPeerDescriptor()
-
-    const fakeData: DataEntry = {
-        key: Uint8Array.from([1, 2, 3]),
-        data: Any.pack(peerDescriptor, PeerDescriptor),
-        creator: peerDescriptor.nodeId,
-        ttl: 1000,
-        stale: false,
-        deleted: false
-    }
-
-    const fakeDeletedData: DataEntry = {
-        key: Uint8Array.from([1, 2, 3]),
-        data: Any.pack(deletedPeerDescriptor, PeerDescriptor),
-        creator: deletedPeerDescriptor.nodeId,
-        ttl: 1000,
-        stale: false,
-        deleted: true
-    }
-
-    const fakeFetchDataFromDht = async (): Promise<DataEntry[]> => {
-        return [fakeData, fakeDeletedData]
-    }
-
-    const fakeStoreDataToDht = async (): Promise<PeerDescriptor[]> => {
-        storeCalled++
-        return [peerDescriptor]
-    }
-
-    const fakeEmptyFetchDataFromDht = async (): Promise<DataEntry[]> => {
-        return []
-    }
-
-    const fakeDeleteDataFromDht = async (): Promise<void> => {}
-
-    beforeEach(() => {
-        storeCalled = 0
-        withData = new PeerDescriptorStoreManager({
-            localPeerDescriptor: peerDescriptor,
-            key: KEY,
-            fetchDataFromDht: fakeFetchDataFromDht,
-            storeDataToDht: fakeStoreDataToDht,
-            deleteDataFromDht: fakeDeleteDataFromDht,
-            storeInterval: 2000
-        })
-        withoutData = new PeerDescriptorStoreManager({
-            localPeerDescriptor: peerDescriptor,
-            key: KEY,
-            fetchDataFromDht: fakeEmptyFetchDataFromDht,
-            storeDataToDht: fakeStoreDataToDht,
-            deleteDataFromDht: fakeDeleteDataFromDht,
-            storeInterval: 2000
-        })
-    })
-
-    afterEach(() => {
-        withData.destroy()
-    })
-
-    it('discoverEntryPoints filters deleted data', async () => {
-        const res = await withData.fetchNodes()
-        expect(res.length).toBe(1)
-        expect(areEqualPeerDescriptors(res[0], peerDescriptor)).toBe(true)
-    })
-
-    it('discoverEntryPoints without results', async () => {
-        const res = await withoutData.fetchNodes()
-        expect(res.length).toBe(0)
-    })
-
-    it('store on stream without saturated entrypoint count', async () => {
-        await withData.storeAndKeepLocalNode()
-        expect(storeCalled).toEqual(1)
-        expect(withData.isLocalNodeStored()).toEqual(true)
-    })
-
-    it('will keep stored until destroyed', async () => {
-        await withData.storeAndKeepLocalNode()
-        expect(storeCalled).toEqual(1)
-        expect(withData.isLocalNodeStored()).toEqual(true)
-        await wait(4500)
-        await withData.destroy()
-        // we have configured storeInterval to 2 seconds, i.e. after 4.5 seconds it should have been called 2 more items 
-        expect(storeCalled).toEqual(3)
-    })
-
-})

package/test/unit/Propagation.test.ts

@@ -1,151 +0,0 @@
-import { DhtAddress } from '@streamr/dht'
-import { hexToBinary, toUserIdRaw, wait } from '@streamr/utils'
-import { Propagation } from '../../src/logic/propagation/Propagation'
-import {
-    ContentType,
-    EncryptionType,
-    MessageID,
-    SignatureType,
-    StreamMessage
-} from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { randomUserId } from '@streamr/test-utils'
-
-const PUBLISHER_ID = randomUserId()
-
-function makeMsg(streamId: string, partition: number, ts: number, msgNo: number): StreamMessage {
-    const messageId: MessageID = {
-        streamId,
-        streamPartition: partition,
-        timestamp: ts,
-        sequenceNumber: msgNo,
-        messageChainId: 'msgChain',
-        publisherId: toUserIdRaw(PUBLISHER_ID)
-    }
-    return {
-        messageId,
-        signature: hexToBinary('0x1111'),
-        signatureType: SignatureType.SECP256K1,
-        body: {
-            oneofKind: 'contentMessage',
-            contentMessage: {
-                content: new Uint8Array([1]),
-                contentType: ContentType.JSON,
-                encryptionType: EncryptionType.NONE
-            }
-        }
-    }
-}
-
-const TTL = 100
-
-const N1 = 'n1' as DhtAddress
-const N2 = 'n2' as DhtAddress
-const N3 = 'n3' as DhtAddress
-const N4 = 'n4' as DhtAddress
-const N5 = 'n5' as DhtAddress
-
-describe(Propagation, () => {
-    let getNeighbors: jest.Mock<readonly DhtAddress[], [string]>
-    let sendToNeighbor: jest.Mock<Promise<void>, [DhtAddress, StreamMessage]>
-    let propagation: Propagation
-
-    beforeEach(() => {
-        getNeighbors = jest.fn()
-        sendToNeighbor = jest.fn()
-        propagation = new Propagation({
-            sendToNeighbor,
-            minPropagationTargets: 3,
-            ttl: TTL,
-            maxMessages: 5
-        })
-    })
-
-    describe('#feedUnseenMessage', () => {
-        it('message is propagated to nodes returned by getNeighbors', () => {
-            getNeighbors.mockReturnValueOnce([N1, N2, N3])
-            const msg = makeMsg('s1', 0, 1000, 1)
-            propagation.feedUnseenMessage(msg, [...getNeighbors('s1#0')], null)
-
-            expect(sendToNeighbor).toHaveBeenCalledTimes(3)
-            expect(sendToNeighbor).toHaveBeenNthCalledWith(1, N1, msg)
-            expect(sendToNeighbor).toHaveBeenNthCalledWith(2, N2, msg)
-            expect(sendToNeighbor).toHaveBeenNthCalledWith(3, N3, msg)
-        })
-
-        it('message does not get propagated to source node (if present in getNeighbors)', () => {
-            getNeighbors.mockReturnValueOnce([N1, N2, N3])
-            const msg = makeMsg('s1', 0, 1000, 1)
-            propagation.feedUnseenMessage(msg, [...getNeighbors('s1#0')], N2)
-
-            expect(sendToNeighbor).toHaveBeenCalledTimes(2)
-            expect(sendToNeighbor).toHaveBeenNthCalledWith(1, N1, msg)
-            expect(sendToNeighbor).toHaveBeenNthCalledWith(2, N3, msg)
-        })
-    })
-
-    describe('#onNeighborJoined', () => {
-        let msg: StreamMessage
-
-        async function setUpAndFeed(neighbors: DhtAddress[]): Promise<void> {
-            getNeighbors.mockReturnValueOnce(neighbors)
-            msg = makeMsg('s1', 0, 1000, 1)
-            propagation.feedUnseenMessage(msg, [...getNeighbors('s1#0')], N2)
-            await wait(0)
-            sendToNeighbor.mockClear()
-            getNeighbors.mockClear()
-        }
-
-        it('sends to new neighbor', async () => {
-            await setUpAndFeed([N1, N2, N3])
-            propagation.onNeighborJoined(N4)
-            expect(sendToNeighbor).toHaveBeenCalledTimes(1)
-            expect(sendToNeighbor).toHaveBeenNthCalledWith(1, N4, msg)
-        })
-
-        it('sends to previously failed neighbor', async () => {
-            sendToNeighbor.mockImplementation(async (neighbor) => {
-                if (neighbor === N3) {
-                    throw new Error('failed to send')
-                }
-            })
-            await setUpAndFeed([N1, N2, N3])
-            propagation.onNeighborJoined(N3)
-            expect(sendToNeighbor).toHaveBeenCalledTimes(1)
-            expect(sendToNeighbor).toHaveBeenNthCalledWith(1, N3, msg)
-        })
-
-        it('no-op if passed source node', async () => {
-            await setUpAndFeed([N1, N2, N3])
-            propagation.onNeighborJoined(N2)
-            expect(sendToNeighbor).toHaveBeenCalledTimes(0)
-        })
-
-        it('no-op if passed already handled neighbor', async () => {
-            await setUpAndFeed([N1, N2, N3])
-            propagation.onNeighborJoined(N3)
-            expect(sendToNeighbor).toHaveBeenCalledTimes(0)
-        })
-
-        it('no-op if initially `minPropagationTargets` were propagated to', async () => {
-            await setUpAndFeed([N1, N2, N3, N4])
-            propagation.onNeighborJoined(N5)
-            expect(sendToNeighbor).toHaveBeenCalledTimes(0)
-        })
-
-        it('no-op if later `minPropagationTargets` have been propagated to', async () => {
-            await setUpAndFeed([N1, N2, N3])
-            propagation.onNeighborJoined(N4)
-            await wait(0)
-            sendToNeighbor.mockClear()
-            propagation.onNeighborJoined(N5)
-            expect(sendToNeighbor).toHaveBeenCalledTimes(0)
-        })
-
-        it('no-op if TTL expires', async () => {
-            await setUpAndFeed([N1, N2, N3])
-            await wait(200)
-            propagation.onNeighborJoined(N3)
-            expect(sendToNeighbor).toHaveBeenCalledTimes(0)
-        })
-    })
-})

package/test/unit/ProxyConnectionRpcRemote.test.ts

@@ -1,39 +0,0 @@
-import { RpcCommunicator } from '@streamr/proto-rpc'
-import { randomUserId } from '@streamr/test-utils'
-import { hexToBinary } from '@streamr/utils'
-import { ProxyConnectionRpcRemote } from '../../src/logic/proxy/ProxyConnectionRpcRemote'
-import { ProxyConnectionRequest, ProxyDirection } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { ProxyConnectionRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('ProxyConnectionRpcRemote', () => {
-
-    it('happy path', async () => {
-        const onOutgoingMessage = jest.fn()
-        const rpcCommunicator = new RpcCommunicator()
-        rpcCommunicator.setOutgoingMessageListener(onOutgoingMessage)
-        const clientPeerDescriptor = createMockPeerDescriptor()
-        const serverPeerDescriptor = createMockPeerDescriptor()
-        const rpcRemote = new ProxyConnectionRpcRemote(
-            clientPeerDescriptor,
-            serverPeerDescriptor,
-            rpcCommunicator,
-            ProxyConnectionRpcClient
-        )
-
-        const userId = randomUserId()
-        await rpcRemote.requestConnection(ProxyDirection.PUBLISH, userId)
-
-        const [rpcMessage, _, callContext] = onOutgoingMessage.mock.calls[0]
-        const request = ProxyConnectionRequest.fromBinary(rpcMessage.body.value)
-        expect(request).toEqual({
-            direction: ProxyDirection.PUBLISH,
-            userId: expect.toEqualBinary(hexToBinary(userId))
-        })
-        expect(callContext).toMatchObject({
-            sourceDescriptor: clientPeerDescriptor,
-            targetDescriptor: serverPeerDescriptor,
-            timeout: 5000
-        })
-    })
-})

package/test/unit/StreamPartIDDataKey.test.ts

@@ -1,12 +0,0 @@
-import { StreamPartIDUtils } from '@streamr/utils'
-import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-
-describe('StreamPartIDtoDataKey', () => {
-
-    it('generated key length is correct (160 bits)', () => {
-        const streamPartId = StreamPartIDUtils.parse('stream#0')
-        const dataKey = streamPartIdToDataKey(streamPartId)
-        expect(dataKey.length).toEqual(40)
-    })
-
-})

package/test/unit/StreamPartNetworkSplitAvoidance.test.ts

@@ -1,31 +0,0 @@
-import { MIN_NEIGHBOR_COUNT, StreamPartNetworkSplitAvoidance } from '../../src/logic/StreamPartNetworkSplitAvoidance'
-import { MockDiscoveryLayerNode } from '../utils/mock/MockDiscoveryLayerNode'
-
-describe('StreamPartNetworkSplitAvoidance', () => {
-
-    let avoidance: StreamPartNetworkSplitAvoidance
-    let discoveryLayerNode: MockDiscoveryLayerNode
-    
-    beforeEach(() => {
-        discoveryLayerNode = new MockDiscoveryLayerNode()
-        avoidance = new StreamPartNetworkSplitAvoidance({
-            discoveryLayerNode,
-            discoverEntryPoints: async () => { 
-                discoveryLayerNode.addNewRandomPeerToKBucket() 
-                return discoveryLayerNode.getNeighbors()
-            },
-            exponentialRunOfBaseDelay: 1
-        })
-    })
-
-    afterEach(() => {
-        discoveryLayerNode.stop()
-        avoidance.destroy()
-    })
-
-    it('runs avoidance until number of neighbors is above MIN_NEIGHBOR_COUNT', async () => {
-        await avoidance.avoidNetworkSplit()
-        expect(discoveryLayerNode.getNeighborCount()).toBeGreaterThan(MIN_NEIGHBOR_COUNT)
-    })
-
-})

package/test/unit/StreamPartReconnect.test.ts

@@ -1,30 +0,0 @@
-import { PeerDescriptorStoreManager } from '../../src/logic/PeerDescriptorStoreManager'
-import { StreamPartReconnect } from '../../src/logic/StreamPartReconnect'
-import { MockDiscoveryLayerNode } from '../utils/mock/MockDiscoveryLayerNode'
-import { createFakePeerDescriptorStoreManager } from '../utils/fake/FakePeerDescriptorStoreManager'
-import { until } from '@streamr/utils'
-
-describe('StreamPartReconnect', () => {
-
-    let peerDescriptorSoreManager: PeerDescriptorStoreManager
-    let discoveryLayerNode: MockDiscoveryLayerNode
-    let streamPartReconnect: StreamPartReconnect
-
-    beforeEach(() => {
-        peerDescriptorSoreManager = createFakePeerDescriptorStoreManager()
-        discoveryLayerNode = new MockDiscoveryLayerNode()
-        streamPartReconnect = new StreamPartReconnect(discoveryLayerNode, peerDescriptorSoreManager)
-    })
-
-    afterEach(() => {
-        streamPartReconnect.destroy()
-    })
-
-    it('Happy path', async () => {
-        await streamPartReconnect.reconnect(1000)
-        expect(streamPartReconnect.isRunning()).toEqual(true)
-        discoveryLayerNode.addNewRandomPeerToKBucket()
-        await until(() => streamPartReconnect.isRunning() === false)
-    })
-
-})

package/test/unit/TemporaryConnectionRpcLocal.test.ts

@@ -1,38 +0,0 @@
-import { ListeningRpcCommunicator, toDhtAddress } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { TemporaryConnectionRpcLocal } from '../../src/logic/temporary-connection/TemporaryConnectionRpcLocal'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('TemporaryConnectionRpcLocal', () => {
-
-    const peerDescriptor = createMockPeerDescriptor()
-    let rpcCommunicator: ListeningRpcCommunicator
-    let rpcLocal: TemporaryConnectionRpcLocal
-
-    beforeEach(() => {
-        rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
-        rpcLocal = new TemporaryConnectionRpcLocal({
-            localPeerDescriptor: peerDescriptor,
-            rpcCommunicator,
-            streamPartId: StreamPartIDUtils.parse('mock#0'),
-            connectionLocker: {
-                weakLockConnection: jest.fn(),
-                weakUnlockConnection: jest.fn()
-            } as any
-        })
-    })
-
-    afterEach(() => {
-        rpcCommunicator.destroy()
-    })
-
-    it('Open and Close Connection', async () => {
-        const caller = createMockPeerDescriptor()
-        await rpcLocal.openConnection({}, { incomingSourceDescriptor: caller } as any)
-        expect(rpcLocal.getNodes().get(toDhtAddress(caller.nodeId))).toBeDefined()
-        await rpcLocal.closeConnection({}, { incomingSourceDescriptor: caller } as any)
-        expect(rpcLocal.getNodes().get(toDhtAddress(caller.nodeId))).toBeUndefined()
-    })
-
-})

package/test/utils/fake/FakePeerDescriptorStoreManager.ts

@@ -1,29 +0,0 @@
-import { PeerDescriptor } from '@streamr/dht'
-import { PeerDescriptorStoreManager } from '../../../src/logic/PeerDescriptorStoreManager'
-
-export const createFakePeerDescriptorStoreManager = (): PeerDescriptorStoreManager => {
-    return new FakePeerDescriptorStoreManager() as unknown as PeerDescriptorStoreManager
-}
-
-class FakePeerDescriptorStoreManager {
-
-    private nodes: PeerDescriptor[] = []
-
-    setNodes(nodes: PeerDescriptor[]): void {
-        this.nodes = nodes
-    } 
-
-    async fetchNodes(): Promise<PeerDescriptor[]> {
-        return this.nodes
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async storeAndKeepLocalNode(): Promise<void> {
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    isLocalNodeStored(): boolean {
-        return true
-    }
-    
-}

package/test/utils/mock/MockConnectionsView.ts

@@ -1,18 +0,0 @@
-import { PeerDescriptor } from '@streamr/dht'
-
-export class MockConnectionsView {
-    // eslint-disable-next-line class-methods-use-this
-    getConnections(): PeerDescriptor[] {
-        return []
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getConnectionCount(): number {
-        return 0
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    hasConnection(): boolean {
-        return false
-    }
-}

package/test/utils/mock/MockControlLayerNode.ts

@@ -1,78 +0,0 @@
-import { PeerDescriptor, DataEntry, ITransport, TransportEvents, ConnectionsView } from '@streamr/dht'
-import { ControlLayerNode } from '../../../src/logic/ControlLayerNode'
-import { EventEmitter } from 'eventemitter3'
-import { MockConnectionsView } from './MockConnectionsView'
-
-export class MockControlLayerNode extends EventEmitter<TransportEvents> implements ControlLayerNode {
-
-    private readonly peerDescriptor: PeerDescriptor
-
-    constructor(peerDescriptor: PeerDescriptor) {
-        super()
-        this.peerDescriptor = peerDescriptor
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    joinDht(): Promise<void> {
-        throw new Error('not implemented')
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    hasJoined(): boolean {
-        throw new Error('not implemented')
-    }
-
-    getLocalPeerDescriptor(): PeerDescriptor {
-        return this.peerDescriptor
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async fetchDataFromDht(): Promise<DataEntry[]> {
-        return []
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async deleteDataFromDht(): Promise<void> {
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async storeDataToDht(): Promise<PeerDescriptor[]> {
-        return []
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async send(): Promise<void> {
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getConnectionsView(): ConnectionsView {
-        return new MockConnectionsView()
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getNeighbors(): PeerDescriptor[] {
-        return []
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async waitForNetworkConnectivity(): Promise<void> {
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getTransport(): ITransport {
-        throw new Error('not implemented')
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async start(): Promise<void> {
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async stop(): Promise<void> {
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getDiagnosticInfo(): Record<string, unknown> {
-        return {}
-    }
-}

package/test/utils/mock/MockDiscoveryLayerNode.ts

@@ -1,60 +0,0 @@
-import { PeerDescriptor, RingContacts } from '@streamr/dht'
-import { EventEmitter } from 'eventemitter3'
-import { DiscoveryLayerNode, DiscoveryLayerNodeEvents } from '../../../src/logic/DiscoveryLayerNode'
-import { createMockPeerDescriptor } from '../utils'
-
-export class MockDiscoveryLayerNode extends EventEmitter<DiscoveryLayerNodeEvents> implements DiscoveryLayerNode {
-
-    private readonly kbucketPeers: PeerDescriptor[] = []
-    private closestContacts: PeerDescriptor[] = []
-    private randomContacts: PeerDescriptor[] = []
-
-    // eslint-disable-next-line class-methods-use-this
-    removeContact(): void {
-    }
-
-    getClosestContacts(): PeerDescriptor[] {
-        return this.closestContacts 
-    }
-
-    setClosestContacts(contacts: PeerDescriptor[]): void {
-        this.closestContacts = contacts
-    }
-
-    getRandomContacts(): PeerDescriptor[] {
-        return this.randomContacts 
-    }
-
-    setRandomContacts(contacts: PeerDescriptor[]): void {
-        this.randomContacts = contacts
-    }
-    
-    // eslint-disable-next-line class-methods-use-this
-    getRingContacts(): RingContacts {
-        return { left: [], right: [] }
-    }
-
-    getNeighbors(): PeerDescriptor[] {
-        return this.kbucketPeers
-    }
-
-    getNeighborCount(): number {
-        return this.kbucketPeers.length
-    }
-
-    addNewRandomPeerToKBucket(): void {
-        this.kbucketPeers.push(createMockPeerDescriptor())
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async joinDht(): Promise<void> {}
-
-    // eslint-disable-next-line class-methods-use-this
-    async joinRing(): Promise<void> {}
-
-    // eslint-disable-next-line class-methods-use-this
-    async start(): Promise<void> {}
-
-    // eslint-disable-next-line class-methods-use-this
-    async stop(): Promise<void> {}    
-}

package/test/utils/mock/MockHandshaker.ts

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

package/test/utils/mock/MockNeighborFinder.ts

@@ -1,20 +0,0 @@
-import { Methods } from '@streamr/test-utils'
-import { NeighborFinder } from '../../../src/logic/neighbor-discovery/NeighborFinder'
-
-export class MockNeighborFinder implements Methods<NeighborFinder> {
-
-    // eslint-disable-next-line class-methods-use-this
-    start(): 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

@@ -1,21 +0,0 @@
-import { Methods } from '@streamr/test-utils'
-import { NeighborUpdateManager } from '../../../src/logic/neighbor-discovery/NeighborUpdateManager'
-import { NeighborUpdate } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
-
-export class MockNeighborUpdateManager implements Methods<NeighborUpdateManager> {
-
-    // 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(): Promise<NeighborUpdate> {
-        return NeighborUpdate.create()
-    }
-}