@kya-os/mcp-i-core 1.3.12 → 1.3.14

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

@@ -1,640 +0,0 @@
-/**
- * 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();
-    });
-  });
-});
-