@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/test/unit/StoreManager.test.ts

@@ -0,0 +1,138 @@
+import { wait, waitForCondition } from '@streamr/utils'
+import { range, sortBy } from 'lodash'
+import { getDistance } from '../../src/dht/PeerManager'
+import { StoreManager } from '../../src/dht/store/StoreManager'
+import {
+    DhtAddress,
+    createRandomDhtAddress,
+    getDhtAddressFromRaw,
+    getRawFromDhtAddress,
+} from '../../src/identifiers'
+import { NodeType, ReplicateDataRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+
+const DATA_ENTRY = {
+    key: getRawFromDhtAddress(createRandomDhtAddress()),
+    creator: getRawFromDhtAddress(createRandomDhtAddress())
+}
+const NODES_CLOSEST_TO_DATA = sortBy(
+    range(5).map(() => createRandomDhtAddress()),
+    (id: DhtAddress) => getDistance(getRawFromDhtAddress(id), DATA_ENTRY.key)
+)
+
+describe('StoreManager', () => {
+
+    describe('new contact', () => {
+
+        const createStoreManager = (
+            localNodeId: DhtAddress,
+            closestNeighbors: DhtAddress[],
+            replicateData: (request: ReplicateDataRequest) => unknown,
+            setAllEntriesAsStale: (key: DhtAddress) => unknown
+        ): StoreManager => {
+            const getClosestNeighborsTo = () => {
+                return closestNeighbors.map((nodeId) => ({ nodeId: getRawFromDhtAddress(nodeId), type: NodeType.NODEJS }))
+            }
+            return new StoreManager({
+                rpcCommunicator: {
+                    registerRpcMethod: () => {},
+                    registerRpcNotification: () => {}
+                } as any,
+                recursiveOperationManager: undefined as any,
+                localPeerDescriptor: { nodeId: getRawFromDhtAddress(localNodeId), type: NodeType.NODEJS },
+                localDataStore: { 
+                    keys: () => [getDhtAddressFromRaw(DATA_ENTRY.key)],
+                    values: () => [DATA_ENTRY],
+                    setAllEntriesAsStale 
+                } as any,
+                serviceId: undefined as any,
+                highestTtl: undefined as any,
+                redundancyFactor: 3,
+                getClosestNeighborsTo,
+                createRpcRemote: () => ({ replicateData } as any)
+            })
+        }
+
+        describe('this node is primary storer', () => {
+
+            it('new node is within redundancy factor', async () => {
+                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+                const manager = createStoreManager(
+                    NODES_CLOSEST_TO_DATA[0],
+                    [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[3], NODES_CLOSEST_TO_DATA[4]],
+                    replicateData,
+                    setAllEntriesAsStale
+                )
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[2]), type: NodeType.NODEJS })
+                await waitForCondition(() => replicateData.mock.calls.length === 1)
+                expect(replicateData).toHaveBeenCalledWith({
+                    entry: DATA_ENTRY
+                })
+                expect(setAllEntriesAsStale).not.toHaveBeenCalled()
+            })
+    
+            it('new node is not within redundancy factor', async () => {
+                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+                const manager = createStoreManager(
+                    NODES_CLOSEST_TO_DATA[0],
+                    [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
+                    replicateData,
+                    setAllEntriesAsStale
+                )
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                await wait(50)
+                expect(replicateData).not.toHaveBeenCalled()
+                expect(setAllEntriesAsStale).not.toHaveBeenCalled()
+            })
+        })
+
+        describe('this node is not primary storer', () => {
+
+            it('this node is within redundancy factor', async () => {
+                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+                const manager = createStoreManager(
+                    NODES_CLOSEST_TO_DATA[1],
+                    [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
+                    replicateData,
+                    setAllEntriesAsStale
+                )
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                await wait(50)
+                expect(replicateData).not.toHaveBeenCalled()
+            })
+
+            it('this node is not within redundancy factor', async () => {
+                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+                const manager = createStoreManager(
+                    NODES_CLOSEST_TO_DATA[3],
+                    [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2]],
+                    replicateData,
+                    setAllEntriesAsStale
+                )
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                await wait(50)
+                expect(replicateData).not.toHaveBeenCalled()
+                expect(setAllEntriesAsStale).toHaveBeenCalledTimes(1)
+                expect(setAllEntriesAsStale).toHaveBeenCalledWith(getDhtAddressFromRaw(DATA_ENTRY.key))
+            })
+
+            it('this node has less than redundancyFactor neighbors', async () => {
+                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
+                const manager = createStoreManager(
+                    NODES_CLOSEST_TO_DATA[3],
+                    [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1]],
+                    replicateData,
+                    setAllEntriesAsStale
+                )
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                await wait(50)
+                expect(replicateData).not.toHaveBeenCalled()
+                expect(setAllEntriesAsStale).toHaveBeenCalledTimes(0)
+            })
+        })
+    })
+})

