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

package/test/unit/ContentDeliveryManager.test.ts

@@ -1,95 +0,0 @@
-import { areEqualPeerDescriptors } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
-import { ContentDeliveryManager } from '../../src/logic/ContentDeliveryManager'
-import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { MockControlLayerNode } from '../utils/mock/MockControlLayerNode'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor, createStreamMessage, mockConnectionLocker } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('ContentDeliveryManager', () => {
-
-    let manager: ContentDeliveryManager
-    const peerDescriptor = createMockPeerDescriptor()
-
-    beforeEach(async () => {
-        manager = new ContentDeliveryManager({})
-        const mockLayer0 = new MockControlLayerNode(peerDescriptor)
-        await manager.start(mockLayer0, new MockTransport(), mockConnectionLocker)
-    })
-
-    afterEach(async () => {
-        await manager.destroy()
-    })
-
-    it('PeerDescriptor is correct', () => {
-        expect(areEqualPeerDescriptors(peerDescriptor, manager.getPeerDescriptor()))
-    })
-
-    describe('join and leave', () => {
-
-        const streamPartId = StreamPartIDUtils.parse('stream#0')
-        const message = createStreamMessage(
-            JSON.stringify({ hello: 'WORLD' }),
-            streamPartId,
-            randomUserId()
-        )
-
-        beforeEach(async () => {
-            manager.setStreamPartEntryPoints(streamPartId, [manager.getPeerDescriptor()])
-        })
-
-        it('can join stream part', async () => {
-            manager.joinStreamPart(streamPartId)
-            expect(manager.hasStreamPart(streamPartId)).toEqual(true)
-        })
-
-        it('can leave stream part', async () => {
-            manager.joinStreamPart(streamPartId)
-            expect(manager.hasStreamPart(streamPartId)).toEqual(true)
-            await manager.leaveStreamPart(streamPartId)
-            expect(manager.hasStreamPart(streamPartId)).toEqual(false)
-        })
-
-        it('broadcast joins stream', async () => {
-            manager.broadcast(message)
-            await waitForCondition(() => manager.hasStreamPart(streamPartId))
-        })
-    })
-
-    describe('proxied stream', () => {
-        it('happy path', async () => {
-            const streamPartId = StreamPartIDUtils.parse('stream#0')
-            const proxy = createMockPeerDescriptor()
-            const userId = randomUserId()
-            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
-            await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
-        })
-
-        it('empty node list', async () => {
-            const streamPartId = StreamPartIDUtils.parse('stream#0')
-            const proxy = createMockPeerDescriptor()
-            const userId = randomUserId()
-            await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
-            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
-            await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
-        })
-
-        it('connection count to 0', async () => {
-            const streamPartId = StreamPartIDUtils.parse('stream#0')
-            const proxy = createMockPeerDescriptor()
-            const userId = randomUserId()
-            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId, 0)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
-            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
-            await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId, 0)
-            expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
-        })
-    })
-})

package/test/unit/ContentDeliveryRpcLocal.test.ts

