@streamr/trackerless-network 102.0.0-beta.1 → 102.0.0-beta.2

package/test/unit/Handshaker.test.ts

@@ -1,69 +0,0 @@
-import { ListeningRpcCommunicator, Simulator, SimulatorTransport, toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { range } from 'lodash'
-import { NodeList } from '../../src/logic/NodeList'
-import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
-import { createMockContentDeliveryRpcRemote, createMockPeerDescriptor } from '../utils/utils'
-
-describe('Handshaker', () => {
-
-    let handshaker: Handshaker
-    const peerDescriptor = createMockPeerDescriptor()
-
-    const maxNeighborCount = 4
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-
-    let neighbors: NodeList
-    let leftNodeView: NodeList
-    let rightNodeView: NodeList
-    let nearbyNodeView: NodeList
-    let randomNodeView: NodeList
-
-    let simulator: Simulator
-    let simulatorTransport: SimulatorTransport
-    
-    beforeEach(async () => {
-        simulator = new Simulator()
-        simulatorTransport = new SimulatorTransport(peerDescriptor, simulator)
-        await simulatorTransport.start()
-        const rpcCommunicator = new ListeningRpcCommunicator(streamPartId, simulatorTransport)
-
-        const nodeId = toNodeId(peerDescriptor)
-        neighbors = new NodeList(nodeId, 10)
-        leftNodeView = new NodeList(nodeId, 20)
-        rightNodeView = new NodeList(nodeId, 20)
-        nearbyNodeView = new NodeList(nodeId, 20)
-        randomNodeView = new NodeList(nodeId, 20)
-
-        handshaker = new Handshaker({
-            localPeerDescriptor: peerDescriptor,
-            streamPartId,
-            neighbors,
-            leftNodeView,
-            rightNodeView,
-            nearbyNodeView,
-            randomNodeView,
-            rpcCommunicator,
-            maxNeighborCount,
-            rpcRequestTimeout: 5000,
-            ongoingHandshakes: new Set()
-        })
-    })
-
-    afterEach(async () => {
-        await simulatorTransport.stop()
-        simulator.stop()
-    })
-
-    it('attemptHandshakesOnContact works with empty structures', async () => {
-        const res = await handshaker.attemptHandshakesOnContacts([])
-        expect(res.length).toEqual(0)
-    })
-
-    it('attemptHandshakesOnContact with known nodes that cannot be connected to', async () => {
-        range(2).forEach(() => randomNodeView.add(createMockContentDeliveryRpcRemote()))
-        const res = await handshaker.attemptHandshakesOnContacts([])
-        expect(res.length).toEqual(2)
-    })
-
-})

package/test/unit/InspectSession.test.ts

@@ -1,83 +0,0 @@
-import { InspectSession, Events } from '../../src/logic/inspect/InspectSession'
-import { MessageID } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { waitForEvent3 } from '../../../utils/dist/src/waitForEvent3'
-import { utf8ToBinary } from '@streamr/utils'
-import { DhtAddress, randomDhtAddress } from '@streamr/dht'
-
-describe('InspectSession', () => {
-
-    let inspectSession: InspectSession
-    let inspectedNode: DhtAddress
-    let anotherNode: DhtAddress
-
-    const publisherId = utf8ToBinary('publisherId')
-    const messageId1: MessageID = {
-        streamId: 'stream',
-        messageChainId: 'messageChain0',
-        streamPartition: 0,
-        sequenceNumber: 0,
-        timestamp: 12345,
-        publisherId
-    }
-
-    const messageId2: MessageID = {
-        streamId: 'stream',
-        messageChainId: 'messageChain1',
-        streamPartition: 0,
-        sequenceNumber: 0,
-        timestamp: 12345,
-        publisherId
-    }
-
-    beforeEach(() => {
-        inspectedNode = randomDhtAddress()
-        anotherNode = randomDhtAddress()
-        inspectSession = new InspectSession({
-            inspectedNode
-        })
-    })
-
-    afterEach(() => {
-        inspectSession.stop()
-    })
-
-    it('should mark message', () => {
-        inspectSession.markMessage(inspectedNode, messageId1)
-        expect(inspectSession.getInspectedMessageCount()).toBe(1)
-        inspectSession.markMessage(inspectedNode, messageId2)
-        expect(inspectSession.getInspectedMessageCount()).toBe(2)
-    })
-
-    it('should emit done event when inspected node sends seen message', async () => {
-        inspectSession.markMessage(anotherNode, messageId1)
-        await Promise.all([
-            waitForEvent3<Events>(inspectSession, 'done', 100),
-            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-            inspectSession.markMessage(inspectedNode, messageId1)
-        ])
-        expect(inspectSession.getInspectedMessageCount()).toBe(1)
-    })
-
-    it('should emit done event another node sends message after inspected node', async () => {
-        inspectSession.markMessage(inspectedNode, messageId1)
-        await Promise.all([
-            waitForEvent3<Events>(inspectSession, 'done', 100),
-            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-            inspectSession.markMessage(anotherNode, messageId1)
-        ])
-        expect(inspectSession.getInspectedMessageCount()).toBe(1)
-    })
-
-    it('should not emit done if messageIds do not match', async () => {
-        inspectSession.markMessage(inspectedNode, messageId1)
-        await expect(async () => {
-            await Promise.all([
-                waitForEvent3<Events>(inspectSession, 'done', 100),
-                // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-                inspectSession.markMessage(anotherNode, messageId2)
-            ])
-        }).rejects.toThrow('waitForEvent3')
-        
-        expect(inspectSession.getInspectedMessageCount()).toBe(2)
-    })
-})

package/test/unit/Inspector.test.ts

@@ -1,51 +0,0 @@
-import { ListeningRpcCommunicator, randomDhtAddress, toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils, utf8ToBinary } from '@streamr/utils'
-import { Inspector } from '../../src/logic/inspect/Inspector'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor, mockConnectionLocker } from '../utils/utils'
-
-describe('Inspector', () => {
-    
-    let inspector: Inspector
-    const inspectorDescriptor = createMockPeerDescriptor()
-
-    const inspectedDescriptor = createMockPeerDescriptor()
-
-    const nodeId = randomDhtAddress()
-    let mockConnect: jest.Mock
-
-    const messageRef = {
-        streamId: 'stream',
-        messageChainId: 'messageChain0',
-        streamPartition: 0,
-        sequenceNumber: 0,
-        timestamp: 12345,
-        publisherId: utf8ToBinary('publisher')
-    }
-
-    beforeEach(() => {
-        mockConnect = jest.fn(() => {})
-        inspector = new Inspector({
-            localPeerDescriptor: inspectorDescriptor,
-            streamPartId: StreamPartIDUtils.parse('stream#0'),
-            rpcCommunicator: new ListeningRpcCommunicator('inspector', new MockTransport()),
-            connectionLocker: mockConnectionLocker,
-            openInspectConnection: async () => mockConnect()
-        })
-    })
-
-    afterEach(() => {
-        inspector.stop()
-    })
-
-    it('Opens inspection connection and runs successfully', async () => {
-        setTimeout(() => {
-            inspector.markMessage(toNodeId(inspectedDescriptor), messageRef)
-            inspector.markMessage(nodeId, messageRef)
-        }, 250)
-        await inspector.inspect(inspectedDescriptor)
-        expect(inspector.isInspected(toNodeId(inspectedDescriptor))).toBe(false)
-        expect(mockConnect).toHaveBeenCalledTimes(1)
-    })
-
-})

