@jolibox/implement 1.2.5-beta.3 → 1.2.5

package/src/common/cache/__tests__/request-cache-service.test.ts

@@ -0,0 +1,686 @@
+import { RequestCacheService, RequestAdapter, CacheConfig } from '../request-cache-service';
+
+// Mock interfaces for testing
+interface TestRequest {
+  id: string;
+  filter?: string;
+}
+
+interface TestResponse {
+  status: string;
+  balance: number;
+  products: Array<{ id: string; name: string; price: number }>;
+  timestamp: number;
+}
+
+interface TestCacheData {
+  products: Array<{ id: string; name: string; price: number }>;
+}
+
+interface TestRealTimeData {
+  balance: number;
+  timestamp: number;
+}
+
+// Test implementation of RequestCacheService
+class TestRequestCacheService extends RequestCacheService<
+  TestRequest,
+  TestResponse,
+  TestCacheData,
+  TestRealTimeData
+> {
+  constructor(
+    adapter: RequestAdapter<TestRequest, TestResponse, TestCacheData, TestRealTimeData>,
+    config?: Partial<CacheConfig<TestCacheData, TestCacheData>>
+  ) {
+    super(adapter, config);
+  }
+
+  // Expose protected/private methods for testing
+  public forceRequest(endpoint: string, options?: TestRequest): Promise<TestResponse> {
+    return super.forceRequest(endpoint, options);
+  }
+
+  public refreshCache(endpoint: string, options?: TestRequest): Promise<TestResponse> {
+    return super.refreshCache(endpoint, options);
+  }
+
+  public warmupCache(endpoint: string, options?: TestRequest): Promise<void> {
+    return super.warmupCache(endpoint, options);
+  }
+
+  // Expose new methods for testing
+  public getPendingRequestKeys(): string[] {
+    return super.getPendingRequestKeys();
+  }
+
+  public hasPendingRequest(key: string): boolean {
+    return super.hasPendingRequest(key);
+  }
+
+  public getCacheSequence(key: string): number | undefined {
+    return super.getCacheSequence(key);
+  }
+
+  public clearCache(key?: string): void {
+    return super.clearCache(key);
+  }
+
+  public clearExpiredCache(): void {
+    return super.clearExpiredCache();
+  }
+
+  public getCacheStats() {
+    return super.getCacheStats();
+  }
+
+  public getCacheKeys(): string[] {
+    return super.getCacheKeys();
+  }
+
+  public hasValidCache(key: string): boolean {
+    return super.hasValidCache(key);
+  }
+}
+
+// Mock RequestAdapter
+class MockRequestAdapter
+  implements RequestAdapter<TestRequest, TestResponse, TestCacheData, TestRealTimeData>
+{
+  private mockExecute: jest.Mock;
+  private mockExtractCacheableData: jest.Mock;
+  private mockExtractRealTimeData: jest.Mock;
+  private mockMergeData: jest.Mock;
+  private mockProcessCachedData: jest.Mock;
+
+  constructor() {
+    this.mockExecute = jest.fn();
+    this.mockExtractCacheableData = jest.fn();
+    this.mockExtractRealTimeData = jest.fn();
+    this.mockMergeData = jest.fn();
+    this.mockProcessCachedData = jest.fn();
+  }
+
+  async execute(endpoint: string, options?: TestRequest): Promise<TestResponse> {
+    return this.mockExecute(endpoint, options);
+  }
+
+  extractCacheableData(response: TestResponse): TestCacheData {
+    return this.mockExtractCacheableData(response);
+  }
+
+  extractRealTimeData(response: TestResponse): TestRealTimeData {
+    return this.mockExtractRealTimeData(response);
+  }
+
+  mergeData(cached: TestCacheData, realTime: TestRealTimeData): TestResponse {
+    return this.mockMergeData(cached, realTime);
+  }
+
+  processCachedData(cached: TestCacheData): TestResponse {
+    return this.mockProcessCachedData(cached);
+  }
+
+  // Getters for accessing mocks in tests
+  get executeMock() {
+    return this.mockExecute;
+  }
+  get extractCacheableDataMock() {
+    return this.mockExtractCacheableData;
+  }
+  get extractRealTimeDataMock() {
+    return this.mockExtractRealTimeData;
+  }
+  get mergeDataMock() {
+    return this.mockMergeData;
+  }
+  get processCachedDataMock() {
+    return this.mockProcessCachedData;
+  }
+}
+
+describe('RequestCacheService', () => {
+  let mockAdapter: MockRequestAdapter;
+  let cacheService: TestRequestCacheService;
+
+  const mockResponse: TestResponse = {
+    status: 'success',
+    balance: 1000,
+    products: [
+      { id: '1', name: 'Product 1', price: 100 },
+      { id: '2', name: 'Product 2', price: 200 }
+    ],
+    timestamp: Date.now()
+  };
+
+  const mockCacheData: TestCacheData = {
+    products: [
+      { id: '1', name: 'Product 1', price: 100 },
+      { id: '2', name: 'Product 2', price: 200 }
+    ]
+  };
+
+  const mockRealTimeData: TestRealTimeData = {
+    balance: 1000,
+    timestamp: Date.now()
+  };
+
+  beforeEach(() => {
+    mockAdapter = new MockRequestAdapter();
+    cacheService = new TestRequestCacheService(mockAdapter, {
+      duration: 5000, // 5 seconds for testing
+      timeout: 1000 // 1 second timeout
+    });
+
+    // Default mock implementations
+    mockAdapter.executeMock.mockResolvedValue(mockResponse);
+    mockAdapter.extractCacheableDataMock.mockReturnValue(mockCacheData);
+    mockAdapter.extractRealTimeDataMock.mockReturnValue(mockRealTimeData);
+    mockAdapter.mergeDataMock.mockReturnValue(mockResponse);
+    mockAdapter.processCachedDataMock.mockReturnValue(mockResponse);
+
+    // Ensure the adapter methods are properly set (not undefined)
+    mockAdapter.extractRealTimeData = mockAdapter.extractRealTimeDataMock;
+    mockAdapter.mergeData = mockAdapter.mergeDataMock;
+
+    // Clear console mocks
+    jest.spyOn(console, 'log').mockImplementation();
+    jest.spyOn(console, 'warn').mockImplementation();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllTimers();
+    // Reset adapter methods to avoid test interference
+    if (mockAdapter) {
+      mockAdapter.extractRealTimeData = mockAdapter.extractRealTimeDataMock;
+      mockAdapter.mergeData = mockAdapter.mergeDataMock;
+    }
+  });
+
+  describe('Cache Miss Scenarios', () => {
+    it('should fetch fresh data when cache is empty', async () => {
+      const result = await cacheService.request('/api/test', { id: '123' });
+
+      expect(mockAdapter.executeMock).toHaveBeenCalledWith('/api/test', { id: '123' });
+      expect(mockAdapter.extractCacheableDataMock).toHaveBeenCalledWith(mockResponse);
+      expect(result).toEqual(mockResponse);
+      expect(console.log).toHaveBeenCalledWith(
+        '[RequestCacheService] Cache miss, fetching fresh data for /api/test (sequence: 1)'
+      );
+    });
+
+    it('should cache extracted data after fresh request', async () => {
+      await cacheService.request('/api/test');
+
+      // Second request should hit cache and merge with real-time data
+      mockAdapter.executeMock.mockClear();
+      await cacheService.request('/api/test');
+
+      // Should still make network request for real-time data
+      expect(mockAdapter.executeMock).toHaveBeenCalledTimes(1);
+      expect(mockAdapter.mergeDataMock).toHaveBeenCalledWith(mockCacheData, mockRealTimeData);
+    });
+
+    it('should handle when extractCacheableData returns undefined', async () => {
+      mockAdapter.extractCacheableDataMock.mockReturnValue(undefined);
+
+      const result = await cacheService.request('/api/no-cache');
+
+      expect(mockAdapter.executeMock).toHaveBeenCalledWith('/api/no-cache', undefined);
+      expect(result).toEqual(mockResponse);
+
+      // Second request should still make network call since no cache was saved
+      mockAdapter.executeMock.mockClear();
+      await cacheService.request('/api/no-cache');
+      expect(mockAdapter.executeMock).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not make network request when no real-time data is needed', async () => {
+      // Create service without real-time data extractors
+      const pureAdapter = new MockRequestAdapter();
+      pureAdapter.executeMock.mockResolvedValue(mockResponse);
+      pureAdapter.extractCacheableDataMock.mockReturnValue(mockCacheData);
+      pureAdapter.processCachedDataMock.mockReturnValue(mockResponse);
+
+      // Set extractRealTimeData and mergeData to undefined to simulate pure cache scenario
+      (pureAdapter as any).extractRealTimeData = undefined;
+      (pureAdapter as any).mergeData = undefined;
+
+      const pureCacheService = new TestRequestCacheService(pureAdapter, {
+        duration: 5000,
+        timeout: 1000
+      });
+
+      // First request - should make network call
+      await pureCacheService.request('/api/pure-cache');
+
+      // Second request - should NOT make network call
+      pureAdapter.executeMock.mockClear();
+      const result = await pureCacheService.request('/api/pure-cache');
+
+      expect(pureAdapter.executeMock).not.toHaveBeenCalled();
+      expect(pureAdapter.processCachedDataMock).toHaveBeenCalledWith(mockCacheData);
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should make fresh request when cache is expired', async () => {
+      jest.useFakeTimers();
+
+      // Create service with very short cache duration
+      const shortCacheService = new TestRequestCacheService(mockAdapter, {
+        duration: 1000, // 1 second
+        timeout: 1000
+      });
+
+      // First request
+      await shortCacheService.request('/api/expire-test');
+      mockAdapter.executeMock.mockClear();
+
+      // Fast-forward time to expire cache
+      jest.advanceTimersByTime(1500);
+
+      // Second request should make network call since cache expired
+      await shortCacheService.request('/api/expire-test');
+      expect(mockAdapter.executeMock).toHaveBeenCalledTimes(1);
+      expect(console.log).toHaveBeenCalledWith(
+        '[RequestCacheService] Cache miss, fetching fresh data for /api/expire-test (sequence: 2)'
+      );
+
+      jest.useRealTimers();
+    });
+  });
+
+  describe('Cache Hit Scenarios', () => {
+    beforeEach(async () => {
+      // Pre-populate cache
+      await cacheService.request('/api/test');
+      mockAdapter.executeMock.mockClear();
+    });
+
+    it('should return cached data without network request for pure cache scenario', async () => {
+      // Set extractRealTimeData and mergeData to undefined to simulate pure cache scenario
+      (mockAdapter as any).extractRealTimeData = undefined;
+      (mockAdapter as any).mergeData = undefined;
+
+      const result = await cacheService.request('/api/test');
+
+      expect(mockAdapter.executeMock).not.toHaveBeenCalled();
+      expect(mockAdapter.processCachedDataMock).toHaveBeenCalledWith(mockCacheData);
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should merge cached data with fresh real-time data', async () => {
+      const result = await cacheService.request('/api/test');
+
+      expect(mockAdapter.executeMock).toHaveBeenCalledTimes(1);
+      expect(mockAdapter.extractRealTimeDataMock).toHaveBeenCalledWith(mockResponse);
+      expect(mockAdapter.mergeDataMock).toHaveBeenCalledWith(mockCacheData, mockRealTimeData);
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('Cache Invalidation', () => {
+    beforeEach(async () => {
+      // Pre-populate cache
+      await cacheService.request('/api/test');
+      mockAdapter.executeMock.mockClear();
+    });
+
+    it('should invalidate cache when consistency check fails', async () => {
+      // Setup service with consistency checker that returns false
+      const consistencyChecker = jest.fn().mockReturnValue(false);
+      cacheService = new TestRequestCacheService(mockAdapter, {
+        duration: 5000,
+        consistencyChecker
+      });
+
+      // Pre-populate cache
+      await cacheService.request('/api/test');
+      mockAdapter.executeMock.mockClear();
+
+      const newCacheData = { products: [{ id: '3', name: 'New Product', price: 300 }] };
+      mockAdapter.extractCacheableDataMock.mockReturnValue(newCacheData);
+
+      const result = await cacheService.request('/api/test');
+
+      expect(consistencyChecker).toHaveBeenCalled();
+      expect(console.log).toHaveBeenCalledWith(
+        '[RequestCacheService] Cache invalidated due to data change for /api/test'
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should keep cache when consistency check passes', async () => {
+      // Setup service with consistency checker that returns true
+      const consistencyChecker = jest.fn().mockReturnValue(true);
+      cacheService = new TestRequestCacheService(mockAdapter, {
+        duration: 5000,
+        consistencyChecker
+      });
+
+      // Pre-populate cache
+      await cacheService.request('/api/test');
+      mockAdapter.executeMock.mockClear();
+
+      const result = await cacheService.request('/api/test');
+
+      expect(consistencyChecker).toHaveBeenCalledWith(mockCacheData, mockCacheData);
+      expect(mockAdapter.mergeDataMock).toHaveBeenCalledWith(mockCacheData, mockRealTimeData);
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should not run consistency check when no server cacheable data', async () => {
+      const consistencyChecker = jest.fn();
+      cacheService = new TestRequestCacheService(mockAdapter, {
+        duration: 5000,
+        consistencyChecker
+      });
+
+      // Pre-populate cache
+      await cacheService.request('/api/test');
+      mockAdapter.executeMock.mockClear();
+
+      // Set extractCacheableData to return undefined
+      mockAdapter.extractCacheableDataMock.mockReturnValue(undefined);
+
+      const result = await cacheService.request('/api/test');
+
+      expect(consistencyChecker).not.toHaveBeenCalled();
+      expect(mockAdapter.mergeDataMock).toHaveBeenCalledWith(mockCacheData, mockRealTimeData);
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('Error Handling', () => {
+    beforeEach(async () => {
+      // Pre-populate cache
+      await cacheService.request('/api/test');
+      mockAdapter.executeMock.mockClear();
+    });
+
+    it('should fallback to cached data when real-time request fails', async () => {
+      mockAdapter.executeMock.mockRejectedValue(new Error('Network error'));
+
+      const result = await cacheService.request('/api/test');
+
+      expect(mockAdapter.processCachedDataMock).toHaveBeenCalledWith(mockCacheData);
+      expect(result).toEqual(mockResponse);
+      expect(console.warn).toHaveBeenCalledWith(
+        '[RequestCacheService] Failed to fetch real-time data, using cache only for /api/test:',
+        expect.any(Error)
+      );
+    });
+
+    it('should handle timeout', async () => {
+      jest.useFakeTimers();
+
+      mockAdapter.executeMock.mockImplementation(
+        () => new Promise((resolve) => setTimeout(() => resolve(mockResponse), 2000))
+      );
+
+      const requestPromise = cacheService.request('/api/test-timeout');
+
+      // Fast-forward time to trigger timeout
+      jest.advanceTimersByTime(1000);
+
+      await expect(requestPromise).rejects.toThrow('[RequestCacheService] Request timeout after 1 seconds');
+
+      jest.useRealTimers();
+    });
+
+    it('should allow background cache update even when timeout occurs', async () => {
+      jest.useFakeTimers();
+
+      // Mock a slow request that completes after timeout
+      let resolveRequest: (value: any) => void;
+      const slowRequestPromise = new Promise((resolve) => {
+        resolveRequest = resolve;
+      });
+      mockAdapter.executeMock.mockImplementation(() => slowRequestPromise);
+
+      // Start the request
+      const requestPromise = cacheService.request('/api/background-test');
+
+      // Advance time to trigger timeout
+      jest.advanceTimersByTime(1000);
+
+      // Request should timeout
+      await expect(requestPromise).rejects.toThrow('[RequestCacheService] Request timeout after 1 seconds');
+
+      // Verify cache is initially empty
+      expect(cacheService.hasValidCache('/api/background-test')).toBe(false);
+
+      // Now let the background request complete
+      resolveRequest!(mockResponse);
+
+      // Use real timers for the async wait
+      jest.useRealTimers();
+
+      // Wait for the background promise to resolve
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      // Verify that cache was updated in the background
+      expect(cacheService.hasValidCache('/api/background-test')).toBe(true);
+    }, 10000);
+
+    it('should fallback to cache when timeout occurs and cache exists', async () => {
+      jest.useFakeTimers();
+
+      // Pre-populate cache
+      await cacheService.request('/api/fallback-test');
+      mockAdapter.executeMock.mockClear();
+
+      // Mock a slow request
+      mockAdapter.executeMock.mockImplementation(
+        () => new Promise((resolve) => setTimeout(() => resolve(mockResponse), 2000))
+      );
+
+      // Set extractRealTimeData and mergeData to undefined to test pure cache scenario
+      (mockAdapter as any).extractRealTimeData = undefined;
+      (mockAdapter as any).mergeData = undefined;
+
+      const requestPromise = cacheService.request('/api/fallback-test');
+
+      // Fast-forward time to trigger timeout
+      jest.advanceTimersByTime(1000);
+
+      // Should return cached data instead of throwing timeout error
+      const result = await requestPromise;
+      expect(result).toEqual(mockResponse);
+      expect(mockAdapter.processCachedDataMock).toHaveBeenCalledWith(mockCacheData);
+
+      jest.useRealTimers();
+    });
+  });
+
+  describe('Cache-Only Operations', () => {
+    it('should return cached data when cache exists', async () => {
+      // Pre-populate cache first
+      await cacheService.request('/api/test');
+      mockAdapter.executeMock.mockClear();
+
+      // Set extractRealTimeData and mergeData to undefined to simulate pure cache scenario
+      (mockAdapter as any).extractRealTimeData = undefined;
+      (mockAdapter as any).mergeData = undefined;
+
+      const result = await cacheService.request('/api/test');
+
+      expect(mockAdapter.executeMock).not.toHaveBeenCalled();
+      expect(mockAdapter.processCachedDataMock).toHaveBeenCalledWith(mockCacheData);
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('Force Request', () => {
+    it('should always make network request and update cache', async () => {
+      // Pre-populate cache
+      await cacheService.request('/api/test');
+
+      // Verify that normal request would not make network call (pure cache scenario)
+      (mockAdapter as any).extractRealTimeData = undefined;
+      (mockAdapter as any).mergeData = undefined;
+      mockAdapter.executeMock.mockClear();
+
+      await cacheService.request('/api/test');
+      expect(mockAdapter.executeMock).not.toHaveBeenCalled(); // 验证缓存有效，没有网络请求
+
+      // Now test force request - should always make network call
+      mockAdapter.executeMock.mockClear();
+      const result = await cacheService.forceRequest('/api/test');
+
+      expect(mockAdapter.executeMock).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(mockResponse);
+      expect(console.log).toHaveBeenCalledWith(
+        '[RequestCacheService] Force request for /api/test (sequence: 3)'
+      );
+    });
+  });
+
+  describe('Cache Management', () => {
+    beforeEach(async () => {
+      // Pre-populate cache
+      await cacheService.request('/api/test1');
+      await cacheService.request('/api/test2');
+    });
+
+    it('should refresh cache by deleting and re-requesting', async () => {
+      const result = await cacheService.refreshCache('/api/test1');
+
+      expect(result).toEqual(mockResponse);
+      // Should have made network request for refresh
+      expect(mockAdapter.executeMock).toHaveBeenCalled();
+    });
+
+    it('should clear specific cache entry', async () => {
+      cacheService.clearCache('/api/test1');
+
+      // Try to get cached data - should trigger network request since cache was cleared
+      mockAdapter.executeMock.mockClear();
+      await cacheService.request('/api/test1');
+      expect(mockAdapter.executeMock).toHaveBeenCalled();
+
+      // Other cache should still exist - should not trigger network request
+      mockAdapter.executeMock.mockClear();
+      // Set extractRealTimeData and mergeData to undefined to test pure cache
+      (mockAdapter as any).extractRealTimeData = undefined;
+      (mockAdapter as any).mergeData = undefined;
+
+      await cacheService.request('/api/test2');
+      expect(mockAdapter.executeMock).not.toHaveBeenCalled();
+    });
+
+    it('should clear all cache when no key provided', async () => {
+      cacheService.clearCache();
+
+      // Both should trigger network requests since cache was cleared
+      mockAdapter.executeMock.mockClear();
+      await cacheService.request('/api/test1');
+      expect(mockAdapter.executeMock).toHaveBeenCalled();
+
+      mockAdapter.executeMock.mockClear();
+      await cacheService.request('/api/test2');
+      expect(mockAdapter.executeMock).toHaveBeenCalled();
+    });
+
+    it('should get cache statistics', () => {
+      const stats = cacheService.getCacheStats();
+
+      expect(stats.cacheCount).toBe(2);
+      expect(stats.validCount).toBe(2);
+      expect(stats.expiredCount).toBe(0);
+    });
+
+    it('should get cache keys', () => {
+      const keys = cacheService.getCacheKeys();
+
+      expect(keys).toContain('/api/test1');
+      expect(keys).toContain('/api/test2');
+      expect(keys.length).toBe(2);
+    });
+
+    it('should check if cache is valid', () => {
+      expect(cacheService.hasValidCache('/api/test1')).toBe(true);
+      expect(cacheService.hasValidCache('/api/nonexistent')).toBe(false);
+    });
+
+    it('should clear expired cache entries', async () => {
+      jest.useFakeTimers();
+
+      // Fast-forward time to expire cache
+      jest.advanceTimersByTime(6000); // More than 5 second cache duration
+
+      cacheService.clearExpiredCache();
+
+      // Both should trigger network requests since cache expired and was cleared
+      mockAdapter.executeMock.mockClear();
+      await cacheService.request('/api/test1');
+      expect(mockAdapter.executeMock).toHaveBeenCalled();
+
+      mockAdapter.executeMock.mockClear();
+      await cacheService.request('/api/test2');
+      expect(mockAdapter.executeMock).toHaveBeenCalled();
+
+      jest.useRealTimers();
+    });
+  });
+
+  describe('Cache Warmup', () => {
+    it('should warmup cache successfully', async () => {
+      await cacheService.warmupCache('/api/warmup');
+
+      expect(mockAdapter.executeMock).toHaveBeenCalledWith('/api/warmup', undefined);
+
+      // Subsequent request should hit cache (no network request)
+      mockAdapter.executeMock.mockClear();
+      // Set extractRealTimeData and mergeData to undefined to test pure cache
+      (mockAdapter as any).extractRealTimeData = undefined;
+      (mockAdapter as any).mergeData = undefined;
+
+      await cacheService.request('/api/warmup');
+      expect(mockAdapter.executeMock).not.toHaveBeenCalled();
+    });
+
+    it('should handle warmup failure gracefully', async () => {
+      mockAdapter.executeMock.mockRejectedValue(new Error('Warmup failed'));
+
+      await expect(cacheService.warmupCache('/api/warmup')).resolves.not.toThrow();
+
+      expect(console.warn).toHaveBeenCalledWith(
+        '[RequestCacheService] Cache warmup failed for /api/warmup:',
+        expect.any(Error)
+      );
+    });
+  });
+
+  describe('Custom Configuration', () => {
+    it('should use custom key generator', async () => {
+      const customKeyGenerator = jest.fn().mockReturnValue('custom-key');
+
+      cacheService = new TestRequestCacheService(mockAdapter, {
+        keyGenerator: customKeyGenerator
+      });
+
+      await cacheService.request('/api/test', { id: '123', filter: 'active' });
+
+      expect(customKeyGenerator).toHaveBeenCalledWith('/api/test', { id: '123', filter: 'active' });
+    });
+
+    it('should use custom consistency checker', async () => {
+      const customConsistencyChecker = jest.fn().mockReturnValue(true);
+
+      cacheService = new TestRequestCacheService(mockAdapter, {
+        consistencyChecker: customConsistencyChecker
+      });
+
+      // Pre-populate cache
+      await cacheService.request('/api/test');
+      mockAdapter.executeMock.mockClear();
+
+      // Second request should trigger consistency check
+      await cacheService.request('/api/test');
+
+      expect(customConsistencyChecker).toHaveBeenCalledWith(mockCacheData, mockCacheData);
+    });
+  });
+});