@streamr/dht 0.0.1-tatum.0

package/test/unit/AddressTools.test.ts

@@ -0,0 +1,40 @@
+import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../src/helpers/AddressTools'
+
+describe('getAddressFromIceCandidate', () => {
+    it('extract IPv4 address from ICE host candidate', () => {
+        expect(getAddressFromIceCandidate('candidate:1 1 udp 2122262783 203.0.113.180 4444 typ host'))
+            .toEqual('203.0.113.180')
+    })
+
+    it('extract IPv4 address from ICE server reflexive candidate', () => {
+        expect(getAddressFromIceCandidate('candidate:1 1 udp 2122262783 198.51.100.130 4445 typ srflx raddr 0.0.0.0 rport 0'))
+            .toEqual('198.51.100.130')
+    })
+
+    it('extract IPv6 address from ICE candidate', () => {
+        expect(getAddressFromIceCandidate('candidate:1 1 udp 3756231458 2001:db8::4125:918c:4402:cc54 6666 typ host'))
+            .toEqual('2001:db8::4125:918c:4402:cc54')
+    })
+
+    it('fail on mDNS ICE candidate', () => {
+        expect(getAddressFromIceCandidate('candidate:1 1 udp 2122296321 9b36eaac-bb2e-49bb-bb78-21c41c499900.local 7000 typ host')).toBeUndefined()
+    })
+})
+
+describe('isPrivateIPv4', () => {
+    it('return true for range 10.0.0.0/8', () => {
+        expect(isPrivateIPv4('10.11.12.13')).toBe(true)
+    })
+
+    it('return true for range 172.16.0.0/12', () => {
+        expect(isPrivateIPv4('172.16.130.131')).toBe(true)
+    })
+
+    it('return true for range 192.168.0.0/16', () => {
+        expect(isPrivateIPv4('192.168.1.1')).toBe(true)
+    })
+
+    it('return false for a public address', () => {
+        expect(isPrivateIPv4('203.0.113.181')).toBe(false)
+    })
+})

package/test/unit/DuplicateDetector.test.ts

@@ -0,0 +1,29 @@
+import { DuplicateDetector } from '../../src/dht/routing/DuplicateDetector'
+
+describe('Duplicate Detector', () => {
+    let detector: DuplicateDetector
+    const maxLimit = 10
+    const senderId = 'sender'
+    beforeEach(async () => {
+        detector = new DuplicateDetector(maxLimit, 100)
+    })
+
+    it('detects duplicates', async () => {
+        detector.add('test', senderId)
+        expect(detector.size()).toEqual(1)
+        expect(detector.isMostLikelyDuplicate('test')).toEqual(true)
+    })
+
+    it('resets on resetLimit', () => {
+        for (let i = 0; i < maxLimit; i++) {
+            detector.add(`test${i}`, senderId)
+        }
+        for (let i = 0; i < maxLimit; i++) {
+            expect(detector.isMostLikelyDuplicate(`test${i}`)).toEqual(true)
+        }
+        detector.add('test10', senderId)
+        expect(detector.size()).toEqual(10)
+        expect(detector.isMostLikelyDuplicate('test0')).toEqual(false)
+        expect(detector.isMostLikelyDuplicate('test10')).toEqual(true)
+    })
+})

package/test/unit/LocalDataStore.test.ts