package/test/unit/NeighborFinder.test.ts

@@ -1,51 +0,0 @@
-import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
-import { NodeList } from '../../src/logic/NodeList'
-import { until } from '@streamr/utils'
-import { range } from 'lodash'
-import { expect } from 'expect'
-import { createMockContentDeliveryRpcRemote } from '../utils/utils'
-import { DhtAddress, randomDhtAddress, toNodeId } from '@streamr/dht'
-
-describe('NeighborFinder', () => {
-
-    const nodeId = randomDhtAddress()
-    let neighbors: NodeList
-    let nearbyNodeView: NodeList
-    let neighborFinder: NeighborFinder
-
-    const minCount = 4
-
-    beforeEach(() => {
-        neighbors = new NodeList(nodeId, 15)
-        nearbyNodeView = new NodeList(nodeId, 30)
-        range(30).forEach(() => nearbyNodeView.add(createMockContentDeliveryRpcRemote()))
-        const mockDoFindNeighbors = async (excluded: DhtAddress[]) => {
-            const target = nearbyNodeView.getRandom(excluded)
-            if (Math.random() < 0.5) {
-                neighbors.add(target!)
-            } else {
-                excluded.push(toNodeId(target!.getPeerDescriptor()))
-            }
-            return excluded
-        }
-        neighborFinder = new NeighborFinder({
-            neighbors,
-            nearbyNodeView,
-            leftNodeView: new NodeList(nodeId, 30),
-            rightNodeView: new NodeList(nodeId, 30),
-            randomNodeView: new NodeList(nodeId, 30),
-            doFindNeighbors: (excluded) => mockDoFindNeighbors(excluded),
-            minCount
-        })
-    })
-
-    afterEach(() => {
-        neighborFinder.stop()
-    })
-
-    it('Finds target number of nodes', async () => {
-        neighborFinder.start()
-        await until(() => neighbors.size() >= minCount, 10000)
-        expect(neighborFinder.isRunning()).toEqual(false)
-    })
-})

