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

package/test/unit/NodeList.test.ts

@@ -1,164 +0,0 @@
-import {
-    ListeningRpcCommunicator,
-    NodeType,
-    PeerDescriptor,
-    randomDhtAddress,
-    toDhtAddress,
-    toNodeId,
-} from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { expect } from 'expect'
-import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
-import { NodeList } from '../../src/logic/NodeList'
-import { formStreamPartContentDeliveryServiceId } from '../../src/logic/formStreamPartDeliveryServiceId'
-import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockContentDeliveryRpcRemote, createMockPeerDescriptor } from '../utils/utils'
-
-const streamPartId = StreamPartIDUtils.parse('stream#0')
-
-describe('NodeList', () => {
-
-    const ids = [
-        new Uint8Array([1, 1, 1]),
-        new Uint8Array([1, 1, 2]),
-        new Uint8Array([1, 1, 3]),
-        new Uint8Array([1, 1, 4]),
-        new Uint8Array([1, 1, 5])
-    ]
-    const ownId = randomDhtAddress()
-    let nodeList: NodeList
-
-    const createRemoteGraphNode = (peerDescriptor: PeerDescriptor) => {
-        const mockCommunicator = new ListeningRpcCommunicator(formStreamPartContentDeliveryServiceId(streamPartId), new MockTransport())
-        return new ContentDeliveryRpcRemote(
-            createMockPeerDescriptor(),
-            peerDescriptor,
-            mockCommunicator,
-            ContentDeliveryRpcClient
-        )
-    }
-
-    beforeEach(() => {
-        nodeList = new NodeList(ownId, 6)
-        for (const id of ids) {
-            const peerDescriptor: PeerDescriptor = {
-                nodeId: id,
-                type: NodeType.NODEJS
-            }
-            nodeList.add(createRemoteGraphNode(peerDescriptor))
-        }
-    })
-
-    it('add', () => {
-        const newDescriptor = {
-            nodeId: new Uint8Array([1, 2, 3]),
-            type: NodeType.NODEJS
-        }
-        const newNode = createRemoteGraphNode(newDescriptor)
-        nodeList.add(newNode)
-        expect(nodeList.has(toNodeId(newDescriptor))).toEqual(true)
-
-        const newDescriptor2 = {
-            nodeId: new Uint8Array([1, 2, 4]),
-            type: NodeType.NODEJS
-        }
-        const newNode2 = createRemoteGraphNode(newDescriptor2)
-        nodeList.add(newNode2)
-        expect(nodeList.has(toNodeId(newDescriptor2))).toEqual(false)
-    })
-
-    it('remove', () => {
-        const toRemove = nodeList.getFirst([])
-        const nodeId = toNodeId(toRemove!.getPeerDescriptor())
-        nodeList.remove(nodeId)
-        expect(nodeList.has(nodeId)).toEqual(false)
-    })
-
-    it('getFirst', () => {
-        const closest = nodeList.getFirst([])
-        expect(toNodeId(closest!.getPeerDescriptor()))
-            .toEqual(toDhtAddress(new Uint8Array([1, 1, 1])))
-    })
-
-    it('getFirst with exclude', () => {
-        const closest = nodeList.getFirst([toDhtAddress(new Uint8Array([1, 1, 1]))])
-        expect(toNodeId(closest!.getPeerDescriptor()))
-            .toEqual(toDhtAddress(new Uint8Array([1, 1, 2])))
-    })
-
-    it('getFirst wsOnly', () => {
-        nodeList.add(createMockContentDeliveryRpcRemote(createMockPeerDescriptor({ websocket: { port: 111, host: '', tls: false } })))
-        const closest = nodeList.getFirst([], true)
-        expect(closest).toBeDefined()
-    })
-
-    it('getLast', () => {
-        const closest = nodeList.getLast([])
-        expect(toNodeId(closest!.getPeerDescriptor()))
-            .toEqual(toDhtAddress(new Uint8Array([1, 1, 5])))
-    })
-
-    it('getLast with exclude', () => {
-        const closest = nodeList.getLast([toDhtAddress(new Uint8Array([1, 1, 5]))])
-        expect(toNodeId(closest!.getPeerDescriptor()))
-            .toEqual(toDhtAddress(new Uint8Array([1, 1, 4])))
-    })
-
-    it('getFirstAndLast', () => {
-        const results = nodeList.getFirstAndLast([])
-        expect(results).toEqual([nodeList.getFirst([]), nodeList.getLast([])])
-    })
-
-    it('getFirst empty', () => {
-        const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getFirst([])).toBeUndefined()
-    })
-
-    it('getLast empty', () => {
-        const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getLast([])).toBeUndefined()
-    })
-
-    it('getRandom empty', () => {
-        const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getRandom([])).toBeUndefined()
-    })
-
-    it('getFirstAndLast empty', () => {
-        const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getFirstAndLast([])).toEqual([])
-    })
-
-    it('getFirstAndLast with exclude', () => {
-        const results = nodeList.getFirstAndLast([
-            toDhtAddress(new Uint8Array([1, 1, 1])),
-            toDhtAddress(new Uint8Array([1, 1, 5]))
-        ])
-        expect(results).toEqual([
-            nodeList.getFirst([toDhtAddress(new Uint8Array([1, 1, 1]))]),
-            nodeList.getLast([toDhtAddress(new Uint8Array([1, 1, 5]))])
-        ])
-    })
-
-    it('items are in insertion order', () => {
-        const list = new NodeList(randomDhtAddress(), 100)
-        const item1 = createRemoteGraphNode(createMockPeerDescriptor())
-        const item2 = createRemoteGraphNode(createMockPeerDescriptor())
-        const item3 = createRemoteGraphNode(createMockPeerDescriptor())
-        const item4 = createRemoteGraphNode(createMockPeerDescriptor())
-        const item5 = createRemoteGraphNode(createMockPeerDescriptor())
-        const item6 = createRemoteGraphNode(createMockPeerDescriptor())
-        list.add(item2)
-        list.add(item3)
-        list.add(item1)
-        list.add(item6)
-        list.add(item4)
-        list.add(item5)
-        expect(list.getFirst([])!).toEqual(item2)
-        expect(list.getLast([])!).toEqual(item5)
-        // the order doesn't change if item re-added
-        list.add(item4)
-        expect(list.getLast([])!).toEqual(item5)
-    })
-})

