@umituz/react-native-design-system 2.8.7 → 2.8.8

package/src/storage/cache/domain/__tests__/CacheManager.test.ts

@@ -0,0 +1,276 @@
+/**
+ * CacheManager Tests
+ */
+
+import { CacheManager, cacheManager } from '../CacheManager';
+import type { CacheConfig } from '../types/Cache';
+
+describe('CacheManager', () => {
+  let manager: CacheManager;
+
+  beforeEach(() => {
+    // Reset singleton for testing
+    (CacheManager as any).instance = null;
+    manager = CacheManager.getInstance();
+  });
+
+  afterEach(() => {
+    manager.clearAll();
+    (CacheManager as any).instance = null;
+  });
+
+  describe('Singleton Pattern', () => {
+    test('should return the same instance', () => {
+      const instance1 = CacheManager.getInstance();
+      const instance2 = CacheManager.getInstance();
+      
+      expect(instance1).toBe(instance2);
+    });
+
+    test('should create only one instance', () => {
+      const instance1 = CacheManager.getInstance();
+      const instance2 = new (CacheManager as any)();
+      
+      expect(instance1).not.toBe(instance2);
+      expect(instance1).toBe(CacheManager.getInstance());
+    });
+  });
+
+  describe('Cache Management', () => {
+    test('should create and retrieve cache instances', () => {
+      const cache1 = manager.getCache<string>('cache1');
+      const cache2 = manager.getCache<number>('cache2');
+      
+      expect(cache1).toBeDefined();
+      expect(cache2).toBeDefined();
+      expect(cache1).not.toBe(cache2);
+    });
+
+    test('should return same cache instance for same name', () => {
+      const cache1 = manager.getCache<string>('cache1');
+      const cache2 = manager.getCache<string>('cache1');
+      
+      expect(cache1).toBe(cache2);
+    });
+
+    test('should create caches with different types', () => {
+      const stringCache = manager.getCache<string>('strings');
+      const numberCache = manager.getCache<number>('numbers');
+      const objectCache = manager.getCache<{ id: string }>('objects');
+      
+      stringCache.set('key', 'value');
+      numberCache.set('key', 42);
+      objectCache.set('key', { id: 'test' });
+      
+      expect(stringCache.get('key')).toBe('value');
+      expect(numberCache.get('key')).toBe(42);
+      expect(objectCache.get('key')).toEqual({ id: 'test' });
+    });
+
+    test('should apply configuration to cache', () => {
+      const config: CacheConfig = {
+        maxSize: 50,
+        defaultTTL: 10000,
+      };
+      
+      const cache = manager.getCache<string>('configured-cache', config);
+      
+      cache.set('key', 'value');
+      expect(cache.get('key')).toBe('value');
+      
+      // Test configuration is applied (basic check)
+      const stats = cache.getStats();
+      expect(stats.size).toBe(1);
+    });
+  });
+
+  describe('Cache Deletion', () => {
+    test('should delete specific cache', () => {
+      manager.getCache<string>('cache1');
+      manager.getCache<string>('cache2');
+      
+      expect(manager.getCacheNames()).toContain('cache1');
+      expect(manager.getCacheNames()).toContain('cache2');
+      
+      const deleted = manager.deleteCache('cache1');
+      
+      expect(deleted).toBe(true);
+      expect(manager.getCacheNames()).not.toContain('cache1');
+      expect(manager.getCacheNames()).toContain('cache2');
+    });
+
+    test('should return false when deleting non-existent cache', () => {
+      const deleted = manager.deleteCache('nonexistent');
+      
+      expect(deleted).toBe(false);
+    });
+
+    test('should clear cache before deletion', () => {
+      const cache = manager.getCache<string>('cache1');
+      cache.set('key1', 'value1');
+      cache.set('key2', 'value2');
+      
+      expect(cache.getStats().size).toBe(2);
+      
+      manager.deleteCache('cache1');
+      
+      // Get new instance to verify old one was cleared
+      const newCache = manager.getCache<string>('cache1');
+      expect(newCache.getStats().size).toBe(0);
+    });
+  });
+
+  describe('Clear All', () => {
+    test('should clear all caches', () => {
+      const cache1 = manager.getCache<string>('cache1');
+      const cache2 = manager.getCache<string>('cache2');
+      const cache3 = manager.getCache<string>('cache3');
+      
+      cache1.set('key1', 'value1');
+      cache2.set('key2', 'value2');
+      cache3.set('key3', 'value3');
+      
+      expect(cache1.getStats().size).toBe(1);
+      expect(cache2.getStats().size).toBe(1);
+      expect(cache3.getStats().size).toBe(1);
+      expect(manager.getCacheNames()).toHaveLength(3);
+      
+      manager.clearAll();
+      
+      expect(cache1.getStats().size).toBe(0);
+      expect(cache2.getStats().size).toBe(0);
+      expect(cache3.getStats().size).toBe(0);
+      expect(manager.getCacheNames()).toHaveLength(0);
+    });
+
+    test('should handle clear all when no caches exist', () => {
+      expect(() => manager.clearAll()).not.toThrow();
+      expect(manager.getCacheNames()).toHaveLength(0);
+    });
+  });
+
+  describe('Cache Names', () => {
+    test('should return list of cache names', () => {
+      expect(manager.getCacheNames()).toHaveLength(0);
+      
+      manager.getCache<string>('cache1');
+      manager.getCache<string>('cache2');
+      manager.getCache<string>('cache3');
+      
+      const names = manager.getCacheNames();
+      expect(names).toHaveLength(3);
+      expect(names).toContain('cache1');
+      expect(names).toContain('cache2');
+      expect(names).toContain('cache3');
+    });
+
+    test('should not duplicate cache names', () => {
+      manager.getCache<string>('cache1');
+      manager.getCache<string>('cache1'); // Same name
+      manager.getCache<string>('cache2');
+      
+      const names = manager.getCacheNames();
+      expect(names).toHaveLength(2);
+      expect(names.filter(name => name === 'cache1')).toHaveLength(1);
+    });
+  });
+
+  describe('Memory Management', () => {
+    test('should handle large number of caches', () => {
+      const cacheCount = 100;
+      
+      for (let i = 0; i < cacheCount; i++) {
+        const cache = manager.getCache<string>(`cache${i}`);
+        cache.set(`key${i}`, `value${i}`);
+      }
+      
+      expect(manager.getCacheNames()).toHaveLength(cacheCount);
+      
+      // Verify all caches have their data
+      for (let i = 0; i < cacheCount; i++) {
+        const cache = manager.getCache<string>(`cache${i}`);
+        expect(cache.get(`key${i}`)).toBe(`value${i}`);
+      }
+    });
+
+    test('should handle cache deletion in large scale', () => {
+      const cacheCount = 50;
+      
+      // Create caches
+      for (let i = 0; i < cacheCount; i++) {
+        manager.getCache<string>(`cache${i}`);
+      }
+      
+      expect(manager.getCacheNames()).toHaveLength(cacheCount);
+      
+      // Delete every other cache
+      for (let i = 0; i < cacheCount; i += 2) {
+        manager.deleteCache(`cache${i}`);
+      }
+      
+      expect(manager.getCacheNames()).toHaveLength(Math.floor(cacheCount / 2));
+      
+      // Verify remaining caches still work
+      for (let i = 1; i < cacheCount; i += 2) {
+        const cache = manager.getCache<string>(`cache${i}`);
+        cache.set('test', 'value');
+        expect(cache.get('test')).toBe('value');
+      }
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle empty string cache name', () => {
+      const cache = manager.getCache<string>('');
+      expect(cache).toBeDefined();
+      expect(manager.getCacheNames()).toContain('');
+    });
+
+    test('should handle special characters in cache names', () => {
+      const specialNames = ['cache-with-dash', 'cache_with_underscore', 'cache.with.dots', 'cache with spaces'];
+      
+      specialNames.forEach(name => {
+        const cache = manager.getCache<string>(name);
+        expect(cache).toBeDefined();
+        expect(manager.getCacheNames()).toContain(name);
+      });
+    });
+
+    test('should handle very long cache names', () => {
+      const longName = 'a'.repeat(1000);
+      const cache = manager.getCache<string>(longName);
+      
+      expect(cache).toBeDefined();
+      expect(manager.getCacheNames()).toContain(longName);
+    });
+  });
+});
+
+describe('cacheManager export', () => {
+  beforeEach(() => {
+    (CacheManager as any).instance = null;
+  });
+
+  afterEach(() => {
+    cacheManager.clearAll();
+    (CacheManager as any).instance = null;
+  });
+
+  test('should export singleton instance', () => {
+    expect(cacheManager).toBeDefined();
+    expect(cacheManager).toBeInstanceOf(CacheManager);
+  });
+
+  test('should be the same instance as CacheManager.getInstance()', () => {
+    const instance = CacheManager.getInstance();
+    expect(cacheManager).toBe(instance);
+  });
+
+  test('should work with exported instance', () => {
+    const cache = cacheManager.getCache<string>('test-cache');
+    cache.set('key', 'value');
+    
+    expect(cache.get('key')).toBe('value');
+    expect(cacheManager.getCacheNames()).toContain('test-cache');
+  });
+});

