@umituz/react-native-design-system 2.3.14 → 2.3.16

package/src/molecules/navigation/utils/__tests__/LabelProcessor.processTitle.test.ts

@@ -0,0 +1,59 @@
+import { LabelProcessor } from '../LabelProcessor';
+
+describe('LabelProcessor - processTitle', () => {
+  beforeEach(() => {
+    // Clear cache before each test
+    (LabelProcessor as any).labelCache.clear();
+  });
+
+  it('should return undefined when title is undefined', () => {
+    const result = LabelProcessor.processTitle(undefined);
+    
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined when title is null', () => {
+    const result = LabelProcessor.processTitle(null as any);
+    
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined when title is not a string', () => {
+    const result = LabelProcessor.processTitle(123 as any);
+    
+    expect(result).toBeUndefined();
+  });
+
+  it('should return original title when no getLabel function provided', () => {
+    const result = LabelProcessor.processTitle('Test Title');
+    
+    expect(result).toBe('Test Title');
+  });
+
+  it('should process title using getLabel function', () => {
+    const getLabel = jest.fn((label: string) => label.toUpperCase());
+    
+    const result = LabelProcessor.processTitle('test title', getLabel);
+
+    expect(result).toBe('TEST TITLE');
+    expect(getLabel).toHaveBeenCalledWith('test title');
+  });
+
+  it('should handle empty string title', () => {
+    const getLabel = jest.fn((label: string) => label.toUpperCase());
+    
+    const result = LabelProcessor.processTitle('', getLabel);
+
+    expect(result).toBe('');
+    expect(getLabel).toHaveBeenCalledWith('');
+  });
+
+  it('should handle special characters in title', () => {
+    const getLabel = jest.fn((label: string) => label);
+    
+    const result = LabelProcessor.processTitle('Test & Title (Special)', getLabel);
+
+    expect(result).toBe('Test & Title (Special)');
+    expect(getLabel).toHaveBeenCalledWith('Test & Title (Special)');
+  });
+});

package/src/molecules/navigation/utils/__tests__/NavigationCleanup.test.ts