package/test/unit/NeighborUpdateRpcLocal.test.ts

@@ -1,139 +0,0 @@
-import { DhtAddress, ListeningRpcCommunicator, toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { range } from 'lodash'
-import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
-import { NodeList } from '../../src/logic/NodeList'
-import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
-import { NeighborUpdateRpcLocal } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcLocal'
-import { ContentDeliveryRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-describe('NeighborUpdateRpcLocal', () => {
-
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
-    const localPeerDescriptor = createMockPeerDescriptor()
-    const neighborTargetCount = 4
-
-    let rpcLocal: NeighborUpdateRpcLocal
-    let neighbors: NodeList
-    let nearbyNodeView: NodeList
-    let neighborFinder: NeighborFinder
-    let rpcCommunicator: ListeningRpcCommunicator
-    let ongoingHandshakes: Set<DhtAddress>
-
-    const addNeighbors = (count: number) => {
-        for (let i = 0; i < count; i++) {
-            neighbors.add(new ContentDeliveryRpcRemote(
-                localPeerDescriptor,
-                createMockPeerDescriptor(),
-                rpcCommunicator,
-                ContentDeliveryRpcClient
-            ))
-        }
-    }
-
-    beforeEach(() => {
-        rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
-        neighbors = new NodeList(toNodeId(localPeerDescriptor), neighborTargetCount + 1)
-        nearbyNodeView = new NodeList(toNodeId(localPeerDescriptor), neighborTargetCount)
-        neighborFinder = {
-            start: jest.fn()
-        } as any
-        ongoingHandshakes = new Set()
-
-        rpcLocal = new NeighborUpdateRpcLocal({
-            localPeerDescriptor,
-            neighbors,
-            nearbyNodeView,
-            neighborFinder,
-            streamPartId,
-            rpcCommunicator,
-            neighborTargetCount,
-            ongoingHandshakes
-        })
-    })
-
-    afterEach(() => {
-        rpcCommunicator.destroy()
-    })
-
-    it('response contains neighbor list of expected size', async () => {
-        addNeighbors(neighborTargetCount)
-        const res = await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: [localPeerDescriptor],
-            removeMe: false
-        }, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
-        expect(res.neighborDescriptors.length).toEqual(neighborTargetCount)
-    })
-
-    it('updates contacts based on callers neighbors', async () => {
-        addNeighbors(neighborTargetCount)
-        expect(nearbyNodeView.size()).toEqual(0)
-        await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: range(neighborTargetCount).map(() => createMockPeerDescriptor()),
-            removeMe: false
-        }, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
-        expect(nearbyNodeView.size()).toEqual(4)
-    })
-
-    it('does not ask to be removed if caller is a neighbor', async () => {
-        const caller = createMockPeerDescriptor()
-        const neighbor = new ContentDeliveryRpcRemote(
-            localPeerDescriptor,
-            caller,
-            rpcCommunicator,
-            ContentDeliveryRpcClient
-        )
-        neighbors.add(neighbor)
-        const res = await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: [localPeerDescriptor],
-            removeMe: false
-        }, { incomingSourceDescriptor: caller } as any)
-        expect(res.removeMe).toEqual(false)
-    })
-
-    it('asks to be removed if caller is not a neighbor', async () => {
-        const caller = createMockPeerDescriptor()
-        const res = await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: [localPeerDescriptor],
-            removeMe: false
-        }, { incomingSourceDescriptor: caller } as any)
-        expect(res.removeMe).toEqual(true)
-    })
-
-    it('asks to be removed if caller is a neighbor and both have too many neighbors', async () => {
-        const caller = createMockPeerDescriptor()
-        const neighbor = new ContentDeliveryRpcRemote(
-            localPeerDescriptor,
-            caller,
-            rpcCommunicator,
-            ContentDeliveryRpcClient
-        )
-        neighbors.add(neighbor)
-        addNeighbors(neighborTargetCount)
-        const res = await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: [localPeerDescriptor, ...range(neighborTargetCount).map(() => createMockPeerDescriptor())],
-            removeMe: false
-        }, { incomingSourceDescriptor: caller } as any)
-        expect(res.removeMe).toEqual(true)
-        expect(neighbors.has(toNodeId(caller))).toEqual(false)
-    })
-
-    it('does not ask to be removed if there is an ongoing handshake to the caller', async () => {
-        const caller = createMockPeerDescriptor()
-        ongoingHandshakes.add(toNodeId(caller))
-        const res = await rpcLocal.neighborUpdate({
-            streamPartId,
-            neighborDescriptors: [localPeerDescriptor],
-            removeMe: false
-        }, { incomingSourceDescriptor: caller } as any)
-        expect(res.removeMe).toEqual(false)
-    })
-
-})

