@umituz/react-native-storage 2.0.0 → 2.3.3

package/src/infrastructure/repositories/__tests__/BaseStorageOperations.test.ts

@@ -0,0 +1,200 @@
+/**
+ * BaseStorageOperations Tests
+ *
+ * Unit tests for BaseStorageOperations
+ */
+
+import { BaseStorageOperations } from '../BaseStorageOperations';
+import { AsyncStorage } from '../../__tests__/mocks/asyncStorage.mock';
+import { StorageReadError, StorageWriteError, StorageDeleteError } from '../../../domain/errors/StorageError';
+
+describe('BaseStorageOperations', () => {
+  let baseOps: BaseStorageOperations;
+
+  beforeEach(() => {
+    baseOps = new BaseStorageOperations();
+    (AsyncStorage as any).__clear();
+  });
+
+  describe('getItem', () => {
+    it('should get item successfully', async () => {
+      const key = 'test-key';
+      const value = { test: 'value' };
+      const defaultValue = { default: true };
+
+      // Setup
+      await AsyncStorage.setItem(key, JSON.stringify(value));
+
+      // Test
+      const result = await baseOps.getItem(key, defaultValue);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(value);
+    });
+
+    it('should return default value for missing key', async () => {
+      const key = 'missing-key';
+      const defaultValue = { default: true };
+
+      const result = await baseOps.getItem(key, defaultValue);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(defaultValue);
+    });
+
+    it('should handle deserialization error', async () => {
+      const key = 'invalid-json-key';
+      const defaultValue = { default: true };
+
+      // Setup invalid JSON
+      await AsyncStorage.setItem(key, 'invalid-json');
+
+      const result = await baseOps.getItem(key, defaultValue);
+
+      expect(result.success).toBe(false);
+      expect(result.data).toBe(defaultValue);
+      expect(result.error).toBeInstanceOf(StorageReadError);
+    });
+
+    it('should handle storage read error', async () => {
+      const key = 'test-key';
+      const defaultValue = { default: true };
+
+      // Mock storage error
+      (AsyncStorage.getItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const result = await baseOps.getItem(key, defaultValue);
+
+      expect(result.success).toBe(false);
+      expect(result.data).toBe(defaultValue);
+      expect(result.error).toBeInstanceOf(StorageReadError);
+    });
+  });
+
+  describe('setItem', () => {
+    it('should set item successfully', async () => {
+      const key = 'test-key';
+      const value = { test: 'value' };
+
+      const result = await baseOps.setItem(key, value);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(value);
+
+      // Verify storage
+      const stored = await AsyncStorage.getItem(key);
+      expect(JSON.parse(stored!)).toEqual(value);
+    });
+
+    it('should handle serialization error', async () => {
+      const key = 'test-key';
+      const value = { circular: {} };
+      value.circular = value; // Create circular reference
+
+      const result = await baseOps.setItem(key, value);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(StorageWriteError);
+    });
+
+    it('should handle storage write error', async () => {
+      const key = 'test-key';
+      const value = { test: 'value' };
+
+      // Mock storage error
+      (AsyncStorage.setItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const result = await baseOps.setItem(key, value);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(StorageWriteError);
+    });
+  });
+
+  describe('removeItem', () => {
+    it('should remove item successfully', async () => {
+      const key = 'test-key';
+
+      // Setup
+      await AsyncStorage.setItem(key, 'test-value');
+
+      const result = await baseOps.removeItem(key);
+
+      expect(result.success).toBe(true);
+
+      // Verify removal
+      const stored = await AsyncStorage.getItem(key);
+      expect(stored).toBeNull();
+    });
+
+    it('should handle storage delete error', async () => {
+      const key = 'test-key';
+
+      // Mock storage error
+      (AsyncStorage.removeItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const result = await baseOps.removeItem(key);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(StorageDeleteError);
+    });
+  });
+
+  describe('hasItem', () => {
+    it('should return true for existing item', async () => {
+      const key = 'test-key';
+
+      // Setup
+      await AsyncStorage.setItem(key, 'test-value');
+
+      const exists = await baseOps.hasItem(key);
+
+      expect(exists).toBe(true);
+    });
+
+    it('should return false for missing item', async () => {
+      const key = 'missing-key';
+
+      const exists = await baseOps.hasItem(key);
+
+      expect(exists).toBe(false);
+    });
+
+    it('should return false on storage error', async () => {
+      const key = 'test-key';
+
+      // Mock storage error
+      (AsyncStorage.getItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const exists = await baseOps.hasItem(key);
+
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('clearAll', () => {
+    it('should clear all storage successfully', async () => {
+      // Setup
+      await AsyncStorage.setItem('key1', 'value1');
+      await AsyncStorage.setItem('key2', 'value2');
+
+      const result = await baseOps.clearAll();
+
+      expect(result.success).toBe(true);
+
+      // Verify clear
+      const keys = await AsyncStorage.getAllKeys();
+      expect(keys).toHaveLength(0);
+    });
+
+    it('should handle storage clear error', async () => {
+      // Mock storage error
+      (AsyncStorage.clear as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const result = await baseOps.clearAll();
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(StorageDeleteError);
+    });
+  });
+});

package/src/presentation/hooks/CacheStorageOperations.ts

@@ -0,0 +1,95 @@
+/**
+ * Cache Storage Operations
+ *
+ * Handles cache storage operations following Single Responsibility Principle
+ */
+
+import { storageRepository } from '../../infrastructure/repositories/AsyncStorageRepository';
+import type { CachedValue } from '../../domain/entities/CachedValue';
+import { createCachedValue } from '../../domain/entities/CachedValue';
+import { devWarn } from '../../domain/utils/devUtils';
+
+export interface CacheStorageOptions {
+  ttl?: number;
+  version?: number;
+  enabled?: boolean;
+}
+
+/**
+ * Handles cache storage operations with proper error handling and memory management
+ */
+export class CacheStorageOperations {
+  private static instance: CacheStorageOperations | null = null;
+
+  /**
+   * Singleton pattern to prevent memory leaks
+   */
+  static getInstance(): CacheStorageOperations {
+    if (!CacheStorageOperations.instance) {
+      CacheStorageOperations.instance = new CacheStorageOperations();
+    }
+    return CacheStorageOperations.instance;
+  }
+
+  /**
+   * Reset singleton instance (useful for testing)
+   */
+  static resetInstance(): void {
+    CacheStorageOperations.instance = null;
+  }
+
+  /**
+   * Load cached data from storage
+   */
+  async loadFromStorage<T>(
+    key: string,
+    version?: number
+  ): Promise<CachedValue<T> | null> {
+    try {
+      const result = await storageRepository.getString(key, '');
+
+      if (result.success && result.data) {
+        const cached = JSON.parse(result.data) as CachedValue<T>;
+        return cached;
+      }
+
+      return null;
+    } catch (error) {
+      devWarn(`CacheStorageOperations: Failed to load cache for key "${key}"`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Save data to cache storage
+   */
+  async saveToStorage<T>(
+    key: string,
+    value: T,
+    options: CacheStorageOptions = {}
+  ): Promise<void> {
+    const { ttl, version, enabled = true } = options;
+
+    if (!enabled) return;
+
+    try {
+      const cached = createCachedValue(value, ttl || 0, version);
+      await storageRepository.setString(key, JSON.stringify(cached));
+    } catch (error) {
+      devWarn(`CacheStorageOperations: Failed to save cache for key "${key}"`, error);
+    }
+  }
+
+  /**
+   * Clear cached data from storage
+   */
+  async clearFromStorage(key: string, enabled = true): Promise<void> {
+    if (!enabled) return;
+
+    try {
+      await storageRepository.removeItem(key);
+    } catch (error) {
+      devWarn(`CacheStorageOperations: Failed to clear cache for key "${key}"`, error);
+    }
+  }
+}

package/src/presentation/hooks/__tests__/usePersistentCache.test.ts

@@ -0,0 +1,404 @@
+/**
+ * usePersistentCache Hook Tests
+ *
+ * Unit tests for usePersistentCache hook
+ */
+
+import { renderHook, act } from '@testing-library/react-hooks';
+import { usePersistentCache } from '../usePersistentCache';
+import { AsyncStorage } from '../../__tests__/mocks/asyncStorage.mock';
+import { DEFAULT_TTL } from '../../../domain/constants/CacheDefaults';
+
+describe('usePersistentCache Hook', () => {
+  beforeEach(() => {
+    (AsyncStorage as any).__clear();
+    jest.clearAllMocks();
+    jest.spyOn(Date, 'now').mockReturnValue(1000000);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('Initial Load', () => {
+    it('should load cached data', async () => {
+      const key = 'test-cache';
+      const data = { test: 'value' };
+      const cachedValue = {
+        value: data,
+        cachedAt: 1000000 - 10000, // 10 seconds ago
+        expiresAt: 1000000 + 50000, // 50 seconds from now
+      };
+
+      await AsyncStorage.setItem(key, JSON.stringify(cachedValue));
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        usePersistentCache(key)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current.data).toEqual(data);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.isExpired).toBe(false);
+    });
+
+    it('should handle missing cache', async () => {
+      const key = 'missing-cache';
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        usePersistentCache(key)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current.data).toBeNull();
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.isExpired).toBe(true);
+    });
+
+    it('should handle expired cache', async () => {
+      const key = 'expired-cache';
+      const data = { test: 'value' };
+      const cachedValue = {
+        value: data,
+        cachedAt: 1000000 - 120000, // 2 minutes ago
+        expiresAt: 1000000 - 60000, // 1 minute ago (expired)
+      };
+
+      await AsyncStorage.setItem(key, JSON.stringify(cachedValue));
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        usePersistentCache(key)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current.data).toEqual(data);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.isExpired).toBe(true);
+    });
+  });
+
+  describe('setData', () => {
+    it('should set data to cache', async () => {
+      const key = 'test-cache';
+      const data = { test: 'value' };
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        usePersistentCache(key)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      // Set data
+      await act(async () => {
+        await result.current.setData(data);
+      });
+
+      expect(result.current.data).toEqual(data);
+      expect(result.current.isExpired).toBe(false);
+
+      // Verify storage
+      const stored = await AsyncStorage.getItem(key);
+      const parsed = JSON.parse(stored!);
+      expect(parsed.value).toEqual(data);
+    });
+
+    it('should use custom TTL', async () => {
+      const key = 'test-cache';
+      const data = { test: 'value' };
+      const ttl = 120000; // 2 minutes
+
+      const { result } = renderHook(() => 
+        usePersistentCache(key, { ttl })
+      );
+
+      await act(async () => {
+        await result.current.setData(data);
+      });
+
+      // Verify storage
+      const stored = await AsyncStorage.getItem(key);
+      const parsed = JSON.parse(stored!);
+      expect(parsed.expiresAt - parsed.cachedAt).toBe(ttl);
+    });
+
+    it('should use version', async () => {
+      const key = 'test-cache';
+      const data = { test: 'value' };
+      const version = 2;
+
+      const { result } = renderHook(() => 
+        usePersistentCache(key, { version })
+      );
+
+      await act(async () => {
+        await result.current.setData(data);
+      });
+
+      // Verify storage
+      const stored = await AsyncStorage.getItem(key);
+      const parsed = JSON.parse(stored!);
+      expect(parsed.version).toBe(version);
+    });
+
+    it('should not set data when disabled', async () => {
+      const key = 'test-cache';
+      const data = { test: 'value' };
+
+      const { result } = renderHook(() => 
+        usePersistentCache(key, { enabled: false })
+      );
+
+      await act(async () => {
+        await result.current.setData(data);
+      });
+
+      // Verify storage
+      const stored = await AsyncStorage.getItem(key);
+      expect(stored).toBeNull();
+    });
+  });
+
+  describe('clearData', () => {
+    it('should clear cached data', async () => {
+      const key = 'test-cache';
+      const data = { test: 'value' };
+      const cachedValue = {
+        value: data,
+        cachedAt: 1000000 - 10000,
+        expiresAt: 1000000 + 50000,
+      };
+
+      await AsyncStorage.setItem(key, JSON.stringify(cachedValue));
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        usePersistentCache(key)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      // Clear data
+      await act(async () => {
+        await result.current.clearData();
+      });
+
+      expect(result.current.data).toBeNull();
+      expect(result.current.isExpired).toBe(true);
+
+      // Verify storage
+      const stored = await AsyncStorage.getItem(key);
+      expect(stored).toBeNull();
+    });
+
+    it('should not clear when disabled', async () => {
+      const key = 'test-cache';
+      const data = { test: 'value' };
+      const cachedValue = {
+        value: data,
+        cachedAt: 1000000 - 10000,
+        expiresAt: 1000000 + 50000,
+      };
+
+      await AsyncStorage.setItem(key, JSON.stringify(cachedValue));
+
+      const { result } = renderHook(() => 
+        usePersistentCache(key, { enabled: false })
+      );
+
+      await act(async () => {
+        await result.current.clearData();
+      });
+
+      // Storage should not be cleared
+      const stored = await AsyncStorage.getItem(key);
+      expect(stored).toBe(JSON.stringify(cachedValue));
+    });
+  });
+
+  describe('refresh', () => {
+    it('should refresh cache from storage', async () => {
+      const key = 'test-cache';
+      const data1 = { test: 'value1' };
+      const data2 = { test: 'value2' };
+
+      // Set initial cache
+      const cachedValue1 = {
+        value: data1,
+        timestamp: 1000000 - 10000,
+        ttl: 60000,
+      };
+
+      await AsyncStorage.setItem(key, JSON.stringify(cachedValue1));
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        usePersistentCache(key)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current.data).toEqual(data1);
+
+      // Update storage directly
+      const cachedValue2 = {
+        value: data2,
+        timestamp: 1000000 - 5000,
+        ttl: 60000,
+      };
+
+      await AsyncStorage.setItem(key, JSON.stringify(cachedValue2));
+
+      // Refresh
+      await act(async () => {
+        await result.current.refresh();
+      });
+
+      expect(result.current.data).toEqual(data2);
+    });
+  });
+
+  describe('Performance', () => {
+    it('should use singleton CacheStorageOperations', () => {
+      const { result: result1 } = renderHook(() => 
+        usePersistentCache('key1')
+      );
+
+      const { result: result2 } = renderHook(() => 
+        usePersistentCache('key2')
+      );
+
+      // Both hooks should use the same instance
+      expect(result1.current.setData).toBe(result2.current.setData);
+    });
+
+    it('should not re-run effect when options change', async () => {
+      const key = 'test-cache';
+      const data = { test: 'value' };
+      const cachedValue = {
+        value: data,
+        cachedAt: 1000000 - 10000,
+        expiresAt: 1000000 + 50000,
+      };
+
+      await AsyncStorage.setItem(key, JSON.stringify(cachedValue));
+
+      const { result, rerender, waitForNextUpdate } = renderHook(
+        ({ options }) => usePersistentCache(key, options),
+        { 
+          initialProps: { 
+            options: { ttl: 60000, version: 1, enabled: true } 
+          } 
+        }
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      const getItemCalls = (AsyncStorage.getItem as jest.Mock).mock.calls.length;
+
+      // Rerender with different options
+      rerender({ 
+        options: { ttl: 120000, version: 2, enabled: true } 
+      });
+
+      // Should not trigger another storage read
+      expect((AsyncStorage.getItem as jest.Mock).mock.calls.length).toBe(getItemCalls);
+    });
+
+    it('should re-run effect when key changes', async () => {
+      const key1 = 'key1';
+      const key2 = 'key2';
+      const data1 = { test: 'value1' };
+      const data2 = { test: 'value2' };
+
+      const cachedValue1 = {
+        value: data1,
+        timestamp: 1000000 - 10000,
+        ttl: 60000,
+      };
+
+      const cachedValue2 = {
+        value: data2,
+        timestamp: 1000000 - 10000,
+        ttl: 60000,
+      };
+
+      await AsyncStorage.setItem(key1, JSON.stringify(cachedValue1));
+      await AsyncStorage.setItem(key2, JSON.stringify(cachedValue2));
+
+      const { result, rerender, waitForNextUpdate } = renderHook(
+        ({ key }) => usePersistentCache(key),
+        { initialProps: { key: key1 } }
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current.data).toEqual(data1);
+
+      // Change key
+      rerender({ key: key2 });
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current.data).toEqual(data2);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle storage read error', async () => {
+      const key = 'test-cache';
+
+      // Mock storage error
+      (AsyncStorage.getItem as jest.Mock).mockRejectedValue(new Error('Storage error'));
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        usePersistentCache(key)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current.data).toBeNull();
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.isExpired).toBe(true);
+    });
+
+    it('should handle invalid cache data', async () => {
+      const key = 'test-cache';
+
+      // Set invalid JSON
+      await AsyncStorage.setItem(key, 'invalid-json');
+
+      const { result, waitForNextUpdate } = renderHook(() => 
+        usePersistentCache(key)
+      );
+
+      await act(async () => {
+        await waitForNextUpdate();
+      });
+
+      expect(result.current.data).toBeNull();
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.isExpired).toBe(true);
+    });
+  });
+});