@@ -0,0 +1,271 @@
+import { NavigationCleanupManager } from '../NavigationCleanup';
+
+describe('NavigationCleanup', () => {
+  describe('NavigationCleanupManager', () => {
+    describe('createMultiCleanup', () => {
+      it('should create a cleanup function that calls all unsubscribers', () => {
+        const unsubscribe1 = jest.fn();
+        const unsubscribe2 = jest.fn();
+        const unsubscribe3 = jest.fn();
+        
+        const cleanup = NavigationCleanupManager.createMultiCleanup([unsubscribe1, unsubscribe2, unsubscribe3]);
+        
+        expect(typeof cleanup).toBe('function');
+        
+        cleanup();
+        
+        expect(unsubscribe1).toHaveBeenCalledTimes(1);
+        expect(unsubscribe2).toHaveBeenCalledTimes(1);
+        expect(unsubscribe3).toHaveBeenCalledTimes(1);
+      });
+
+      it('should handle empty array of unsubscribers', () => {
+        const cleanup = NavigationCleanupManager.createMultiCleanup([]);
+        
+        expect(() => cleanup()).not.toThrow();
+      });
+
+      it('should handle single unsubscribe function', () => {
+        const unsubscribe = jest.fn();
+        const cleanup = NavigationCleanupManager.createMultiCleanup([unsubscribe]);
+        
+        cleanup();
+        
+        expect(unsubscribe).toHaveBeenCalledTimes(1);
+      });
+
+      it('should handle errors in individual unsubscribe functions', () => {
+        const originalDev = __DEV__;
+        (global as any).__DEV__ = true;
+        const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+        
+        const unsubscribe1 = jest.fn();
+        const unsubscribe2 = jest.fn(() => {
+          throw new Error('Unsubscribe failed');
+        });
+        const unsubscribe3 = jest.fn();
+        
+        const cleanup = NavigationCleanupManager.createMultiCleanup([unsubscribe1, unsubscribe2, unsubscribe3]);
+        
+        cleanup();
+        
+        expect(unsubscribe1).toHaveBeenCalledTimes(1);
+        expect(unsubscribe2).toHaveBeenCalledTimes(1);
+        expect(unsubscribe3).toHaveBeenCalledTimes(1);
+        expect(consoleSpy).toHaveBeenCalledWith(
+          '[NavigationCleanupManager] Error during cleanup:',
+          expect.any(Error)
+        );
+        
+        (global as any).__DEV__ = originalDev;
+        consoleSpy.mockRestore();
+      });
+
+      it('should not log errors in production', () => {
+        const originalDev = __DEV__;
+        (global as any).__DEV__ = false;
+        const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+        
+        const unsubscribe = jest.fn(() => {
+          throw new Error('Unsubscribe failed');
+        });
+        
+        const cleanup = NavigationCleanupManager.createMultiCleanup([unsubscribe]);
+        
+        cleanup();
+        
+        expect(unsubscribe).toHaveBeenCalledTimes(1);
+        expect(consoleSpy).not.toHaveBeenCalled();
+        
+        (global as any).__DEV__ = originalDev;
+        consoleSpy.mockRestore();
+      });
+
+      it('should handle multiple errors', () => {
+        const originalDev = __DEV__;
+        (global as any).__DEV__ = true;
+        const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+        
+        const unsubscribe1 = jest.fn(() => {
+          throw new Error('Error 1');
+        });
+        const unsubscribe2 = jest.fn(() => {
+          throw new Error('Error 2');
+        });
+        
+        const cleanup = NavigationCleanupManager.createMultiCleanup([unsubscribe1, unsubscribe2]);
+        
+        cleanup();
+        
+        expect(unsubscribe1).toHaveBeenCalledTimes(1);
+        expect(unsubscribe2).toHaveBeenCalledTimes(1);
+        expect(consoleSpy).toHaveBeenCalledTimes(2);
+        
+        (global as any).__DEV__ = originalDev;
+        consoleSpy.mockRestore();
+      });
+    });
+
+    describe('safeCleanup', () => {
+      it('should create a safe cleanup wrapper', () => {
+        const unsubscribe = jest.fn();
+        const safeUnsubscribe = NavigationCleanupManager.safeCleanup(unsubscribe);
+        
+        expect(typeof safeUnsubscribe).toBe('function');
+        
+        safeUnsubscribe();
+        
+        expect(unsubscribe).toHaveBeenCalledTimes(1);
+      });
+
+      it('should handle errors in unsubscribe function', () => {
+        const originalDev = __DEV__;
+        (global as any).__DEV__ = true;
+        const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+        
+        const unsubscribe = jest.fn(() => {
+          throw new Error('Unsubscribe failed');
+        });
+        
+        const safeUnsubscribe = NavigationCleanupManager.safeCleanup(unsubscribe);
+        
+        expect(() => safeUnsubscribe()).not.toThrow();
+        
+        expect(unsubscribe).toHaveBeenCalledTimes(1);
+        expect(consoleSpy).toHaveBeenCalledWith(
+          '[NavigationCleanupManager] Error during cleanup:',
+          expect.any(Error)
+        );
+        
+        (global as any).__DEV__ = originalDev;
+        consoleSpy.mockRestore();
+      });
+
+      it('should not log errors in production', () => {
+        const originalDev = __DEV__;
+        (global as any).__DEV__ = false;
+        const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+        
+        const unsubscribe = jest.fn(() => {
+          throw new Error('Unsubscribe failed');
+        });
+        
+        const safeUnsubscribe = NavigationCleanupManager.safeCleanup(unsubscribe);
+        
+        safeUnsubscribe();
+        
+        expect(unsubscribe).toHaveBeenCalledTimes(1);
+        expect(consoleSpy).not.toHaveBeenCalled();
+        
+        (global as any).__DEV__ = originalDev;
+        consoleSpy.mockRestore();
+      });
+
+      it('should handle successful unsubscribe', () => {
+        const unsubscribe = jest.fn();
+        const safeUnsubscribe = NavigationCleanupManager.safeCleanup(unsubscribe);
+        
+        safeUnsubscribe();
+        
+        expect(unsubscribe).toHaveBeenCalledTimes(1);
+      });
+
+      it('should handle unsubscribe that returns a value', () => {
+        const unsubscribe = jest.fn().mockReturnValue('cleanup result');
+        const safeUnsubscribe = NavigationCleanupManager.safeCleanup(unsubscribe);
+        
+        const result = safeUnsubscribe();
+        
+        expect(unsubscribe).toHaveBeenCalledTimes(1);
+        expect(result).toBeUndefined(); // safeCleanup doesn't return the value
+      });
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('should work with nested cleanup functions', () => {
+      const innerUnsubscribe1 = jest.fn();
+      const innerUnsubscribe2 = jest.fn();
+      const outerUnsubscribe = jest.fn();
+      
+      const innerCleanup = NavigationCleanupManager.createMultiCleanup([innerUnsubscribe1, innerUnsubscribe2]);
+      const outerCleanup = NavigationCleanupManager.createMultiCleanup([innerCleanup, outerUnsubscribe]);
+      
+      outerCleanup();
+      
+      expect(innerUnsubscribe1).toHaveBeenCalledTimes(1);
+      expect(innerUnsubscribe2).toHaveBeenCalledTimes(1);
+      expect(outerUnsubscribe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should work with mixed safe and unsafe cleanup functions', () => {
+      const unsafeUnsubscribe = jest.fn();
+      const safeUnsubscribe = NavigationCleanupManager.safeCleanup(jest.fn());
+      
+      const cleanup = NavigationCleanupManager.createMultiCleanup([unsafeUnsubscribe, safeUnsubscribe]);
+      
+      cleanup();
+      
+      expect(unsafeUnsubscribe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle cleanup functions that throw different types of errors', () => {
+      const originalDev = __DEV__;
+      (global as any).__DEV__ = true;
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      
+      const stringError = jest.fn(() => {
+        throw 'String error';
+      });
+      const objectError = jest.fn(() => {
+        throw { code: 500, message: 'Object error' };
+      });
+      const errorInstance = jest.fn(() => {
+        throw new Error('Error instance');
+      });
+      
+      const cleanup = NavigationCleanupManager.createMultiCleanup([stringError, objectError, errorInstance]);
+      
+      cleanup();
+      
+      expect(stringError).toHaveBeenCalledTimes(1);
+      expect(objectError).toHaveBeenCalledTimes(1);
+      expect(errorInstance).toHaveBeenCalledTimes(1);
+      expect(consoleSpy).toHaveBeenCalledTimes(3);
+      
+      (global as any).__DEV__ = originalDev;
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle null/undefined in unsubscribe array', () => {
+      const unsubscribe = jest.fn();
+      
+      expect(() => {
+        const cleanup = NavigationCleanupManager.createMultiCleanup([unsubscribe, null, undefined] as any);
+        cleanup();
+      }).not.toThrow();
+      
+      expect(unsubscribe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle non-function unsubscribe', () => {
+      const originalDev = __DEV__;
+      (global as any).__DEV__ = true;
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      
+      const validUnsubscribe = jest.fn();
+      
+      expect(() => {
+        const cleanup = NavigationCleanupManager.createMultiCleanup([validUnsubscribe, 'not-a-function'] as any);
+        cleanup();
+      }).not.toThrow();
+      
+      expect(validUnsubscribe).toHaveBeenCalledTimes(1);
+      
+      (global as any).__DEV__ = originalDev;
+      consoleSpy.mockRestore();
+    });
+  });
+});

package/src/molecules/navigation/utils/__tests__/NavigationValidator.test.ts

@@ -0,0 +1,252 @@
+import { NavigationValidator } from '../NavigationValidator';
+import type { TabScreen, StackScreen } from '../../types';
+
+describe('NavigationValidator', () => {
+  const mockTabScreens: TabScreen[] = [
+    {
+      name: 'Home',
+      component: () => null,
+      label: 'Home',
+      icon: 'home',
+    },
+    {
+      name: 'Profile',
+      component: () => null,
+      label: 'Profile',
+      icon: 'profile',
+    },
+  ];
+
+  const mockStackScreens: StackScreen[] = [
+    {
+      name: 'Home',
+      component: () => null,
+    },
+    {
+      name: 'Profile',
+      component: () => null,
+    },
+  ];
+
+  describe('validateScreens', () => {
+    describe('tab navigator validation', () => {
+      it('should validate valid tab screens', () => {
+        expect(() => {
+          NavigationValidator.validateScreens(mockTabScreens, 'tab');
+        }).not.toThrow();
+      });
+
+      it('should throw error for non-array screens', () => {
+        expect(() => {
+          NavigationValidator.validateScreens({} as any, 'tab');
+        }).toThrow('Screens must be an array for tab navigator');
+      });
+
+      it('should warn for empty screens array', () => {
+        const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+        NavigationValidator.validateScreens([], 'tab');
+
+        expect(consoleSpy).toHaveBeenCalledWith('[NavigationValidator] No screens provided for tab navigator');
+        consoleSpy.mockRestore();
+      });
+
+      it('should throw error for screen without name', () => {
+        const invalidScreens = [{ component: () => null, label: 'Test', icon: 'test' }] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(invalidScreens, 'tab');
+        }).toThrow('Screen at index 0 must have a valid non-empty name');
+      });
+
+      it('should throw error for screen with empty name', () => {
+        const invalidScreens = [{ name: '', component: () => null, label: 'Test', icon: 'test' }] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(invalidScreens, 'tab');
+        }).toThrow('Screen at index 0 must have a valid non-empty name');
+      });
+
+      it('should throw error for screen without component', () => {
+        const invalidScreens = [{ name: 'Test', label: 'Test', icon: 'test' }] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(invalidScreens, 'tab');
+        }).toThrow('Screen \'Test\' must have a valid component');
+      });
+
+      it('should throw error for screen with invalid component', () => {
+        const invalidScreens = [{ name: 'Test', component: 'not-a-function', label: 'Test', icon: 'test' }] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(invalidScreens, 'tab');
+        }).toThrow('Screen \'Test\' must have a valid component');
+      });
+
+      it('should throw error for tab screen without label', () => {
+        const invalidScreens = [{ name: 'Test', component: () => null, icon: 'test' }] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(invalidScreens, 'tab');
+        }).toThrow('Tab screen \'Test\' must have a valid non-empty label');
+      });
+
+      it('should throw error for tab screen with empty label', () => {
+        const invalidScreens = [{ name: 'Test', component: () => null, label: '', icon: 'test' }] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(invalidScreens, 'tab');
+        }).toThrow('Tab screen \'Test\' must have a valid non-empty label');
+      });
+
+      it('should warn for tab screen with invalid icon', () => {
+        const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+        const screensWithInvalidIcon = [{ name: 'Test', component: () => null, label: 'Test', icon: '' }] as any;
+
+        NavigationValidator.validateScreens(screensWithInvalidIcon, 'tab');
+
+        expect(consoleSpy).toHaveBeenCalledWith('[NavigationValidator] Tab screen \'Test\' has invalid icon, it will be ignored');
+        consoleSpy.mockRestore();
+      });
+
+      it('should throw error for tab screen with too long label', () => {
+        const longLabel = 'a'.repeat(51);
+        const invalidScreens = [{ name: 'Test', component: () => null, label: longLabel, icon: 'test' }] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(invalidScreens, 'tab');
+        }).toThrow('Tab screen \'Test\' label too long (max 50 characters)');
+      });
+
+      it('should throw error for duplicate screen names', () => {
+        const duplicateScreens = [
+          { name: 'Home', component: () => null, label: 'Home', icon: 'home' },
+          { name: 'Home', component: () => null, label: 'Home 2', icon: 'home2' },
+        ] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(duplicateScreens, 'tab');
+        }).toThrow('Duplicate screen name \'Home\' found at index 1');
+      });
+    });
+
+    describe('stack navigator validation', () => {
+      it('should validate valid stack screens', () => {
+        expect(() => {
+          NavigationValidator.validateScreens(mockStackScreens, 'stack');
+        }).not.toThrow();
+      });
+
+      it('should throw error for stack screen without name', () => {
+        const invalidScreens = [{ component: () => null }] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(invalidScreens, 'stack');
+        }).toThrow('Screen at index 0 must have a valid non-empty name');
+      });
+
+      it('should throw error for stack screen without component', () => {
+        const invalidScreens = [{ name: 'Test' }] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(invalidScreens, 'stack');
+        }).toThrow('Screen \'Test\' must have a valid component');
+      });
+
+      it('should throw error for duplicate stack screen names', () => {
+        const duplicateScreens = [
+          { name: 'Home', component: () => null },
+          { name: 'Home', component: () => null },
+        ] as any;
+
+        expect(() => {
+          NavigationValidator.validateScreens(duplicateScreens, 'stack');
+        }).toThrow('Duplicate screen name \'Home\' found at index 1');
+      });
+    });
+  });
+
+  describe('validateInitialRoute', () => {
+    it('should not throw for valid initial route', () => {
+      expect(() => {
+        NavigationValidator.validateInitialRoute('Home', mockTabScreens);
+      }).not.toThrow();
+    });
+
+    it('should not throw for undefined initial route', () => {
+      expect(() => {
+        NavigationValidator.validateInitialRoute(undefined, mockTabScreens);
+      }).not.toThrow();
+    });
+
+    it('should throw error for initial route not in screens', () => {
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+
+      expect(() => {
+        NavigationValidator.validateInitialRoute('NonExistent', mockTabScreens);
+      }).toThrow('Initial route \'NonExistent\' not found in screens. Available screens: Home, Profile');
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should log error in development for invalid initial route', () => {
+      const originalDev = __DEV__;
+      (global as any).__DEV__ = true;
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+
+      try {
+        NavigationValidator.validateInitialRoute('NonExistent', mockTabScreens);
+      } catch (_error) {
+        // Expected to throw
+      }
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        '[NavigationValidator] Initial route \'NonExistent\' not found in screens. Available screens: Home, Profile'
+      );
+
+      (global as any).__DEV__ = originalDev;
+      consoleSpy.mockRestore();
+    });
+
+    it('should handle empty screens array', () => {
+      expect(() => {
+        NavigationValidator.validateInitialRoute('Home', []);
+      }).toThrow('Initial route \'Home\' not found in screens. Available screens: ');
+    });
+
+    it('should work with both tab and stack screens', () => {
+      expect(() => {
+        NavigationValidator.validateInitialRoute('Home', mockTabScreens);
+        NavigationValidator.validateInitialRoute('Profile', mockStackScreens);
+      }).not.toThrow();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle screens with whitespace-only names', () => {
+      const invalidScreens = [{ name: '   ', component: () => null, label: 'Test', icon: 'test' }] as any;
+
+      expect(() => {
+        NavigationValidator.validateScreens(invalidScreens, 'tab');
+      }).toThrow('Screen at index 0 must have a valid non-empty name');
+    });
+
+    it('should handle screens with whitespace-only labels', () => {
+      const invalidScreens = [{ name: 'Test', component: () => null, label: '   ', icon: 'test' }] as any;
+
+      expect(() => {
+        NavigationValidator.validateScreens(invalidScreens, 'tab');
+      }).toThrow('Tab screen \'Test\' must have a valid non-empty label');
+    });
+
+    it('should handle null/undefined values gracefully', () => {
+      expect(() => {
+        NavigationValidator.validateScreens(null as any, 'tab');
+      }).toThrow('Screens must be an array for tab navigator');
+
+      expect(() => {
+        NavigationValidator.validateScreens(undefined as any, 'tab');
+      }).toThrow('Screens must be an array for tab navigator');
+    });
+  });
+});