@streamr/dht 100.0.0-testnet-one.3 → 100.0.0-testnet-two.0

package/test/unit/StoreManager.test.ts

@@ -0,0 +1,132 @@
+import { wait, waitForCondition } from '@streamr/utils'
+import crypto from 'crypto'
+import { range, sortBy } from 'lodash'
+import { Key } from 'readline'
+import { getDistance } from '../../src/dht/PeerManager'
+import { StoreManager } from '../../src/dht/store/StoreManager'
+import { NodeID, createRandomNodeId, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { NodeType, ReplicateDataRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+
+const DATA_ENTRY = {
+    key: createRandomNodeId(),
+    creator: crypto.randomBytes(20)
+}
+const NODES_CLOSEST_TO_DATA = sortBy(
+    range(5).map(() => createRandomNodeId()),
+    (id: Uint8Array) => getDistance(getNodeIdFromBinary(id), getNodeIdFromBinary(DATA_ENTRY.key))
+)
+
+describe('StoreManager', () => {
+
+    describe('new contact', () => {
+
+        const createStoreManager = (
+            localNodeId: Uint8Array,
+            closestNeighbors: Uint8Array[],
+            replicateData: (request: ReplicateDataRequest) => unknown,
+            setStale: (key: Key, creator: NodeID, stale: boolean) => unknown
+        ): StoreManager => {
+            const getClosestNeighborsTo = () => {
+                return closestNeighbors.map((nodeId) => ({ nodeId, type: NodeType.NODEJS }))
+            }
+            return new StoreManager({
+                rpcCommunicator: {
+                    registerRpcMethod: () => {},
+                    registerRpcNotification: () => {}
+                } as any,
+                recursiveOperationManager: undefined as any,
+                localPeerDescriptor: { nodeId: localNodeId, type: NodeType.NODEJS },
+                localDataStore: { values: () => [DATA_ENTRY], setStale } 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 setStale = jest.fn<undefined, [Key, NodeID]>()
+                const manager = createStoreManager(
+                    NODES_CLOSEST_TO_DATA[0],
+                    [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[3], NODES_CLOSEST_TO_DATA[4]],
+                    replicateData,
+                    setStale
+                )
+                manager.onNewContact({ nodeId: NODES_CLOSEST_TO_DATA[2], type: NodeType.NODEJS })
+                await waitForCondition(() => replicateData.mock.calls.length === 1)
+                expect(replicateData).toHaveBeenCalledWith({
+                    entry: DATA_ENTRY
+                })
+                expect(setStale).not.toHaveBeenCalled()
+            })
+    
+            it('new node is not within redundancy factor', async () => {
+                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
+                const setStale = jest.fn<undefined, [Key, NodeID]>()
+                const manager = createStoreManager(
+                    NODES_CLOSEST_TO_DATA[0],
+                    [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
+                    replicateData,
+                    setStale
+                )
+                manager.onNewContact({ nodeId: NODES_CLOSEST_TO_DATA[4], type: NodeType.NODEJS })
+                await wait(50)
+                expect(replicateData).not.toHaveBeenCalled()
+                expect(setStale).not.toHaveBeenCalled()
+            })
+        })
+
+        describe('this node is not primary storer', () => {
+
+            it('this node is within redundancy factor', async () => {
+                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
+                const setStale = jest.fn<undefined, [Key, NodeID]>()
+                const manager = createStoreManager(
+                    NODES_CLOSEST_TO_DATA[1],
+                    [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
+                    replicateData,
+                    setStale
+                )
+                manager.onNewContact({ nodeId: NODES_CLOSEST_TO_DATA[4], type: NodeType.NODEJS })
+                await wait(50)
+                expect(replicateData).not.toHaveBeenCalled()
+                expect(setStale).not.toHaveBeenCalled()
+            })
+
+            it('this node is not within redundancy factor', async () => {
+                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
+                const setStale = jest.fn<undefined, [Key, NodeID]>()
+                const manager = createStoreManager(
+                    NODES_CLOSEST_TO_DATA[3],
+                    [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2]],
+                    replicateData,
+                    setStale
+                )
+                manager.onNewContact({ nodeId: NODES_CLOSEST_TO_DATA[4], type: NodeType.NODEJS })
+                await wait(50)
+                expect(replicateData).not.toHaveBeenCalled()
+                expect(setStale).toHaveBeenCalledTimes(1)
+                expect(setStale).toHaveBeenCalledWith(DATA_ENTRY.key, getNodeIdFromBinary(DATA_ENTRY.creator), true)
+            })
+
+            it('this node has less than redundancyFactor neighbors', async () => {
+                const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
+                const setStale = jest.fn<undefined, [Key, NodeID]>()
+                const manager = createStoreManager(
+                    NODES_CLOSEST_TO_DATA[3],
+                    [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1]],
+                    replicateData,
+                    setStale
+                )
+                manager.onNewContact({ nodeId: NODES_CLOSEST_TO_DATA[4], type: NodeType.NODEJS })
+                await wait(50)
+                expect(replicateData).not.toHaveBeenCalled()
+                expect(setStale).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 {
-        nodeId: 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/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/utils/FakeTransport.ts

@@ -0,0 +1,44 @@
+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
+
+    constructor(onSend: (msg: Message) => void) {
+        super()
+        this.onSend = onSend
+    }
+
+    async send(msg: Message): Promise<void> {
+        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
+    getAllConnectionPeerDescriptors(): 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(): ITransport {
+        const transport = new FakeTransport((msg) => {
+            this.transports.forEach((t) => t.emit('message', msg))
+        })
+        this.transports.push(transport)
+        return transport
+    }
+}

package/test/utils/customMatchers.ts

@@ -0,0 +1,70 @@
+import { areEqualBinaries, binaryToHex } 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'
+
+// 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', binaryToHex(expected.nodeId), binaryToHex(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 {

package/test/utils/mock/mockDataEntry.ts

@@ -0,0 +1,36 @@
+import { MessageType as MessageType$, ScalarType } from '@protobuf-ts/runtime'
+import { randomString } from '@streamr/utils'
+import crypto from 'crypto'
+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 { createRandomNodeId } from '../../../src/helpers/nodeId'
+
+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<DataEntry> = {}): DataEntry => {
+    return { 
+        key: crypto.randomBytes(10),
+        data: Any.pack({ foo: randomString(5) }, MockData),
+        creator: entry.creator ?? createRandomNodeId(),
+        ttl: 10000,
+        stale: false,
+        deleted: false,
+        createdAt: Timestamp.now(),
+        ...entry
+    }
+}
+
+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)
+}

package/test/utils/utils.ts

@@ -10,12 +10,10 @@ import {
     RouteMessageWrapper,
     StoreDataRequest,
     StoreDataResponse,
-    WebsocketConnectionResponse,
-    FindRequest, 
-    FindAction
+    RecursiveOperationRequest, 
+    RecursiveOperation
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { PeerID } from '../../src/helpers/PeerID'
 import {
     IDhtNodeRpc,
     IRouterRpc,
@@ -32,33 +30,23 @@ import { wait, waitForCondition } from '@streamr/utils'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { createRandomNodeId } from '../../src/helpers/nodeId'
 
-export const generateId = (stringId: string): Uint8Array => {
-    return PeerID.fromString(stringId).value
-}
-
-export const createMockPeerDescriptor = (): PeerDescriptor => {
+export const createMockPeerDescriptor = (opts?: Partial<Omit<PeerDescriptor, 'nodeId'>>): PeerDescriptor => {
     return {
         nodeId: createRandomNodeId(),
         type: NodeType.NODEJS,
-    }  
+        ...opts
+    }
 }
 
 export const createMockConnectionDhtNode = async (
-    stringId: string,
     simulator: Simulator,
-    binaryId?: Uint8Array,
+    nodeId?: Uint8Array,
     numberOfNodesPerKBucket?: number,
     maxConnections = 80,
     dhtJoinTimeout = 45000
 ): Promise<DhtNode> => {
-    let id: PeerID
-    if (binaryId) {
-        id = PeerID.fromValue(binaryId)
-    } else {
-        id = PeerID.fromString(stringId)
-    }
     const peerDescriptor: PeerDescriptor = {
-        nodeId: id.value,
+        nodeId: nodeId ?? createRandomNodeId(),
         type: NodeType.NODEJS,
         region: getRandomRegion()
     }
@@ -83,14 +71,12 @@ export const createMockConnectionDhtNode = async (
 }
 
 export const createMockConnectionLayer1Node = async (
-    stringId: string,
     layer0Node: DhtNode,
     serviceId?: string,
     numberOfNodesPerKBucket = 8
 ): Promise<DhtNode> => {
-    const id = PeerID.fromString(stringId)
     const descriptor: PeerDescriptor = {
-        nodeId: id.value,
+        nodeId: layer0Node.getLocalPeerDescriptor().nodeId,
         type: NodeType.NODEJS,
     }
     const node = new DhtNode({
@@ -121,11 +107,9 @@ export const createWrappedClosestPeersRequest = (
     return rpcWrapper
 }
 
-export const createFindRequest = (
-    action: FindAction
-): FindRequest => {
-    const request: FindRequest = {
-        action,
+export const createFindRequest = (): RecursiveOperationRequest => {
+    const request: RecursiveOperationRequest = {
+        operation: RecursiveOperation.FIND_NODE,
         sessionId: v4()
     }
     return request
@@ -137,36 +121,37 @@ interface IDhtRpcWithError extends IDhtNodeRpc {
     throwGetClosestPeersError: (request: ClosestPeersRequest) => Promise<ClosestPeersResponse>
 }
 
-export const MockDhtRpc: IDhtRpcWithError = {
-    async getClosestPeers(): Promise<ClosestPeersResponse> {
-        const neighbors = getMockPeers()
-        const response: ClosestPeersResponse = {
-            peers: neighbors,
-            requestId: 'why am i still here'
-        }
-        return response
-    },
-    async ping(request: PingRequest): Promise<PingResponse> {
-        const response: PingResponse = {
-            requestId: request.requestId
-        }
-        return response
-    },
-    async leaveNotice(): Promise<Empty> {
-        return {}
-    },
-    async throwPingError(): Promise<PingResponse> {
-        throw new Error()
-    },
-    async respondPingWithTimeout(request: PingRequest): Promise<PingResponse> {
-        const response: PingResponse = {
-            requestId: request.requestId
+export const createMockDhtRpc = (neighbors: PeerDescriptor[]): IDhtRpcWithError => {
+    return {
+        async getClosestPeers(): Promise<ClosestPeersResponse> {
+            const response: ClosestPeersResponse = {
+                peers: neighbors,
+                requestId: 'why am i still here'
+            }
+            return response
+        },
+        async ping(request: PingRequest): Promise<PingResponse> {
+            const response: PingResponse = {
+                requestId: request.requestId
+            }
+            return response
+        },
+        async leaveNotice(): Promise<Empty> {
+            return {}
+        },
+        async throwPingError(): Promise<PingResponse> {
+            throw new Error()
+        },
+        async respondPingWithTimeout(request: PingRequest): Promise<PingResponse> {
+            const response: PingResponse = {
+                requestId: request.requestId
+            }
+            await wait(2000)
+            return response
+        },
+        async throwGetClosestPeersError(): Promise<ClosestPeersResponse> {
+            throw new Error('Closest peers error')
         }
-        await wait(2000)
-        return response
-    },
-    async throwGetClosestPeersError(): Promise<ClosestPeersResponse> {
-        throw new Error('Closest peers error')
     }
 }
 
@@ -194,54 +179,31 @@ export const mockRouterRpc: IRouterRpcWithError = {
 
 interface IStoreRpcWithError extends IStoreRpc {
     throwStoreDataError: (request: StoreDataRequest) => Promise<StoreDataResponse>
-    storeDataErrorString: (request: StoreDataRequest) => Promise<StoreDataResponse>
 }
 
 export const mockStoreRpc: IStoreRpcWithError = {
     async storeData(): Promise<StoreDataResponse> {
-        return {
-            error: ''
-        }
+        return {}
     },
     async throwStoreDataError(): Promise<StoreDataResponse> {
         throw new Error('Mock')
     },
-    async storeDataErrorString(): Promise<StoreDataResponse> {
-        return {
-            error: 'Mock'
-        }
-    },
     async replicateData(): Promise<Empty> {
         return {}
     }
 }
 
 export const mockWebsocketConnectorRpc: IWebsocketConnectorRpc = {
-    async requestConnection(): Promise<WebsocketConnectionResponse> {
-        const responseConnection: WebsocketConnectionResponse = {
-            accepted: true
-        }
-        return responseConnection
+    async requestConnection(): Promise<Empty> {
+        return {}
     }
 }
 
-export const getMockPeers = (): PeerDescriptor[] => {
-    const n1: PeerDescriptor = {
-        nodeId: generateId('Neighbor1'),
-        type: NodeType.NODEJS,
-    }
-    const n2: PeerDescriptor = {
-        nodeId: generateId('Neighbor2'),
-        type: NodeType.NODEJS,
-    }
-    const n3: PeerDescriptor = {
-        nodeId: generateId('Neighbor3'),
-        type: NodeType.NODEJS,
-    }
-    const n4: PeerDescriptor = {
-        nodeId: generateId('Neighbor4'),
-        type: NodeType.NODEJS,
-    }
+export const createMockPeers = (): PeerDescriptor[] => {
+    const n1 = createMockPeerDescriptor()
+    const n2 = createMockPeerDescriptor()
+    const n3 = createMockPeerDescriptor()
+    const n4 = createMockPeerDescriptor()
     return [
         n1, n2, n3, n4
     ]

package/dist/src/dht/find/FindRpcLocal.d.ts

@@ -1,14 +0,0 @@
-import { PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc';
-import { IFindRpc } from '../../proto/packages/dht/protos/DhtRpc.server';
-interface FindRpcLocalConfig {
-    doRouteFindRequest: (routedMessage: RouteMessageWrapper) => RouteMessageAck;
-    addContact: (contact: PeerDescriptor, setActive?: boolean) => void;
-    isMostLikelyDuplicate: (requestId: string) => boolean;
-    addToDuplicateDetector: (requestId: string) => void;
-}
-export declare class FindRpcLocal implements IFindRpc {
-    private readonly config;
-    constructor(config: FindRpcLocalConfig);
-    routeFindRequest(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck>;
-}
-export {};

package/dist/src/dht/find/FindRpcLocal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FindRpcLocal.js","sourceRoot":"","sources":["../../../../src/dht/find/FindRpcLocal.ts"],"names":[],"mappings":";;;AAAA,0CAAuC;AACvC,mEAAgI;AAEhI,qFAAoF;AACpF,8DAAiE;AACjE,gEAA4D;AAE5D,MAAM,MAAM,GAAG,IAAI,cAAM,CAAC,MAAM,CAAC,CAAA;AASjC,MAAa,YAAY;IAIrB,YAAY,MAA0B;QAClC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACxB,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,aAAkC;QACrD,IAAI,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,aAAa,CAAC,SAAS,CAAC,EAAE;YAC5D,OAAO,IAAA,sCAAqB,EAAC,aAAa,EAAE,0BAAiB,CAAC,SAAS,CAAC,CAAA;SAC3E;QACD,MAAM,QAAQ,GAAG,IAAA,sDAA2B,EAAC,IAAA,iCAAe,EAAC,aAAa,CAAC,IAAI,aAAa,CAAC,UAAW,CAAC,CAAA;QACzG,MAAM,CAAC,KAAK,CAAC,uCAAuC,QAAQ,EAAE,CAAC,CAAA;QAC/D,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,aAAa,CAAC,UAAW,EAAE,IAAI,CAAC,CAAA;QACvD,IAAI,CAAC,MAAM,CAAC,sBAAsB,CAAC,aAAa,CAAC,SAAS,CAAC,CAAA;QAC3D,OAAO,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAA;IACxD,CAAC;CACJ;AAlBD,oCAkBC"}