@@ -0,0 +1,107 @@
+import { Any } from '../../src/proto/google/protobuf/any'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import {
+    isSamePeerDescriptor,
+    keyFromPeerDescriptor,
+    peerIdFromPeerDescriptor
+} from '../../src/helpers/peerIdFromPeerDescriptor'
+import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
+import { wait } from '@streamr/utils'
+import { Timestamp } from '../../src/proto/google/protobuf/timestamp'
+
+describe('LocalDataStore', () => {
+    let localDataStore: LocalDataStore
+    const storer1: PeerDescriptor = {
+        kademliaId: new Uint8Array([1, 2, 3]),
+        type: NodeType.NODEJS,
+        nodeName: 'storer1'
+    }
+    const storer2: PeerDescriptor = {
+        kademliaId: new Uint8Array([3, 2, 1]),
+        type: NodeType.NODEJS,
+        nodeName: 'storer2'
+    }
+    const data1 = Any.pack(storer1, PeerDescriptor)
+    const data2 = Any.pack(storer2, PeerDescriptor)
+
+    beforeEach(() => {
+        localDataStore = new LocalDataStore()
+    })
+
+    afterEach(() => {
+        localDataStore.clear()
+    })
+
+    it('can store', () => {
+        const dataKey = peerIdFromPeerDescriptor(storer1)
+        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1, 
+            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        const fetchedData = localDataStore.getEntry(dataKey)
+        fetchedData!.forEach((entry) => {
+            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
+            expect(isSamePeerDescriptor(fetchedDescriptor, storer1)).toBeTrue()
+        })
+    })
+
+    it('multiple storers behind one key', () => {
+        const dataKey = peerIdFromPeerDescriptor(storer1)
+        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
+            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, 
+            data: data1, ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        const fetchedData = localDataStore.getEntry(dataKey)
+        fetchedData!.forEach((entry) => {
+            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
+            expect(isSamePeerDescriptor(fetchedDescriptor, storer1)).toBeTrue()
+        })
+    })
+
+    it('can remove data entries', () => {
+        const dataKey = peerIdFromPeerDescriptor(storer1)
+        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
+            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, data: data2,
+            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        localDataStore.deleteEntry(dataKey, storer1)
+        const fetchedData = localDataStore.getEntry(dataKey)
+        fetchedData!.forEach((entry) => {
+            const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
+            expect(isSamePeerDescriptor(fetchedDescriptor, storer2)).toBeTrue()
+        })
+    })
+
+    it('can remove all data entries', () => {
+        const dataKey = peerIdFromPeerDescriptor(storer1)
+        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
+            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, data: data2,
+            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        localDataStore.deleteEntry(dataKey, storer1)
+        localDataStore.deleteEntry(dataKey, storer2)
+        const fetchedData = localDataStore.getEntry(dataKey)
+        expect(fetchedData.size).toBe(0)
+    })
+
+    it('data is deleted after TTL', async () => {
+        const dataKey = peerIdFromPeerDescriptor(storer1)
+        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
+            ttl: 1000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        const intitialStore = localDataStore.getEntry(dataKey)
+        expect(intitialStore.size).toBe(1)
+        await wait(1100)
+        const fetchedData = localDataStore.getEntry(dataKey)
+        expect(fetchedData.size).toBe(0)
+    })
+
+    it('can mark data as deleted', () => {
+        const dataKey = peerIdFromPeerDescriptor(storer1)
+        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
+            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        const notDeletedData = localDataStore.getEntry(dataKey)
+        expect(notDeletedData.get(keyFromPeerDescriptor(storer1))!.deleted).toBeFalse()
+        localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(storer1))
+        const deletedData = localDataStore.getEntry(dataKey)
+        expect(deletedData.get(keyFromPeerDescriptor(storer1))!.deleted).toBeTrue()
+    })
+
+})

package/test/unit/PeerID.test.ts

@@ -0,0 +1,22 @@
+import { PeerID } from '../../src/helpers/PeerID'
+
+describe('PeerID', () => {
+
+    it('Conversions between input formats work', async () => {
+        const stringId = '123'
+        const id1 = PeerID.fromString(stringId)
+        const id2 = PeerID.fromValue(id1.value)
+
+        expect(id1.equals(id2)).toBeTruthy()
+        expect(id1.toString()).toEqual(id2.toString())
+        expect(stringId).toEqual(id2.toString())
+    })
+
+    it('peerKey', () => {
+        const peerIdFromString = PeerID.fromString('peerId')
+        const peerKey = peerIdFromString.toKey()
+        const peerIdFromKey = PeerID.fromKey(peerKey)
+        expect(peerIdFromString.equals(peerIdFromKey)).toEqual(true)        
+    })
+
+})

package/test/unit/ProtobufMessage.test.ts

