@jolibox/implement 1.2.5 → 1.2.6

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

@@ -1,686 +0,0 @@
-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);
-    });
-  });
-});