@umituz/react-native-auth 3.4.21 → 3.4.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.4.21",
+  "version": "3.4.23",
   "description": "Authentication service for React Native apps - Secure, type-safe, and production-ready. Provider-agnostic design with dependency injection, configurable validation, and comprehensive error handling.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/__tests__/services/AnonymousModeService.test.ts

@@ -1,7 +1,3 @@
-/**
- * AnonymousModeService Tests
- */
-
 import { AnonymousModeService } from '../../infrastructure/services/AnonymousModeService';
 import type { IStorageProvider } from '../../infrastructure/services/AuthPackage';
 
@@ -10,188 +6,61 @@ describe('AnonymousModeService', () => {
   let mockStorageProvider: jest.Mocked<IStorageProvider>;
 
   beforeEach(() => {
-    mockStorageProvider = {
-      get: jest.fn(),
-      set: jest.fn(),
-      remove: jest.fn(),
-    };
-
+    mockStorageProvider = { get: jest.fn(), set: jest.fn(), remove: jest.fn() };
     anonymousModeService = new AnonymousModeService('@test_anonymous_mode');
   });
 
-  describe('constructor', () => {
-    it('should use default storage key when none provided', () => {
-      const service = new AnonymousModeService();
-      expect(service.getIsAnonymousMode()).toBe(false);
-    });
-
-    it('should use custom storage key when provided', () => {
-      const service = new AnonymousModeService('@custom_key');
+  describe('configuration', () => {
+    it('should use storage keys correctly', () => {
+      const service = new AnonymousModeService('@custom');
       expect(service.getIsAnonymousMode()).toBe(false);
     });
   });
 
-  describe('load', () => {
-    it('should load false when storage returns null', async () => {
-      mockStorageProvider.get.mockResolvedValue(null);
-
-      const result = await anonymousModeService.load(mockStorageProvider);
-
-      expect(result).toBe(false);
-      expect(mockStorageProvider.get).toHaveBeenCalledWith('@test_anonymous_mode');
-    });
-
-    it('should load false when storage returns "false"', async () => {
-      mockStorageProvider.get.mockResolvedValue('false');
-
-      const result = await anonymousModeService.load(mockStorageProvider);
-
-      expect(result).toBe(false);
-    });
-
-    it('should load true when storage returns "true"', async () => {
+  describe('persistence', () => {
+    it('should load state from storage', async () => {
       mockStorageProvider.get.mockResolvedValue('true');
-
       const result = await anonymousModeService.load(mockStorageProvider);
-
       expect(result).toBe(true);
       expect(anonymousModeService.getIsAnonymousMode()).toBe(true);
     });
 
-    it('should handle storage errors gracefully', async () => {
-      mockStorageProvider.get.mockRejectedValue(new Error('Storage error'));
-
-      const result = await anonymousModeService.load(mockStorageProvider);
-
-      expect(result).toBe(false);
+    it('should handle missing storage state', async () => {
+      mockStorageProvider.get.mockResolvedValue(null);
+      expect(await anonymousModeService.load(mockStorageProvider)).toBe(false);
     });
-  });
 
-  describe('save', () => {
-    it('should save true to storage when anonymous mode is enabled', async () => {
+    it('should save state to storage', async () => {
       anonymousModeService.setAnonymousMode(true);
-
       await anonymousModeService.save(mockStorageProvider);
-
       expect(mockStorageProvider.set).toHaveBeenCalledWith('@test_anonymous_mode', 'true');
     });
 
-    it('should save false to storage when anonymous mode is disabled', async () => {
-      anonymousModeService.setAnonymousMode(false);
-
-      await anonymousModeService.save(mockStorageProvider);
-
-      expect(mockStorageProvider.set).toHaveBeenCalledWith('@test_anonymous_mode', 'false');
-    });
-
-    it('should handle storage errors gracefully', async () => {
-      anonymousModeService.setAnonymousMode(true);
-      mockStorageProvider.set.mockRejectedValue(new Error('Storage error'));
-
-      await expect(anonymousModeService.save(mockStorageProvider)).resolves.not.toThrow();
-    });
-  });
-
-  describe('clear', () => {
-    it('should clear anonymous mode and remove from storage', async () => {
-      anonymousModeService.setAnonymousMode(true);
-
+    it('should clear state from storage', async () => {
       await anonymousModeService.clear(mockStorageProvider);
-
       expect(anonymousModeService.getIsAnonymousMode()).toBe(false);
       expect(mockStorageProvider.remove).toHaveBeenCalledWith('@test_anonymous_mode');
     });
-
-    it('should handle storage errors gracefully', async () => {
-      mockStorageProvider.remove.mockRejectedValue(new Error('Storage error'));
-
-      await expect(anonymousModeService.clear(mockStorageProvider)).resolves.not.toThrow();
-      expect(anonymousModeService.getIsAnonymousMode()).toBe(false);
-    });
   });
 
-  describe('enable', () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let mockAuthProvider: any;
-
-    beforeEach(() => {
-      mockAuthProvider = {
-        getCurrentUser: jest.fn(),
-        signOut: jest.fn(),
-      };
-    });
-
-    it('should enable anonymous mode without provider', async () => {
-      await anonymousModeService.enable(mockStorageProvider);
-
-      expect(anonymousModeService.getIsAnonymousMode()).toBe(true);
-      expect(mockStorageProvider.set).toHaveBeenCalledWith('@test_anonymous_mode', 'true');
-    });
-
-    it('should sign out provider if user is logged in', async () => {
-      mockAuthProvider.getCurrentUser.mockReturnValue({ uid: 'test-user' });
-      mockAuthProvider.signOut.mockResolvedValue(undefined);
-
-      await anonymousModeService.enable(mockStorageProvider, mockAuthProvider);
-
-      expect(mockAuthProvider.signOut).toHaveBeenCalled();
-      expect(anonymousModeService.getIsAnonymousMode()).toBe(true);
-    });
-
-    it('should ignore sign out errors', async () => {
-      mockAuthProvider.getCurrentUser.mockReturnValue({ uid: 'test-user' });
-      mockAuthProvider.signOut.mockRejectedValue(new Error('Sign out error'));
-
-      await expect(anonymousModeService.enable(mockStorageProvider, mockAuthProvider)).resolves.not.toThrow();
+  describe('auth integration', () => {
+    it('should enable and sign out if user is logged in', async () => {
+      const mockAuth = { getCurrentUser: jest.fn().mockReturnValue({ uid: 'u' }), signOut: jest.fn() };
+      await anonymousModeService.enable(mockStorageProvider, mockAuth as any);
+      expect(mockAuth.signOut).toHaveBeenCalled();
       expect(anonymousModeService.getIsAnonymousMode()).toBe(true);
     });
-  });
 
-  describe('wrapAuthStateCallback', () => {
-    it('should call callback with user when not in anonymous mode', () => {
+    it('should wrap auth state callback correctly', () => {
       const callback = jest.fn();
-      const wrappedCallback = anonymousModeService.wrapAuthStateCallback(callback);
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const mockUser = { uid: 'test-user' } as any;
-
-      wrappedCallback(mockUser);
-
-      expect(callback).toHaveBeenCalledWith(mockUser);
-    });
+      const wrapped = anonymousModeService.wrapAuthStateCallback(callback);
+      
+      wrapped({ uid: 'u' } as any);
+      expect(callback).toHaveBeenCalledWith({ uid: 'u' });
 
-    it('should call callback with null when in anonymous mode', () => {
       anonymousModeService.setAnonymousMode(true);
-      const callback = jest.fn();
-      const wrappedCallback = anonymousModeService.wrapAuthStateCallback(callback);
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const mockUser = { uid: 'test-user' } as any;
-
-      wrappedCallback(mockUser);
-
-      expect(callback).toHaveBeenCalledWith(null);
-    });
-
-    it('should call callback with null when user is null', () => {
-      const callback = jest.fn();
-      const wrappedCallback = anonymousModeService.wrapAuthStateCallback(callback);
-
-      wrappedCallback(null);
-
+      wrapped({ uid: 'u' } as any);
       expect(callback).toHaveBeenCalledWith(null);
     });
   });
-
-  describe('getIsAnonymousMode and setAnonymousMode', () => {
-    it('should return initial anonymous mode state', () => {
-      expect(anonymousModeService.getIsAnonymousMode()).toBe(false);
-    });
-
-    it('should set and get anonymous mode state', () => {
-      anonymousModeService.setAnonymousMode(true);
-      expect(anonymousModeService.getIsAnonymousMode()).toBe(true);
-
-      anonymousModeService.setAnonymousMode(false);
-      expect(anonymousModeService.getIsAnonymousMode()).toBe(false);
-    });
-  });
 });

package/src/__tests__/services/AuthCoreInitialization.test.ts

@@ -0,0 +1,45 @@
+import { AuthCoreService } from '../../../src/infrastructure/services/AuthCoreService';
+import { DEFAULT_AUTH_CONFIG } from '../../../src/domain/value-objects/AuthConfig';
+import type { IAuthProvider } from '../../../src/application/ports/IAuthProvider';
+
+describe('AuthCoreInitialization', () => {
+  let authCoreService: AuthCoreService;
+  let mockProvider: jest.Mocked<IAuthProvider>;
+
+  beforeEach(() => {
+    mockProvider = {
+      initialize: jest.fn(),
+      isInitialized: jest.fn().mockReturnValue(true),
+      signIn: jest.fn(),
+      signUp: jest.fn(),
+      signOut: jest.fn(),
+      getCurrentUser: jest.fn(),
+      onAuthStateChange: jest.fn().mockReturnValue(jest.fn()),
+    };
+    authCoreService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
+  });
+
+  it('should initialize with provided config', () => {
+    const customConfig = { ...DEFAULT_AUTH_CONFIG, password: { ...DEFAULT_AUTH_CONFIG.password, minLength: 12 } };
+    const service = new AuthCoreService(customConfig);
+    expect(service.getConfig()).toEqual(customConfig);
+  });
+
+  it('should initialize with IAuthProvider', async () => {
+    await authCoreService.initialize(mockProvider);
+    expect(mockProvider.initialize).toHaveBeenCalled();
+  });
+
+  it('should throw error when no provider provided', async () => {
+    await expect(authCoreService.initialize(null as any)).rejects.toThrow();
+  });
+
+  it('should return false when not initialized', () => {
+    expect(authCoreService.isInitialized()).toBe(false);
+  });
+
+  it('should return true when initialized', async () => {
+    await authCoreService.initialize(mockProvider);
+    expect(authCoreService.isInitialized()).toBe(true);
+  });
+});

package/src/__tests__/services/AuthCoreOperations.test.ts

@@ -0,0 +1,71 @@
+import { AuthCoreService } from '../../../src/infrastructure/services/AuthCoreService';
+import { DEFAULT_AUTH_CONFIG } from '../../../src/domain/value-objects/AuthConfig';
+import type { IAuthProvider } from '../../../src/application/ports/IAuthProvider';
+import type { AuthUser } from '../../../src/domain/entities/AuthUser';
+
+describe('AuthCoreOperations', () => {
+  let authCoreService: AuthCoreService;
+  let mockProvider: jest.Mocked<IAuthProvider>;
+  const mockUser: AuthUser = {
+    uid: 'test-uid',
+    email: 'test@example.com',
+    displayName: 'Test User',
+    isAnonymous: false,
+    emailVerified: false,
+    photoURL: null,
+  };
+
+  beforeEach(async () => {
+    mockProvider = {
+      initialize: jest.fn(),
+      isInitialized: jest.fn().mockReturnValue(true),
+      signIn: jest.fn(),
+      signUp: jest.fn(),
+      signOut: jest.fn(),
+      getCurrentUser: jest.fn(),
+      onAuthStateChange: jest.fn().mockReturnValue(jest.fn()),
+    };
+    authCoreService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
+    await authCoreService.initialize(mockProvider);
+  });
+
+  describe('Auth Flow', () => {
+    it('should sign up successfully', async () => {
+      mockProvider.signUp.mockResolvedValue(mockUser);
+      const result = await authCoreService.signUp({ email: 'test@example.com', password: 'password123' });
+      expect(result).toEqual(mockUser);
+    });
+
+    it('should sign in successfully', async () => {
+      mockProvider.signIn.mockResolvedValue(mockUser);
+      const result = await authCoreService.signIn({ email: 'test@example.com', password: 'password123' });
+      expect(result).toEqual(mockUser);
+    });
+
+    it('should sign out successfully', async () => {
+      await authCoreService.signOut();
+      expect(mockProvider.signOut).toHaveBeenCalled();
+    });
+  });
+
+  describe('User State', () => {
+    it('should return current user', () => {
+      mockProvider.getCurrentUser.mockReturnValue(mockUser);
+      expect(authCoreService.getCurrentUser()).toEqual(mockUser);
+    });
+
+    it('should return null when no user', () => {
+      mockProvider.getCurrentUser.mockReturnValue(null);
+      expect(authCoreService.getCurrentUser()).toBeNull();
+    });
+
+    it('should subscribe to auth state changes', () => {
+      const callback = jest.fn();
+      const mockCleanup = jest.fn();
+      mockProvider.onAuthStateChange.mockReturnValue(mockCleanup);
+      const cleanup = authCoreService.onAuthStateChange(callback);
+      expect(mockProvider.onAuthStateChange).toHaveBeenCalledWith(callback);
+      expect(cleanup).toBe(mockCleanup);
+    });
+  });
+});

package/src/__tests__/services/AuthPackage.test.ts

@@ -1,7 +1,3 @@
-/**
- * AuthPackage Tests
- */
-
 import { 
   AuthPackage, 
   initializeAuthPackage, 
@@ -17,210 +13,67 @@ describe('AuthPackage', () => {
   let mockValidationProvider: jest.Mocked<IValidationProvider>;
 
   beforeEach(() => {
-    mockStorageProvider = {
-      get: jest.fn(),
-      set: jest.fn(),
-      remove: jest.fn(),
-    };
-
-    mockUIProvider = {
-      getTheme: jest.fn(),
-      getLocalization: jest.fn(),
-    };
-
-    mockValidationProvider = {
-      validateEmail: jest.fn(),
-      validatePassword: jest.fn(),
-    };
-
-    // Reset package state
+    mockStorageProvider = { get: jest.fn(), set: jest.fn(), remove: jest.fn() };
+    mockUIProvider = { getTheme: jest.fn(), getLocalization: jest.fn() };
+    mockValidationProvider = { validateEmail: jest.fn(), validatePassword: jest.fn() };
     resetAuthPackage();
   });
 
   describe('constructor', () => {
     it('should initialize with default config', () => {
-      const authPackage = new AuthPackage();
-      const config = authPackage.getConfig();
-      
-      expect(config).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG);
-    });
-
-    it('should merge custom config with defaults', () => {
-      const customConfig = {
-        storageKeys: {
-          anonymousMode: '@custom_anonymous_mode',
-          showRegister: 'custom_show_register',
-        },
-        features: {
-          anonymousMode: false,
-          registration: false,
-          passwordStrength: false,
-        },
-      };
-
-      const authPackage = new AuthPackage(customConfig);
-      const config = authPackage.getConfig();
-
-      expect(config.storageKeys).toEqual(customConfig.storageKeys);
-      expect(config.features).toEqual(customConfig.features);
-      expect(config.validation).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG.validation);
-      expect(config.ui).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG.ui);
+      expect(new AuthPackage().getConfig()).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG);
     });
 
-    it('should deeply merge nested config', () => {
-      const customConfig = {
-        validation: {
-          passwordConfig: {
-            minLength: 12,
-            requireUppercase: true,
-          },
-        },
-      };
-
+    it('should merge custom config and deeply nested config', () => {
+      const customConfig = { features: { anonymousMode: false }, validation: { passwordConfig: { minLength: 12 } } };
       const authPackage = new AuthPackage(customConfig);
       const config = authPackage.getConfig();
-      
+      expect(config.features.anonymousMode).toBe(false);
       expect(config.validation.passwordConfig.minLength).toBe(12);
-      expect(config.validation.passwordConfig.requireUppercase).toBe(true);
-      expect(config.validation.passwordConfig.requireLowercase).toBe(true); // Should keep default
+      expect(config.validation.passwordConfig.requireLowercase).toBe(true);
     });
   });
 
-  describe('provider setters and getters', () => {
-    let authPackage: AuthPackage;
-
-    beforeEach(() => {
-      authPackage = new AuthPackage();
-    });
-
-    it('should set and get storage provider', () => {
+  describe('provider management', () => {
+    it('should set and get providers', () => {
+      const authPackage = new AuthPackage();
       authPackage.setStorageProvider(mockStorageProvider);
-      expect(authPackage.getStorageProvider()).toBe(mockStorageProvider);
-    });
-
-    it('should set and get UI provider', () => {
       authPackage.setUIProvider(mockUIProvider);
-      expect(authPackage.getUIProvider()).toBe(mockUIProvider);
-    });
-
-    it('should set and get validation provider', () => {
       authPackage.setValidationProvider(mockValidationProvider);
+      expect(authPackage.getStorageProvider()).toBe(mockStorageProvider);
+      expect(authPackage.getUIProvider()).toBe(mockUIProvider);
       expect(authPackage.getValidationProvider()).toBe(mockValidationProvider);
     });
   });
 
-  describe('isFeatureEnabled', () => {
-    let authPackage: AuthPackage;
-
-    beforeEach(() => {
-      authPackage = new AuthPackage();
-    });
-
+  describe('feature flags', () => {
     it('should return feature status from config', () => {
-      expect(authPackage.isFeatureEnabled('anonymousMode')).toBe(true);
+      const authPackage = new AuthPackage({ features: { anonymousMode: false } });
+      expect(authPackage.isFeatureEnabled('anonymousMode')).toBe(false);
       expect(authPackage.isFeatureEnabled('registration')).toBe(true);
-      expect(authPackage.isFeatureEnabled('passwordStrength')).toBe(true);
-    });
-
-    it('should return custom feature status', () => {
-      const customConfig = {
-        features: {
-          anonymousMode: false,
-          registration: false,
-          passwordStrength: false,
-        },
-      };
-
-      const customPackage = new AuthPackage(customConfig);
-
-      expect(customPackage.isFeatureEnabled('anonymousMode')).toBe(false);
-      expect(customPackage.isFeatureEnabled('registration')).toBe(false);
-      expect(customPackage.isFeatureEnabled('passwordStrength')).toBe(false);
     });
   });
 
-  describe('global package instance', () => {
-    it('should initialize package globally', () => {
-      const customConfig = {
-        storageKeys: {
-          anonymousMode: '@global_anonymous_mode',
-        },
-      };
-
-      const packageInstance = initializeAuthPackage(customConfig);
-      expect(packageInstance.getConfig().storageKeys.anonymousMode).toBe('@global_anonymous_mode');
-    });
-
-    it('should return existing package instance', () => {
-      const firstInstance = initializeAuthPackage();
-      const secondInstance = getAuthPackage();
+  describe('global instance', () => {
+    it('should manage global instances correctly', () => {
+      const instance = initializeAuthPackage({ storageKeys: { anonymousMode: '@custom' } });
+      expect(getAuthPackage()).toBe(instance);
+      expect(getAuthPackage()?.getConfig().storageKeys.anonymousMode).toBe('@custom');
       
-      expect(firstInstance).toBe(secondInstance);
-    });
-
-    it('should return null when no package initialized', () => {
       resetAuthPackage();
-      const packageInstance = getAuthPackage();
-      expect(packageInstance).toBeNull();
-    });
-
-    it('should not reinitialize when already initialized', () => {
-      const firstInstance = initializeAuthPackage();
-      const secondInstance = initializeAuthPackage({
-        storageKeys: { anonymousMode: '@different' },
-      });
-
-      expect(firstInstance).toBe(secondInstance);
-      expect(secondInstance.getConfig().storageKeys.anonymousMode).toBe('@auth_anonymous_mode');
+      expect(getAuthPackage()).toBeNull();
     });
 
-    it('should reset package instance', () => {
-      initializeAuthPackage();
-      expect(getAuthPackage()).not.toBeNull();
-      
+    it('should return null when not initialized', () => {
       resetAuthPackage();
       expect(getAuthPackage()).toBeNull();
     });
-  });
-
-  describe('provider integration', () => {
-    let authPackage: AuthPackage;
-
-    beforeEach(() => {
-      authPackage = new AuthPackage();
-      authPackage.setStorageProvider(mockStorageProvider);
-      authPackage.setUIProvider(mockUIProvider);
-      authPackage.setValidationProvider(mockValidationProvider);
-    });
-
-    it('should integrate all providers', () => {
-      expect(authPackage.getStorageProvider()).toBe(mockStorageProvider);
-      expect(authPackage.getUIProvider()).toBe(mockUIProvider);
-      expect(authPackage.getValidationProvider()).toBe(mockValidationProvider);
-    });
-  });
-
-  describe('config validation', () => {
-    it('should handle empty config', () => {
-      const authPackage = new AuthPackage({});
-      const config = authPackage.getConfig();
-
-      expect(config).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG);
-    });
 
     it('should handle partial config', () => {
-      const partialConfig = {
-        features: {
-          anonymousMode: false,
-        },
-      };
-
-      const authPackage = new AuthPackage(partialConfig);
+      const authPackage = new AuthPackage({ features: { anonymousMode: false } });
       const config = authPackage.getConfig();
-
       expect(config.features.anonymousMode).toBe(false);
       expect(config.features.registration).toBe(true);
-      expect(config.features.passwordStrength).toBe(true);
     });
   });
 });

package/src/__tests__/utils/AuthDisplayNameValidation.test.ts

@@ -0,0 +1,44 @@
+import { validateDisplayName } from '../../../src/infrastructure/utils/AuthValidation';
+
+describe('AuthDisplayNameValidation', () => {
+  describe('validateDisplayName', () => {
+    it('should reject empty name', () => {
+      const result = validateDisplayName('');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Name is required');
+    });
+
+    it('should reject whitespace-only name', () => {
+      const result = validateDisplayName('   ');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Name is required');
+    });
+
+    it('should reject name that is too short', () => {
+      const result = validateDisplayName('A');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Name must be at least 2 characters');
+    });
+
+    it('should accept name that meets minimum length', () => {
+      const result = validateDisplayName('Al');
+      expect(result.isValid).toBe(true);
+    });
+
+    it('should use custom minimum length', () => {
+      const result = validateDisplayName('Al', 3);
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Name must be at least 3 characters');
+    });
+
+    it('should trim whitespace', () => {
+      const result = validateDisplayName('  John Doe  ');
+      expect(result.isValid).toBe(true);
+    });
+
+    it('should accept name with special characters', () => {
+      const result = validateDisplayName('John-O\'Connor');
+      expect(result.isValid).toBe(true);
+    });
+  });
+});

package/src/__tests__/utils/AuthEmailValidation.test.ts

@@ -0,0 +1,38 @@
+import { validateEmail } from '../../../src/infrastructure/utils/AuthValidation';
+
+describe('AuthEmailValidation', () => {
+  describe('validateEmail', () => {
+    it('should reject empty email', () => {
+      const result = validateEmail('');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Email is required');
+    });
+
+    it('should reject whitespace-only email', () => {
+      const result = validateEmail('   ');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Email is required');
+    });
+
+    it('should reject invalid email format', () => {
+      const result = validateEmail('invalid-email');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Please enter a valid email address');
+    });
+
+    it('should accept valid email format', () => {
+      const result = validateEmail('test@example.com');
+      expect(result.isValid).toBe(true);
+    });
+
+    it('should accept valid email with subdomain', () => {
+      const result = validateEmail('test@mail.example.com');
+      expect(result.isValid).toBe(true);
+    });
+
+    it('should trim whitespace', () => {
+      const result = validateEmail('  test@example.com  ');
+      expect(result.isValid).toBe(true);
+    });
+  });
+});