@kya-os/create-mcpi-app 1.7.38-canary.1 → 1.7.38

package/test-cloudflare/tests/cache-invalidation.test.ts

@@ -1,410 +0,0 @@
-import { describe, test, expect, vi, beforeEach } from 'vitest';
-
-/**
- * Cache Invalidation Tests
- * Tests various cache invalidation strategies for security and performance
- */
-describe('Cache Invalidation Strategies', () => {
-
-  // Mock KV namespaces
-  const mockKV = {
-    get: vi.fn(),
-    put: vi.fn(),
-    delete: vi.fn(),
-    list: vi.fn()
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    global.fetch = vi.fn();
-  });
-
-  describe('Short TTL Strategy (Recommended)', () => {
-    test('should use 5-minute TTL for delegation cache', async () => {
-      const token = 'test-token';
-      const CACHE_TTL = 5 * 60; // 5 minutes
-
-      // Store with short TTL
-      await mockKV.put(
-        `delegation:${token}`,
-        'valid',
-        { expirationTtl: CACHE_TTL }
-      );
-
-      expect(mockKV.put).toHaveBeenCalledWith(
-        `delegation:${token}`,
-        'valid',
-        { expirationTtl: 300 } // 5 minutes in seconds
-      );
-    });
-
-    test('should use 1-minute TTL for verification cache', async () => {
-      const token = 'verified-token';
-      const VERIFICATION_TTL = 60; // 1 minute
-
-      // Cache verification result
-      await mockKV.put(
-        `verified:${token.substring(0, 16)}`,
-        '1',
-        { expirationTtl: VERIFICATION_TTL }
-      );
-
-      expect(mockKV.put).toHaveBeenCalledWith(
-        expect.stringContaining('verified:'),
-        '1',
-        { expirationTtl: 60 }
-      );
-    });
-
-    test('should re-verify after TTL expiration', async () => {
-      const token = 'expired-cache-token';
-      const cacheKey = `verified:${token.substring(0, 16)}`;
-
-      // First check - cache miss
-      mockKV.get.mockResolvedValueOnce(null);
-
-      // Verify with API
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true
-      });
-
-      // Actually call the API
-      await global.fetch('https://test-api/verify');
-
-      // Cache the result
-      await mockKV.put(cacheKey, '1', { expirationTtl: 60 });
-
-      // After TTL expires, should re-verify
-      mockKV.get.mockResolvedValueOnce(null); // Cache expired
-
-      // Call API again
-      await global.fetch('https://test-api/verify');
-
-      // Should have been called twice
-      expect(global.fetch).toHaveBeenCalledTimes(2);
-    });
-
-    test('should handle cache miss gracefully', async () => {
-      const token = 'no-cache-token';
-
-      // Cache miss
-      mockKV.get.mockResolvedValueOnce(null);
-
-      // Should proceed with verification
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true
-      });
-
-      // Should not throw
-      expect(() => mockKV.get(`verified:${token.substring(0, 16)}`)).not.toThrow();
-    });
-  });
-
-  describe('Immediate Invalidation on Revocation', () => {
-    test('should invalidate all caches when delegation revoked', async () => {
-      const sessionId = 'revoked-session';
-      const agentDid = 'did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK';
-      const token = 'revoked-token';
-
-      const keysToDelete = [
-        `session:${sessionId}`,
-        `agent:${agentDid}:delegation`,
-        `verified:${token.substring(0, 16)}`
-      ];
-
-      // Perform invalidation
-      for (const key of keysToDelete) {
-        await mockKV.delete(key);
-      }
-
-      // Verify all caches cleared
-      expect(mockKV.delete).toHaveBeenCalledTimes(3);
-      expect(mockKV.delete).toHaveBeenCalledWith(`session:${sessionId}`);
-      expect(mockKV.delete).toHaveBeenCalledWith(`agent:${agentDid}:delegation`);
-      expect(mockKV.delete).toHaveBeenCalledWith(`verified:${token.substring(0, 16)}`);
-    });
-
-    test('should handle partial invalidation failures', async () => {
-      const sessionId = 'partial-fail-session';
-      const token = 'partial-fail-token';
-
-      // Some deletions fail
-      mockKV.delete
-        .mockResolvedValueOnce(undefined) // Success
-        .mockRejectedValueOnce(new Error('KV error')) // Fail
-        .mockResolvedValueOnce(undefined); // Success
-
-      const deletions = [
-        mockKV.delete(`session:${sessionId}`),
-        mockKV.delete(`agent:test:delegation`).catch(() => null),
-        mockKV.delete(`verified:${token.substring(0, 16)}`)
-      ];
-
-      const results = await Promise.allSettled(deletions);
-
-      // Should not throw, handle failures gracefully
-      expect(results[0].status).toBe('fulfilled');
-      expect(results[1].status).toBe('fulfilled'); // Caught error
-      expect(results[2].status).toBe('fulfilled');
-    });
-
-    test('should invalidate when API returns 401/403', async () => {
-      const token = 'unauthorized-token';
-
-      // API returns unauthorized
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: false,
-        status: 401
-      });
-
-      // Should trigger invalidation
-      await mockKV.delete(`verified:${token.substring(0, 16)}`);
-      await mockKV.delete(`delegation:${token}`);
-
-      expect(mockKV.delete).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('Batch Invalidation', () => {
-    test('should invalidate all tokens for a user', async () => {
-      const userId = 'user-123';
-
-      // List all user's tokens
-      mockKV.list.mockResolvedValueOnce({
-        keys: [
-          { name: `user:${userId}:delegation:1` },
-          { name: `user:${userId}:delegation:2` },
-          { name: `user:${userId}:delegation:3` }
-        ]
-      });
-
-      // Get list of keys
-      const result = await mockKV.list({ prefix: `user:${userId}:` });
-
-      // Delete all
-      const deletions = result.keys.map(key =>
-        mockKV.delete(key.name)
-      );
-
-      await Promise.all(deletions);
-
-      expect(mockKV.delete).toHaveBeenCalledTimes(3);
-    });
-
-    test('should invalidate all tokens for an agent', async () => {
-      const agentDid = 'did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK';
-
-      // List all agent's tokens
-      mockKV.list.mockResolvedValueOnce({
-        keys: [
-          { name: `agent:${agentDid}:delegation` },
-          { name: `agent:${agentDid}:session:1` },
-          { name: `agent:${agentDid}:session:2` }
-        ]
-      });
-
-      const result = await mockKV.list({ prefix: `agent:${agentDid}:` });
-
-      // Delete all
-      const deletions = result.keys.map(key =>
-        mockKV.delete(key.name)
-      );
-
-      await Promise.all(deletions);
-
-      expect(mockKV.delete).toHaveBeenCalledTimes(3);
-    });
-  });
-
-  describe('Performance Optimization', () => {
-    test('should batch verification requests', async () => {
-      const tokens = ['token1', 'token2', 'token3'];
-
-      // Check cache for all tokens
-      mockKV.get
-        .mockResolvedValueOnce(null) // token1 miss
-        .mockResolvedValueOnce('1')  // token2 hit
-        .mockResolvedValueOnce(null); // token3 miss
-
-      // Only verify uncached tokens
-      const toVerify = ['token1', 'token3'];
-
-      // Batch API call
-      global.fetch = vi.fn().mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          results: {
-            token1: { valid: true },
-            token3: { valid: false }
-          }
-        })
-      });
-
-      // Make the batch API call
-      await global.fetch('https://test-api/batch-verify', {
-        method: 'POST',
-        body: JSON.stringify({ tokens: toVerify })
-      });
-
-      // Should have made single API call for multiple tokens
-      expect(global.fetch).toHaveBeenCalledTimes(1);
-    });
-
-    test('should use stale-while-revalidate pattern', async () => {
-      const token = 'stale-token';
-      const cacheKey = `verified:${token.substring(0, 16)}`;
-
-      // Stale-while-revalidate pattern test
-      // This test verifies that:
-      // 1. Cached value is returned immediately (fast response)
-      // 2. Background revalidation happens asynchronously
-
-      // Simulate getting a cached value
-      const staleCachedValue = '1';
-
-      // In a real implementation:
-      // - Check cache first, return immediately if found (stale but fast)
-      // - Trigger background revalidation without blocking
-      // - User experiences fast response with eventual consistency
-
-      expect(staleCachedValue).toBe('1'); // Immediate return
-
-      // Background revalidation would happen asynchronously
-      const backgroundRevalidation = async () => {
-        await mockKV.put(cacheKey, '1', { expirationTtl: 60 });
-      };
-
-      // Verify pattern is conceptually sound
-      expect(typeof backgroundRevalidation).toBe('function');
-    });
-  });
-
-  describe('Cache Consistency', () => {
-    test('should maintain consistency across DO instances', async () => {
-      const token = 'consistent-token';
-
-      // Instance 1 invalidates
-      await mockKV.delete(`verified:${token.substring(0, 16)}`);
-
-      // Instance 2 should see invalidation
-      mockKV.get.mockResolvedValueOnce(null);
-
-      const result = await mockKV.get(`verified:${token.substring(0, 16)}`);
-      expect(result).toBeNull();
-    });
-
-    test('should handle race conditions during invalidation', async () => {
-      const token = 'race-condition-token';
-
-      // Simulate concurrent operations
-      const operations = [
-        mockKV.put(`verified:${token.substring(0, 16)}`, '1', { expirationTtl: 60 }),
-        mockKV.delete(`verified:${token.substring(0, 16)}`),
-        mockKV.get(`verified:${token.substring(0, 16)}`)
-      ];
-
-      // All operations should complete without error
-      const results = await Promise.allSettled(operations);
-
-      expect(results.every(r => r.status === 'fulfilled')).toBe(true);
-    });
-  });
-
-  describe('Monitoring and Metrics', () => {
-    test('should track cache hit rate', () => {
-      const metrics = {
-        cacheHits: 0,
-        cacheMisses: 0,
-        get hitRate() {
-          const total = this.cacheHits + this.cacheMisses;
-          return total > 0 ? this.cacheHits / total : 0;
-        }
-      };
-
-      // Simulate cache operations
-      metrics.cacheHits += 8;
-      metrics.cacheMisses += 2;
-
-      expect(metrics.hitRate).toBe(0.8); // 80% hit rate
-    });
-
-    test('should track invalidation frequency', () => {
-      const metrics = {
-        invalidations: [],
-        addInvalidation(reason: string) {
-          this.invalidations.push({
-            timestamp: Date.now(),
-            reason
-          });
-        },
-        getRate(windowMs: number) {
-          const now = Date.now();
-          const recent = this.invalidations.filter(
-            i => i.timestamp > now - windowMs
-          );
-          return recent.length;
-        }
-      };
-
-      // Track invalidations
-      metrics.addInvalidation('revocation');
-      metrics.addInvalidation('expiration');
-      metrics.addInvalidation('manual');
-
-      // Check rate in last minute
-      const ratePerMinute = metrics.getRate(60000);
-      expect(ratePerMinute).toBe(3);
-    });
-  });
-
-  describe('Edge Cases', () => {
-    test('should handle KV storage limits', async () => {
-      // KV has 25 MiB value limit
-      // Use a smaller token for testing (1 MiB instead of 26 MiB to avoid test output issues)
-      const largeToken = 'x'.repeat(1024 * 1024); // 1 MiB
-
-      try {
-        await mockKV.put('large-key', largeToken);
-      } catch (error: any) {
-        expect(error.message).toContain('too large');
-      }
-
-      // Should use token hash instead
-      const tokenHash = 'hash-of-large-token';
-      await mockKV.put(`verified:${tokenHash.substring(0, 16)}`, '1');
-
-      expect(mockKV.put).toHaveBeenCalledWith(
-        expect.stringContaining('verified:'),
-        '1'
-        // No third argument expected
-      );
-    });
-
-    test('should handle KV operation failures', async () => {
-      // KV operations can fail
-      mockKV.get.mockRejectedValueOnce(new Error('KV unavailable'));
-
-      try {
-        await mockKV.get('test-key');
-      } catch (error: any) {
-        expect(error.message).toBe('KV unavailable');
-      }
-
-      // Should fail open (allow request) in read failures
-      // Should fail closed (deny request) in write failures
-    });
-
-    test('should handle clock skew', () => {
-      const serverTime = Date.now();
-      const clientTime = serverTime + (5 * 60 * 1000); // 5 minutes ahead
-
-      const skew = Math.abs(clientTime - serverTime);
-      const maxSkew = 2 * 60 * 1000; // 2 minutes tolerance
-
-      // Should detect excessive skew
-      if (skew > maxSkew) {
-        expect(skew).toBeGreaterThan(maxSkew);
-      }
-    });
-  });
-});