package/test/unit/WebsocketConnector.test.ts

@@ -1,16 +1,8 @@
 /* eslint-disable max-len */
 import { WebsocketConnector } from '../../src/connection/websocket/WebsocketConnector'
-import { ConnectivityMethod, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import crypto from 'crypto'
+import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { MockTransport } from '../utils/mock/Transport'
-
-const createMockPeerDescriptor = (nodeType: NodeType, websocket?: ConnectivityMethod): PeerDescriptor => {
-    return {
-        kademliaId: crypto.randomBytes(10),
-        type: nodeType,
-        websocket
-    }
-}
+import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('WebsocketConnector', () => {
 
@@ -22,43 +14,43 @@ describe('WebsocketConnector', () => {
         } as any)
 
         it('node without server', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor(NodeType.NODEJS))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: false }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: true }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.BROWSER))).toBe(false)
+            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS }))
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(false)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
         })
 
         it('node with TLS server', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor(NodeType.NODEJS, { host: '1.1.1.1', port: 11, tls: true }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: false }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: true }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.BROWSER))).toBe(true)
+            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: true } }))
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(true)
         })
 
         it('node with non-TLS server', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor(NodeType.NODEJS, { host: '1.1.1.1', port: 11, tls: false }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: false }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: true }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.BROWSER))).toBe(false)
+            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '1.1.1.1', port: 11, tls: false } }))
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
         })
 
         it('node with non-TLS server in local network', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor(NodeType.NODEJS, { host: '192.168.11.11', port: 11, tls: false }))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: false }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: true }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.BROWSER))).toBe(true)
+            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '192.168.11.11', port: 11, tls: false } }))
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(true)
         })
 
         it('browser', () => {
-            connector.setLocalPeerDescriptor(createMockPeerDescriptor(NodeType.BROWSER))
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: false }))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS, { host: '2.2.2.2', port: 22, tls: true }))).toBe(true)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.NODEJS))).toBe(false)
-            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor(NodeType.BROWSER))).toBe(false)
+            connector.setLocalPeerDescriptor(createMockPeerDescriptor({ type: NodeType.BROWSER }))
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: false } }))).toBe(false)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS, websocket: { host: '2.2.2.2', port: 22, tls: true } }))).toBe(true)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.NODEJS }))).toBe(false)
+            expect(connector.isPossibleToFormConnection(createMockPeerDescriptor({ type: NodeType.BROWSER }))).toBe(false)
         })
     })
 })

package/test/unit/connectivityRequestHandler.test.ts

@@ -0,0 +1,104 @@
+import { ipv4ToNumber, waitForCondition } from '@streamr/utils'
+import { EventEmitter } from 'eventemitter3'
+import { once } from 'events'
+import { Server as HttpServer, createServer as createHttpServer } from 'http'
+import { server as WsServer } from 'websocket'
+import { CONNECTIVITY_CHECKER_SERVICE_ID } from '../../src/connection/connectivityChecker'
+import { attachConnectivityRequestHandler } from '../../src/connection/connectivityRequestHandler'
+import { Message } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { LOCAL_PROTOCOL_VERSION } from '../../src/helpers/version'
+
+const HOST = '127.0.0.1'
+const PORT = 15001
+
+describe('connectivityRequestHandler', () => {
+
+    let httpServer: HttpServer
+    let wsServer: WsServer
+    let connection: any
+
+    beforeEach(async () => {
+        httpServer = createHttpServer()
+        wsServer = new WsServer({
+            httpServer,
+            autoAcceptConnections: true
+        })
+        httpServer.listen(PORT)
+        await once(httpServer, 'listening')
+        connection = new EventEmitter()
+        connection.send = jest.fn()
+        connection.remoteIpAddress = HOST
+    })
+
+    afterEach(async () => {
+        wsServer.shutDown()
+        httpServer.close()
+        await once(httpServer, 'close')
+    })
+
+    it('happy path', async () => {
+        attachConnectivityRequestHandler(connection)
+        const request: Message = {
+            serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
+            messageId: 'mock-message-id',
+            body: {
+                oneofKind: 'connectivityRequest',
+                connectivityRequest: { port: PORT, host: HOST, tls: false, selfSigned: false }
+            }
+        }
+        connection.emit('data', Message.toBinary(request))
+
+        await waitForCondition(() => connection.send.mock.calls.length > 0)
+
+        const receivedMessage = Message.fromBinary(connection.send.mock.calls[0][0])
+        expect(receivedMessage).toEqual({
+            body: {
+                connectivityResponse: {
+                    host: HOST,
+                    natType: 'open_internet',
+                    websocket: {
+                        host: HOST,
+                        port: PORT,
+                        tls: false
+                    },
+                    ipAddress: ipv4ToNumber(HOST),
+                    version: LOCAL_PROTOCOL_VERSION
+                },
+                oneofKind: 'connectivityResponse'
+            },
+            messageId: expect.any(String),
+            serviceId: 'system/connectivity-checker'
+        })
+    })
+
+    it('disabled connectivity probing', async () => {
+        attachConnectivityRequestHandler(connection)
+        const request: Message = {
+            serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
+            messageId: 'mock-message-id',
+            body: {
+                oneofKind: 'connectivityRequest',
+                connectivityRequest: { port: 0, host: HOST, tls: false, selfSigned: false }
+            }
+        }
+        connection.emit('data', Message.toBinary(request))
+
+        await waitForCondition(() => connection.send.mock.calls.length > 0)
+
+        const receivedMessage = Message.fromBinary(connection.send.mock.calls[0][0])
+        expect(receivedMessage).toEqual({
+            body: {
+                connectivityResponse: {
+                    host: HOST,
+                    natType: 'unknown',
+                    ipAddress: ipv4ToNumber(HOST),
+                    version: LOCAL_PROTOCOL_VERSION
+                },
+                oneofKind: 'connectivityResponse'
+            },
+            messageId: expect.any(String),
+            serviceId: 'system/connectivity-checker'
+        })
+    })
+
+})