package/test/unit/NetworkNode.test.ts

@@ -1,42 +0,0 @@
-import { StreamPartIDUtils } from '@streamr/utils'
-import { EventEmitter } from 'eventemitter3'
-import { NetworkNode } from '../../src/NetworkNode'
-import { NetworkStack } from '../../src/NetworkStack'
-import { Events } from '../../src/logic/ContentDeliveryManager'
-import { StreamMessage } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-const STREAM_PART = StreamPartIDUtils.parse('stream#0')
-const PUBLISHER_ID = randomUserId()
-
-const createMessage = (id: number): StreamMessage => {
-    return createStreamMessage(`${id}`, STREAM_PART, PUBLISHER_ID)
-}
-
-describe('NetworkNode', () => {
-
-    it('message listener', async () => {
-        const contentDeliveryManager = new EventEmitter<Events>()
-        const stack: Partial<NetworkStack> = {
-            getContentDeliveryManager: () => contentDeliveryManager as any,
-            joinStreamPart: async () => {}
-        }
-        const node = new NetworkNode(stack as any)
-        await node.join(STREAM_PART)
-        const onMessage = jest.fn()
-
-        node.addMessageListener(onMessage)
-        const msg1 = createMessage(1)
-        const msg2 = createMessage(2)
-        contentDeliveryManager.emit('newMessage', msg1)
-        contentDeliveryManager.emit('newMessage', msg2)
-        expect(onMessage.mock.calls[0][0]).toEqual(msg1)
-        expect(onMessage.mock.calls[1][0]).toEqual(msg2)
-        expect(onMessage).toHaveBeenCalledTimes(2)
-
-        node.removeMessageListener(onMessage)
-        contentDeliveryManager.emit('newMessage', createMessage(3))
-        expect(onMessage).toHaveBeenCalledTimes(2)
-    })
-})

