@streamr/dht 0.0.1-tatum.0

package/test/unit/UUID.test.ts

@@ -0,0 +1,49 @@
+import { UUID } from '../../src/helpers/UUID'
+import { v4 } from 'uuid'
+
+describe('UUID', () => {
+
+    it('generates unique IDs without constructor parameters', () => {
+        const ids: UUID[] = []
+        for (let i = 0; i < 100; i++) {
+            ids.push(new UUID())
+        }
+        for (let x = 0; x < ids.length; x++) {
+            const compare1 = ids[x]
+            for (let y = 0; y < ids.length; y++) {
+                if (x !== y) {
+                    const compare2 = ids[y]
+                    expect(compare1.toString() === compare2.toString()).toEqual(false)
+                }
+            }
+        }
+    })
+
+    it('Uses passed string uuid parameter as id', () => {
+        const stringId = v4()
+        const uuid = new UUID(stringId)
+        expect(uuid.toString() === stringId).toEqual(true)
+    })
+
+    it('Throws if incorrect string is given as uuid string parameter', () => {
+        expect(()=> {new UUID('äå%')}).toThrow(TypeError)
+    })
+
+    it('Uses passed UUID as id', () => {
+        const uuid1 = new UUID()
+        const uuid2 = new UUID(uuid1)
+        expect(uuid1.toString() === uuid2.toString()).toEqual(true)
+    })
+
+    it('Uses passed UintArray uuid as id', () => {
+        const uuid1 = new UUID()
+        const uuid2 = new UUID(uuid1.value)
+        expect(uuid1.toString() === uuid2.toString()).toEqual(true)
+    })
+
+    it('Get value returns correct value', () => {
+        const uuid1 = new UUID()
+        const uuid2 = new UUID(uuid1.value)
+        expect(Buffer.compare(uuid1.value, uuid2.value) === 0)
+    })
+})

package/test/unit/WebSocketServer.test.ts

@@ -0,0 +1,42 @@
+/* eslint-disable promise/no-nesting */
+
+import { WebSocketServer } from '../../src/connection/WebSocket/WebSocketServer'
+
+describe('WebSocketServer', () => {
+
+    it('starts and stops with host "127.0.0.1"', async () => {
+        const server = new WebSocketServer()
+        await server.start(19792, '127.0.0.1')
+        await server.stop()
+    })
+
+    it('starts and stops if no host given', async () => {
+        const server = new WebSocketServer()
+        await server.start(19792)
+        await server.stop()
+    })
+
+    it('throws if too big a port number is given', async () => {
+        const server1 = new WebSocketServer()
+        await server1.start(19792)
+        
+        const server2 = new WebSocketServer()
+        
+        await expect(server2.start(19792))
+            .rejects
+            .toThrow()
+
+        await server1.stop()
+        await server2.stop()
+    })
+
+    it('throws if port is already in use', async () => {
+        const server = new WebSocketServer()
+
+        await expect(server.start(197923233))
+            .rejects
+            .toThrow()
+
+        await server.stop()
+    })
+})

package/test/utils/mock/RecursiveFinder.ts