package/src/storage/cache/domain/__tests__/ErrorHandler.test.ts

@@ -0,0 +1,303 @@
+/**
+ * ErrorHandler Tests
+ */
+
+import { ErrorHandler, CacheError } from '../ErrorHandler';
+
+describe('ErrorHandler', () => {
+  describe('CacheError', () => {
+    test('should create CacheError with message and code', () => {
+      const error = new CacheError('Test message', 'TEST_CODE');
+      
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toBeInstanceOf(CacheError);
+      expect(error.message).toBe('Test message');
+      expect(error.code).toBe('TEST_CODE');
+      expect(error.name).toBe('CacheError');
+    });
+
+    test('should have stack trace', () => {
+      const error = new CacheError('Test message', 'TEST_CODE');
+      
+      expect(error.stack).toBeDefined();
+      expect(typeof error.stack).toBe('string');
+    });
+
+    test('should be serializable', () => {
+      const error = new CacheError('Test message', 'TEST_CODE');
+      const serialized = JSON.stringify(error);
+      const parsed = JSON.parse(serialized);
+      
+      expect(parsed.message).toBe('Test message');
+      expect(parsed.code).toBe('TEST_CODE');
+      expect(parsed.name).toBe('CacheError');
+    });
+  });
+
+  describe('handle', () => {
+    test('should throw CacheError as-is', () => {
+      const originalError = new CacheError('Original error', 'ORIGINAL');
+      
+      expect(() => {
+        ErrorHandler.handle(originalError, 'test context');
+      }).toThrow('Original error');
+    });
+
+    test('should wrap regular Error in CacheError', () => {
+      const originalError = new Error('Regular error');
+      
+      expect(() => {
+        ErrorHandler.handle(originalError, 'test context');
+      }).toThrow(CacheError);
+    });
+
+    test('should include context in wrapped error message', () => {
+      const originalError = new Error('Regular error');
+      
+      try {
+        ErrorHandler.handle(originalError, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Regular error');
+        expect((error as CacheError).code).toBe('CACHE_ERROR');
+      }
+    });
+
+    test('should handle unknown error type', () => {
+      const unknownError = 'string error';
+      
+      try {
+        ErrorHandler.handle(unknownError, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Unknown error');
+        expect((error as CacheError).code).toBe('UNKNOWN_ERROR');
+      }
+    });
+
+    test('should handle null error', () => {
+      try {
+        ErrorHandler.handle(null, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Unknown error');
+        expect((error as CacheError).code).toBe('UNKNOWN_ERROR');
+      }
+    });
+
+    test('should handle undefined error', () => {
+      try {
+        ErrorHandler.handle(undefined, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Unknown error');
+        expect((error as CacheError).code).toBe('UNKNOWN_ERROR');
+      }
+    });
+
+    test('should preserve original error properties when possible', () => {
+      const originalError = new Error('Original error');
+      (originalError as any).customProperty = 'custom value';
+      
+      try {
+        ErrorHandler.handle(originalError, 'test context');
+      } catch (error) {
+        const cacheError = error as CacheError;
+        expect(cacheError.message).toBe('test context: Original error');
+        expect(cacheError.code).toBe('CACHE_ERROR');
+        // Note: original properties are not copied to maintain clean error structure
+      }
+    });
+  });
+
+  describe('withTimeout', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    test('should resolve promise before timeout', async () => {
+      const promise = Promise.resolve('success');
+      const result = await ErrorHandler.withTimeout(promise, 1000, 'test context');
+      
+      expect(result).toBe('success');
+    });
+
+    test('should timeout when promise takes too long', async () => {
+      const promise = new Promise(resolve => setTimeout(() => resolve('late'), 2000));
+      
+      await expect(
+        ErrorHandler.withTimeout(promise, 1000, 'test context')
+      ).rejects.toThrow(CacheError);
+    });
+
+    test('should include timeout in error message', async () => {
+      const promise = new Promise(resolve => setTimeout(() => resolve('late'), 2000));
+      
+      try {
+        await ErrorHandler.withTimeout(promise, 1000, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Operation timed out after 1000ms');
+        expect((error as CacheError).code).toBe('TIMEOUT');
+      }
+    });
+
+    test('should handle promise rejection before timeout', async () => {
+      const promise = Promise.reject(new Error('Promise rejected'));
+      
+      await expect(
+        ErrorHandler.withTimeout(promise, 1000, 'test context')
+      ).rejects.toThrow(CacheError);
+    });
+
+    test('should include context in promise rejection error', async () => {
+      const promise = Promise.reject(new Error('Promise rejected'));
+      
+      try {
+        await ErrorHandler.withTimeout(promise, 1000, 'test context');
+      } catch (error) {
+        expect((error as CacheError).message).toBe('test context: Promise rejected');
+        expect((error as CacheError).code).toBe('CACHE_ERROR');
+      }
+    });
+
+    test('should handle zero timeout', async () => {
+      const promise = new Promise(resolve => setTimeout(() => resolve('success'), 100));
+      
+      await expect(
+        ErrorHandler.withTimeout(promise, 0, 'test context')
+      ).rejects.toThrow(CacheError);
+    });
+
+    test('should handle negative timeout', async () => {
+      const promise = Promise.resolve('success');
+      
+      // Negative timeout should trigger immediate timeout
+      await expect(
+        ErrorHandler.withTimeout(promise, -1000, 'test context')
+      ).rejects.toThrow(CacheError);
+    });
+
+    test('should cleanup timeout when promise resolves', async () => {
+      const clearTimeoutSpy = jest.spyOn(global, 'clearTimeout');
+      const promise = Promise.resolve('success');
+      
+      await ErrorHandler.withTimeout(promise, 1000, 'test context');
+      
+      // Should clear timeout after promise resolves
+      expect(clearTimeoutSpy).toHaveBeenCalled();
+      
+      clearTimeoutSpy.mockRestore();
+    });
+
+    test('should handle multiple concurrent timeouts', async () => {
+      const promise1 = Promise.resolve('success1');
+      const promise2 = Promise.resolve('success2');
+      const promise3 = new Promise(resolve => setTimeout(() => resolve('success3'), 2000));
+      
+      const results = await Promise.allSettled([
+        ErrorHandler.withTimeout(promise1, 1000, 'context1'),
+        ErrorHandler.withTimeout(promise2, 1000, 'context2'),
+        ErrorHandler.withTimeout(promise3, 1000, 'context3'),
+      ]);
+      
+      expect(results[0].status).toBe('fulfilled');
+      expect(results[1].status).toBe('fulfilled');
+      expect(results[2].status).toBe('rejected');
+    });
+  });
+
+  describe('Integration with Cache Operations', () => {
+    test('should handle cache operation errors', () => {
+      const mockOperation = () => {
+        throw new Error('Cache operation failed');
+      };
+      
+      expect(() => {
+        ErrorHandler.handle(mockOperation(), 'cache.set');
+      }).toThrow('cache.set: Cache operation failed');
+    });
+
+    test('should handle async cache operation errors', async () => {
+      const mockAsyncOperation = async () => {
+        throw new Error('Async cache operation failed');
+      };
+      
+      await expect(
+        ErrorHandler.withTimeout(mockAsyncOperation(), 1000, 'cache.get')
+      ).rejects.toThrow('cache.get: Async cache operation failed');
+    });
+
+    test('should handle network timeout scenarios', async () => {
+      const mockNetworkCall = new Promise(resolve => 
+        setTimeout(() => resolve({ data: 'response' }), 5000)
+      );
+      
+      await expect(
+        ErrorHandler.withTimeout(mockNetworkCall, 1000, 'api.fetch')
+      ).rejects.toThrow('api.fetch: Operation timed out after 1000ms');
+    });
+  });
+
+  describe('Error Code Constants', () => {
+    test('should use consistent error codes', () => {
+      const scenarios = [
+        { error: new Error('test'), expectedCode: 'CACHE_ERROR' },
+        { error: 'string', expectedCode: 'UNKNOWN_ERROR' },
+        { error: null, expectedCode: 'UNKNOWN_ERROR' },
+        { error: undefined, expectedCode: 'UNKNOWN_ERROR' },
+      ];
+
+      scenarios.forEach(({ error, expectedCode }) => {
+        try {
+          ErrorHandler.handle(error, 'test');
+        } catch (caught) {
+          expect((caught as CacheError).code).toBe(expectedCode);
+        }
+      });
+    });
+
+    test('should use TIMEOUT code for timeout errors', async () => {
+      const promise = new Promise(resolve => setTimeout(() => resolve('late'), 2000));
+      
+      try {
+        await ErrorHandler.withTimeout(promise, 1000, 'test');
+      } catch (error) {
+        expect((error as CacheError).code).toBe('TIMEOUT');
+      }
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle empty context string', () => {
+      const error = new Error('test error');
+      
+      try {
+        ErrorHandler.handle(error, '');
+      } catch (caught) {
+        expect((caught as CacheError).message).toBe(': test error');
+      }
+    });
+
+    test('should handle very long context string', () => {
+      const longContext = 'context'.repeat(1000);
+      const error = new Error('test error');
+      
+      try {
+        ErrorHandler.handle(error, longContext);
+      } catch (caught) {
+        expect((caught as CacheError).message).toBe(`${longContext}: test error`);
+      }
+    });
+
+    test('should handle special characters in context', () => {
+      const context = 'context-with-special-chars-!@#$%^&*()';
+      const error = new Error('test error');
+      
+      try {
+        ErrorHandler.handle(error, context);
+      } catch (caught) {
+        expect((caught as CacheError).message).toBe(`${context}: test error`);
+      }
+    });
+  });
+});