package/test/unit/NodeList.test.ts

@@ -1,164 +0,0 @@
-import {
-    ListeningRpcCommunicator,
-    NodeType,
-    PeerDescriptor,
-    randomDhtAddress,
-    toDhtAddress,
-    toNodeId,
-} from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { expect } from 'expect'
-import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
-import { NodeList } from '../../src/logic/NodeList'
-import { formStreamPartContentDeliveryServiceId } from '../../src/logic/formStreamPartDeliveryServiceId'
-import { ContentDeliveryRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockContentDeliveryRpcRemote, createMockPeerDescriptor } from '../utils/utils'
-
-const streamPartId = StreamPartIDUtils.parse('stream#0')
-
-describe('NodeList', () => {
-
-    const ids = [
-        new Uint8Array([1, 1, 1]),
-        new Uint8Array([1, 1, 2]),
-        new Uint8Array([1, 1, 3]),
-        new Uint8Array([1, 1, 4]),
-        new Uint8Array([1, 1, 5])
-    ]
-    const ownId = randomDhtAddress()
-    let nodeList: NodeList
-
-    const createRemoteGraphNode = (peerDescriptor: PeerDescriptor) => {
-        const mockCommunicator = new ListeningRpcCommunicator(formStreamPartContentDeliveryServiceId(streamPartId), new MockTransport())
-        return new ContentDeliveryRpcRemote(
-            createMockPeerDescriptor(),
-            peerDescriptor,
-            mockCommunicator,
-            ContentDeliveryRpcClient
-        )
-    }
-
-    beforeEach(() => {
-        nodeList = new NodeList(ownId, 6)
-        for (const id of ids) {
-            const peerDescriptor: PeerDescriptor = {
-                nodeId: id,
-                type: NodeType.NODEJS
-            }
-            nodeList.add(createRemoteGraphNode(peerDescriptor))
-        }
-    })
-
-    it('add', () => {
-        const newDescriptor = {
-            nodeId: new Uint8Array([1, 2, 3]),
-            type: NodeType.NODEJS
-        }
-        const newNode = createRemoteGraphNode(newDescriptor)
-        nodeList.add(newNode)
-        expect(nodeList.has(toNodeId(newDescriptor))).toEqual(true)
-
-        const newDescriptor2 = {
-            nodeId: new Uint8Array([1, 2, 4]),
-            type: NodeType.NODEJS
-        }
-        const newNode2 = createRemoteGraphNode(newDescriptor2)
-        nodeList.add(newNode2)
-        expect(nodeList.has(toNodeId(newDescriptor2))).toEqual(false)
-    })
-
-    it('remove', () => {
-        const toRemove = nodeList.getFirst([])
-        const nodeId = toNodeId(toRemove!.getPeerDescriptor())
-        nodeList.remove(nodeId)
-        expect(nodeList.has(nodeId)).toEqual(false)
-    })
-
-    it('getFirst', () => {
-        const closest = nodeList.getFirst([])
-        expect(toNodeId(closest!.getPeerDescriptor()))
-            .toEqual(toDhtAddress(new Uint8Array([1, 1, 1])))
-    })
-
-    it('getFirst with exclude', () => {
-        const closest = nodeList.getFirst([toDhtAddress(new Uint8Array([1, 1, 1]))])
-        expect(toNodeId(closest!.getPeerDescriptor()))
-            .toEqual(toDhtAddress(new Uint8Array([1, 1, 2])))
-    })
-
-    it('getFirst wsOnly', () => {
-        nodeList.add(createMockContentDeliveryRpcRemote(createMockPeerDescriptor({ websocket: { port: 111, host: '', tls: false } })))
-        const closest = nodeList.getFirst([], true)
-        expect(closest).toBeDefined()
-    })
-
-    it('getLast', () => {
-        const closest = nodeList.getLast([])
-        expect(toNodeId(closest!.getPeerDescriptor()))
-            .toEqual(toDhtAddress(new Uint8Array([1, 1, 5])))
-    })
-
-    it('getLast with exclude', () => {
-        const closest = nodeList.getLast([toDhtAddress(new Uint8Array([1, 1, 5]))])
-        expect(toNodeId(closest!.getPeerDescriptor()))
-            .toEqual(toDhtAddress(new Uint8Array([1, 1, 4])))
-    })
-
-    it('getFirstAndLast', () => {
-        const results = nodeList.getFirstAndLast([])
-        expect(results).toEqual([nodeList.getFirst([]), nodeList.getLast([])])
-    })
-
-    it('getFirst empty', () => {
-        const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getFirst([])).toBeUndefined()
-    })
-
-    it('getLast empty', () => {
-        const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getLast([])).toBeUndefined()
-    })
-
-    it('getRandom empty', () => {
-        const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getRandom([])).toBeUndefined()
-    })
-
-    it('getFirstAndLast empty', () => {
-        const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getFirstAndLast([])).toEqual([])
-    })
-
-    it('getFirstAndLast with exclude', () => {
-        const results = nodeList.getFirstAndLast([
-            toDhtAddress(new Uint8Array([1, 1, 1])),
-            toDhtAddress(new Uint8Array([1, 1, 5]))
-        ])
-        expect(results).toEqual([
-            nodeList.getFirst([toDhtAddress(new Uint8Array([1, 1, 1]))]),
-            nodeList.getLast([toDhtAddress(new Uint8Array([1, 1, 5]))])
-        ])
-    })
-
-    it('items are in insertion order', () => {
-        const list = new NodeList(randomDhtAddress(), 100)
-        const item1 = createRemoteGraphNode(createMockPeerDescriptor())
-        const item2 = createRemoteGraphNode(createMockPeerDescriptor())
-        const item3 = createRemoteGraphNode(createMockPeerDescriptor())
-        const item4 = createRemoteGraphNode(createMockPeerDescriptor())
-        const item5 = createRemoteGraphNode(createMockPeerDescriptor())
-        const item6 = createRemoteGraphNode(createMockPeerDescriptor())
-        list.add(item2)
-        list.add(item3)
-        list.add(item1)
-        list.add(item6)
-        list.add(item4)
-        list.add(item5)
-        expect(list.getFirst([])!).toEqual(item2)
-        expect(list.getLast([])!).toEqual(item5)
-        // the order doesn't change if item re-added
-        list.add(item4)
-        expect(list.getLast([])!).toEqual(item5)
-    })
-})