@@ -0,0 +1,21 @@
+/*
+import { ProtobufMessage } from '../../src/protobufclasses/ProtobufMessage'
+import { Message, RpcMessage } from '../../src/proto/DhtRpc'
+import { v4 } from 'uuid'
+import { MessageType } from '@protobuf-ts/runtime'
+*/
+
+describe('ProtobufMessage', () => {
+
+    it('can parse and print a Message', async () => {
+        
+        /*
+        const message: Message = {
+            messageId: v4(),
+            messageType: 
+        }
+        const data = Message.toBinary(message)
+        ProtobufMessage.fromBinary(data)
+        */
+    })
+})

package/test/unit/RandomContactList.test.ts

@@ -0,0 +1,87 @@
+import { RandomContactList } from '../../src/dht/contact/RandomContactList'
+import type { ServiceInfo, MethodInfo } from '@protobuf-ts/runtime-rpc'
+import { PeerID } from '../../src/helpers/PeerID'
+import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { IDhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { LeaveNotice, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import type { FindDataRequest, FindDataResponse, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import type { PingRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+import type { ClosestPeersResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import type { ClosestPeersRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { UnaryCall } from '@protobuf-ts/runtime-rpc'
+import type { RpcOptions } from '@protobuf-ts/runtime-rpc'
+import { DhtPeer } from '../../src/dht/DhtPeer'
+import { IMessageType } from '@protobuf-ts/runtime'
+import { Empty } from '../../src/proto/google/protobuf/empty'
+
+class MockRpcClient implements IDhtRpcServiceClient, ServiceInfo {
+    typeName = 'MockRpcClient'
+    methods: MethodInfo<any, any> [] = [
+        { name: 'getClosestPeers', O: {} as IMessageType<ClosestPeersResponse> } as MethodInfo<any, any>,
+        { name: 'ping', O: {} as IMessageType<PingResponse> } as MethodInfo<any, any>,
+        { name: 'findData', O: {} as IMessageType<FindDataRequest> } as MethodInfo<any, any>,
+        { name: 'leaveNotice', O: {} as IMessageType<Empty> } as MethodInfo<any, any>
+    ]
+    options = {}
+
+    // eslint-disable-next-line class-methods-use-this
+    getClosestPeers(_input: ClosestPeersRequest, _options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse> {
+        return {} as UnaryCall<ClosestPeersRequest, ClosestPeersResponse>
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    ping(_input: PingRequest, _options?: RpcOptions): UnaryCall <PingRequest, PingResponse> {
+        return {} as UnaryCall<PingRequest, PingResponse>
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    findData(_input: FindDataRequest, _options?: RpcOptions): UnaryCall<FindDataRequest, FindDataResponse> {
+        return {} as UnaryCall<FindDataRequest, FindDataResponse>
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    leaveNotice(_input: LeaveNotice, _options?: RpcOptions): UnaryCall<LeaveNotice, Empty> {
+        return {} as UnaryCall<LeaveNotice, Empty>
+    }
+}
+
+describe('RandomContactList', () => {
+    const serviceId = 'random'
+    const id0 = PeerID.fromValue(Buffer.from([0, 0, 0, 0]))
+    const id1 = PeerID.fromValue(Buffer.from([0, 0, 0, 1]))
+    const id2 = PeerID.fromValue(Buffer.from([0, 0, 0, 2]))
+    const id3 = PeerID.fromValue(Buffer.from([0, 0, 0, 3]))
+    const id4 = PeerID.fromValue(Buffer.from([0, 0, 0, 4]))
+
+    const descriptor0: PeerDescriptor = { kademliaId: id0.value, type: NodeType.NODEJS }
+    const descriptor1: PeerDescriptor = { kademliaId: id1.value, type: NodeType.NODEJS }
+    const descriptor2: PeerDescriptor = { kademliaId: id2.value, type: NodeType.NODEJS }
+    const descriptor3: PeerDescriptor = { kademliaId: id3.value, type: NodeType.NODEJS }
+    const descriptor4: PeerDescriptor = { kademliaId: id4.value, type: NodeType.NODEJS }
+
+    const peer1 = new DhtPeer(descriptor0, descriptor1, toProtoRpcClient(new MockRpcClient()), serviceId)
+    const peer2 = new DhtPeer(descriptor0, descriptor2, toProtoRpcClient(new MockRpcClient()), serviceId)
+    const peer3 = new DhtPeer(descriptor0, descriptor3, toProtoRpcClient(new MockRpcClient()), serviceId)
+    const peer4 = new DhtPeer(descriptor0, descriptor4, toProtoRpcClient(new MockRpcClient()), serviceId)
+
+    it('adds contacts correctly', () => {
+        const list = new RandomContactList(id0, 5, 1)
+        list.addContact(peer1)
+        list.addContact(peer2)
+        list.addContact(peer3)
+        list.addContact(peer3)
+        list.addContact(peer4)
+        list.addContact(peer4)
+        expect(list.getSize()).toEqual(4)
+    })
+
+    it('removes contacts correctly', () => {
+        const list = new RandomContactList(id0, 5, 1)
+        list.addContact(peer1)
+        list.addContact(peer2)
+        list.removeContact(id2)
+        expect(list.getContact(id1)).toBeTruthy()
+        expect(list.getSize()).toEqual(1)
+    })
+
+})

package/test/unit/RecursiveFinder.test.ts

@@ -0,0 +1,112 @@
+import {
+    FindMode,
+    Message,
+    MessageType,
+    PeerDescriptor,
+    RouteMessageWrapper
+} from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
+import {
+    createMockRoutingRpcCommunicator,
+    createWrappedClosestPeersRequest,
+    createRecursiveFindRequest
+} from '../utils/utils'
+import { RecursiveFinder } from '../../src/dht/find/RecursiveFinder'
+import { DhtPeer } from '../../src/dht/DhtPeer'
+import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
+import { v4 } from 'uuid'
+import { MockRouter } from '../utils/mock/Router'
+import { MockTransport } from '../utils/mock/Transport'
+import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+
+describe('RecursiveFinder', () => {
+
+    let recursiveFinder: RecursiveFinder
+    let connections: Map<PeerIDKey, DhtPeer>
+
+    const peerId1 = PeerID.fromString('peerid')
+    const peerDescriptor1: PeerDescriptor = {
+        kademliaId: peerId1.value,
+        type: 0,
+        nodeName: 'peerid'
+    }
+    const peerDescriptor2: PeerDescriptor = {
+        kademliaId: PeerID.fromString('destination').value,
+        type: 0,
+        nodeName: 'destination'
+    }
+    const recursiveFindRequest = createRecursiveFindRequest(FindMode.NODE)
+    const message: Message = {
+        serviceId: 'unknown',
+        messageId: v4(),
+        messageType: MessageType.RPC,
+        body: {
+            oneofKind: 'recursiveFindRequest',
+            recursiveFindRequest
+        },
+        sourceDescriptor: peerDescriptor1,
+        targetDescriptor: peerDescriptor2
+    }
+    const routedMessage: RouteMessageWrapper = {
+        message,
+        requestId: 'REQ',
+        routingPath: [],
+        reachableThrough: [],
+        destinationPeer: peerDescriptor1,
+        sourcePeer: peerDescriptor2
+    }
+
+    beforeEach(() => {
+        connections = new Map()
+        recursiveFinder = new RecursiveFinder({
+            ownPeerDescriptor: peerDescriptor1,
+            ownPeerId: peerId1,
+            router: new MockRouter(),
+            connections,
+            serviceId: 'RecursiveFinder',
+            localDataStore: new LocalDataStore(),
+            sessionTransport: new MockTransport(),
+            addContact: (_contact, _setActive) => {},
+            isPeerCloserToIdThanSelf: (_peer1, _compareToId) => true,
+            rpcCommunicator: createMockRoutingRpcCommunicator()
+        })
+    })
+
+    afterEach(() => {
+        recursiveFinder.stop()
+    })
+
+    it('RecursiveFinder server', async () => {
+        const res = await recursiveFinder.findRecursively(routedMessage)
+        expect(res.error).toEqual('')
+    })
+
+    it('startRecursiveFind with mode Node returns self if no peers', async () => {
+        const res = await recursiveFinder.startRecursiveFind(PeerID.fromString('find').value)
+        expect(isSamePeerDescriptor(res.closestNodes[0], peerDescriptor1)).toEqual(true)
+    })
+
+    it('RecursiveFinder server throws if payload is not recursiveFindRequest', async () => {
+        const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1, peerDescriptor2)
+        const badMessage: Message = {
+            serviceId: 'unknown',
+            messageId: v4(),
+            messageType: MessageType.RPC,
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: rpcWrapper
+            },
+            sourceDescriptor: peerDescriptor1,
+            targetDescriptor: peerDescriptor2
+        }
+        await expect(recursiveFinder.findRecursively({
+            message: badMessage,
+            requestId: 'REQ',
+            routingPath: [],
+            reachableThrough: [],
+            destinationPeer: peerDescriptor1,
+            sourcePeer: peerDescriptor2
+        })).rejects.toThrow()
+    })
+
+})

package/test/unit/Router.test.ts

@@ -0,0 +1,124 @@
+import { Router } from '../../src/dht/routing/Router'
+import { Message, MessageType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
+import { DhtPeer } from '../../src/dht/DhtPeer'
+import { createWrappedClosestPeersRequest, createMockRoutingRpcCommunicator } from '../utils/utils'
+import { v4 } from 'uuid'
+import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+
+describe('Router', () => {
+    let router: Router
+
+    const peerId = PeerID.fromString('router')
+    const peerDescriptor1: PeerDescriptor = {
+        kademliaId: peerId.value,
+        type: 0,
+        nodeName: 'router'
+    }
+    const peerDescriptor2: PeerDescriptor = {
+        kademliaId: PeerID.fromString('destination').value,
+        type: 0,
+    }
+    const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1, peerDescriptor2)
+    const message: Message = {
+        serviceId: 'unknown',
+        messageId: v4(),
+        messageType: MessageType.RPC,
+        body: {
+            oneofKind: 'rpcMessage',
+            rpcMessage: rpcWrapper
+        },
+        sourceDescriptor: peerDescriptor1,
+        targetDescriptor: peerDescriptor2
+    }
+    const routedMessage: RouteMessageWrapper = {
+        message,
+        requestId: 'REQ',
+        routingPath: [],
+        reachableThrough: [],
+        destinationPeer: peerDescriptor1,
+        sourcePeer: peerDescriptor2
+    }
+    let connections: Map<PeerIDKey, DhtPeer>
+    const mockRpcCommunicator = createMockRoutingRpcCommunicator()
+
+    const createMockDhtPeer = (destination: PeerDescriptor): DhtPeer => {
+        return new DhtPeer(peerDescriptor1, destination, {} as any, 'router')
+    }
+
+    beforeEach(() => {
+        connections = new Map()
+        router = new Router({
+            ownPeerDescriptor: peerDescriptor1,
+            ownPeerId: peerId,
+            rpcCommunicator: mockRpcCommunicator,
+            addContact: (_contact) => {},
+            serviceId: 'router',
+            connections
+        })
+    })
+
+    afterEach(() => {
+        router.stop()
+    })
+
+    it('doRouteMessage without connections', () => {
+        const ack = router.doRouteMessage({
+            message,
+            destinationPeer: peerDescriptor2,
+            requestId: v4(),
+            sourcePeer: peerDescriptor1,
+            reachableThrough: [],
+            routingPath: []
+        })
+        expect(ack.error).toEqual('No routing candidates found')
+    })
+
+    it('doRouteMessage with connections', () => {
+        connections.set(PeerID.fromString('test').toKey(), createMockDhtPeer(peerDescriptor2))
+        const ack = router.doRouteMessage({
+            message,
+            destinationPeer: peerDescriptor2,
+            requestId: v4(),
+            sourcePeer: peerDescriptor1,
+            reachableThrough: [],
+            routingPath: []
+        })
+        expect(ack.error).toEqual('')
+    })
+
+    it('route server is destination without connections', async () => {
+        const ack = await router.routeMessage(routedMessage, {} as any)
+        expect(ack.error).toEqual('')
+    })
+
+    it('route server with connections', async () => {
+        connections.set(PeerID.fromString('test').toKey(), createMockDhtPeer(peerDescriptor2))
+        const ack = await router.routeMessage(routedMessage, {} as any)
+        expect(ack.error).toEqual('')
+    })
+
+    it('route server on duplicate message', async () => {
+        router.addToDuplicateDetector(routedMessage.requestId, keyFromPeerDescriptor(peerDescriptor2))
+        const ack = await router.routeMessage(routedMessage, {} as any)
+        expect(ack.error).toEqual('message given to routeMessage() service is likely a duplicate')
+    })
+
+    it('forward server no connections', async () => {
+        const ack = await router.forwardMessage(routedMessage, {} as any)
+        expect(ack.error).toEqual('No routing candidates found')
+    })
+
+    it('forward server with connections', async () => {
+        connections.set(PeerID.fromString('test').toKey(), createMockDhtPeer(peerDescriptor2))
+        const ack = await router.forwardMessage(routedMessage, {} as any)
+        expect(ack.error).toEqual('')
+    })
+
+    it('forward server on duplicate message', async () => {
+        router.addToDuplicateDetector(routedMessage.requestId, keyFromPeerDescriptor(peerDescriptor2))
+        const ack = await router.forwardMessage(routedMessage, {} as any)
+        expect(ack.error).toEqual('message given to forwardMessage() service is likely a duplicate')
+    })
+
+})

package/test/unit/SortedContactList.test.ts

@@ -0,0 +1,127 @@
+import { SortedContactList } from '../../src/dht/contact/SortedContactList'
+import type { ServiceInfo, MethodInfo } from '@protobuf-ts/runtime-rpc'
+import { PeerID } from '../../src/helpers/PeerID'
+import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { IDhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { LeaveNotice, NodeType, PeerDescriptor, RouteMessageAck } from '../../src/proto/packages/dht/protos/DhtRpc'
+import type { FindDataRequest, FindDataResponse, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import type { PingRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+import type { ClosestPeersResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import type { ClosestPeersRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { UnaryCall } from '@protobuf-ts/runtime-rpc'
+import type { RpcOptions } from '@protobuf-ts/runtime-rpc'
+import { DhtPeer } from '../../src/dht/DhtPeer'
+import { IMessageType } from '@protobuf-ts/runtime'
+import { Empty } from '../../src/proto/google/protobuf/empty'
+
+/* eslint-disable class-methods-use-this */
+class MockRpcClient implements IDhtRpcServiceClient, ServiceInfo {
+    typeName = 'MockRpcClient'
+    methods: MethodInfo<any, any> [] = [
+        { name: 'getClosestPeers', O: {} as IMessageType<ClosestPeersResponse> } as MethodInfo<any, any>,
+        { name: 'ping', O: {} as IMessageType<PingResponse> } as MethodInfo<any, any>,
+        { name: 'findData', O: {} as IMessageType<RouteMessageAck> } as MethodInfo<any, any>,
+        { name: 'leaveNotice', O: {} as IMessageType<Empty> } as MethodInfo<any, any>
+    ]
+    options = {}
+    getClosestPeers(_input: ClosestPeersRequest, _options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse> {
+        return {} as UnaryCall<ClosestPeersRequest, ClosestPeersResponse>
+    }
+    ping(_input: PingRequest, _options?: RpcOptions): UnaryCall <PingRequest, PingResponse> {
+        return {} as UnaryCall<PingRequest, PingResponse>
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    findData(_input: FindDataRequest, _options?: RpcOptions): UnaryCall<FindDataRequest, FindDataResponse> {
+        return {} as UnaryCall<FindDataRequest, FindDataResponse>
+    }
+
+    leaveNotice(_input: LeaveNotice, _options?: RpcOptions): UnaryCall<LeaveNotice, Empty> {
+        return {} as UnaryCall<LeaveNotice, Empty>
+    }
+}
+
+describe('SortedContactList', () => {
+    const serviceId = 'sorted'
+    const id0 = PeerID.fromValue(Buffer.from([0, 0, 0, 0]))
+    const id1 = PeerID.fromValue(Buffer.from([0, 0, 0, 1]))
+    const id2 = PeerID.fromValue(Buffer.from([0, 0, 0, 2]))
+    const id3 = PeerID.fromValue(Buffer.from([0, 0, 0, 3]))
+    const id4 = PeerID.fromValue(Buffer.from([0, 0, 0, 4]))
+
+    const descriptor0: PeerDescriptor = { kademliaId: id0.value, type: NodeType.NODEJS }
+    const descriptor1: PeerDescriptor = { kademliaId: id1.value, type: NodeType.NODEJS }
+    const descriptor2: PeerDescriptor = { kademliaId: id2.value, type: NodeType.NODEJS }
+    const descriptor3: PeerDescriptor = { kademliaId: id3.value, type: NodeType.NODEJS }
+    const descriptor4: PeerDescriptor = { kademliaId: id4.value, type: NodeType.NODEJS }
+
+    const peer1 = new DhtPeer(descriptor0, descriptor1, toProtoRpcClient(new MockRpcClient()), serviceId)
+    const peer2 = new DhtPeer(descriptor0, descriptor2, toProtoRpcClient(new MockRpcClient()), serviceId)
+    const peer3 = new DhtPeer(descriptor0, descriptor3, toProtoRpcClient(new MockRpcClient()), serviceId)
+    const peer4 = new DhtPeer(descriptor0, descriptor4, toProtoRpcClient(new MockRpcClient()), serviceId)
+
+    it('compares Ids correctly', async () => {
+        const list = new SortedContactList(id0, 10)
+        expect(list.compareIds(id0, id0)).toBe(0)
+        expect(list.compareIds(id1, id1)).toBe(0)
+        expect(list.compareIds(id0, id1)).toBe(-1)
+        expect(list.compareIds(id0, id2)).toBe(-2)
+        expect(list.compareIds(id1, id0)).toBe(1)
+        expect(list.compareIds(id2, id0)).toBe(2)
+        expect(list.compareIds(id2, id3)).toBe(-1)
+        expect(list.compareIds(id1, id4)).toBe(-3)
+    })
+    
+    it('orders itself correctly', async () => {
+
+        const list = new SortedContactList(id0, 10)
+
+        list.addContact(peer3)
+        list.addContact(peer2)
+        list.addContact(peer1)
+
+        const contacts = list.getUncontactedContacts(3)
+        expect(contacts.length).toEqual(3)
+        expect(contacts[0]).toEqual(peer1)
+        expect(contacts[1]).toEqual(peer2)
+        expect(contacts[2]).toEqual(peer3)
+    })
+    
+    it('handles contacted nodes correctly', async () => {
+        const list = new SortedContactList(id0, 10)
+
+        list.addContact(peer3)
+        list.addContact(peer2)
+        list.addContact(peer1)
+
+        list.setContacted(id2)
+        const contacts = list.getUncontactedContacts(3)
+        expect(contacts.length).toEqual(2)
+        expect(contacts[0]).toEqual(peer1)
+        expect(contacts[1]).toEqual(peer3)
+    })
+
+    it('cannot exceed maxSize', async () => {
+        const list = new SortedContactList(id0, 3)
+        list.addContact(peer4)
+        list.addContact(peer3)
+        list.addContact(peer2)
+        list.addContact(peer1)
+        expect(list.getSize()).toEqual(3)
+        expect(list.getContact(id4)).toBeFalsy()
+    })
+
+    it('removing contacts', async () => {
+        const list = new SortedContactList(id0, 8)
+        list.addContact(peer4)
+        list.addContact(peer3)
+        list.addContact(peer2)
+        list.addContact(peer1)
+        list.removeContact(id2)
+        expect(list.getSize()).toEqual(3)
+        expect(list.getContact(id2)).toBeFalsy()
+        expect(list.getContactIds()).toEqual(list.getContactIds().sort(list.compareIds))
+        const ret = list.removeContact(PeerID.fromValue(Buffer.from([0, 0, 0, 6])))
+        expect(ret).toEqual(false)
+    })
+})