@umituz/react-native-auth 3.4.22 → 3.4.24

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

@@ -1,247 +0,0 @@
-/**
- * AuthCoreService Tests
- */
-
-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('AuthCoreService', () => {
-  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);
-  });
-
-  describe('constructor', () => {
-    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);
-    });
-  });
-
-  describe('initialize', () => {
-    it('should initialize with IAuthProvider', async () => {
-      await authCoreService.initialize(mockProvider);
-      expect(mockProvider.initialize).toHaveBeenCalled();
-    });
-
-    it('should initialize with Firebase Auth instance', async () => {
-      const mockFirebaseAuth = {
-        currentUser: null,
-      } as any;
-
-      await expect(authCoreService.initialize(mockFirebaseAuth)).rejects.toThrow();
-    });
-
-    it('should throw error when no provider provided', async () => {
-      await expect(authCoreService.initialize(null as any)).rejects.toThrow(
-        'Auth provider or Firebase Auth instance is required'
-      );
-    });
-  });
-
-  describe('isInitialized', () => {
-    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);
-    });
-  });
-
-  describe('signUp', () => {
-    const mockUser: AuthUser = {
-      uid: 'test-uid',
-      email: 'test@example.com',
-      displayName: 'Test User',
-      isAnonymous: false,
-      emailVerified: false,
-      photoURL: null,
-    };
-
-    beforeEach(async () => {
-      await authCoreService.initialize(mockProvider);
-    });
-
-    it('should sign up successfully with valid credentials', async () => {
-      mockProvider.signUp.mockResolvedValue(mockUser);
-
-      const result = await authCoreService.signUp({
-        email: 'test@example.com',
-        password: 'password123',
-        displayName: 'Test User',
-      });
-
-      expect(result).toEqual(mockUser);
-      expect(mockProvider.signUp).toHaveBeenCalledWith({
-        email: 'test@example.com',
-        password: 'password123',
-        displayName: 'Test User',
-      });
-    });
-
-    it('should sign up without display name', async () => {
-      mockProvider.signUp.mockResolvedValue(mockUser);
-
-      await authCoreService.signUp({
-        email: 'test@example.com',
-        password: 'password123',
-      });
-
-      expect(mockProvider.signUp).toHaveBeenCalledWith({
-        email: 'test@example.com',
-        password: 'password123',
-        displayName: undefined,
-      });
-    });
-
-    it('should throw error when not initialized', async () => {
-      const uninitializedService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
-      
-      await expect(uninitializedService.signUp({
-        email: 'test@example.com',
-        password: 'password123',
-      })).rejects.toThrow('Auth service is not initialized');
-    });
-  });
-
-  describe('signIn', () => {
-    const mockUser: AuthUser = {
-      uid: 'test-uid',
-      email: 'test@example.com',
-      displayName: 'Test User',
-      isAnonymous: false,
-      emailVerified: false,
-      photoURL: null,
-    };
-
-    beforeEach(async () => {
-      await authCoreService.initialize(mockProvider);
-    });
-
-    it('should sign in successfully with valid credentials', async () => {
-      mockProvider.signIn.mockResolvedValue(mockUser);
-
-      const result = await authCoreService.signIn({
-        email: 'test@example.com',
-        password: 'password123',
-      });
-
-      expect(result).toEqual(mockUser);
-      expect(mockProvider.signIn).toHaveBeenCalledWith({
-        email: 'test@example.com',
-        password: 'password123',
-      });
-    });
-
-    it('should throw error when not initialized', async () => {
-      const uninitializedService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
-      
-      await expect(uninitializedService.signIn({
-        email: 'test@example.com',
-        password: 'password123',
-      })).rejects.toThrow('Auth service is not initialized');
-    });
-  });
-
-  describe('signOut', () => {
-    beforeEach(async () => {
-      await authCoreService.initialize(mockProvider);
-    });
-
-    it('should sign out successfully', async () => {
-      await authCoreService.signOut();
-      expect(mockProvider.signOut).toHaveBeenCalled();
-    });
-
-    it('should handle sign out when not initialized', async () => {
-      const uninitializedService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
-      
-      await expect(uninitializedService.signOut()).resolves.not.toThrow();
-    });
-  });
-
-  describe('getCurrentUser', () => {
-    const mockUser: AuthUser = {
-      uid: 'test-uid',
-      email: 'test@example.com',
-      displayName: 'Test User',
-      isAnonymous: false,
-      emailVerified: false,
-      photoURL: null,
-    };
-
-    it('should return null when not initialized', () => {
-      const result = authCoreService.getCurrentUser();
-      expect(result).toBeNull();
-    });
-
-    it('should return current user when initialized', async () => {
-      mockProvider.getCurrentUser.mockReturnValue(mockUser);
-      await authCoreService.initialize(mockProvider);
-
-      const result = authCoreService.getCurrentUser();
-      expect(result).toEqual(mockUser);
-    });
-
-    it('should return null when no current user', async () => {
-      mockProvider.getCurrentUser.mockReturnValue(null);
-      await authCoreService.initialize(mockProvider);
-
-      const result = authCoreService.getCurrentUser();
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('onAuthStateChange', () => {
-    it('should return cleanup function when not initialized', () => {
-      const callback = jest.fn();
-      const cleanup = authCoreService.onAuthStateChange(callback);
-      
-      expect(callback).toHaveBeenCalledWith(null);
-      expect(typeof cleanup).toBe('function');
-    });
-
-    it('should subscribe to auth state changes when initialized', async () => {
-      const callback = jest.fn();
-      const mockCleanup = jest.fn();
-      mockProvider.onAuthStateChange.mockReturnValue(mockCleanup);
-      
-      await authCoreService.initialize(mockProvider);
-      const cleanup = authCoreService.onAuthStateChange(callback);
-
-      expect(mockProvider.onAuthStateChange).toHaveBeenCalledWith(callback);
-      expect(cleanup).toBe(mockCleanup);
-    });
-  });
-
-  describe('getConfig', () => {
-    it('should return the current config', () => {
-      const config = authCoreService.getConfig();
-      expect(config).toEqual(DEFAULT_AUTH_CONFIG);
-    });
-  });
-});

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

@@ -1,270 +0,0 @@
-/**
- * AuthValidation Tests
- */
-
-import {
-  validateEmail,
-  validatePasswordForLogin,
-  validatePasswordForRegister,
-  validatePasswordConfirmation,
-  validateDisplayName,
-} from '../../../src/infrastructure/utils/AuthValidation';
-import { DEFAULT_PASSWORD_CONFIG } from '../../../src/domain/value-objects/AuthConfig';
-import { initializeAuthPackage } from '../../../src/infrastructure/services/AuthPackage';
-
-describe('AuthValidation', () => {
-  beforeEach(() => {
-    // Reset package config before each test
-    initializeAuthPackage();
-  });
-
-  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);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should accept valid email with subdomain', () => {
-      const result = validateEmail('test@mail.example.com');
-      expect(result.isValid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should trim whitespace', () => {
-      const result = validateEmail('  test@example.com  ');
-      expect(result.isValid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-  });
-
-  describe('validatePasswordForLogin', () => {
-    it('should reject empty password', () => {
-      const result = validatePasswordForLogin('');
-      expect(result.isValid).toBe(false);
-      expect(result.error).toBe('Password is required');
-    });
-
-    it('should accept any non-empty password', () => {
-      const result = validatePasswordForLogin('any');
-      expect(result.isValid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should accept password with spaces', () => {
-      const result = validatePasswordForLogin('  password  ');
-      expect(result.isValid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-  });
-
-  describe('validatePasswordForRegister', () => {
-    const config = DEFAULT_PASSWORD_CONFIG;
-
-    it('should reject empty password', () => {
-      const result = validatePasswordForRegister('', config);
-      expect(result.isValid).toBe(false);
-      expect(result.error).toBe('Password is required');
-      expect(result.requirements.hasMinLength).toBe(false);
-    });
-
-    it('should reject password that is too short', () => {
-      const result = validatePasswordForRegister('123', config);
-      expect(result.isValid).toBe(false);
-      expect(result.error).toBe(`Password must be at least ${config.minLength} characters`);
-      expect(result.requirements.hasMinLength).toBe(false);
-    });
-
-    it('should accept password that meets minimum length', () => {
-      const result = validatePasswordForRegister('12345678', config);
-      expect(result.requirements.hasMinLength).toBe(true);
-    });
-
-    it('should validate uppercase requirement', () => {
-      const configWithUppercase = {
-        ...config,
-        requireUppercase: true,
-      };
-
-      const result = validatePasswordForRegister('password', configWithUppercase);
-      expect(result.isValid).toBe(false);
-      expect(result.error).toBe('Password must contain at least one uppercase letter');
-      expect(result.requirements.hasUppercase).toBe(false);
-
-      const validResult = validatePasswordForRegister('Password', configWithUppercase);
-      expect(validResult.requirements.hasUppercase).toBe(true);
-    });
-
-    it('should validate lowercase requirement', () => {
-      const configWithLowercase = {
-        ...config,
-        requireLowercase: true,
-      };
-
-      const result = validatePasswordForRegister('PASSWORD', configWithLowercase);
-      expect(result.isValid).toBe(false);
-      expect(result.error).toBe('Password must contain at least one lowercase letter');
-      expect(result.requirements.hasLowercase).toBe(false);
-
-      const validResult = validatePasswordForRegister('Password', configWithLowercase);
-      expect(validResult.requirements.hasLowercase).toBe(true);
-    });
-
-    it('should validate number requirement', () => {
-      const configWithNumber = {
-        ...config,
-        requireNumber: true,
-      };
-
-      const result = validatePasswordForRegister('Password', configWithNumber);
-      expect(result.isValid).toBe(false);
-      expect(result.error).toBe('Password must contain at least one number');
-      expect(result.requirements.hasNumber).toBe(false);
-
-      const validResult = validatePasswordForRegister('Password1', configWithNumber);
-      expect(validResult.requirements.hasNumber).toBe(true);
-    });
-
-    it('should validate special character requirement', () => {
-      const configWithSpecial = {
-        ...config,
-        requireSpecialChar: true,
-      };
-
-      const result = validatePasswordForRegister('Password1', configWithSpecial);
-      expect(result.isValid).toBe(false);
-      expect(result.error).toBe('Password must contain at least one special character');
-      expect(result.requirements.hasSpecialChar).toBe(false);
-
-      const validResult = validatePasswordForRegister('Password1!', configWithSpecial);
-      expect(validResult.requirements.hasSpecialChar).toBe(true);
-    });
-
-    it('should accept password that meets all requirements', () => {
-      const strictConfig = {
-        ...config,
-        requireUppercase: true,
-        requireLowercase: true,
-        requireNumber: true,
-        requireSpecialChar: true,
-      };
-
-      const result = validatePasswordForRegister('Password1!', strictConfig);
-      expect(result.isValid).toBe(true);
-      expect(result.requirements).toEqual({
-        hasMinLength: true,
-        hasUppercase: true,
-        hasLowercase: true,
-        hasNumber: true,
-        hasSpecialChar: true,
-      });
-    });
-
-    it('should skip requirements when disabled', () => {
-      const lenientConfig = {
-        ...config,
-        requireUppercase: false,
-        requireLowercase: false,
-        requireNumber: false,
-        requireSpecialChar: false,
-      };
-
-      const result = validatePasswordForRegister('password', lenientConfig);
-      expect(result.requirements).toEqual({
-        hasMinLength: true,
-        hasUppercase: true, // Should be true when requirement is disabled
-        hasLowercase: true, // Should be true when requirement is disabled
-        hasNumber: true, // Should be true when requirement is disabled
-        hasSpecialChar: true, // Should be true when requirement is disabled
-      });
-    });
-  });
-
-  describe('validatePasswordConfirmation', () => {
-    it('should reject empty confirmation', () => {
-      const result = validatePasswordConfirmation('password', '');
-      expect(result.isValid).toBe(false);
-      expect(result.error).toBe('Please confirm your password');
-    });
-
-    it('should reject mismatched passwords', () => {
-      const result = validatePasswordConfirmation('password', 'different');
-      expect(result.isValid).toBe(false);
-      expect(result.error).toBe('Passwords do not match');
-    });
-
-    it('should accept matching passwords', () => {
-      const result = validatePasswordConfirmation('password', 'password');
-      expect(result.isValid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should handle empty passwords that match', () => {
-      const result = validatePasswordConfirmation('', '');
-      expect(result.isValid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-  });
-
-  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);
-      expect(result.error).toBeUndefined();
-    });
-
-    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);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should accept name with special characters', () => {
-      const result = validateDisplayName('John-O\'Connor');
-      expect(result.isValid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-  });
-});