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

package/test/unit/Finder.test.ts

@@ -1,110 +0,0 @@
-import {
-    Message,
-    MessageType,
-    NodeType,
-    PeerDescriptor,
-    RouteMessageAck,
-    RouteMessageWrapper
-} from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
-import {
-    createWrappedClosestPeersRequest,
-    createFindRequest
-} from '../utils/utils'
-import { Finder } from '../../src/dht/find/Finder'
-import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
-import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
-import { v4 } from 'uuid'
-import { MockRouter } from '../utils/mock/Router'
-import { MockTransport } from '../utils/mock/Transport'
-import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
-
-describe('Finder', () => {
-
-    let finder: Finder
-    let connections: Map<PeerIDKey, DhtNodeRpcRemote>
-
-    const peerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peerid').value,
-        type: NodeType.NODEJS
-    }
-    const peerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('destination').value,
-        type: NodeType.NODEJS
-    }
-    const findRequest = createFindRequest(false)
-    const message: Message = {
-        serviceId: 'unknown',
-        messageId: v4(),
-        messageType: MessageType.RPC,
-        body: {
-            oneofKind: 'findRequest',
-            findRequest
-        },
-        sourceDescriptor: peerDescriptor1,
-        targetDescriptor: peerDescriptor2
-    }
-    const routedMessage: RouteMessageWrapper = {
-        message,
-        requestId: 'REQ',
-        routingPath: [],
-        reachableThrough: [],
-        destinationPeer: peerDescriptor1,
-        sourcePeer: peerDescriptor2
-    }
-    const rpcCommunicator = new FakeRpcCommunicator()
-
-    beforeEach(() => {
-        connections = new Map()
-        finder = new Finder({
-            localPeerDescriptor: peerDescriptor1,
-            router: new MockRouter(),
-            connections,
-            serviceId: 'Finder',
-            localDataStore: new LocalDataStore(),
-            sessionTransport: new MockTransport(),
-            addContact: (_contact, _setActive) => {},
-            isPeerCloserToIdThanSelf: (_peer1, _compareToId) => true,
-            rpcCommunicator: rpcCommunicator as any
-        })
-    })
-
-    afterEach(() => {
-        finder.stop()
-    })
-
-    it('Finder server', async () => {
-        const res = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage) as RouteMessageAck
-        expect(res.error).toEqual('')
-    })
-
-    it('startFind with mode Node returns self if no peers', async () => {
-        const res = await finder.startFind(PeerID.fromString('find').value)
-        expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
-    })
-
-    it('Finder server throws if payload is not FindRequest', async () => {
-        const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
-        const badMessage: Message = {
-            serviceId: 'unknown',
-            messageId: v4(),
-            messageType: MessageType.RPC,
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: rpcWrapper
-            },
-            sourceDescriptor: peerDescriptor1,
-            targetDescriptor: peerDescriptor2
-        }
-        await expect(() => rpcCommunicator.callRpcMethod('routeFindRequest', {
-            message: badMessage,
-            requestId: 'REQ',
-            routingPath: [],
-            reachableThrough: [],
-            destinationPeer: peerDescriptor1,
-            sourcePeer: peerDescriptor2
-        })).rejects.toThrow()
-    })
-
-})

package/test/unit/PeerID.test.ts

@@ -1,22 +0,0 @@
-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/UUID.test.ts

@@ -1,55 +0,0 @@
-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('toHex', () => {
-        const stringId = v4()
-        const uuid = new UUID(stringId)
-        expect(uuid.toHex() === stringId.replaceAll('-', '')).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)
-    })
-})