package/test/unit/createPeerDescriptor.test.ts

@@ -0,0 +1,69 @@
+import { ipv4ToNumber } from '@streamr/utils'
+import { createPeerDescriptor } from '../../src/helpers/createPeerDescriptor'
+import { isBrowserEnvironment } from '../../src/helpers/browser/isBrowserEnvironment'
+import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+import { getRandomRegion } from '../../dist/src/connection/simulator/pings'
+
+const IP_ADDRESS = '1.2.3.4'
+
+describe('createPeerDescriptor', () => {
+
+    const region = getRandomRegion()
+
+    it('without websocket', () => {
+        const connectivityResponse = {
+            ipAddress: ipv4ToNumber(IP_ADDRESS)
+        } as any
+        const peerDescriptor = createPeerDescriptor(connectivityResponse, region)
+        expect(peerDescriptor).toEqual({
+            nodeId: expect.any(Uint8Array),
+            type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
+            ipAddress: ipv4ToNumber(IP_ADDRESS),
+            publicKey: expect.any(Uint8Array),
+            signature: expect.any(Uint8Array),
+            region
+        })
+    })
+
+    it('with websocket', () => {
+        const connectivityResponse = {
+            ipAddress: ipv4ToNumber(IP_ADDRESS),
+            websocket: {
+                host: 'bar.com',
+                port: 123,
+                tls: true
+            }
+        } as any
+        const peerDescriptor = createPeerDescriptor(connectivityResponse, region)
+        expect(peerDescriptor).toEqual({
+            nodeId: expect.any(Uint8Array),
+            type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
+            ipAddress: ipv4ToNumber(IP_ADDRESS),
+            publicKey: expect.any(Uint8Array),
+            signature: expect.any(Uint8Array),
+            websocket: {
+                host: 'bar.com',
+                port: 123,
+                tls: true
+            },
+            region
+        })
+    })
+
+    it('explicit nodeId', () => {
+        const nodeId = createRandomDhtAddress()
+        const connectivityResponse = {
+            ipAddress: ipv4ToNumber(IP_ADDRESS)
+        } as any
+        const peerDescriptor = createPeerDescriptor(connectivityResponse, region, nodeId)
+        expect(peerDescriptor).toEqual({
+            nodeId: getRawFromDhtAddress(nodeId),
+            type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
+            ipAddress: ipv4ToNumber(IP_ADDRESS),
+            publicKey: expect.any(Uint8Array),
+            signature: expect.any(Uint8Array),
+            region
+        })
+    })
+})

package/test/unit/customMatchers.test.ts

@@ -0,0 +1,16 @@
+import { cloneDeep } from 'lodash'
+import { createMockPeerDescriptor } from '../utils/utils'
+
+describe('custom matchers', () => {
+
+    it('happy path', () => {
+        const peerDescriptor = createMockPeerDescriptor({
+            websocket: { port: 1, host: 'x', tls: true }
+        })
+        expect(peerDescriptor).toEqualPeerDescriptor(cloneDeep(peerDescriptor))
+    })
+
+    it('no match', () => {
+        expect(createMockPeerDescriptor()).not.toEqualPeerDescriptor(createMockPeerDescriptor())
+    })
+})