package/test/unit/NumberPair.test.ts

@@ -1,22 +0,0 @@
-import { NumberPair } from '../../src/logic/DuplicateMessageDetector'
-
-test('equalTo', () => {
-    expect(new NumberPair(5, 2).equalTo(new NumberPair(5, 3))).toEqual(false)
-    expect(new NumberPair(5, 2).equalTo(new NumberPair(5, 2))).toEqual(true)
-})
-
-test('greaterThan', () => {
-    expect(new NumberPair(5, 2).greaterThan(new NumberPair(6, 2))).toEqual(false)
-    expect(new NumberPair(5, 2).greaterThan(new NumberPair(5, 3))).toEqual(false)
-    expect(new NumberPair(5, 2).greaterThan(new NumberPair(5, 2))).toEqual(false)
-    expect(new NumberPair(5, 2).greaterThan(new NumberPair(5, 1))).toEqual(true)
-    expect(new NumberPair(5, 2).greaterThan(new NumberPair(3, 2))).toEqual(true)
-})
-
-test('greaterThanOrEqual', () => {
-    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(6, 2))).toEqual(false)
-    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(5, 3))).toEqual(false)
-    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(5, 2))).toEqual(true)
-    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(5, 1))).toEqual(true)
-    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(3, 2))).toEqual(true)
-})

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 '../../src/proto/google/protobuf/any'
-import { DataEntry } from '../../src/proto/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, wait } from '@streamr/utils'
-import { Propagation } from '../../src/logic/propagation/Propagation'
-import {
-    ContentType,
-    EncryptionType,
-    MessageID,
-    SignatureType,
-    StreamMessage
-} from '../../src/proto/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: hexToBinary(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<ReadonlyArray<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 '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { ProxyConnectionRpcClient } from '../../src/proto/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 { waitForCondition } 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 waitForCondition(() => 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
-    }
-}