@@ -1,60 +0,0 @@
-import { ListeningRpcCommunicator } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/utils'
-import { ContentDeliveryRpcLocal } from '../../src/logic/ContentDeliveryRpcLocal'
-import { LeaveStreamPartNotice } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { randomUserId } from '@streamr/test-utils'
-
-describe('ContentDeliveryRpcLocal', () => {
-
-    let rpcLocal: ContentDeliveryRpcLocal
-    const peerDescriptor = createMockPeerDescriptor()
-
-    const mockSender = createMockPeerDescriptor()
-
-    const message = createStreamMessage(
-        JSON.stringify({ hello: 'WORLD' }),
-        StreamPartIDUtils.parse('random-graph#0'),
-        randomUserId()
-    )
-
-    let mockBroadcast: jest.Mock
-    let mockDuplicateCheck: jest.Mock
-    let mockOnLeaveNotice: jest.Mock
-    let mockMarkForInspection: jest.Mock
-
-    beforeEach(async () => {
-        mockDuplicateCheck = jest.fn((_c, _p) => true)
-        mockBroadcast = jest.fn((_m, _p) => {})
-        mockOnLeaveNotice = jest.fn((_m) => {})
-        mockMarkForInspection = jest.fn((_m) => {})
-
-        rpcLocal = new ContentDeliveryRpcLocal({
-            markAndCheckDuplicate: mockDuplicateCheck,
-            broadcast: mockBroadcast,
-            onLeaveNotice: mockOnLeaveNotice,
-            markForInspection: mockMarkForInspection,
-            localPeerDescriptor: peerDescriptor,
-            streamPartId: StreamPartIDUtils.parse('stream#0'),
-            rpcCommunicator: new ListeningRpcCommunicator('random-graph-node', new MockTransport())
-        })
-    })
-    
-    it('Server sendStreamMessage()', async () => {
-        await rpcLocal.sendStreamMessage(message, { incomingSourceDescriptor: mockSender } as any)
-        expect(mockDuplicateCheck).toHaveBeenCalledTimes(1)
-        expect(mockBroadcast).toHaveBeenCalledTimes(1)
-        expect(mockMarkForInspection).toHaveBeenCalledTimes(1)
-    })
-
-    it('Server leaveStreamPartNotice()', async () => {
-        const leaveNotice: LeaveStreamPartNotice = {
-            streamPartId: StreamPartIDUtils.parse('stream#0'),
-            isEntryPoint: false
-        }
-        await rpcLocal.leaveStreamPartNotice(leaveNotice, { incomingSourceDescriptor: mockSender } as any)
-        expect(mockOnLeaveNotice).toHaveBeenCalledTimes(1)
-    })
-
-})

package/test/unit/DuplicateMessageDetector.test.ts