package/test/unit/version.test.ts

@@ -0,0 +1,18 @@
+import { isMaybeSupportedVersion } from '../../src/helpers/version'
+
+describe('version', () => {
+
+    it('supported', () => {
+        expect(isMaybeSupportedVersion('1.0')).toBe(true)
+        expect(isMaybeSupportedVersion('1.1')).toBe(true)
+        expect(isMaybeSupportedVersion('2.0')).toBe(true)
+        expect(isMaybeSupportedVersion('3.5')).toBe(true)
+    })
+
+    it('not supported', () => {
+        expect(isMaybeSupportedVersion('')).toBe(false)
+        expect(isMaybeSupportedVersion('100.0.0-testnet-three.3')).toBe(false)
+        expect(isMaybeSupportedVersion('0.0')).toBe(false)
+        expect(isMaybeSupportedVersion('0.1')).toBe(false)
+    })
+})

package/test/utils/FakeTransport.ts

@@ -0,0 +1,47 @@
+import { EventEmitter } from 'eventemitter3'
+import { ITransport, TransportEvents } from '../../src/transport/ITransport'
+import { Message, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+
+class FakeTransport extends EventEmitter<TransportEvents> implements ITransport {
+
+    private onSend: (msg: Message) => void
+    private readonly localPeerDescriptor: PeerDescriptor
+
+    constructor(peerDescriptor: PeerDescriptor, onSend: (msg: Message) => void) {
+        super()
+        this.onSend = onSend
+        this.localPeerDescriptor = peerDescriptor
+    }
+
+    async send(msg: Message): Promise<void> {
+        msg.sourceDescriptor = this.localPeerDescriptor
+        this.onSend(msg)
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getLocalPeerDescriptor(): PeerDescriptor {
+        throw new Error('not implemented')
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getConnections(): PeerDescriptor[] {
+        throw new Error('not implemented')
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    stop(): void | Promise<void> {
+    }
+}
+
+export class FakeEnvironment {
+
+    private transports: FakeTransport[] = []
+
+    createTransport(peerDescriptor: PeerDescriptor): ITransport {
+        const transport = new FakeTransport(peerDescriptor, (msg) => {
+            this.transports.forEach((t) => t.emit('message', msg))
+        })
+        this.transports.push(transport)
+        return transport
+    }
+}

package/test/utils/customMatchers.ts

@@ -0,0 +1,71 @@
+import { areEqualBinaries } from '@streamr/utils'
+import { printExpected, printReceived } from 'jest-matcher-utils'
+import { isEqual } from 'lodash'
+import { ConnectivityMethod, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
+
+// we could ES2015 module syntax (https://jestjs.io/docs/expect#expectextendmatchers),
+// but the IDE doesn't find custom matchers if we do that
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    namespace jest {
+        interface Matchers<R> {
+            toEqualPeerDescriptor(expected: PeerDescriptor): R
+        }
+    }
+}
+
+const formErrorMessage = (description: string, expected: string | number | undefined, actual: string | number | undefined): string => {
+    return `${description}\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(actual)}`
+}
+
+const toEqualPeerDescriptor = (
+    actual: PeerDescriptor,
+    expected: PeerDescriptor
+): jest.CustomMatcherResult => {
+    const messages: string[] = []
+    if (!areEqualBinaries(expected.nodeId, actual.nodeId)) {
+        messages.push(formErrorMessage('nodeId', getDhtAddressFromRaw(expected.nodeId), getDhtAddressFromRaw(actual.nodeId)))
+    }
+    if (!isEqual(expected.type, actual.type)) {
+        const typeNames = { [NodeType.NODEJS]: 'NODEJS', [NodeType.BROWSER]: 'BROWSER' }
+        messages.push(formErrorMessage('type', typeNames[expected.type], typeNames[actual.type]))
+    }
+    expectEqualConnectivityMethod('udp', expected.udp, actual.udp, messages)
+    expectEqualConnectivityMethod('tpc', expected.tcp, actual.tcp, messages)
+    expectEqualConnectivityMethod('websocket', expected.websocket, actual.websocket, messages)
+    if (expected.region !== actual.region) {
+        messages.push(formErrorMessage('region', expected?.region, actual?.region))
+    } 
+    if (messages.length > 0) {
+        return {
+            pass: false,
+            message: () => messages.join('\n\n')
+        }
+    } else {
+        return {
+            pass: true,
+            message: () => `Expected not to throw ${printReceived('StreamrClientError')}`
+        }
+    }
+}
+
+const expectEqualConnectivityMethod = (
+    description: string,
+    method1: ConnectivityMethod | undefined,
+    method2: ConnectivityMethod | undefined,
+    messages: string[]
+) => {
+    const toOutput = (method?: ConnectivityMethod) => {
+        return (method !== undefined)
+            ? `{port: ${method.port}, host: '${method.host}', tls: ${method.tls}}`
+            : undefined
+    }
+    if (!isEqual(method1, method2)) {
+        messages.push(formErrorMessage(description, toOutput(method1), toOutput(method2)))
+    }
+}
+
+expect.extend({
+    toEqualPeerDescriptor
+})

package/test/utils/mock/MockRpcCommunicator.ts

@@ -0,0 +1,7 @@
+import { RoutingRpcCommunicator } from '../../../src/transport/RoutingRpcCommunicator'
+
+export class MockRpcCommunicator extends RoutingRpcCommunicator {
+    constructor() {
+        super('mock-service', async () => {})
+    }
+}

package/test/utils/mock/Router.ts

@@ -1,7 +1,8 @@
-import { IRouter } from '../../../src/dht/routing/Router'
+import { Methods } from '@streamr/test-utils'
+import { Router } from '../../../src/dht/routing/Router'
 import { RouteMessageAck } from '../../../src/proto/packages/dht/protos/DhtRpc'
 
-export class MockRouter implements IRouter {
+export class MockRouter implements Methods<Router> {
 
     // eslint-disable-next-line class-methods-use-this
     addRoutingSession(): void {
@@ -30,7 +31,7 @@ export class MockRouter implements IRouter {
 
     // eslint-disable-next-line class-methods-use-this
     send(): Promise<void> {
-        throw Error('Not implemented')
+        throw new Error('Not implemented')
     }
 
     // eslint-disable-next-line class-methods-use-this
@@ -48,4 +49,13 @@ export class MockRouter implements IRouter {
         return RouteMessageAck.create()
     }
 
+    // eslint-disable-next-line class-methods-use-this
+    onNodeConnected(): void {}
+
+    // eslint-disable-next-line class-methods-use-this
+    onNodeDisconnected(): void {}
+
+    // eslint-disable-next-line class-methods-use-this
+    resetCache(): void {}
+
 }

package/test/utils/mock/Transport.ts

@@ -15,7 +15,7 @@ export class MockTransport extends EventEmitter<TransportEvents> implements ITra
     }
 
     // eslint-disable-next-line class-methods-use-this
-    getAllConnectionPeerDescriptors(): PeerDescriptor[] {
+    getConnections(): PeerDescriptor[] {
         return []
     }
 

package/test/utils/mock/mockDataEntry.ts

@@ -0,0 +1,38 @@
+import { MessageType as MessageType$, ScalarType } from '@protobuf-ts/runtime'
+import { randomString } from '@streamr/utils'
+import { Timestamp } from '../../../src/proto/google/protobuf/timestamp'
+import { Any } from '../../../src/proto/google/protobuf/any'
+import { DataEntry } from '../../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtAddress, createRandomDhtAddress, getRawFromDhtAddress } from '../../../src/identifiers'
+import { omit } from 'lodash'
+
+const MockData = new class extends MessageType$<{ foo: string }> {
+    constructor() {
+        super('MockData', [
+            { no: 1, name: 'foo', kind: 'scalar', opt: false, T: ScalarType.STRING }
+        ])
+    }
+}
+
+export const createMockDataEntry = (
+    entry: Partial<Omit<DataEntry, 'key' | 'creator'> & { key: DhtAddress, creator: DhtAddress }> = {}
+): DataEntry => {
+    return { 
+        key: getRawFromDhtAddress(entry.key ?? createRandomDhtAddress()),
+        data: Any.pack({ foo: randomString(5) }, MockData),
+        creator: getRawFromDhtAddress(entry.creator ?? createRandomDhtAddress()),
+        ttl: 10000,
+        stale: false,
+        deleted: false,
+        createdAt: Timestamp.now(),
+        ...omit(entry, 'key', 'creator')
+    }
+}
+
+export const unpackData = (entry: DataEntry): { foo: string } => {
+    return Any.unpack(entry.data!, MockData)
+}
+
+export const expectEqualData = (entry1: DataEntry, entry2: DataEntry): void => {
+    expect(unpackData(entry1).foo).toBe(unpackData(entry2).foo)
+}