mcp-rubber-duck 1.5.1 → 1.5.2

package/tests/cache.test.ts

@@ -0,0 +1,240 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { ResponseCache } from '../src/services/cache.js';
+
+// Mock logger to avoid console noise during tests
+jest.mock('../src/utils/logger');
+
+describe('ResponseCache', () => {
+  let cache: ResponseCache;
+
+  beforeEach(() => {
+    cache = new ResponseCache(300); // 5 minute TTL
+  });
+
+  describe('basic operations', () => {
+    it('should store and retrieve values', () => {
+      cache.set('key1', 'value1');
+      expect(cache.get('key1')).toBe('value1');
+    });
+
+    it('should return undefined for missing keys', () => {
+      expect(cache.get('nonexistent')).toBeUndefined();
+    });
+
+    it('should check if key exists', () => {
+      cache.set('key1', 'value1');
+      expect(cache.has('key1')).toBe(true);
+      expect(cache.has('nonexistent')).toBe(false);
+    });
+
+    it('should delete keys', () => {
+      cache.set('key1', 'value1');
+      expect(cache.has('key1')).toBe(true);
+
+      const deleted = cache.delete('key1');
+      expect(deleted).toBe(1);
+      expect(cache.has('key1')).toBe(false);
+    });
+
+    it('should return 0 when deleting nonexistent key', () => {
+      const deleted = cache.delete('nonexistent');
+      expect(deleted).toBe(0);
+    });
+
+    it('should store complex objects', () => {
+      const obj = { foo: 'bar', nested: { value: 123 } };
+      cache.set('obj', obj);
+      expect(cache.get('obj')).toEqual(obj);
+    });
+  });
+
+  describe('key generation', () => {
+    it('should generate consistent keys for same input', () => {
+      const key1 = cache.generateKey('openai', 'test prompt', { temp: 0.7 });
+      const key2 = cache.generateKey('openai', 'test prompt', { temp: 0.7 });
+      expect(key1).toBe(key2);
+    });
+
+    it('should generate different keys for different providers', () => {
+      const key1 = cache.generateKey('openai', 'test prompt');
+      const key2 = cache.generateKey('groq', 'test prompt');
+      expect(key1).not.toBe(key2);
+    });
+
+    it('should generate different keys for different prompts', () => {
+      const key1 = cache.generateKey('openai', 'prompt 1');
+      const key2 = cache.generateKey('openai', 'prompt 2');
+      expect(key1).not.toBe(key2);
+    });
+
+    it('should generate different keys for different options', () => {
+      const key1 = cache.generateKey('openai', 'test', { temp: 0.7 });
+      const key2 = cache.generateKey('openai', 'test', { temp: 0.5 });
+      expect(key1).not.toBe(key2);
+    });
+
+    it('should generate valid hex hashes', () => {
+      const key = cache.generateKey('openai', 'test');
+      expect(key).toMatch(/^[a-f0-9]{64}$/); // SHA-256 produces 64 hex chars
+    });
+  });
+
+  describe('TTL handling', () => {
+    it('should respect custom TTL on set', () => {
+      const shortTTLCache = new ResponseCache(1); // 1 second default TTL
+      shortTTLCache.set('key', 'value', 10); // 10 second TTL
+      expect(shortTTLCache.get('key')).toBe('value');
+    });
+
+    it('should use default TTL when not specified', () => {
+      cache.set('key', 'value');
+      expect(cache.get('key')).toBe('value');
+    });
+  });
+
+  describe('flush', () => {
+    it('should clear all entries', () => {
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+      cache.set('key3', 'value3');
+
+      expect(cache.has('key1')).toBe(true);
+      expect(cache.has('key2')).toBe(true);
+
+      cache.flush();
+
+      expect(cache.has('key1')).toBe(false);
+      expect(cache.has('key2')).toBe(false);
+      expect(cache.has('key3')).toBe(false);
+    });
+
+    it('should allow new entries after flush', () => {
+      cache.set('key1', 'value1');
+      cache.flush();
+      cache.set('key2', 'value2');
+
+      expect(cache.get('key2')).toBe('value2');
+    });
+  });
+
+  describe('stats', () => {
+    it('should track cache statistics', () => {
+      cache.set('key1', 'value1');
+
+      // Generate a hit
+      cache.get('key1');
+
+      // Generate a miss
+      cache.get('nonexistent');
+
+      const stats = cache.getStats();
+      expect(stats.keys).toBe(1);
+      expect(stats.hits).toBe(1);
+      expect(stats.misses).toBe(1);
+      expect(stats.hitRate).toBe(0.5);
+    });
+
+    it('should handle zero hits and misses', () => {
+      const stats = cache.getStats();
+      expect(stats.keys).toBe(0);
+      expect(stats.hitRate).toBe(0); // NaN protection check
+    });
+  });
+
+  describe('getOrSet', () => {
+    it('should return cached value on hit', async () => {
+      cache.set('key', 'cached-value');
+      const fetcher = jest.fn<() => Promise<string>>().mockResolvedValue('fetched-value');
+
+      const result = await cache.getOrSet('key', fetcher);
+
+      expect(result.value).toBe('cached-value');
+      expect(result.cached).toBe(true);
+      expect(fetcher).not.toHaveBeenCalled();
+    });
+
+    it('should fetch and cache on miss', async () => {
+      const fetcher = jest.fn<() => Promise<string>>().mockResolvedValue('fetched-value');
+
+      const result = await cache.getOrSet('key', fetcher);
+
+      expect(result.value).toBe('fetched-value');
+      expect(result.cached).toBe(false);
+      expect(fetcher).toHaveBeenCalledTimes(1);
+
+      // Verify it was cached
+      expect(cache.get('key')).toBe('fetched-value');
+    });
+
+    it('should use custom TTL when provided', async () => {
+      const fetcher = jest.fn<() => Promise<string>>().mockResolvedValue('value');
+
+      await cache.getOrSet('key', fetcher, 600);
+
+      expect(cache.get('key')).toBe('value');
+    });
+
+    it('should handle async fetcher errors', async () => {
+      const fetcher = jest.fn<() => Promise<string>>().mockRejectedValue(new Error('Fetch failed'));
+
+      await expect(cache.getOrSet('key', fetcher)).rejects.toThrow('Fetch failed');
+
+      // Should not cache failed result
+      expect(cache.has('key')).toBe(false);
+    });
+
+    it('should cache complex objects', async () => {
+      const complexValue = { data: [1, 2, 3], nested: { key: 'value' } };
+      const fetcher = jest.fn<() => Promise<typeof complexValue>>().mockResolvedValue(complexValue);
+
+      const result = await cache.getOrSet('key', fetcher);
+
+      expect(result.value).toEqual(complexValue);
+      expect(cache.get('key')).toEqual(complexValue);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty string values', () => {
+      cache.set('key', '');
+      expect(cache.get('key')).toBe('');
+      expect(cache.has('key')).toBe(true);
+    });
+
+    it('should handle null values', () => {
+      cache.set('key', null);
+      expect(cache.get('key')).toBe(null);
+      expect(cache.has('key')).toBe(true);
+    });
+
+    it('should handle zero values', () => {
+      cache.set('key', 0);
+      expect(cache.get('key')).toBe(0);
+      expect(cache.has('key')).toBe(true);
+    });
+
+    it('should handle false boolean values', () => {
+      cache.set('key', false);
+      expect(cache.get('key')).toBe(false);
+      expect(cache.has('key')).toBe(true);
+    });
+
+    it('should handle undefined values by not storing', () => {
+      // node-cache doesn't store undefined values
+      cache.set('key', undefined);
+      expect(cache.has('key')).toBe(true);
+    });
+
+    it('should handle very long keys', () => {
+      const longKey = 'a'.repeat(10000);
+      cache.set(longKey, 'value');
+      expect(cache.get(longKey)).toBe('value');
+    });
+
+    it('should handle special characters in keys', () => {
+      const specialKey = 'key:with/special\\chars!@#$%^&*()';
+      cache.set(specialKey, 'value');
+      expect(cache.get(specialKey)).toBe('value');
+    });
+  });
+});