Add tests for Cache, MemoryLimitedMap, and other util.js coverage gaps (#5365)

a45ec30cf0e9bc7468b6351719330ed15bf9e2ce

Tony Gies <tgies@tgies.net>

Signed

Parents: 8d8e3833f6e7ae41ab0c6c7aecfc4b8df5103192

tests/util-pure.test.js+268 -0 Viewed

     isPathUnderParent,
     isFileURL,
     getRequestURL,
+    delay,
+    formatBytes,
+    sanitizeSafeCharacterReplacements,
+    generateTimestamp,
+    mergeObjectWithYaml,
+    excludeKeysByYaml,
+    Cache,
+    MemoryLimitedMap,
 } from '../src/util';
 describe('keyToEnv', () => {

         expect(() => getRequestURL(42)).toThrow(TypeError);
     });
 });
+describe('delay', () => {
+    test('should resolve after the specified time', async () => {
+        jest.useFakeTimers();
+        let resolved = false;
+        delay(50).then(() => { resolved = true; });
+        expect(resolved).toBe(false);
+        jest.advanceTimersByTime(50);
+        await Promise.resolve();
+        expect(resolved).toBe(true);
+        jest.useRealTimers();
+    });
+    test('should return a promise', () => {
+        jest.useFakeTimers();
+        const result = delay(0);
+        expect(result).toBeInstanceOf(Promise);
+        jest.useRealTimers();
+    });
+});
+describe('formatBytes', () => {
+    test('should format bytes to human-readable string', () => {
+        expect(formatBytes(0)).toBe('0B');
+        expect(formatBytes(1024)).toBe('1KB');
+        expect(formatBytes(1048576)).toBe('1MB');
+    });
+    test('should return empty string for null/undefined', () => {
+        expect(formatBytes(null)).toBe('');
+        expect(formatBytes(undefined)).toBe('');
+    });
+});
+describe('sanitizeSafeCharacterReplacements', () => {
+    test('should always return underscore', () => {
+        expect(sanitizeSafeCharacterReplacements('/')).toBe('_');
+        expect(sanitizeSafeCharacterReplacements('\\')).toBe('_');
+        expect(sanitizeSafeCharacterReplacements(':')).toBe('_');
+        expect(sanitizeSafeCharacterReplacements('')).toBe('_');
+    });
+});
+describe('generateTimestamp', () => {
+    test('should return YYYYMMDD-HHMMSS format for a known date', () => {
+        jest.useFakeTimers();
+        jest.setSystemTime(new Date('2025-07-15T09:30:45'));
+        expect(generateTimestamp()).toBe('20250715-093045');
+        jest.useRealTimers();
+    });
+});
+describe('mergeObjectWithYaml', () => {
+    test('should merge a YAML object into the target', () => {
+        const obj = { a: 1 };
+        mergeObjectWithYaml(obj, 'b: 2\nc: 3');
+        expect(obj).toEqual({ a: 1, b: 2, c: 3 });
+    });
+    test('should merge a YAML array of objects into the target', () => {
+        const obj = { a: 1 };
+        mergeObjectWithYaml(obj, '- b: 2\n- c: 3');
+        expect(obj).toEqual({ a: 1, b: 2, c: 3 });
+    });
+    test('should override existing keys', () => {
+        const obj = { a: 1 };
+        mergeObjectWithYaml(obj, 'a: 99');
+        expect(obj.a).toBe(99);
+    });
+    test('should do nothing for empty/falsy yamlString', () => {
+        const obj = { a: 1 };
+        mergeObjectWithYaml(obj, '');
+        mergeObjectWithYaml(obj, null);
+        mergeObjectWithYaml(obj, undefined);
+        expect(obj).toEqual({ a: 1 });
+    });
+    test('should not throw on invalid YAML', () => {
+        const obj = { a: 1 };
+        expect(() => mergeObjectWithYaml(obj, '{{{')).not.toThrow();
+        expect(obj).toEqual({ a: 1 });
+    });
+    test('should skip non-object items in YAML array', () => {
+        const obj = { a: 1 };
+        mergeObjectWithYaml(obj, '- hello\n- b: 2');
+        expect(obj).toEqual({ a: 1, b: 2 });
+    });
+});
+describe('excludeKeysByYaml', () => {
+    test('should delete keys listed in a YAML array', () => {
+        const obj = { a: 1, b: 2, c: 3 };
+        excludeKeysByYaml(obj, '- a\n- c');
+        expect(obj).toEqual({ b: 2 });
+    });
+    test('should delete keys from a YAML object', () => {
+        const obj = { a: 1, b: 2 };
+        excludeKeysByYaml(obj, 'a: whatever\nb: whatever');
+        expect(obj).toEqual({});
+    });
+    test('should delete a single string key', () => {
+        const obj = { a: 1, b: 2 };
+        excludeKeysByYaml(obj, 'a');
+        expect(obj).toEqual({ b: 2 });
+    });
+    test('should do nothing for empty/falsy yamlString', () => {
+        const obj = { a: 1 };
+        excludeKeysByYaml(obj, '');
+        excludeKeysByYaml(obj, null);
+        expect(obj).toEqual({ a: 1 });
+    });
+    test('should not throw on invalid YAML', () => {
+        const obj = { a: 1 };
+        expect(() => excludeKeysByYaml(obj, '{{{')).not.toThrow();
+        expect(obj).toEqual({ a: 1 });
+    });
+});
+describe('Cache', () => {
+    test('should store and retrieve values', () => {
+        const cache = new Cache(1000);
+        cache.set('key', 'value');
+        expect(cache.get('key')).toBe('value');
+    });
+    test('should return null for missing keys', () => {
+        const cache = new Cache(1000);
+        expect(cache.get('missing')).toBeNull();
+    });
+    test('should return null for expired entries', () => {
+        jest.useFakeTimers();
+        const cache = new Cache(10);
+        cache.set('key', 'value');
+        jest.advanceTimersByTime(20);
+        expect(cache.get('key')).toBeNull();
+        jest.useRealTimers();
+    });
+    test('should remove entries', () => {
+        const cache = new Cache(1000);
+        cache.set('key', 'value');
+        cache.remove('key');
+        expect(cache.get('key')).toBeNull();
+    });
+    test('should clear all entries', () => {
+        const cache = new Cache(1000);
+        cache.set('a', 1);
+        cache.set('b', 2);
+        cache.clear();
+        expect(cache.get('a')).toBeNull();
+        expect(cache.get('b')).toBeNull();
+    });
+});
+describe('MemoryLimitedMap', () => {
+    test('should store and retrieve values', () => {
+        const map = new MemoryLimitedMap('1 MB');
+        map.set('key', 'value');
+        expect(map.get('key')).toBe('value');
+        expect(map.has('key')).toBe(true);
+    });
+    test('should reject non-string keys and values', () => {
+        const map = new MemoryLimitedMap('1 MB');
+        map.set(123, 'value');
+        map.set('key', 123);
+        expect(map.size()).toBe(0);
+    });
+    test('should evict oldest entries when memory limit is reached', () => {
+        // 20 bytes capacity = 10 chars (2 bytes per char)
+        const map = new MemoryLimitedMap('20B');
+        map.set('a', '12345'); // 10 bytes
+        map.set('b', '12345'); // 10 bytes, fills capacity
+        map.set('c', '12345'); // 10 bytes, should evict 'a'
+        expect(map.has('a')).toBe(false);
+        expect(map.has('b')).toBe(true);
+        expect(map.has('c')).toBe(true);
+    });
+    test('should reject values larger than max memory', () => {
+        const map = new MemoryLimitedMap('10B');
+        map.set('key', '123456'); // 12 bytes > 10 byte limit
+        expect(map.has('key')).toBe(false);
+    });
+    test('should do nothing when maxMemory is 0', () => {
+        const map = new MemoryLimitedMap('0B');
+        map.set('key', 'value');
+        expect(map.size()).toBe(0);
+    });
+    test('should track memory usage', () => {
+        const map = new MemoryLimitedMap('1 MB');
+        map.set('key', 'hello'); // 10 bytes
+        expect(map.totalMemory()).toBe(10);
+    });
+    test('should update memory when overwriting a key', () => {
+        const map = new MemoryLimitedMap('1 MB');
+        map.set('key', 'hi');    // 4 bytes
+        map.set('key', 'hello'); // 10 bytes
+        expect(map.totalMemory()).toBe(10);
+        expect(map.get('key')).toBe('hello');
+    });
+    test('should delete entries and free memory', () => {
+        const map = new MemoryLimitedMap('1 MB');
+        map.set('key', 'hello');
+        expect(map.delete('key')).toBe(true);
+        expect(map.totalMemory()).toBe(0);
+        expect(map.has('key')).toBe(false);
+    });
+    test('should return false when deleting non-existent key', () => {
+        const map = new MemoryLimitedMap('1 MB');
+        expect(map.delete('nope')).toBe(false);
+    });
+    test('should clear all entries and reset memory', () => {
+        const map = new MemoryLimitedMap('1 MB');
+        map.set('a', 'hello');
+        map.set('b', 'world');
+        map.clear();
+        expect(map.size()).toBe(0);
+        expect(map.totalMemory()).toBe(0);
+    });
+    test('should iterate with forEach', () => {
+        const map = new MemoryLimitedMap('1 MB');
+        map.set('a', '1');
+        map.set('b', '2');
+        const entries = [];
+        map.forEach((value, key) => entries.push([key, value]));
+        expect(entries).toEqual([['a', '1'], ['b', '2']]);
+    });
+    test('should expose keys and values iterators', () => {
+        const map = new MemoryLimitedMap('1 MB');
+        map.set('a', '1');
+        map.set('b', '2');
+        expect([...map.keys()]).toEqual(['a', 'b']);
+        expect([...map.values()]).toEqual(['1', '2']);
+    });
+    test('estimateStringSize should return 2 bytes per character', () => {
+        expect(MemoryLimitedMap.estimateStringSize('hello')).toBe(10);
+        expect(MemoryLimitedMap.estimateStringSize('')).toBe(0);
+        expect(MemoryLimitedMap.estimateStringSize(null)).toBe(0);
+    });
+});