@@ -1,192 +0,0 @@
-import { DuplicateMessageDetector, NumberPair, GapMisMatchError, InvalidNumberingError } from '../../src/logic/DuplicateMessageDetector'
-
-test('starts empty', () => {
-    const detector = new DuplicateMessageDetector()
-    expect(detector.toString()).toEqual('')
-})
-
-test('first check initializes default gap', () => {
-    const detector = new DuplicateMessageDetector()
-    const result = detector.markAndCheck(new NumberPair(1, 5), new NumberPair(10, 10))
-    const state = detector.toString()
-    expect(result).toEqual(true)
-    expect(state).toEqual('(10|10, Infinity|Infinity]')
-})
-
-test('checking numbers in order introduces no new gaps', () => {
-    const detector = new DuplicateMessageDetector()
-    detector.markAndCheck(null, new NumberPair(10, 0))
-    expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0))).toEqual(true)
-    expect(detector.markAndCheck(new NumberPair(20, 0), new NumberPair(30, 0))).toEqual(true)
-    expect(detector.markAndCheck(null, new NumberPair(30, 1))).toEqual(true)
-    expect(detector.markAndCheck(new NumberPair(30, 1), new NumberPair(30, 5))).toEqual(true)
-    const state = detector.toString()
-    expect(state).toEqual('(30|5, Infinity|Infinity]')
-})
-
-test('skipping next expected messages creates gaps', () => {
-    const detector = new DuplicateMessageDetector()
-    detector.markAndCheck(null, new NumberPair(10, 0))
-
-    expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 0))).toEqual(true)
-    expect(detector.toString()).toEqual('(10|0, 15|0], (20|0, Infinity|Infinity]')
-
-    expect(detector.markAndCheck(new NumberPair(30, 0), new NumberPair(40, 0))).toEqual(true)
-    expect(detector.toString()).toEqual('(10|0, 15|0], (20|0, 30|0], (40|0, Infinity|Infinity]')
-
-    expect(detector.markAndCheck(new NumberPair(40, 10), new NumberPair(80, 20))).toEqual(true)
-    expect(detector.toString()).toEqual('(10|0, 15|0], (20|0, 30|0], (40|0, 40|10], (80|20, Infinity|Infinity]')
-})
-
-test('only last gap is checked if no previous number given', () => {
-    const detector = new DuplicateMessageDetector()
-    detector.markAndCheck(null, new NumberPair(10, 0))
-    detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0))
-
-    expect(detector.markAndCheck(null, new NumberPair(15, 0))).toEqual(false)
-    expect(detector.markAndCheck(null, new NumberPair(30, 5))).toEqual(true)
-    const state = detector.toString()
-    expect(state).toEqual('(30|5, Infinity|Infinity]')
-})
-
-describe('gap handling', () => {
-    let detector: DuplicateMessageDetector
-    beforeEach(() => {
-        detector = new DuplicateMessageDetector()
-        detector.markAndCheck(null, new NumberPair(10, 0))
-        detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
-        detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
-        expect(detector.toString()).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-    })
-
-    test('gap division', () => {
-        expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(18, 0)))
-        expect(detector.toString()).toEqual('(10|0, 15|0], (18|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-
-        expect(detector.markAndCheck(new NumberPair(60, 0), new NumberPair(79, 5)))
-        expect(detector.toString()).toEqual('(10|0, 15|0], (18|0, 20|0], (40|0, 60|0], (79|5, 80|10], (100|0, Infinity|Infinity]')
-    })
-
-    test('left-side gap contraction', () => {
-        expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(15, 0))).toEqual(true)
-        expect(detector.toString()).toEqual('(15|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-
-        expect(detector.markAndCheck(new NumberPair(40, 0), new NumberPair(80, 9))).toEqual(true)
-        expect(detector.toString()).toEqual('(15|0, 20|0], (80|9, 80|10], (100|0, Infinity|Infinity]')
-    })
-
-    test('right-side gap contraction', () => {
-        expect(detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 0))).toEqual(true)
-        expect(detector.toString()).toEqual('(10|0, 15|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-
-        expect(detector.markAndCheck(new NumberPair(40, 1), new NumberPair(80, 10))).toEqual(true)
-        expect(detector.toString()).toEqual('(10|0, 15|0], (40|0, 40|1], (100|0, Infinity|Infinity]')
-    })
-
-    test('full contraction', () => {
-        expect(detector.markAndCheck(new NumberPair(40, 0), new NumberPair(80, 10)))
-        expect(detector.toString()).toEqual('(10|0, 20|0], (100|0, Infinity|Infinity]')
-
-        expect(detector.markAndCheck(new NumberPair(10, 0), new NumberPair(20, 0)))
-        expect(detector.toString()).toEqual('(100|0, Infinity|Infinity]')
-    })
-})
-
-describe('duplicates return false and do not change state', () => {
-    let detector: DuplicateMessageDetector
-    let expectedState: string
-    beforeEach(() => {
-        detector = new DuplicateMessageDetector()
-        detector.markAndCheck(new NumberPair(1, 0), new NumberPair(10, 0))
-        detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
-        detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
-        expectedState = detector.toString()
-        expect(expectedState).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-    })
-
-    it('way below 1st gap', () => {
-        expect(detector.markAndCheck(new NumberPair(5, 0), new NumberPair(7, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('number touches lower bound of 1st gap', () => {
-        expect(detector.markAndCheck(new NumberPair(8, 0), new NumberPair(10, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('in-between gaps', () => {
-        expect(detector.markAndCheck(new NumberPair(25, 5), new NumberPair(30, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('number touches lower bound of 2nd gap', () => {
-        expect(detector.markAndCheck(new NumberPair(25, 0), new NumberPair(40, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('previous number touches upper bound of 2nd gap', () => {
-        expect(detector.markAndCheck(new NumberPair(80, 10), new NumberPair(90, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('previous number not provided, number is below last gap', () => {
-        expect(detector.markAndCheck(null, new NumberPair(80, 10))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-
-    it('previous number not provided, number touches lower bound of last gap', () => {
-        expect(detector.markAndCheck(null, new NumberPair(100, 0))).toEqual(false)
-        expect(detector.toString()).toEqual(expectedState)
-    })
-})
-
-describe('erroneous messages that overlap gaps', () => {
-    let detector: DuplicateMessageDetector
-    let expectedState
-    beforeEach(() => {
-        detector = new DuplicateMessageDetector()
-        detector.markAndCheck(new NumberPair(1, 0), new NumberPair(10, 0))
-        detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
-        detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
-        expectedState = detector.toString()
-        expect(expectedState).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-    })
-
-    it('completely around gap', () => {
-        expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(30, 0))).toThrowError(GapMisMatchError)
-    })
-
-    it('previousNumber below gap while number in gap', () => {
-        expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(15, 0))).toThrowError(GapMisMatchError)
-    })
-
-    it('previousNumber in gap while number over gap', () => {
-        expect(() => detector.markAndCheck(new NumberPair(15, 0), new NumberPair(20, 5))).toThrowError(GapMisMatchError)
-    })
-
-    it('completely around multiple gaps', () => {
-        expect(() => detector.markAndCheck(new NumberPair(10, 0), new NumberPair(200, 0))).toThrowError(GapMisMatchError)
-    })
-})
-
-test('checks that number > previousNumber', () => {
-    const detector = new DuplicateMessageDetector()
-    expect(() => detector.markAndCheck(new NumberPair(5, 0), new NumberPair(1, 0)))
-        .toThrowError(InvalidNumberingError)
-    expect(() => detector.markAndCheck(new NumberPair(5, 5), new NumberPair(5, 5)))
-        .toThrowError(InvalidNumberingError)
-})
-
-test('lowest gaps get dropped when reaching maximum number of gaps', () => {
-    const detector = new DuplicateMessageDetector(3)
-    detector.markAndCheck(new NumberPair(1, 0), new NumberPair(10, 0))
-    detector.markAndCheck(new NumberPair(20, 0), new NumberPair(40, 0))
-    detector.markAndCheck(new NumberPair(80, 10), new NumberPair(100, 0))
-    expect(detector.toString()).toEqual('(10|0, 20|0], (40|0, 80|10], (100|0, Infinity|Infinity]')
-
-    detector.markAndCheck(new NumberPair(150, 0), new NumberPair(200, 0))
-    expect(detector.toString()).toEqual('(40|0, 80|10], (100|0, 150|0], (200|0, Infinity|Infinity]')
-
-    detector.markAndCheck(new NumberPair(50, 0), new NumberPair(70, 0))
-    expect(detector.toString()).toEqual('(70|0, 80|10], (100|0, 150|0], (200|0, Infinity|Infinity]')
-})

package/test/unit/ExternalNetworkRpc.test.ts

@@ -1,48 +0,0 @@
-import { Message } from '@streamr/dht'
-import { ExternalNetworkRpc, SERVICE_ID } from '../../src/logic/ExternalNetworkRpc'
-import { HandshakeRequest, HandshakeResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { MockTransport } from '../utils/mock/MockTransport'
-import { RpcMessage } from '@streamr/proto-rpc'
-import { Any } from '../../src/proto/google/protobuf/any'
-import { HandshakeRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-
-describe('ExternalNetworkRpc', () => {
-
-    let rpc: ExternalNetworkRpc
-    let fn: jest.Mock
-    let transport: MockTransport
-
-    beforeEach(() => {
-        transport = new MockTransport
-        rpc = new ExternalNetworkRpc(transport)
-        fn = jest.fn()
-    })
-
-    afterEach(() => {
-        rpc.destroy()
-    })
-
-    it('registers method', async () => {
-        rpc.registerRpcMethod(HandshakeRequest, HandshakeResponse, 'handshake', () => fn())
-        transport.emit('message', Message.create({
-            serviceId: SERVICE_ID,
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create({
-                    header: {
-                        request: 'request',
-                        method: 'handshake'
-                    },
-                    body: Any.pack(HandshakeRequest.create(), HandshakeRequest)
-                })
-            }
-        }))
-        expect(fn).toHaveBeenCalledTimes(1)
-    })
-
-    it('creates clients', async () => {
-        const client = rpc.createRpcClient(HandshakeRpcClient)
-        expect(client.methods.length).toEqual(2)
-    })
-
-})

package/test/unit/FifoMapWithTtl.test.ts

@@ -1,253 +0,0 @@
-import { FifoMapWithTTL } from '../../src/logic/propagation/FifoMapWithTTL'
-
-describe('FifoMapWithTtl', () => {
-    describe('invalid constructor arguments', () => {
-        it('cannot instantiate with negative ttl', () => {
-            expect(() => new FifoMapWithTTL({ ttlInMs: -5, maxSize: 10 }))
-                .toThrow('ttlInMs (-5) cannot be < 0')
-        })
-
-        it('cannot instantiate with negative maxSize', () => {
-            expect(() => new FifoMapWithTTL({ ttlInMs: 100, maxSize: -6 }))
-                .toThrow('maxSize (-6) cannot be < 0')
-        })
-    })
-
-    it('of maxSize=0 always remains empty', () => {
-        const fifoMap = new FifoMapWithTTL<string, string>({
-            ttlInMs: 100,
-            maxSize: 0
-        })
-        fifoMap.set('hello', 'world')
-        fifoMap.set('are', 'you empty?')
-        expect(fifoMap.get('hello')).toBeUndefined()
-        expect(fifoMap.get('are')).toBeUndefined()
-    })
-
-    describe('of maxSize=5', () => {
-        let fifoMap: FifoMapWithTTL<string, string>
-
-        beforeEach(() => {
-            fifoMap = new FifoMapWithTTL<string, string>({
-                ttlInMs: 100,
-                maxSize: 5
-            })
-        })
-
-        function setFirstFiveMessages() {
-            fifoMap.set('1st', 'foo')
-            fifoMap.set('2nd', 'bar')
-            fifoMap.set('3rd', 'hello')
-            fifoMap.set('4th', 'world')
-            fifoMap.set('5th', '!')
-        }
-
-        function set6thAnd7thMessages() {
-            fifoMap.set('6th', 'new')
-            fifoMap.set('7th', 'messages')
-        }
-
-        it('can insert 5 items and retrieve all of them', () => {
-            setFirstFiveMessages()
-            expect(fifoMap.get('1st')).toEqual('foo')
-            expect(fifoMap.get('2nd')).toEqual('bar')
-            expect(fifoMap.get('3rd')).toEqual('hello')
-            expect(fifoMap.get('4th')).toEqual('world')
-            expect(fifoMap.get('5th')).toEqual('!')
-        })
-
-        it('inserting items when full causes oldest items to get dropped', () => {
-            setFirstFiveMessages()
-            set6thAnd7thMessages()
-            expect(fifoMap.get('1st')).toBeUndefined()
-            expect(fifoMap.get('2nd')).toBeUndefined()
-            expect(fifoMap.get('3rd')).toEqual('hello')
-            expect(fifoMap.get('4th')).toEqual('world')
-            expect(fifoMap.get('5th')).toEqual('!')
-            expect(fifoMap.get('6th')).toEqual('new')
-            expect(fifoMap.get('7th')).toEqual('messages')
-        })
-
-        describe('(re-)setting an item', () => {
-            beforeEach(() => {
-                setFirstFiveMessages()
-                fifoMap.set('4th', 'modified-once')
-                fifoMap.set('4th', 'modified-twice')
-            })
-
-            it('does not cause oldest items to drop', () => {
-                expect(fifoMap.get('1st')).toEqual('foo')
-                expect(fifoMap.get('2nd')).toEqual('bar')
-                expect(fifoMap.get('3rd')).toEqual('hello')
-                expect(fifoMap.get('5th')).toEqual('!')
-            })
-
-            it('newest value stays in place', () => {
-                expect(fifoMap.get('4th')).toEqual('modified-twice')
-            })
-        })
-
-        describe('#delete', () => {
-            it('can delete an item', () => {
-                setFirstFiveMessages()
-                fifoMap.delete('4th')
-                expect(fifoMap.get('1st')).toEqual('foo')
-                expect(fifoMap.get('2nd')).toEqual('bar')
-                expect(fifoMap.get('3rd')).toEqual('hello')
-                expect(fifoMap.get('4th')).toBeUndefined()
-                expect(fifoMap.get('5th')).toEqual('!')
-            })
-
-            it('deleting items makes room for new ones', () => {
-                setFirstFiveMessages()
-                fifoMap.delete('2nd')
-                fifoMap.delete('4th')
-                set6thAnd7thMessages()
-                expect(fifoMap.get('1st')).toEqual('foo')
-                expect(fifoMap.get('2nd')).toBeUndefined()
-                expect(fifoMap.get('3rd')).toEqual('hello')
-                expect(fifoMap.get('4th')).toBeUndefined()
-                expect(fifoMap.get('5th')).toEqual('!')
-                expect(fifoMap.get('6th')).toEqual('new')
-                expect(fifoMap.get('7th')).toEqual('messages')
-            })
-
-            it('deleting a non-existing item does not throw', () => {
-                setFirstFiveMessages()
-                expect(() =>fifoMap.delete('non-existing-key')).not.toThrow()
-            })
-
-            it('deleting a non-existing item keeps existing items intact', () => {
-                setFirstFiveMessages()
-                fifoMap.delete('non-existing-key')
-                expect(fifoMap.get('1st')).toEqual('foo')
-                expect(fifoMap.get('2nd')).toEqual('bar')
-                expect(fifoMap.get('3rd')).toEqual('hello')
-                expect(fifoMap.get('4th')).toEqual('world')
-                expect(fifoMap.get('5th')).toEqual('!')
-            })
-        })
-
-        describe('TTL', () => {
-            let time: number
-
-            beforeEach(() => {
-                time = 0
-                fifoMap = new FifoMapWithTTL<string, string>({
-                    ttlInMs: 100,
-                    maxSize: 5,
-                    timeProvider: () => time
-                })
-            })
-
-            it('#get returns undefined after TTL', () => {
-                time = 0
-                fifoMap.set('hello', 'world')
-                time = 50
-                fifoMap.set('foo', 'bar')
-
-                time = 100
-                expect(fifoMap.get('hello')).toBeUndefined()
-                expect(fifoMap.get('foo')).toEqual('bar')
-
-                time = 160
-                expect(fifoMap.get('hello')).toBeUndefined()
-                expect(fifoMap.get('foo')).toBeUndefined()
-            })
-
-            it('re-setting an item resets TTL', () => {
-                time = 0
-                fifoMap.set('hello', 'world')
-
-                time = 90
-                fifoMap.set('hello', 'world')
-
-                time = 100
-                expect(fifoMap.get('hello')).toEqual('world')
-            })
-
-            it('re-setting expired resets TTL', () => {
-                time = 0
-                fifoMap.set('hello', 'world')
-
-                time = 110
-                expect(fifoMap.get('hello')).toBeUndefined() // sanity check
-                fifoMap.set('hello', 'world')
-
-                time = 150
-                expect(fifoMap.get('hello')).toEqual('world')
-            })
-
-            it('#values returns non-expired items', () => {
-                time = 0
-                fifoMap.set('hello', 'world')
-                time = 50
-                fifoMap.set('foo', 'bar')
-                time = 100
-                fifoMap.set('lorem', 'ipsum')
-                time = 120
-                fifoMap.set('dolor', 'sit')
-
-                expect(fifoMap.values()).toEqual(['bar', 'ipsum', 'sit'])
-
-                time = 130
-                fifoMap.set('amet', 'consectetur')
-
-                expect(fifoMap.values()).toEqual(['bar', 'ipsum', 'sit', 'consectetur'])
-
-                time = 200
-                expect(fifoMap.values()).toEqual(['sit', 'consectetur'])
-
-                time = 300
-                expect(fifoMap.values()).toEqual([])
-            })
-        })
-
-        describe('onItemDropped callback', () => {
-            let time: number
-            let onItemDropped: jest.Mock<undefined, [string]>
-
-            beforeEach(() => {
-                time = 0
-                onItemDropped = jest.fn<undefined, [string]>()
-                fifoMap = new FifoMapWithTTL<string, string>({
-                    ttlInMs: 100,
-                    maxSize: 5,
-                    onItemDropped,
-                    timeProvider: () => time
-                })
-            })
-
-            it('invoked when deleting an item', () => {
-                setFirstFiveMessages()
-                fifoMap.delete('3rd')
-                expect(onItemDropped).toHaveBeenCalledTimes(1)
-                expect(onItemDropped).toHaveBeenCalledWith('3rd')
-            })
-
-            it('invoked when items are dropped due to being full', () => {
-                setFirstFiveMessages()
-                set6thAnd7thMessages()
-                expect(onItemDropped).toHaveBeenCalledTimes(2)
-                expect(onItemDropped).toHaveBeenNthCalledWith(1, '1st')
-                expect(onItemDropped).toHaveBeenNthCalledWith(2, '2nd')
-            })
-
-            it('invoked when re-setting an item', () => {
-                setFirstFiveMessages()
-                fifoMap.set('4th', '!!!')
-                expect(onItemDropped).toHaveBeenCalledTimes(1)
-                expect(onItemDropped).toHaveBeenNthCalledWith(1, '4th')
-            })
-
-            it('invoked when getting a stale item', () => {
-                time = 0
-                setFirstFiveMessages()
-                time = 500
-                expect(fifoMap.get('1st')).toBeUndefined()
-                expect(onItemDropped).toHaveBeenCalledTimes(1)
-                expect(onItemDropped).toHaveBeenNthCalledWith(1, '1st')
-            })
-        })
-    })
-})