@umituz/react-native-settings 4.20.62 → 4.21.2

package/src/domains/appearance/__tests__/services/appearanceService.test.ts

@@ -1,299 +0,0 @@
-/**
- * Appearance Service Tests
- */
-
-import { AppearanceService, appearanceService } from '../../infrastructure/services/appearanceService';
-import type { ThemeMode, CustomThemeColors } from '../../types';
-
-// Mock dependencies
-jest.mock('../../infrastructure/stores/appearanceStore');
-jest.mock('../../infrastructure/storage/appearanceStorage');
-jest.mock('@umituz/react-native-design-system', () => ({
-  useTheme: {
-    getState: jest.fn(() => ({
-      setThemeMode: jest.fn(),
-    })),
-  },
-  useDesignSystemTheme: {
-    getState: jest.fn(() => ({
-      setThemeMode: jest.fn(),
-      setCustomColors: jest.fn(),
-    })),
-  },
-}));
-
-const mockAppearanceStore = require('../../infrastructure/stores/appearanceStore').useAppearanceStore;
-const mockAppearanceStorage = require('../../infrastructure/storage/appearanceStorage').AppearanceStorage;
-const mockUseTheme = require('@umituz/react-native-design-system').useTheme;
-const mockUseDesignSystemTheme = require('@umituz/react-native-design-system').useDesignSystemTheme;
-
-describe('AppearanceService', () => {
-  let service: AppearanceService;
-  let mockGetState: jest.MockedFunction<typeof mockAppearanceStore.getState>;
-  let mockSetSettings: jest.MockedFunction<typeof mockAppearanceStore.getState>;
-  let mockSetInitialized: jest.MockedFunction<typeof mockAppearanceStore.getState>;
-  let mockUpdateThemeMode: jest.MockedFunction<typeof mockAppearanceStore.getState>;
-  let mockUpdateCustomColors: jest.MockedFunction<typeof mockAppearanceStore.getState>;
-  let mockResetState: jest.MockedFunction<typeof mockAppearanceStore.getState>;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    
-    service = appearanceService;
-    
-    mockGetState = mockAppearanceStore.getState as jest.MockedFunction<typeof mockAppearanceStore.getState>;
-    mockSetSettings = mockAppearanceStore.getState as jest.MockedFunction<typeof mockAppearanceStore.getState>;
-    mockSetInitialized = mockAppearanceStore.getState as jest.MockedFunction<typeof mockAppearanceStore.getState>;
-    mockUpdateThemeMode = mockAppearanceStore.getState as jest.MockedFunction<typeof mockAppearanceStore.getState>;
-    mockUpdateCustomColors = mockAppearanceStore.getState as jest.MockedFunction<typeof mockAppearanceStore.getState>;
-    mockResetState = mockAppearanceStore.getState as jest.MockedFunction<typeof mockAppearanceStore.getState>;
-
-    // Setup mock implementations
-    mockGetState.mockReturnValue({
-      settings: { themeMode: 'dark' as ThemeMode },
-      isInitialized: false,
-    });
-
-    mockSetSettings.mockReturnValue({} as any);
-    mockSetInitialized.mockReturnValue({} as any);
-    mockUpdateThemeMode.mockReturnValue({} as any);
-    mockUpdateCustomColors.mockReturnValue({} as any);
-    mockResetState.mockReturnValue({} as any);
-
-    mockAppearanceStorage.getSettings.mockResolvedValue(null);
-    mockAppearanceStorage.setSettings.mockResolvedValue();
-    mockAppearanceStorage.clear.mockResolvedValue();
-
-    mockUseTheme.getState.mockReturnValue({
-      setThemeMode: jest.fn(),
-    });
-
-    mockUseDesignSystemTheme.getState.mockReturnValue({
-      setThemeMode: jest.fn(),
-      setCustomColors: jest.fn(),
-    });
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  describe('initialize', () => {
-    it('should initialize with saved settings', async () => {
-      const savedSettings = { themeMode: 'light' as ThemeMode };
-      mockAppearanceStorage.getSettings.mockResolvedValue(savedSettings);
-
-      await service.initialize();
-
-      expect(mockAppearanceStorage.getSettings).toHaveBeenCalled();
-      expect(mockSetSettings).toHaveBeenCalledWith(savedSettings);
-      expect(mockSetInitialized).toHaveBeenCalledWith(true);
-      expect(mockUseTheme.getState().setThemeMode).toHaveBeenCalledWith('light');
-      expect(mockUseDesignSystemTheme.getState().setThemeMode).toHaveBeenCalledWith('light');
-      expect(mockUseDesignSystemTheme.getState().setCustomColors).toHaveBeenCalledWith(undefined);
-    });
-
-    it('should initialize with default settings when no saved settings', async () => {
-      mockAppearanceStorage.getSettings.mockResolvedValue(null);
-
-      await service.initialize();
-
-      expect(mockSetSettings).toHaveBeenCalledWith({ themeMode: 'dark' });
-      expect(mockSetInitialized).toHaveBeenCalledWith(true);
-      expect(mockUseTheme.getState().setThemeMode).toHaveBeenCalledWith('dark');
-      expect(mockUseDesignSystemTheme.getState().setThemeMode).toHaveBeenCalledWith('dark');
-    });
-
-    it('should handle initialization errors gracefully', async () => {
-      const error = new Error('Init failed');
-      mockAppearanceStorage.getSettings.mockRejectedValue(error);
-
-      await service.initialize();
-
-      expect(mockSetSettings).toHaveBeenCalledWith({ themeMode: 'dark' });
-      expect(mockSetInitialized).toHaveBeenCalledWith(true);
-    });
-
-    it('should prevent multiple initializations', async () => {
-      const savedSettings = { themeMode: 'light' as ThemeMode };
-      mockAppearanceStorage.getSettings.mockResolvedValue(savedSettings);
-
-      const promise1 = service.initialize();
-      const promise2 = service.initialize();
-
-      await Promise.all([promise1, promise2]);
-
-      expect(mockAppearanceStorage.getSettings).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('getThemeMode', () => {
-    it('should return current theme mode', () => {
-      mockGetState.mockReturnValue({
-        settings: { themeMode: 'light' as ThemeMode },
-        isInitialized: true,
-      });
-
-      const result = service.getThemeMode();
-
-      expect(result).toBe('light');
-      expect(mockGetState).toHaveBeenCalled();
-    });
-  });
-
-  describe('setThemeMode', () => {
-    it('should set theme mode and sync with design system', async () => {
-      const newMode: ThemeMode = 'light';
-      mockGetState.mockReturnValue({
-        settings: { themeMode: 'dark' as ThemeMode },
-        isInitialized: true,
-      });
-
-      await service.setThemeMode(newMode);
-
-      expect(mockUpdateThemeMode).toHaveBeenCalledWith(newMode);
-      expect(mockAppearanceStorage.setSettings).toHaveBeenCalledWith({
-        themeMode: newMode,
-      });
-      expect(mockUseTheme.getState().setThemeMode).toHaveBeenCalledWith(newMode);
-      expect(mockUseDesignSystemTheme.getState().setThemeMode).toHaveBeenCalledWith(newMode);
-    });
-
-    it('should handle setThemeMode errors', async () => {
-      const error = new Error('Set theme failed');
-      mockAppearanceStorage.setSettings.mockRejectedValue(error);
-
-      await expect(service.setThemeMode('light')).rejects.toThrow(error);
-    });
-  });
-
-  describe('toggleTheme', () => {
-    it('should toggle between light and dark', async () => {
-      mockGetState.mockReturnValue({
-        settings: { themeMode: 'light' as ThemeMode },
-        isInitialized: true,
-      });
-
-      await service.toggleTheme();
-
-      expect(mockUpdateThemeMode).toHaveBeenCalledWith('dark');
-    });
-
-    it('should toggle from dark to light', async () => {
-      mockGetState.mockReturnValue({
-        settings: { themeMode: 'dark' as ThemeMode },
-        isInitialized: true,
-      });
-
-      await service.toggleTheme();
-
-      expect(mockUpdateThemeMode).toHaveBeenCalledWith('light');
-    });
-  });
-
-  describe('getCustomColors', () => {
-    it('should return current custom colors', () => {
-      const customColors: CustomThemeColors = { primary: '#FF0000' };
-      mockGetState.mockReturnValue({
-        settings: { themeMode: 'dark', customColors },
-        isInitialized: true,
-      });
-
-      const result = service.getCustomColors();
-
-      expect(result).toEqual(customColors);
-    });
-
-    it('should return undefined when no custom colors', () => {
-      mockGetState.mockReturnValue({
-        settings: { themeMode: 'dark' },
-        isInitialized: true,
-      });
-
-      const result = service.getCustomColors();
-
-      expect(result).toBeUndefined();
-    });
-  });
-
-  describe('setCustomColors', () => {
-    it('should set custom colors and sync with design system', async () => {
-      const newColors: CustomThemeColors = { primary: '#FF0000' };
-      const currentColors = { secondary: '#00FF00' };
-      mockGetState.mockReturnValue({
-        settings: { themeMode: 'dark', customColors: currentColors },
-        isInitialized: true,
-      });
-
-      await service.setCustomColors(newColors);
-
-      expect(mockUpdateCustomColors).toHaveBeenCalledWith({
-        ...currentColors,
-        ...newColors,
-      });
-      expect(mockAppearanceStorage.setSettings).toHaveBeenCalledWith({
-        themeMode: 'dark',
-        customColors: { ...currentColors, ...newColors },
-      });
-      expect(mockUseDesignSystemTheme.getState().setCustomColors).toHaveBeenCalledWith({
-        ...currentColors,
-        ...newColors,
-      });
-    });
-
-    it('should handle setCustomColors errors', async () => {
-      const error = new Error('Set colors failed');
-      mockAppearanceStorage.setSettings.mockRejectedValue(error);
-
-      await expect(service.setCustomColors({ primary: '#FF0000' })).rejects.toThrow(error);
-    });
-  });
-
-  describe('resetCustomColors', () => {
-    it('should reset custom colors', async () => {
-      mockGetState.mockReturnValue({
-        settings: { themeMode: 'dark', customColors: { primary: '#FF0000' } },
-        isInitialized: true,
-      });
-
-      await service.resetCustomColors();
-
-      expect(mockUpdateCustomColors).toHaveBeenCalledWith(undefined);
-      expect(mockAppearanceStorage.setSettings).toHaveBeenCalledWith({
-        themeMode: 'dark',
-        customColors: undefined,
-      });
-      expect(mockUseDesignSystemTheme.getState().setCustomColors).toHaveBeenCalledWith(undefined);
-    });
-  });
-
-  describe('reset', () => {
-    it('should reset all settings', async () => {
-      mockGetState.mockReturnValue({
-        settings: { themeMode: 'light', customColors: { primary: '#FF0000' } },
-        isInitialized: true,
-      });
-
-      await service.reset();
-
-      expect(mockAppearanceStorage.clear).toHaveBeenCalled();
-      expect(mockResetState).toHaveBeenCalled();
-      expect(mockUseTheme.getState().setThemeMode).toHaveBeenCalledWith('dark');
-      expect(mockUseDesignSystemTheme.getState().setThemeMode).toHaveBeenCalledWith('dark');
-      expect(mockUseDesignSystemTheme.getState().setCustomColors).toHaveBeenCalledWith(undefined);
-    });
-  });
-
-  describe('isInitialized', () => {
-    it('should return initialization status', () => {
-      mockGetState.mockReturnValue({
-        settings: { themeMode: 'dark' },
-        isInitialized: true,
-      });
-
-      const result = service.isInitialized();
-
-      expect(result).toBe(true);
-    });
-  });
-});

package/src/domains/appearance/__tests__/setup.ts

@@ -1,88 +0,0 @@
-/**
- * Jest Setup File
- * 
- * Global test setup for React Native Appearance package
- */
-
-import 'react-native-gesture-handler/jestSetup';
-
-// Mock console methods for testing
-if (__DEV__) {
-  global.console = {
-    ...console,
-    // Suppress specific console warnings in tests
-    warn: jest.fn(),
-    error: jest.fn(),
-  };
-}
-
-// Mock performance API for testing
-if (typeof performance === 'undefined') {
-  global.performance = {
-    now: jest.fn(() => Date.now()),
-    mark: jest.fn(),
-    measure: jest.fn(),
-    getEntriesByName: jest.fn(() => []),
-    getEntriesByType: jest.fn(() => []),
-    clearMarks: jest.fn(),
-    clearMeasures: jest.fn(),
-    clearResourceTimings: jest.fn(),
-  } as any;
-}
-
-// Mock React Native modules
-jest.mock('react-native', () => {
-  const RN = jest.requireActual('react-native');
-  return {
-    ...RN,
-    Platform: {
-      OS: 'ios',
-      select: jest.fn((obj) => obj.ios),
-    },
-  };
-});
-
-// Mock design system theme
-jest.mock('@umituz/react-native-design-system', () => ({
-  useTheme: jest.fn(() => ({
-    setThemeMode: jest.fn(),
-  })),
-  useDesignSystemTheme: jest.fn(() => ({
-    setThemeMode: jest.fn(),
-    setCustomColors: jest.fn(),
-  })),
-}));
-
-// Mock storage
-jest.mock('@umituz/react-native-storage', () => ({
-  storageRepository: {
-    getItem: jest.fn(() => ({
-      success: true,
-      data: null,
-    })),
-    setItem: jest.fn(() => ({
-      success: true,
-    })),
-    removeItem: jest.fn(() => ({
-      success: true,
-    })),
-  },
-  unwrap: jest.fn((result, defaultValue) =>
-    result.success ? result.data : defaultValue
-  ),
-}));
-
-
-
-// Mock localization
-jest.mock('@umituz/react-native-localization', () => ({
-  useLocalization: jest.fn(() => ({
-    t: jest.fn((key) => key),
-  })),
-}));
-
-// Global test utilities
-(globalThis as any).__TEST__ = true;
-
-// Mock timers
-jest.useFakeTimers();

package/src/domains/appearance/__tests__/stores/appearanceStore.test.tsx

@@ -1,175 +0,0 @@
-/**
- * Appearance Store Tests
- */
-
-import { renderHook, act } from '@testing-library/react-native';
-import { useAppearanceStore } from '../../infrastructure/stores/appearanceStore';
-import type { AppearanceSettings, ThemeMode, CustomThemeColors } from '../../types';
-
-// Mock design system theme
-jest.mock('@umituz/react-native-design-system', () => ({
-  useTheme: {
-    getState: jest.fn(() => ({
-      setThemeMode: jest.fn(),
-    })),
-  },
-  useDesignSystemTheme: {
-    getState: jest.fn(() => ({
-      setThemeMode: jest.fn(),
-      setCustomColors: jest.fn(),
-    })),
-  },
-}));
-
-const mockUseTheme = require('@umituz/react-native-design-system').useTheme;
-const mockUseDesignSystemTheme = require('@umituz/react-native-design-system').useDesignSystemTheme;
-
-describe('useAppearanceStore', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('should initialize with default settings', () => {
-    const { result } = renderHook(() => useAppearanceStore());
-
-    expect(result.current).toEqual({
-      settings: {
-        themeMode: 'dark',
-      },
-      isInitialized: false,
-    });
-
-    expect(typeof result.current.setSettings).toBe('function');
-    expect(typeof result.current.setInitialized).toBe('function');
-    expect(typeof result.current.updateThemeMode).toBe('function');
-    expect(typeof result.current.updateCustomColors).toBe('function');
-    expect(typeof result.current.resetState).toBe('function');
-  });
-
-  it('should update settings correctly', () => {
-    const { result } = renderHook(() => useAppearanceStore());
-
-    const newSettings: AppearanceSettings = {
-      themeMode: 'light',
-      customColors: { primary: '#FF0000' },
-    };
-
-    act(() => {
-      result.current.setSettings(newSettings);
-    });
-
-    expect(result.current.settings).toEqual(newSettings);
-    expect(mockUseTheme.getState().setThemeMode).not.toHaveBeenCalled();
-    expect(mockUseDesignSystemTheme.getState().setThemeMode).not.toHaveBeenCalled();
-  });
-
-  it('should update theme mode correctly', () => {
-    const { result } = renderHook(() => useAppearanceStore());
-
-    act(() => {
-      result.current.updateThemeMode('light');
-    });
-
-    expect(result.current.settings.themeMode).toBe('light');
-    expect(mockUseTheme.getState().setThemeMode).not.toHaveBeenCalled();
-    expect(mockUseDesignSystemTheme.getState().setThemeMode).not.toHaveBeenCalled();
-  });
-
-  it('should not update theme mode if same value', () => {
-    const { result } = renderHook(() => useAppearanceStore());
-
-    act(() => {
-      result.current.updateThemeMode('dark'); // Default is dark
-    });
-
-    expect(result.current.settings.themeMode).toBe('dark');
-  });
-
-  it('should update custom colors correctly', () => {
-    const { result } = renderHook(() => useAppearanceStore());
-
-    const newColors: CustomThemeColors = { primary: '#FF0000' };
-
-    act(() => {
-      result.current.updateCustomColors(newColors);
-    });
-
-    expect(result.current.settings.customColors).toEqual(newColors);
-  });
-
-  it('should not update custom colors if same value', () => {
-    const { result } = renderHook(() => useAppearanceStore());
-
-    const newColors: CustomThemeColors = { primary: '#FF0000' };
-
-    act(() => {
-      result.current.updateCustomColors(newColors);
-      result.current.updateCustomColors(newColors); // Second call with same value
-    });
-
-    // Should only be called once due to optimization
-    expect(mockUseDesignSystemTheme.getState().setCustomColors).toHaveBeenCalledTimes(1);
-  });
-
-  it('should reset state correctly', () => {
-    const { result } = renderHook(() => useAppearanceStore());
-
-    const customColors: CustomThemeColors = { primary: '#FF0000' };
-
-    act(() => {
-      result.current.updateCustomColors(customColors);
-      result.current.setInitialized(true);
-      result.current.resetState();
-    });
-
-    expect(result.current.settings).toEqual({
-      themeMode: 'dark',
-    });
-    expect(result.current.isInitialized).toBe(false);
-  });
-
-  it('should not reset if already at default', () => {
-    const { result } = renderHook(() => useAppearanceStore());
-
-    act(() => {
-      result.current.resetState();
-      result.current.resetState(); // Second call
-    });
-
-    // Should only be called once due to optimization
-    expect(mockUseTheme.getState().setThemeMode).toHaveBeenCalledTimes(1);
-    expect(mockUseDesignSystemTheme.getState().setThemeMode).toHaveBeenCalledTimes(1);
-  });
-
-  it('should handle setInitialized correctly', () => {
-    const { result } = renderHook(() => useAppearanceStore());
-
-    act(() => {
-      result.current.setInitialized(true);
-    });
-
-    expect(result.current.isInitialized).toBe(true);
-
-    act(() => {
-      result.current.setInitialized(true); // Second call with same value
-    });
-
-    // Should not be called again due to optimization
-    expect(result.current.isInitialized).toBe(true);
-  });
-
-  it('should handle setInitialized changes correctly', () => {
-    const { result } = renderHook(() => useAppearanceStore());
-
-    act(() => {
-      result.current.setInitialized(false);
-      result.current.setInitialized(true);
-    });
-
-    expect(result.current.isInitialized).toBe(true);
-  });
-});

package/src/domains/cloud-sync/presentation/components/__tests__/CloudSyncSetting.test.tsx

@@ -1,78 +0,0 @@
-/**
- * Tests for CloudSyncSetting Component
- */
-
-import React from 'react';
-import { render, fireEvent } from '@testing-library/react-native';
-import { CloudSyncSetting } from '../CloudSyncSetting';
-
-// Mock lucide-react-native
-jest.mock('lucide-react-native', () => ({
-  Cloud: 'Cloud',
-}));
-
-// Mock SettingsItemCard component
-jest.mock('../../../../../presentation/components/SettingsItemCard', () => {
-  const React = require('react');
-  const { View, Text } = require('react-native');
-  
-  return {
-    SettingsItemCard: ({ icon, title, description, onPress, testID, showSwitch, switchValue, onSwitchChange, disabled }: any) => (
-      React.createElement(View, { 
-        testID: testID || 'setting-item',
-        onTouchEnd: onPress,
-        style: { padding: 16 }
-      }, [
-        React.createElement(Text, { key: 'title' }, title || ''),
-        description && React.createElement(Text, { key: 'description' }, description),
-        showSwitch && React.createElement(Text, { key: 'switch' }, switchValue ? 'ON' : 'OFF'),
-      ])
-    ),
-  };
-});
-
-describe('CloudSyncSetting', () => {
-  it('renders with default props', () => {
-    const { getByText } = render(<CloudSyncSetting />);
-    
-    expect(getByText('cloud_sync')).toBeTruthy();
-  });
-
-  it('renders with custom title', () => {
-    const { getByText } = render(<CloudSyncSetting title="Custom Sync" />);
-    
-    expect(getByText('Custom Sync')).toBeTruthy();
-  });
-
-  it('shows syncing state when isSyncing is true', () => {
-    const { getByText } = render(<CloudSyncSetting isSyncing={true} />);
-    
-    expect(getByText('syncing')).toBeTruthy();
-  });
-
-  it('displays custom description when provided', () => {
-    const { getByText } = render(
-      <CloudSyncSetting description="Custom description" />
-    );
-    
-    expect(getByText('Custom description')).toBeTruthy();
-  });
-
-  it('shows last synced time when provided', () => {
-    const lastSynced = new Date(Date.now() - 5 * 60 * 1000); // 5 minutes ago
-    const { getByText } = render(<CloudSyncSetting lastSynced={lastSynced} />);
-    
-    expect(getByText('last_synced_5m_ago')).toBeTruthy();
-  });
-
-  it('handles onPress callback', () => {
-    const mockOnPress = jest.fn();
-    const { getByTestId } = render(
-      <CloudSyncSetting onPress={mockOnPress} />
-    );
-    
-    const pressable = getByTestId('setting-item');
-    fireEvent.press(pressable);
-    expect(mockOnPress).toHaveBeenCalled();
-  });
-});