@@ -0,0 +1,19 @@
+import { RecursiveFindResult, IRecursiveFinder } from '../../../src/dht/find/RecursiveFinder'
+import { RouteMessageAck, RouteMessageWrapper } from '../../../src/proto/packages/dht/protos/DhtRpc'
+
+export class MockRecursiveFinder implements IRecursiveFinder {
+
+    // eslint-disable-next-line class-methods-use-this
+    async startRecursiveFind(): Promise<RecursiveFindResult> {
+        return {
+            closestNodes: [],
+            dataEntries: []
+        }
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async findRecursively(_routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
+        return RouteMessageAck.create()
+    }
+
+}

package/test/utils/mock/Router.ts

@@ -0,0 +1,53 @@
+import { IRouter } from '../../../src/dht/routing/Router'
+import { RoutingSession, RoutingMode } from '../../../src/dht/routing/RoutingSession'
+import { PeerDescriptor, Message, RouteMessageAck, RouteMessageWrapper } from '../../../src/proto/packages/dht/protos/DhtRpc'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+
+export class MockRouter implements IRouter {
+
+    // eslint-disable-next-line class-methods-use-this
+    addRoutingSession(_session: RoutingSession): void {
+        return
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    removeRoutingSession(_sessionId: string): void {
+        return
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    addToDuplicateDetector(_messageId: string, _senderId: string, _message?: Message): void {
+        return
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    checkDuplicate(_messageId: string): boolean {
+        return false
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    doRouteMessage(_routedMessage: RouteMessageWrapper, _mode: RoutingMode): RouteMessageAck {
+        return RouteMessageAck.create()
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    send(_msg: Message, _reachableThrough: PeerDescriptor[]): Promise<void> {
+        throw Error('Not implemented')
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    stop(): void {
+
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async routeMessage(_routedMessage: RouteMessageWrapper, _context: ServerCallContext): Promise<RouteMessageAck> {
+        return RouteMessageAck.create()
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    async forwardMessage(_forwardMessage: RouteMessageWrapper, _context: ServerCallContext): Promise<RouteMessageAck> {
+        return RouteMessageAck.create()
+    }
+
+}

package/test/utils/mock/Transport.ts

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

package/test/utils/utils.ts

@@ -0,0 +1,311 @@
+import { DhtNode } from '../../src/dht/DhtNode'
+import {
+    ClosestPeersRequest,
+    ClosestPeersResponse,
+    LeaveNotice,
+    MigrateDataRequest,
+    MigrateDataResponse,
+    NodeType,
+    PeerDescriptor,
+    PingRequest,
+    PingResponse,
+    RouteMessageAck,
+    RouteMessageWrapper,
+    StoreDataRequest,
+    StoreDataResponse,
+    WebSocketConnectionRequest,
+    WebSocketConnectionResponse,
+    RecursiveFindRequest, 
+    FindMode,
+    DeleteDataRequest,
+    DeleteDataResponse
+} from '../../src/proto/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { PeerID } from '../../src/helpers/PeerID'
+import {
+    IDhtRpcService,
+    IRoutingService,
+    IStoreService,
+    IWebSocketConnectorService
+} from '../../src/proto/packages/dht/protos/DhtRpc.server'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { v4 } from 'uuid'
+import { getRandomRegion } from '../../src/connection/Simulator/pings'
+import { Empty } from '../../src/proto/google/protobuf/empty'
+import { Any } from '../../src/proto/google/protobuf/any'
+import { waitForCondition } from '@streamr/utils'
+import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
+
+export const generateId = (stringId: string): Uint8Array => {
+    return PeerID.fromString(stringId).value
+}
+
+export const createMockConnectionDhtNode = async (stringId: string,
+    simulator: Simulator,
+    binaryId?: Uint8Array,
+    K?: number,
+    nodeName?: string,
+    maxConnections = 80,
+    dhtJoinTimeout = 45000
+): Promise<DhtNode> => {
+
+    let id: PeerID
+    if (binaryId) {
+        id = PeerID.fromValue(binaryId)
+    } else {
+        id = PeerID.fromString(stringId)
+    }
+    const peerDescriptor: PeerDescriptor = {
+        kademliaId: id.value,
+        type: NodeType.NODEJS,
+        region: getRandomRegion(),
+        nodeName: nodeName ? nodeName : stringId
+    }
+
+    const mockConnectionManager = new ConnectionManager({
+        ownPeerDescriptor: peerDescriptor,
+        simulator: simulator,
+        nodeName: nodeName ? nodeName : stringId
+    })
+
+    const node = new DhtNode({
+        peerDescriptor: peerDescriptor,
+        transportLayer: mockConnectionManager,
+        nodeName: nodeName,
+        numberOfNodesPerKBucket: K ? K : 8,
+        maxConnections: maxConnections,
+        dhtJoinTimeout
+    })
+    await node.start()
+
+    return node
+}
+
+export const createMockConnectionLayer1Node = async (stringId: string, layer0Node: DhtNode, serviceId?: string): Promise<DhtNode> => {
+    const id = PeerID.fromString(stringId)
+    const descriptor: PeerDescriptor = {
+        kademliaId: id.value,
+        type: 0,
+        nodeName: stringId
+    }
+
+    const node = new DhtNode({
+        peerDescriptor: descriptor, transportLayer: layer0Node,
+        serviceId: serviceId ? serviceId : 'layer1', numberOfNodesPerKBucket: 8, nodeName: stringId
+    })
+    await node.start()
+    return node
+}
+
+export const createWrappedClosestPeersRequest = (
+    sourceDescriptor: PeerDescriptor,
+    _udestinationDescriptor: PeerDescriptor
+): RpcMessage => {
+
+    const routedMessage: ClosestPeersRequest = {
+        kademliaId: sourceDescriptor.kademliaId,
+        requestId: v4()
+    }
+    const rpcWrapper: RpcMessage = {
+        body: Any.pack(routedMessage, ClosestPeersRequest),
+        header: {
+            method: 'closestPeersRequest',
+            request: 'request'
+        },
+        requestId: v4()
+    }
+    return rpcWrapper
+}
+
+export const createRecursiveFindRequest = (
+    findMode: FindMode
+): RecursiveFindRequest => {
+    const request: RecursiveFindRequest = {
+        findMode,
+        recursiveFindSessionId: v4()
+    }
+    return request
+}
+
+interface IDhtRpcWithError extends IDhtRpcService {
+    throwPingError: (request: PingRequest, _context: ServerCallContext) => Promise<PingResponse>
+    respondPingWithTimeout: (request: PingRequest, _context: ServerCallContext) => Promise<PingResponse>
+    throwGetClosestPeersError: (request: ClosestPeersRequest, _context: ServerCallContext) => Promise<ClosestPeersResponse>
+}
+
+export const MockDhtRpc: IDhtRpcWithError = {
+    async getClosestPeers(_request: ClosestPeersRequest, _context: ServerCallContext): Promise<ClosestPeersResponse> {
+        const neighbors = getMockPeers()
+        const response: ClosestPeersResponse = {
+            peers: neighbors,
+            requestId: 'why am i still here'
+        }
+        return response
+    },
+    async ping(request: PingRequest, _context: ServerCallContext): Promise<PingResponse> {
+        const response: PingResponse = {
+            requestId: request.requestId
+        }
+        return response
+    },
+    async leaveNotice(_request: LeaveNotice, _context: ServerCallContext): Promise<Empty> {
+        return {}
+    },
+    async throwPingError(_urequest: PingRequest, _context: ServerCallContext): Promise<PingResponse> {
+        throw new Error()
+    },
+    respondPingWithTimeout(request: PingRequest, _context: ServerCallContext): Promise<PingResponse> {
+        return new Promise((resolve, _reject) => {
+            const response: PingResponse = {
+                requestId: request.requestId
+            }
+            setTimeout(() => resolve(response), 2000)
+        })
+    },
+    async throwGetClosestPeersError(_urequest: ClosestPeersRequest, _context: ServerCallContext): Promise<ClosestPeersResponse> {
+        throw new Error('Closest peers error')
+    }
+}
+
+interface IRouterServiceWithError extends IRoutingService {
+    throwRouteMessageError: (request: RouteMessageWrapper, _context: ServerCallContext) => Promise<RouteMessageAck>
+}
+
+export const MockRoutingService: IRouterServiceWithError = {
+    async routeMessage(routed: RouteMessageWrapper, _context: ServerCallContext): Promise<RouteMessageAck> {
+        const response: RouteMessageAck = {
+            requestId: routed.requestId,
+            destinationPeer: routed.sourcePeer,
+            sourcePeer: routed.destinationPeer,
+            error: ''
+        }
+        return response
+    },
+    async findRecursively(routed: RouteMessageWrapper, _context: ServerCallContext): Promise<RouteMessageAck> {
+        const response: RouteMessageAck = {
+            requestId: routed.requestId,
+            destinationPeer: routed.sourcePeer,
+            sourcePeer: routed.destinationPeer,
+            error: ''
+        }
+        return response
+    },
+    async forwardMessage(routed: RouteMessageWrapper, _context: ServerCallContext): Promise<RouteMessageAck> {
+        const response: RouteMessageAck = {
+            requestId: routed.requestId,
+            destinationPeer: routed.sourcePeer,
+            sourcePeer: routed.destinationPeer,
+            error: ''
+        }
+        return response
+    },
+    async throwRouteMessageError(_urequest: RouteMessageWrapper, _context: ServerCallContext): Promise<RouteMessageAck> {
+        throw new Error()
+    }
+}
+
+interface IStoreServiceWithError extends IStoreService {
+    throwStoreDataError: (request: StoreDataRequest, _context: ServerCallContext) => Promise<StoreDataResponse>
+    storeDataErrorString: (request: StoreDataRequest, _context: ServerCallContext) => Promise<StoreDataResponse>
+}
+
+export const MockStoreService: IStoreServiceWithError = {
+    async storeData(_request: StoreDataRequest, _context: ServerCallContext): Promise<StoreDataResponse> {
+        return {
+            error: ''
+        }
+    },
+    async throwStoreDataError(_request: StoreDataRequest, _context: ServerCallContext): Promise<StoreDataResponse> {
+        throw new Error('Mock')
+    },
+    async storeDataErrorString(_request: StoreDataRequest, _context: ServerCallContext): Promise<StoreDataResponse> {
+        return {
+            error: 'Mock'
+        }
+    },
+    async migrateData(_request: MigrateDataRequest, _context: ServerCallContext): Promise<MigrateDataResponse> {
+        return MigrateDataResponse.create()
+    },
+    async deleteData(_request: DeleteDataRequest, _context: ServerCallContext): Promise<DeleteDataResponse> {
+        return DeleteDataResponse.create()
+    }
+}
+
+export const MockWebSocketConnectorRpc: IWebSocketConnectorService = {
+    async requestConnection(request: WebSocketConnectionRequest, _context: ServerCallContext): Promise<WebSocketConnectionResponse> {
+        const responseConnection: WebSocketConnectionResponse = {
+            target: request.target,
+            requester: request.requester,
+            accepted: true
+        }
+        return responseConnection
+    }
+}
+
+export const getMockPeers = (): PeerDescriptor[] => {
+    const n1: PeerDescriptor = {
+        kademliaId: generateId('Neighbor1'),
+        type: NodeType.NODEJS,
+    }
+    const n2: PeerDescriptor = {
+        kademliaId: generateId('Neighbor2'),
+        type: NodeType.NODEJS,
+    }
+    const n3: PeerDescriptor = {
+        kademliaId: generateId('Neighbor3'),
+        type: NodeType.NODEJS,
+    }
+    const n4: PeerDescriptor = {
+        kademliaId: generateId('Neighbor1'),
+        type: NodeType.BROWSER,
+    }
+    return [
+        n1, n2, n3, n4
+    ]
+}
+
+export const waitConnectionManagersReadyForTesting = async (connectionManagers: ConnectionManager[], limit: number): Promise<void> => {
+    connectionManagers.forEach((connectionManager) => garbageCollectConnections(connectionManager, limit))
+    try {
+        await Promise.all(connectionManagers.map((connectionManager) => waitReadyForTesting(connectionManager, limit)))
+    } catch (_err) {
+        // did not successfully meet condition but network should be in a stable non-star state
+    }
+}
+
+export const waitNodesReadyForTesting = async (nodes: DhtNode[], limit: number = 10000): Promise<void> => {
+    return waitConnectionManagersReadyForTesting(
+        nodes.map((node) => {
+            return (node.getTransport() as ConnectionManager)
+        }), limit)
+}
+
+function garbageCollectConnections(connectionManager: ConnectionManager, limit: number): void {
+    const LAST_USED_LIMIT = 100
+    connectionManager.garbageCollectConnections(limit, LAST_USED_LIMIT)
+}
+
+async function waitReadyForTesting(connectionManager: ConnectionManager, limit: number): Promise<void> {
+    const LAST_USED_LIMIT = 100
+    connectionManager.garbageCollectConnections(limit, LAST_USED_LIMIT)
+    try {
+        await waitForCondition(() => {
+            return (connectionManager.getNumberOfLocalLockedConnections() === 0 &&
+                connectionManager.getNumberOfRemoteLockedConnections() === 0 &&
+                connectionManager.getAllConnectionPeerDescriptors().length <= limit)
+        }, 20000)
+    } catch (err) {
+        if (connectionManager.getNumberOfLocalLockedConnections() > 0
+            && connectionManager.getNumberOfRemoteLockedConnections() > 0) {
+            throw Error('Connections are still locked')
+        } else if (connectionManager.getAllConnectionPeerDescriptors().length > limit) {
+            throw Error(`ConnectionManager has more than ${limit}`)
+        }
+    }
+}
+
+export function createMockRoutingRpcCommunicator(): RoutingRpcCommunicator {
+    return new RoutingRpcCommunicator('router', async (_msg, _doNotConnect) => {})
+}

package/tsconfig.browser.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.browser.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDirs": ["src", "test"],
+    "noImplicitOverride": false
+  },
+  "include": [
+    "src/**/*",
+    "test/**/*"
+  ],
+  "exclude": [
+    "src/connection/WebRTC/NodeWebRtcConnection.ts"
+  ]
+}

package/tsconfig.jest.json

@@ -0,0 +1,19 @@
+{
+    "extends": "../../tsconfig.jest.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "noImplicitOverride": false
+    },
+    "include": [
+        "src/**/*",
+        "test/**/*"
+    ],
+    "exclude": [
+        "src/connection/WebRTC/BrowserWebRtcConnection.ts"
+    ],  
+    "references": [
+        { "path": "../utils/tsconfig.node.json" },
+        { "path": "../test-utils/tsconfig.node.json" },
+        { "path": "../proto-rpc/tsconfig.node.json" }
+    ]
+}

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig.jest.json"
+}

package/tsconfig.node.json

@@ -0,0 +1,18 @@
+{
+    "extends": "../../tsconfig.node.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "noImplicitOverride": false
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "src/connection/WebRTC/BrowserWebRtcConnection.ts"
+    ],
+    "references": [
+        { "path": "../utils/tsconfig.node.json" },
+        { "path": "../test-utils/tsconfig.node.json" },
+        { "path": "../proto-rpc/tsconfig.node.json" }
+    ]
+}