@kya-os/mcp-i-core 1.2.3-canary.6 → 1.3.0-canary.clientinfo.20251126003544

package/src/__tests__/cache/tool-protection-cache.test.ts

@@ -0,0 +1,640 @@
+/**
+ * Tool Protection Cache Tests
+ *
+ * Tests for tool protection cache implementations:
+ * - InMemoryToolProtectionCache
+ * - NoOpToolProtectionCache
+ * - Cache interface compliance
+ */
+
+import { describe, test, expect, beforeEach, vi } from 'vitest';
+import {
+  InMemoryToolProtectionCache,
+  NoOpToolProtectionCache,
+  type ToolProtectionCache,
+} from '../../cache/tool-protection-cache';
+import type { ToolProtectionConfig } from '../../types/tool-protection';
+
+describe('ToolProtectionCache Interface', () => {
+  describe('InMemoryToolProtectionCache', () => {
+    let cache: InMemoryToolProtectionCache;
+    const testConfig: ToolProtectionConfig = {
+      toolProtections: {
+        tool1: {
+          requiresDelegation: true,
+          requiredScopes: ['scope1'],
+        },
+        tool2: {
+          requiresDelegation: false,
+          requiredScopes: [],
+        },
+      },
+    };
+
+    beforeEach(() => {
+      cache = new InMemoryToolProtectionCache();
+    });
+
+    describe('get', () => {
+      test('should return null for non-existent key', async () => {
+        const result = await cache.get('non-existent');
+        expect(result).toBeNull();
+      });
+
+      test('should return cached value when present', async () => {
+        await cache.set('key1', testConfig, 300000);
+
+        const result = await cache.get('key1');
+
+        expect(result).toEqual(testConfig);
+      });
+
+      test('should return null for expired entry', async () => {
+        // Set with very short TTL
+        await cache.set('key1', testConfig, 100);
+
+        // Wait for expiration
+        await new Promise((resolve) => setTimeout(resolve, 150));
+
+        const result = await cache.get('key1');
+
+        expect(result).toBeNull();
+      });
+
+      test('should return null for entry that expired during get', async () => {
+        // Manually create expired entry
+        const now = Date.now();
+        vi.spyOn(Date, 'now').mockReturnValue(now);
+        await cache.set('key1', testConfig, 1000);
+
+        // Advance time past expiration
+        vi.spyOn(Date, 'now').mockReturnValue(now + 2000);
+
+        const result = await cache.get('key1');
+
+        expect(result).toBeNull();
+        vi.restoreAllMocks();
+      });
+
+      test('should handle multiple keys independently', async () => {
+        const config1: ToolProtectionConfig = {
+          toolProtections: {
+            tool1: {
+              requiresDelegation: true,
+              requiredScopes: ['scope1'],
+            },
+          },
+        };
+
+        const config2: ToolProtectionConfig = {
+          toolProtections: {
+            tool2: {
+              requiresDelegation: false,
+              requiredScopes: [],
+            },
+          },
+        };
+
+        await cache.set('key1', config1, 300000);
+        await cache.set('key2', config2, 300000);
+
+        const result1 = await cache.get('key1');
+        const result2 = await cache.get('key2');
+
+        expect(result1).toEqual(config1);
+        expect(result2).toEqual(config2);
+      });
+
+      test('should handle empty config', async () => {
+        const emptyConfig: ToolProtectionConfig = {
+          toolProtections: {},
+        };
+
+        await cache.set('empty', emptyConfig, 300000);
+
+        const result = await cache.get('empty');
+
+        expect(result).toEqual(emptyConfig);
+      });
+
+      test('should handle large config objects', async () => {
+        const largeConfig: ToolProtectionConfig = {
+          toolProtections: {},
+        };
+
+        // Create config with many tools
+        for (let i = 0; i < 1000; i++) {
+          largeConfig.toolProtections[`tool${i}`] = {
+            requiresDelegation: i % 2 === 0,
+            requiredScopes: [`scope${i}`],
+          };
+        }
+
+        await cache.set('large', largeConfig, 300000);
+
+        const result = await cache.get('large');
+
+        expect(result).toEqual(largeConfig);
+        expect(Object.keys(result!.toolProtections)).toHaveLength(1000);
+      });
+    });
+
+    describe('set', () => {
+      test('should store config with TTL', async () => {
+        await cache.set('key1', testConfig, 300000);
+
+        const result = await cache.get('key1');
+
+        expect(result).toEqual(testConfig);
+      });
+
+      test('should overwrite existing entry', async () => {
+        const config1: ToolProtectionConfig = {
+          toolProtections: {
+            tool1: {
+              requiresDelegation: false,
+              requiredScopes: [],
+            },
+          },
+        };
+
+        const config2: ToolProtectionConfig = {
+          toolProtections: {
+            tool2: {
+              requiresDelegation: true,
+              requiredScopes: ['scope1'],
+            },
+          },
+        };
+
+        await cache.set('key1', config1, 300000);
+        await cache.set('key1', config2, 300000);
+
+        const result = await cache.get('key1');
+
+        expect(result).toEqual(config2);
+      });
+
+      test('should handle zero TTL', async () => {
+        await cache.set('key1', testConfig, 0);
+
+        // Entry should be immediately expired
+        const result = await cache.get('key1');
+
+        expect(result).toBeNull();
+      });
+
+      test('should handle negative TTL', async () => {
+        await cache.set('key1', testConfig, -1000);
+
+        // Entry should be immediately expired
+        const result = await cache.get('key1');
+
+        expect(result).toBeNull();
+      });
+
+      test('should handle very large TTL', async () => {
+        await cache.set('key1', testConfig, Number.MAX_SAFE_INTEGER);
+
+        const result = await cache.get('key1');
+
+        expect(result).toEqual(testConfig);
+      });
+
+      test('should store different configs for different keys', async () => {
+        const config1: ToolProtectionConfig = {
+          toolProtections: {
+            tool1: {
+              requiresDelegation: true,
+              requiredScopes: ['scope1'],
+            },
+          },
+        };
+
+        const config2: ToolProtectionConfig = {
+          toolProtections: {
+            tool2: {
+              requiresDelegation: false,
+              requiredScopes: [],
+            },
+          },
+        };
+
+        await cache.set('key1', config1, 300000);
+        await cache.set('key2', config2, 300000);
+
+        expect(await cache.get('key1')).toEqual(config1);
+        expect(await cache.get('key2')).toEqual(config2);
+      });
+    });
+
+    describe('delete', () => {
+      test('should remove cached entry', async () => {
+        await cache.set('key1', testConfig, 300000);
+
+        await cache.delete('key1');
+
+        const result = await cache.get('key1');
+        expect(result).toBeNull();
+      });
+
+      test('should handle deleting non-existent key', async () => {
+        await expect(cache.delete('non-existent')).resolves.not.toThrow();
+      });
+
+      test('should handle deleting multiple keys', async () => {
+        await cache.set('key1', testConfig, 300000);
+        await cache.set('key2', testConfig, 300000);
+        await cache.set('key3', testConfig, 300000);
+
+        await cache.delete('key1');
+        await cache.delete('key3');
+
+        expect(await cache.get('key1')).toBeNull();
+        expect(await cache.get('key2')).toEqual(testConfig);
+        expect(await cache.get('key3')).toBeNull();
+      });
+    });
+
+    describe('clear', () => {
+      test('should remove all cached entries', async () => {
+        await cache.set('key1', testConfig, 300000);
+        await cache.set('key2', testConfig, 300000);
+        await cache.set('key3', testConfig, 300000);
+
+        await cache.clear();
+
+        expect(await cache.get('key1')).toBeNull();
+        expect(await cache.get('key2')).toBeNull();
+        expect(await cache.get('key3')).toBeNull();
+      });
+
+      test('should handle clearing empty cache', async () => {
+        await expect(cache.clear()).resolves.not.toThrow();
+      });
+
+      test('should allow adding entries after clear', async () => {
+        await cache.set('key1', testConfig, 300000);
+        await cache.clear();
+
+        await cache.set('key2', testConfig, 300000);
+
+        expect(await cache.get('key2')).toEqual(testConfig);
+      });
+    });
+
+    describe('cleanup', () => {
+      test('should remove expired entries', async () => {
+        const now = Date.now();
+        vi.spyOn(Date, 'now').mockReturnValue(now);
+
+        await cache.set('expired1', testConfig, 100);
+        await cache.set('expired2', testConfig, 100);
+        await cache.set('valid', testConfig, 300000);
+
+        // Advance time
+        vi.spyOn(Date, 'now').mockReturnValue(now + 200);
+
+        cache.cleanup();
+
+        expect(await cache.get('expired1')).toBeNull();
+        expect(await cache.get('expired2')).toBeNull();
+        expect(await cache.get('valid')).toEqual(testConfig);
+
+        vi.restoreAllMocks();
+      });
+
+      test('should handle cleanup with no expired entries', async () => {
+        await cache.set('key1', testConfig, 300000);
+        await cache.set('key2', testConfig, 300000);
+
+        cache.cleanup();
+
+        expect(await cache.get('key1')).toEqual(testConfig);
+        expect(await cache.get('key2')).toEqual(testConfig);
+      });
+
+      test('should handle cleanup with empty cache', async () => {
+        expect(() => cache.cleanup()).not.toThrow();
+      });
+
+      test('should handle cleanup with partially expired entries', async () => {
+        const now = Date.now();
+        vi.spyOn(Date, 'now').mockReturnValue(now);
+
+        await cache.set('expired', testConfig, 100);
+        await cache.set('valid1', testConfig, 300000);
+        await cache.set('valid2', testConfig, 300000);
+
+        // Advance time
+        vi.spyOn(Date, 'now').mockReturnValue(now + 200);
+
+        cache.cleanup();
+
+        expect(await cache.get('expired')).toBeNull();
+        expect(await cache.get('valid1')).toEqual(testConfig);
+        expect(await cache.get('valid2')).toEqual(testConfig);
+
+        vi.restoreAllMocks();
+      });
+    });
+
+    describe('getStale', () => {
+      test('should return stale (expired) cache entry', async () => {
+        const now = Date.now();
+        vi.spyOn(Date, 'now').mockReturnValue(now);
+        
+        await cache.set('key1', testConfig, 100);
+        
+        // Advance time past expiration
+        vi.spyOn(Date, 'now').mockReturnValue(now + 200);
+        
+        // getStale() should return the expired entry BEFORE get() deletes it
+        const stale = cache.getStale('key1');
+        expect(stale).toEqual(testConfig);
+        
+        // Now get() should return null (expired and might be deleted)
+        // But getStale should still work if entry still exists in map
+        const afterGet = await cache.get('key1');
+        expect(afterGet).toBeNull();
+        
+        // After get() deletes expired entry, getStale should also return null
+        const staleAfterGet = cache.getStale('key1');
+        expect(staleAfterGet).toBeNull();
+        
+        vi.restoreAllMocks();
+      });
+
+      test('should return null for non-existent key', () => {
+        expect(cache.getStale('non-existent')).toBeNull();
+      });
+
+      test('should return valid (non-expired) cache entry', async () => {
+        await cache.set('key1', testConfig, 300000);
+        
+        const stale = cache.getStale('key1');
+        expect(stale).toEqual(testConfig);
+      });
+    });
+
+    describe('getExpiresAt', () => {
+      test('should return expiration timestamp for existing entry', async () => {
+        const now = Date.now();
+        vi.spyOn(Date, 'now').mockReturnValue(now);
+        
+        await cache.set('key1', testConfig, 5000);
+        
+        const expiresAt = cache.getExpiresAt('key1');
+        expect(expiresAt).toBe(now + 5000);
+        
+        vi.restoreAllMocks();
+      });
+
+      test('should return null for non-existent key', () => {
+        expect(cache.getExpiresAt('non-existent')).toBeNull();
+      });
+
+      test('should return expiration timestamp for expired entry', async () => {
+        const now = Date.now();
+        vi.spyOn(Date, 'now').mockReturnValue(now);
+        
+        await cache.set('key1', testConfig, 100);
+        
+        // Advance time past expiration
+        vi.spyOn(Date, 'now').mockReturnValue(now + 200);
+        
+        // Entry is expired but getExpiresAt should still return the timestamp
+        const expiresAt = cache.getExpiresAt('key1');
+        expect(expiresAt).toBe(now + 100);
+        
+        vi.restoreAllMocks();
+      });
+    });
+
+    describe('edge cases', () => {
+      test('should handle special characters in keys', async () => {
+        const specialKeys = [
+          'key-with-dashes',
+          'key_with_underscores',
+          'key.with.dots',
+          'key/with/slashes',
+          'key:with:colons',
+          'key with spaces',
+          'key@with#special$chars',
+        ];
+
+        for (const key of specialKeys) {
+          await cache.set(key, testConfig, 300000);
+          expect(await cache.get(key)).toEqual(testConfig);
+        }
+      });
+
+      test('should handle very long keys', async () => {
+        const longKey = 'a'.repeat(10000);
+        await cache.set(longKey, testConfig, 300000);
+
+        expect(await cache.get(longKey)).toEqual(testConfig);
+      });
+
+      test('should handle empty key', async () => {
+        await cache.set('', testConfig, 300000);
+        expect(await cache.get('')).toEqual(testConfig);
+      });
+
+      test('should handle concurrent get and set operations', async () => {
+        const promises = [];
+
+        // Concurrent sets
+        for (let i = 0; i < 10; i++) {
+          promises.push(cache.set(`key${i}`, testConfig, 300000));
+        }
+
+        await Promise.all(promises);
+
+        // Concurrent gets
+        const getPromises = [];
+        for (let i = 0; i < 10; i++) {
+          getPromises.push(cache.get(`key${i}`));
+        }
+
+        const results = await Promise.all(getPromises);
+
+        results.forEach((result) => {
+          expect(result).toEqual(testConfig);
+        });
+      });
+
+      test('should handle rapid set/get/delete cycles', async () => {
+        for (let i = 0; i < 100; i++) {
+          await cache.set('key1', testConfig, 300000);
+          await cache.get('key1');
+          await cache.delete('key1');
+        }
+
+        expect(await cache.get('key1')).toBeNull();
+      });
+    });
+  });
+
+  describe('NoOpToolProtectionCache', () => {
+    let cache: NoOpToolProtectionCache;
+    const testConfig: ToolProtectionConfig = {
+      toolProtections: {
+        tool1: {
+          requiresDelegation: true,
+          requiredScopes: ['scope1'],
+        },
+      },
+    };
+
+    beforeEach(() => {
+      cache = new NoOpToolProtectionCache();
+    });
+
+    describe('get', () => {
+      test('should always return null', async () => {
+        const result = await cache.get('any-key');
+        expect(result).toBeNull();
+      });
+
+      test('should return null even after set', async () => {
+        await cache.set('key1', testConfig, 300000);
+
+        const result = await cache.get('key1');
+
+        expect(result).toBeNull();
+      });
+
+      test('should return null for any key', async () => {
+        expect(await cache.get('key1')).toBeNull();
+        expect(await cache.get('key2')).toBeNull();
+        expect(await cache.get('')).toBeNull();
+      });
+    });
+
+    describe('set', () => {
+      test('should not throw when setting', async () => {
+        await expect(cache.set('key1', testConfig, 300000)).resolves.not.toThrow();
+      });
+
+      test('should not store anything', async () => {
+        await cache.set('key1', testConfig, 300000);
+
+        const result = await cache.get('key1');
+        expect(result).toBeNull();
+      });
+
+      test('should handle any TTL value', async () => {
+        await expect(cache.set('key1', testConfig, 0)).resolves.not.toThrow();
+        await expect(cache.set('key1', testConfig, -1000)).resolves.not.toThrow();
+        await expect(cache.set('key1', testConfig, Number.MAX_SAFE_INTEGER)).resolves.not.toThrow();
+      });
+    });
+
+    describe('delete', () => {
+      test('should not throw when deleting', async () => {
+        await expect(cache.delete('key1')).resolves.not.toThrow();
+      });
+
+      test('should not throw even if key was never set', async () => {
+        await expect(cache.delete('non-existent')).resolves.not.toThrow();
+      });
+    });
+
+    describe('clear', () => {
+      test('should not throw when clearing', async () => {
+        await expect(cache.clear()).resolves.not.toThrow();
+      });
+
+      test('should not throw even after sets', async () => {
+        await cache.set('key1', testConfig, 300000);
+        await cache.set('key2', testConfig, 300000);
+
+        await expect(cache.clear()).resolves.not.toThrow();
+      });
+    });
+
+    describe('use cases', () => {
+      test('should be useful for testing scenarios requiring fresh data', async () => {
+        // Simulate always fetching from API (no cache)
+        let fetchCount = 0;
+        const mockFetch = async () => {
+          fetchCount++;
+          return testConfig;
+        };
+
+        // First "fetch"
+        await mockFetch();
+        await cache.set('key1', testConfig, 300000);
+
+        // Second "fetch" - cache returns null, so would fetch again
+        const cached = await cache.get('key1');
+        if (!cached) {
+          await mockFetch();
+        }
+
+        expect(fetchCount).toBe(2);
+      });
+
+      test('should allow disabling caching entirely', async () => {
+        // Set multiple times
+        await cache.set('key1', testConfig, 300000);
+        await cache.set('key1', testConfig, 300000);
+        await cache.set('key1', testConfig, 300000);
+
+        // Still returns null
+        expect(await cache.get('key1')).toBeNull();
+      });
+    });
+  });
+
+  describe('Cache Interface Compliance', () => {
+    test('InMemoryToolProtectionCache should implement ToolProtectionCache interface', () => {
+      const cache: ToolProtectionCache = new InMemoryToolProtectionCache();
+
+      expect(cache).toBeDefined();
+      expect(typeof cache.get).toBe('function');
+      expect(typeof cache.set).toBe('function');
+      expect(typeof cache.delete).toBe('function');
+      expect(typeof cache.clear).toBe('function');
+    });
+
+    test('NoOpToolProtectionCache should implement ToolProtectionCache interface', () => {
+      const cache: ToolProtectionCache = new NoOpToolProtectionCache();
+
+      expect(cache).toBeDefined();
+      expect(typeof cache.get).toBe('function');
+      expect(typeof cache.set).toBe('function');
+      expect(typeof cache.delete).toBe('function');
+      expect(typeof cache.clear).toBe('function');
+    });
+
+    test('both cache implementations should handle same interface methods', async () => {
+      const inMemoryCache = new InMemoryToolProtectionCache();
+      const noOpCache = new NoOpToolProtectionCache();
+
+      const testConfig: ToolProtectionConfig = {
+        toolProtections: {
+          tool1: {
+            requiresDelegation: true,
+            requiredScopes: ['scope1'],
+          },
+        },
+      };
+
+      // Both should accept same method signatures
+      await inMemoryCache.set('key1', testConfig, 300000);
+      await noOpCache.set('key1', testConfig, 300000);
+
+      await inMemoryCache.get('key1');
+      await noOpCache.get('key1');
+
+      await inMemoryCache.delete('key1');
+      await noOpCache.delete('key1');
+
+      await inMemoryCache.clear();
+      await noOpCache.clear();
+    });
+  });
+});
+