@littlebearapps/platform-admin-sdk 2.0.0 → 2.2.0

package/templates/shared/tests/integration/kv-cache.test.ts

@@ -0,0 +1,252 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  cacheData,
+  getCachedData,
+  getOrCompute,
+  getStoredData,
+  invalidateCache,
+  putWithMetadata,
+  shouldSendAlert,
+  type KVNamespaceLike,
+} from '../../storage/kv/cache';
+import {
+  getCircuitBreakerState,
+  incrementHopCount,
+  isServiceAllowed,
+  recordFailure,
+  recordSuccess,
+  resetCircuitBreaker,
+  updateCircuitBreakerState,
+} from '../../storage/kv/circuit-breaker';
+
+function createMockKV(): KVNamespaceLike & {
+  get: ReturnType<typeof vi.fn>;
+  put: ReturnType<typeof vi.fn>;
+  delete: ReturnType<typeof vi.fn>;
+} {
+  return {
+    get: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn(),
+  } as unknown as KVNamespaceLike & {
+    get: ReturnType<typeof vi.fn>;
+    put: ReturnType<typeof vi.fn>;
+    delete: ReturnType<typeof vi.fn>;
+  };
+}
+
+describe('KV Cache helpers', () => {
+  let mockKV: ReturnType<typeof createMockKV>;
+
+  beforeEach(() => {
+    mockKV = createMockKV();
+  });
+
+  describe('Alert deduplication', () => {
+    it('allows first alert and stores marker', async () => {
+      mockKV.get.mockResolvedValue(null);
+
+      const result = await shouldSendAlert('test-alert', mockKV);
+
+      expect(result).toBe(true);
+      expect(mockKV.put).toHaveBeenCalledWith(
+        'alert:test-alert',
+        expect.any(String),
+        expect.objectContaining({ expirationTtl: 3600 })
+      );
+    });
+
+    it('suppresses duplicate alerts within TTL window', async () => {
+      mockKV.get.mockResolvedValue('already-sent');
+
+      const result = await shouldSendAlert('duplicate-alert', mockKV);
+
+      expect(result).toBe(false);
+      expect(mockKV.put).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Cache primitives', () => {
+    it('stores hot data with default TTL', async () => {
+      await cacheData('mrr', { value: 100 }, mockKV);
+      expect(mockKV.put).toHaveBeenCalledWith(
+        'cache:mrr',
+        JSON.stringify({ value: 100 }),
+        expect.objectContaining({ expirationTtl: 900 })
+      );
+    });
+
+    it('retrieves cached data and parses JSON', async () => {
+      mockKV.get.mockResolvedValue(JSON.stringify({ foo: 'bar' }));
+
+      const cached = await getCachedData<{ foo: string }>('demo', mockKV);
+
+      expect(cached).toEqual({ foo: 'bar' });
+      expect(mockKV.get).toHaveBeenCalledWith('cache:demo');
+    });
+
+    it('supports getOrCompute pattern with cache miss', async () => {
+      mockKV.get.mockResolvedValueOnce(null);
+      const compute = vi.fn().mockResolvedValue({ total: 42 });
+
+      const result = await getOrCompute('report', compute, mockKV, 120);
+
+      expect(compute).toHaveBeenCalledTimes(1);
+      expect(mockKV.put).toHaveBeenCalledWith(
+        'cache:report',
+        JSON.stringify({ total: 42 }),
+        expect.objectContaining({ expirationTtl: 120 })
+      );
+      expect(result).toEqual({ total: 42 });
+    });
+
+    it('returns cached value when available without recomputing', async () => {
+      mockKV.get.mockResolvedValue(JSON.stringify({ total: 99 }));
+      const compute = vi.fn();
+
+      const result = await getOrCompute('report', compute, mockKV);
+
+      expect(compute).not.toHaveBeenCalled();
+      expect(result).toEqual({ total: 99 });
+    });
+
+    it('invalidates cached entries', async () => {
+      await invalidateCache('stale', mockKV);
+      expect(mockKV.delete).toHaveBeenCalledWith('cache:stale');
+    });
+
+    it('stores and retrieves arbitrary data payloads', async () => {
+      mockKV.get.mockResolvedValue(JSON.stringify({ state: 'ok' }));
+
+      await putWithMetadata('status', { state: 'ok' }, mockKV, {
+        ttl: 30,
+        metadata: { scope: 'demo' },
+      });
+      expect(mockKV.put).toHaveBeenCalledWith(
+        'data:status',
+        JSON.stringify({ state: 'ok' }),
+        expect.objectContaining({ expirationTtl: 30, metadata: { scope: 'demo' } })
+      );
+
+      const retrieved = await getStoredData<{ state: string }>('status', mockKV);
+      expect(retrieved).toEqual({ state: 'ok' });
+    });
+  });
+
+  describe('Circuit breaker integration', () => {
+    it('returns default state when none persisted', async () => {
+      mockKV.get.mockResolvedValue(null);
+
+      const state = await getCircuitBreakerState('cloakpipe', mockKV);
+
+      expect(state).toMatchObject({
+        hop_count: 0,
+        cooldown: false,
+        kill_switch: false,
+        consecutive_failures: 0,
+      });
+    });
+
+    it('updates stored state when incrementing hop count', async () => {
+      mockKV.get.mockResolvedValue(
+        JSON.stringify({
+          hop_count: 1,
+          cooldown: false,
+          kill_switch: false,
+          last_updated: '2025-10-25T10:00:00Z',
+          consecutive_failures: 0,
+        })
+      );
+
+      const state = await incrementHopCount('cloakpipe', mockKV, 3);
+
+      expect(state.hop_count).toBe(2);
+      expect(mockKV.put).toHaveBeenCalled();
+    });
+
+    it('trips circuit breaker when hop count exceeds limit', async () => {
+      mockKV.get.mockResolvedValue(
+        JSON.stringify({
+          hop_count: 2,
+          cooldown: false,
+          kill_switch: false,
+          last_updated: '2025-10-25T10:00:00Z',
+          consecutive_failures: 0,
+        })
+      );
+
+      const state = await incrementHopCount('homeostat', mockKV, 3);
+
+      expect(state.cooldown).toBe(true);
+    });
+
+    it('blocks service when kill switch active', async () => {
+      mockKV.get.mockResolvedValue(
+        JSON.stringify({
+          hop_count: 0,
+          cooldown: false,
+          kill_switch: true,
+          consecutive_failures: 0,
+        })
+      );
+
+      const allowed = await isServiceAllowed('gatekeeper', mockKV);
+      expect(allowed).toBe(false);
+    });
+
+    it('records failures and trips when threshold reached', async () => {
+      mockKV.get.mockResolvedValue(
+        JSON.stringify({
+          hop_count: 0,
+          cooldown: false,
+          kill_switch: false,
+          consecutive_failures: 4,
+        })
+      );
+
+      const state = await recordFailure('cloakpipe', mockKV, 5);
+      expect(state.consecutive_failures).toBe(5);
+      expect(state.cooldown).toBe(true);
+    });
+
+    it('resets failure counter on success and clears cooldown', async () => {
+      mockKV.get.mockResolvedValue(
+        JSON.stringify({
+          hop_count: 0,
+          cooldown: true,
+          kill_switch: false,
+          consecutive_failures: 2,
+        })
+      );
+
+      const state = await recordSuccess('homeostat', mockKV);
+      expect(state.consecutive_failures).toBe(0);
+      expect(state.cooldown).toBe(false);
+    });
+
+    it('allows manual state updates and resets', async () => {
+      const updatedState = {
+        hop_count: 1,
+        cooldown: true,
+        kill_switch: false,
+        last_updated: '2025-10-25T10:00:00Z',
+        consecutive_failures: 3,
+      };
+
+      await updateCircuitBreakerState('gatekeeper', updatedState, mockKV);
+      expect(mockKV.put).toHaveBeenCalledWith(
+        'circuit:gatekeeper',
+        expect.any(String),
+        expect.objectContaining({ expirationTtl: 86400 })
+      );
+
+      mockKV.put.mockClear();
+      await resetCircuitBreaker('gatekeeper', mockKV);
+      expect(mockKV.put).toHaveBeenCalledWith(
+        'circuit:gatekeeper',
+        expect.any(String),
+        expect.objectContaining({ expirationTtl: 86400 })
+      );
+    });
+  });
+});