Files
orca/src/shared/bounded-map.test.ts
T

159 lines
5.0 KiB
TypeScript

import { describe, expect, it, vi } from 'vitest'
import { BoundedMap } from './bounded-map'
describe('BoundedMap', () => {
it('get() marks recently-used so it survives eviction', () => {
const m = new BoundedMap<string, number>({ maxEntries: 3 })
m.set('a', 1)
m.set('b', 2)
m.set('c', 3)
expect(m.get('a')).toBe(1) // 'a' now most-recent
m.set('d', 4) // evicts oldest, which is now 'b' not 'a'
expect(m.has('a')).toBe(true)
expect(m.has('b')).toBe(false)
})
it('bounds aggregate retained bytes and evicts to fit', () => {
const m = new BoundedMap<string, string>({
maxEntries: 100,
maxBytes: 10,
sizeOf: (v) => v.length
})
m.set('a', 'xxxxx') // 5
m.set('b', 'yyyyy') // 5 -> total 10 (exactly at cap)
expect(m.retainedBytes).toBe(10)
expect(m.size).toBe(2)
m.set('c', 'z') // 11 > 10 -> evict oldest until <= 10
expect(m.retainedBytes).toBeLessThanOrEqual(10)
expect(m.has('a')).toBe(false)
expect(m.has('c')).toBe(true)
})
it('never reports success for an entry it did not retain', () => {
const onEvict = vi.fn()
// An entry ceiling above total once admitted then evicted the same key while set returned true.
const m = new BoundedMap<string, string>({
maxEntries: 10,
maxBytes: 3,
maxEntryBytes: 5,
sizeOf: (v) => v.length,
onEvict
})
m.set('s1', 'x')
m.set('s2', 'y')
expect(m.set('big', 'xxxx')).toBe(false)
expect(m.has('big')).toBe(false)
expect(m.has('s1')).toBe(true)
expect(m.has('s2')).toBe(true)
expect(onEvict).not.toHaveBeenCalled()
expect(m.retainedBytes).toBe(2)
})
it('fails closed on an unmeasurable weight instead of poisoning the ledger', () => {
const m = new BoundedMap<string, string>({
maxEntries: 10,
maxBytes: 10,
sizeOf: (v) => (v === 'bad' ? Number.NaN : v.length)
})
expect(m.set('ok', 'abc')).toBe(true)
expect(m.set('nan', 'bad')).toBe(false)
expect(m.set('neg', 'x')).toBe(true)
expect(m.retainedBytes).toBe(4)
expect(Number.isFinite(m.retainedBytes)).toBe(true)
// ceiling still armed after the rejected weight
expect(m.set('huge', 'zzzzzzzzzzzz')).toBe(false)
})
it('a rejected oversized overwrite leaves the existing value untouched', () => {
const m = new BoundedMap<string, string>({
maxEntries: 10,
maxBytes: 20,
maxEntryBytes: 4,
sizeOf: (v) => v.length
})
m.set('k', 'old')
expect(m.set('k', 'muchlonger')).toBe(false)
expect(m.get('k')).toBe('old')
expect(m.retainedBytes).toBe(3)
})
it('supports touching reads during a full traversal', () => {
const m = new BoundedMap<string, number>({ maxEntries: 5 })
m.set('a', 1)
m.set('b', 2)
const seen: string[] = []
for (const k of m.keys()) {
seen.push(k)
m.get(k) // reorders the backing map mid-iteration
}
expect(seen).toEqual(['a', 'b'])
expect(m.entries()).toEqual([
['a', 1],
['b', 2]
])
})
it('an overflow-rejected overwrite keeps the prior value and leaves no orphaned weight', () => {
const weights = new Map<string, number>([
['a', Number.MAX_SAFE_INTEGER - 1],
['b', 1]
])
const m = new BoundedMap<string, string>({
maxEntries: 10,
maxBytes: Number.MAX_SAFE_INTEGER,
sizeOf: (_v, k) => weights.get(k) ?? 0
})
m.set('a', 'A')
m.set('b', 'B')
weights.set('b', 3) // next weight for 'b' exceeds the remaining headroom
expect(m.set('b', 'B2')).toBe(false)
expect(m.has('b')).toBe(true) // rejection must not displace the prior value
expect(m.peek('b')).toBe('B')
expect(m.retainedBytes).toBe(Number.MAX_SAFE_INTEGER)
// the rejected key must not strand a weight: deleting everything returns the ledger to zero
weights.set('b', 1)
m.delete('a')
m.delete('b')
expect(m.retainedBytes).toBe(0)
expect(m.size).toBe(0)
})
it('rejects the entry when sizeOf throws instead of propagating', () => {
const m = new BoundedMap<string, string>({
maxEntries: 4,
maxBytes: 50,
sizeOf: (v) => {
if (v === 'boom') {
throw new Error('measure failed')
}
return v.length
}
})
expect(m.set('ok', 'abc')).toBe(true)
expect(() => m.set('bad', 'boom')).not.toThrow()
expect(m.set('bad', 'boom')).toBe(false)
expect(m.has('bad')).toBe(false)
expect(m.retainedBytes).toBe(3)
})
it('runs every disposal even when one onEvict throws', () => {
const disposed: string[] = []
const m = new BoundedMap<string, string>({
maxEntries: 10,
maxBytes: 2,
sizeOf: (v) => v.length,
onEvict: (_v, k) => {
disposed.push(k)
if (k === 'a') {
throw new Error('dispose failed')
}
}
})
m.set('a', 'x')
m.set('b', 'y')
expect(() => m.set('c', 'zz')).toThrow('dispose failed')
expect(disposed).toEqual(['a', 'b']) // 'b' still disposed despite the earlier throw
expect(m.retainedBytes).toBeLessThanOrEqual(2)
})
})