package/test/unit/NumberPair.test.ts

@@ -1,22 +0,0 @@
-import { NumberPair } from '../../src/logic/DuplicateMessageDetector'
-
-test('equalTo', () => {
-    expect(new NumberPair(5, 2).equalTo(new NumberPair(5, 3))).toEqual(false)
-    expect(new NumberPair(5, 2).equalTo(new NumberPair(5, 2))).toEqual(true)
-})
-
-test('greaterThan', () => {
-    expect(new NumberPair(5, 2).greaterThan(new NumberPair(6, 2))).toEqual(false)
-    expect(new NumberPair(5, 2).greaterThan(new NumberPair(5, 3))).toEqual(false)
-    expect(new NumberPair(5, 2).greaterThan(new NumberPair(5, 2))).toEqual(false)
-    expect(new NumberPair(5, 2).greaterThan(new NumberPair(5, 1))).toEqual(true)
-    expect(new NumberPair(5, 2).greaterThan(new NumberPair(3, 2))).toEqual(true)
-})
-
-test('greaterThanOrEqual', () => {
-    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(6, 2))).toEqual(false)
-    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(5, 3))).toEqual(false)
-    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(5, 2))).toEqual(true)
-    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(5, 1))).toEqual(true)
-    expect(new NumberPair(5, 2).greaterThanOrEqual(new NumberPair(3, 2))).toEqual(true)
-})