@vida-global/core 2.0.10 → 2.1.0

package/test/cache/memoryCache.test.js

@@ -0,0 +1,233 @@
+const { MemoryCache } = require('../../lib/cache');
+const { MemoryCache: PublicMemoryCache } = require('../../index');
+
+
+describe('MemoryCache', () => {
+    let cache;
+
+
+    beforeEach(() => {
+        cache = new MemoryCache();
+    });
+
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+
+    describe('#fetch', () => {
+        const options = {
+            namespace: 'squire:shop-data',
+            key: { shopId: 'shop-1' },
+            ttlSeconds: 300,
+        };
+
+
+        it('fetches and caches a value', async () => {
+            const value   = { services: ['Cut'] };
+            const fetcher = jest.fn().mockResolvedValue(value);
+
+            const first = await cache.fetch(options, fetcher);
+            const second = await cache.fetch(options, fetcher);
+
+            expect(first).toEqual({ value, cacheHit: false });
+            expect(second).toEqual({ value, cacheHit: true });
+            expect(first.value).toBe(value);
+            expect(second.value).toBe(value);
+            expect(fetcher).toHaveBeenCalledTimes(1);
+        });
+
+
+        it('uses equivalent object keys regardless of property order', async () => {
+            const fetcher = jest.fn().mockResolvedValue({ services: ['Cut'] });
+            const firstOptions = {
+                ...options,
+                key: { agentId: 'agent-1', shopId: 'shop-1' },
+            };
+            const secondOptions = {
+                ...options,
+                key: { shopId: 'shop-1', agentId: 'agent-1' },
+            };
+
+            await cache.fetch(firstOptions, fetcher);
+            const result = await cache.fetch(secondOptions, fetcher);
+
+            expect(result).toEqual({ value: { services: ['Cut'] }, cacheHit: true });
+            expect(fetcher).toHaveBeenCalledTimes(1);
+        });
+
+
+        it('fetches an expired value again', async () => {
+            jest.spyOn(Date, 'now').mockReturnValue(1000);
+            const fetcher = jest.fn()
+                                .mockResolvedValueOnce({ version: 1 })
+                                .mockResolvedValueOnce({ version: 2 });
+            await cache.fetch({ ...options, ttlSeconds: 1 }, fetcher);
+
+            Date.now.mockReturnValue(2000);
+            const result = await cache.fetch({ ...options, ttlSeconds: 1 }, fetcher);
+
+            expect(result).toEqual({ value: { version: 2 }, cacheHit: false });
+            expect(fetcher).toHaveBeenCalledTimes(2);
+        });
+
+
+        it('allows cached values to be mutated', async () => {
+            const value   = { shop: { name: 'Original' } };
+            const fetcher = jest.fn().mockResolvedValue(value);
+            const first   = await cache.fetch(options, fetcher);
+            first.value.shop.name = 'Changed by receiver';
+
+            const second = await cache.fetch(options, fetcher);
+
+            expect(second.value).toEqual({ shop: { name: 'Changed by receiver' } });
+            expect(second.value).toBe(first.value);
+        });
+
+
+        it('caches null values', async () => {
+            const fetcher = jest.fn().mockResolvedValue(null);
+
+            const first  = await cache.fetch(options, fetcher);
+            const second = await cache.fetch(options, fetcher);
+
+            expect(first).toEqual({ value: null, cacheHit: false });
+            expect(second).toEqual({ value: null, cacheHit: true });
+            expect(fetcher).toHaveBeenCalledTimes(1);
+        });
+
+
+        it('shares one fetch between concurrent calls for the same key', async () => {
+            let resolveFetch;
+            const data    = { shop: { name: 'Shop' } };
+            const fetcher = jest.fn(() => new Promise((resolve) => {
+                resolveFetch = resolve;
+            }));
+
+            const first  = cache.fetch(options, fetcher);
+            const second = cache.fetch(options, fetcher);
+            resolveFetch(data);
+            const [firstResult, secondResult] = await Promise.all([first, second]);
+
+            expect(fetcher).toHaveBeenCalledTimes(1);
+            expect(firstResult).toEqual({ value: data, cacheHit: false });
+            expect(secondResult).toEqual({ value: data, cacheHit: false });
+            expect(firstResult.value).toBe(data);
+            expect(secondResult.value).toBe(data);
+        });
+
+
+        it('shares a fetch between equivalent key object order', async () => {
+            const fetcher = jest.fn().mockResolvedValue({ services: ['Cut'] });
+            const first   = cache.fetch({
+                ...options,
+                key: { agentId: 'agent-1', shopId: 'shop-1' },
+            }, fetcher);
+            const second  = cache.fetch({
+                ...options,
+                key: { shopId: 'shop-1', agentId: 'agent-1' },
+            }, fetcher);
+
+            await expect(Promise.all([first, second])).resolves.toEqual([
+                { value: { services: ['Cut'] }, cacheHit: false },
+                { value: { services: ['Cut'] }, cacheHit: false },
+            ]);
+            expect(fetcher).toHaveBeenCalledTimes(1);
+        });
+
+
+        it('fetches different keys independently', async () => {
+            const firstFetcher  = jest.fn().mockResolvedValue({ id: 1 });
+            const secondFetcher = jest.fn().mockResolvedValue({ id: 2 });
+
+            const results = await Promise.all([
+                cache.fetch({ ...options, key: 'first' }, firstFetcher),
+                cache.fetch({ ...options, key: 'second' }, secondFetcher),
+            ]);
+
+            expect(results).toEqual([
+                { value: { id: 1 }, cacheHit: false },
+                { value: { id: 2 }, cacheHit: false },
+            ]);
+            expect(firstFetcher).toHaveBeenCalledTimes(1);
+            expect(secondFetcher).toHaveBeenCalledTimes(1);
+        });
+
+
+        it('rejects concurrent calls and allows the fetch to be retried', async () => {
+            const fetcher = jest.fn()
+                                .mockRejectedValueOnce(new Error('fetch failed'))
+                                .mockResolvedValueOnce({ services: ['Cut'] });
+            const first  = cache.fetch(options, fetcher);
+            const second = cache.fetch(options, fetcher);
+
+            await expect(Promise.all([first, second])).rejects.toThrow('fetch failed');
+            await expect(cache.fetch(options, fetcher)).resolves.toEqual({
+                value: { services: ['Cut'] },
+                cacheHit: false,
+            });
+            expect(fetcher).toHaveBeenCalledTimes(2);
+        });
+
+
+        it('evicts the least recently used value when full', async () => {
+            cache = new MemoryCache({ maxEntries: 2 });
+            const optionsFor = (key) => ({ ...options, key });
+            await cache.fetch(optionsFor('first'), async () => ({ value: 'first' }));
+            await cache.fetch(optionsFor('second'), async () => ({ value: 'second' }));
+            await cache.fetch(optionsFor('first'), async () => ({ value: 'unused' }));
+            await cache.fetch(optionsFor('third'), async () => ({ value: 'third' }));
+            const fetcher = jest.fn().mockResolvedValue({ value: 'new-second' });
+
+            const result = await cache.fetch(optionsFor('second'), fetcher);
+
+            expect(result).toEqual({ value: { value: 'new-second' }, cacheHit: false });
+            expect(fetcher).toHaveBeenCalledTimes(1);
+        });
+
+
+        it('removes expired values before evicting an active value', async () => {
+            cache = new MemoryCache({ maxEntries: 2 });
+            jest.spyOn(Date, 'now').mockReturnValue(1000);
+            await cache.fetch({ ...options, key: 'active' }, async () => ({ value: 'active' }));
+            await cache.fetch({ ...options, key: 'expired', ttlSeconds: 1 }, async () => ({ value: 'expired' }));
+
+            Date.now.mockReturnValue(2000);
+            await cache.fetch({ ...options, key: 'new' }, async () => ({ value: 'new' }));
+            const active = await cache.fetch({ ...options, key: 'active' }, async () => ({ value: 'unused' }));
+
+            expect(active).toEqual({ value: { value: 'active' }, cacheHit: true });
+        });
+
+
+        it('caches values that cannot be structured cloned', async () => {
+            const value = { fetch: () => 'value' };
+
+            const first  = await cache.fetch(options, async () => value);
+            const second = await cache.fetch(options, jest.fn());
+
+            expect(first.value).toBe(value);
+            expect(second.value).toBe(value);
+            expect(second.value.fetch()).toBe('value');
+        });
+
+
+        it('requires a fetcher and valid options', async () => {
+            await expect(cache.fetch(options)).rejects.toThrow('MemoryCache fetcher must be a function.');
+            await expect(cache.fetch({ ...options, ttlSeconds: null }, jest.fn()))
+                .rejects.toThrow('ttlSeconds must be a positive integer');
+            await expect(cache.fetch()).rejects.toThrow('MemoryCache namespace is required.');
+        });
+    });
+
+
+    describe('constructor', () => {
+        it('requires a cache entry limit between 1 and 1000', () => {
+            expect(() => new MemoryCache({ maxEntries: 0 }))
+                .toThrow('MemoryCache maxEntries must be between 1 and 1000.');
+            expect(() => new MemoryCache({ maxEntries: 1001 }))
+                .toThrow('MemoryCache maxEntries must be between 1 and 1000.');
+        });
+    });
+});