@umituz/react-native-auth 3.4.21 → 3.4.23

package/src/infrastructure/utils/AuthValidation.ts

@@ -1,38 +1,17 @@
-/**
- * Auth Validation Utilities
- * Single Responsibility: Email and password validation for authentication
- */
-
 import type { PasswordConfig } from "../../domain/value-objects/AuthConfig";
 import { getAuthPackage } from "../services/AuthPackage";
 
-export interface ValidationResult {
-  isValid: boolean;
-  error?: string; // This should be a localization key
-}
-
-export interface PasswordStrengthResult extends ValidationResult {
-  requirements: PasswordRequirements;
-}
-
+export interface ValidationResult { isValid: boolean; error?: string; }
+export interface PasswordStrengthResult extends ValidationResult { requirements: PasswordRequirements; }
 export interface PasswordRequirements {
-  hasMinLength: boolean;
-  hasUppercase: boolean;
-  hasLowercase: boolean;
-  hasNumber: boolean;
-  hasSpecialChar: boolean;
+  hasMinLength: boolean; hasUppercase: boolean; hasLowercase: boolean; hasNumber: boolean; hasSpecialChar: boolean;
 }
-
 export interface ValidationConfig {
-  emailRegex: RegExp;
-  uppercaseRegex: RegExp;
-  lowercaseRegex: RegExp;
-  numberRegex: RegExp;
-  specialCharRegex: RegExp;
-  displayNameMinLength: number;
+  emailRegex: RegExp; uppercaseRegex: RegExp; lowercaseRegex: RegExp;
+  numberRegex: RegExp; specialCharRegex: RegExp; displayNameMinLength: number;
 }
 
-const DEFAULT_VALIDATION_CONFIG: ValidationConfig = {
+const DEFAULT_VAL_CONFIG: ValidationConfig = {
   emailRegex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
   uppercaseRegex: /[A-Z]/,
   lowercaseRegex: /[a-z]/,
@@ -41,155 +20,57 @@ const DEFAULT_VALIDATION_CONFIG: ValidationConfig = {
   displayNameMinLength: 2,
 };
 
-function getValidationConfig(): ValidationConfig {
-  const packageConfig = getAuthPackage()?.getConfig();
+function getValConfig(): ValidationConfig {
+  const p = getAuthPackage()?.getConfig();
   return {
-    emailRegex: packageConfig?.validation.emailRegex || DEFAULT_VALIDATION_CONFIG.emailRegex,
-    uppercaseRegex: DEFAULT_VALIDATION_CONFIG.uppercaseRegex,
-    lowercaseRegex: DEFAULT_VALIDATION_CONFIG.lowercaseRegex,
-    numberRegex: DEFAULT_VALIDATION_CONFIG.numberRegex,
-    specialCharRegex: DEFAULT_VALIDATION_CONFIG.specialCharRegex,
-    displayNameMinLength: DEFAULT_VALIDATION_CONFIG.displayNameMinLength,
+    emailRegex: p?.validation.emailRegex || DEFAULT_VAL_CONFIG.emailRegex,
+    uppercaseRegex: DEFAULT_VAL_CONFIG.uppercaseRegex,
+    lowercaseRegex: DEFAULT_VAL_CONFIG.lowercaseRegex,
+    numberRegex: DEFAULT_VAL_CONFIG.numberRegex,
+    specialCharRegex: DEFAULT_VAL_CONFIG.specialCharRegex,
+    displayNameMinLength: DEFAULT_VAL_CONFIG.displayNameMinLength,
   };
 }
 
-/**
- * Validate email format
- */
 export function validateEmail(email: string): ValidationResult {
-  if (!email || email.trim() === "") {
-    return { isValid: false, error: "auth.validation.emailRequired" };
-  }
-
-  const config = getValidationConfig();
-  if (!config.emailRegex.test(email.trim())) {
-    return { isValid: false, error: "auth.validation.invalidEmail" };
-  }
-
+  if (!email || email.trim() === "") return { isValid: false, error: "auth.validation.emailRequired" };
+  if (!getValConfig().emailRegex.test(email.trim())) return { isValid: false, error: "auth.validation.invalidEmail" };
   return { isValid: true };
 }
 
-/**
- * Validate password for login - only checks if password is provided
- * No strength requirements for login (existing users may have old passwords)
- */
 export function validatePasswordForLogin(password: string): ValidationResult {
-  if (!password || password.length === 0) {
-    return { isValid: false, error: "auth.validation.passwordRequired" };
-  }
-
+  if (!password || password.length === 0) return { isValid: false, error: "auth.validation.passwordRequired" };
   return { isValid: true };
 }
 
-/**
- * Validate password strength for registration
- * Returns detailed requirements for UI feedback
- */
-export function validatePasswordForRegister(
-  password: string,
-  config: PasswordConfig
-): PasswordStrengthResult {
-  const validationConfig = getValidationConfig();
-  const requirements: PasswordRequirements = {
+export function validatePasswordForRegister(password: string, config: PasswordConfig): PasswordStrengthResult {
+  const v = getValConfig();
+  const req: PasswordRequirements = {
     hasMinLength: password.length >= config.minLength,
-    hasUppercase: !config.requireUppercase || validationConfig.uppercaseRegex.test(password),
-    hasLowercase: !config.requireLowercase || validationConfig.lowercaseRegex.test(password),
-    hasNumber: !config.requireNumber || validationConfig.numberRegex.test(password),
-    hasSpecialChar:
-      !config.requireSpecialChar || validationConfig.specialCharRegex.test(password),
+    hasUppercase: !config.requireUppercase || v.uppercaseRegex.test(password),
+    hasLowercase: !config.requireLowercase || v.lowercaseRegex.test(password),
+    hasNumber: !config.requireNumber || v.numberRegex.test(password),
+    hasSpecialChar: !config.requireSpecialChar || v.specialCharRegex.test(password),
   };
 
-  if (!password || password.length === 0) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequired",
-      requirements,
-    };
-  }
-
-  if (!requirements.hasMinLength) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordTooShort",
-      requirements,
-    };
-  }
-
-  if (config.requireUppercase && !validationConfig.uppercaseRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireUppercase",
-      requirements,
-    };
-  }
+  if (!password) return { isValid: false, error: "auth.validation.passwordRequired", requirements: req };
+  if (!req.hasMinLength) return { isValid: false, error: "auth.validation.passwordTooShort", requirements: req };
+  if (config.requireUppercase && !req.hasUppercase) return { isValid: false, error: "auth.validation.passwordRequireUppercase", requirements: req };
+  if (config.requireLowercase && !req.hasLowercase) return { isValid: false, error: "auth.validation.passwordRequireLowercase", requirements: req };
+  if (config.requireNumber && !req.hasNumber) return { isValid: false, error: "auth.validation.passwordRequireNumber", requirements: req };
+  if (config.requireSpecialChar && !req.hasSpecialChar) return { isValid: false, error: "auth.validation.passwordRequireSpecialChar", requirements: req };
 
-  if (config.requireLowercase && !validationConfig.lowercaseRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireLowercase",
-      requirements,
-    };
-  }
-
-  if (config.requireNumber && !validationConfig.numberRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireNumber",
-      requirements,
-    };
-  }
-
-  if (config.requireSpecialChar && !validationConfig.specialCharRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireSpecialChar",
-      requirements,
-    };
-  }
-
-  return { isValid: true, requirements };
+  return { isValid: true, requirements: req };
 }
 
-/**
- * Validate password confirmation
- */
-export function validatePasswordConfirmation(
-  password: string,
-  confirmPassword: string
-): ValidationResult {
-  if (!confirmPassword) {
-    return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
-  }
-
-  if (password !== confirmPassword) {
-    return { isValid: false, error: "auth.validation.passwordsDoNotMatch" };
-  }
-
+export function validatePasswordConfirmation(password: string, confirm: string): ValidationResult {
+  if (!confirm) return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
+  if (password !== confirm) return { isValid: false, error: "auth.validation.passwordsDoNotMatch" };
   return { isValid: true };
 }
 
-/**
- * Validate display name
- */
-export function validateDisplayName(
-  displayName: string,
-  minLength?: number
-): ValidationResult {
-  if (!displayName || displayName.trim() === "") {
-    return { isValid: false, error: "auth.validation.nameRequired" };
-  }
-
-  const config = getValidationConfig();
-  const actualMinLength = minLength ?? config.displayNameMinLength;
-
-  if (displayName.trim().length < actualMinLength) {
-    return {
-      isValid: false,
-      error: "auth.validation.nameTooShort",
-    };
-  }
-
+export function validateDisplayName(name: string, minLength?: number): ValidationResult {
+  if (!name || name.trim() === "") return { isValid: false, error: "auth.validation.nameRequired" };
+  if (name.trim().length < (minLength ?? getValConfig().displayNameMinLength)) return { isValid: false, error: "auth.validation.nameTooShort" };
   return { isValid: true };
 }
-
-

package/src/presentation/components/AuthBottomSheet.tsx

@@ -13,23 +13,22 @@ import {
   BottomSheetModal,
 } from "@umituz/react-native-design-system";
 import { useLocalization } from "@umituz/react-native-localization";
-import { useAuthBottomSheet } from "../hooks/useAuthBottomSheet";
+import { useAuthBottomSheet, type SocialAuthConfiguration } from "../hooks/useAuthBottomSheet";
 import { LoginForm } from "./LoginForm";
 import { RegisterForm } from "./RegisterForm";
 import { SocialLoginButtons } from "./SocialLoginButtons";
 import { styles } from "./AuthBottomSheet.styles";
-import type { SocialAuthProvider } from "../../domain/value-objects/AuthConfig";
 
 export interface AuthBottomSheetProps {
   termsUrl?: string;
   privacyUrl?: string;
   onTermsPress?: () => void;
   onPrivacyPress?: () => void;
-  /** Enabled social auth providers */
-  socialProviders?: SocialAuthProvider[];
-  /** Called when Google sign-in is requested */
+  /** Social auth configuration */
+  socialConfig?: SocialAuthConfiguration;
+  /** Called when Google sign-in is requested (overrides internal behavior) */
   onGoogleSignIn?: () => Promise<void>;
-  /** Called when Apple sign-in is requested */
+  /** Called when Apple sign-in is requested (overrides internal behavior) */
   onAppleSignIn?: () => Promise<void>;
 }
 
@@ -38,7 +37,7 @@ export const AuthBottomSheet: React.FC<AuthBottomSheetProps> = ({
   privacyUrl,
   onTermsPress,
   onPrivacyPress,
-  socialProviders = [],
+  socialConfig,
   onGoogleSignIn,
   onAppleSignIn,
 }) => {
@@ -50,13 +49,14 @@ export const AuthBottomSheet: React.FC<AuthBottomSheetProps> = ({
     googleLoading,
     appleLoading,
     mode,
+    providers,
     handleDismiss,
     handleClose,
     handleNavigateToRegister,
     handleNavigateToLogin,
     handleGoogleSignIn,
     handleAppleSignIn,
-  } = useAuthBottomSheet({ onGoogleSignIn, onAppleSignIn });
+  } = useAuthBottomSheet({ socialConfig, onGoogleSignIn, onAppleSignIn });
 
   return (
     <BottomSheetModal
@@ -106,9 +106,9 @@ export const AuthBottomSheet: React.FC<AuthBottomSheetProps> = ({
             />
           )}
 
-          {socialProviders.length > 0 && (
+          {providers.length > 0 && (
             <SocialLoginButtons
-              enabledProviders={socialProviders}
+              enabledProviders={providers}
               onGooglePress={() => { void handleGoogleSignIn(); }}
               onApplePress={() => { void handleAppleSignIn(); }}
               googleLoading={googleLoading}

package/src/presentation/hooks/useAuthBottomSheet.ts

@@ -1,14 +1,28 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Platform } from "react-native";
 import type { BottomSheetModalRef } from "@umituz/react-native-design-system";
 import { useAuthModalStore } from "../stores/authModalStore";
 import { useAuth } from "../hooks/useAuth";
+import { useGoogleAuth, type GoogleAuthConfig } from "./useGoogleAuth";
+import { useAppleAuth } from "./useAppleAuth";
+import type { SocialAuthProvider } from "../../domain/value-objects/AuthConfig";
 
-interface UseAuthBottomSheetProps {
+declare const __DEV__: boolean;
+
+export interface SocialAuthConfiguration {
+  google?: GoogleAuthConfig;
+  apple?: { enabled: boolean };
+}
+
+interface UseAuthBottomSheetParams {
+  socialConfig?: SocialAuthConfiguration;
   onGoogleSignIn?: () => Promise<void>;
   onAppleSignIn?: () => Promise<void>;
 }
 
-export function useAuthBottomSheet({ onGoogleSignIn, onAppleSignIn }: UseAuthBottomSheetProps) {
+export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
+  const { socialConfig, onGoogleSignIn, onAppleSignIn } = params;
+  
   const modalRef = useRef<BottomSheetModalRef>(null);
   const [googleLoading, setGoogleLoading] = useState(false);
   const [appleLoading, setAppleLoading] = useState(false);
@@ -17,6 +31,25 @@ export function useAuthBottomSheet({ onGoogleSignIn, onAppleSignIn }: UseAuthBot
     useAuthModalStore();
   const { isAuthenticated, isAnonymous } = useAuth();
 
+  // Social Auth Hooks
+  const { signInWithGoogle, googleConfigured } = useGoogleAuth(socialConfig?.google);
+  const { signInWithApple, appleAvailable } = useAppleAuth();
+
+  // Determine enabled providers
+  const providers = useMemo<SocialAuthProvider[]>(() => {
+    const result: SocialAuthProvider[] = [];
+
+    if (Platform.OS === "ios" && socialConfig?.apple?.enabled && appleAvailable) {
+      result.push("apple");
+    }
+
+    if (googleConfigured) {
+      result.push("google");
+    }
+
+    return result;
+  }, [socialConfig?.apple?.enabled, appleAvailable, googleConfigured]);
+
   // Handle visibility sync with modalRef
   useEffect(() => {
     if (isVisible) {
@@ -41,14 +74,13 @@ export function useAuthBottomSheet({ onGoogleSignIn, onAppleSignIn }: UseAuthBot
   const prevIsAnonymousRef = useRef(isAnonymous);
 
   useEffect(() => {
-    // Determine if user just successfully authenticated (either A: were not authed at all, or B: were anonymous and now aren't)
     const justAuthenticated = !prevIsAuthenticatedRef.current && isAuthenticated;
     const justConvertedFromAnonymous = prevIsAnonymousRef.current && !isAnonymous && isAuthenticated;
 
     if ((justAuthenticated || justConvertedFromAnonymous) && isVisible && !isAnonymous) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         // eslint-disable-next-line no-console
-        console.log("[AuthBottomSheet] Auto-closing due to successful authentication transition", {
+        console.log("[useAuthBottomSheet] Auto-closing due to successful authentication transition", {
           justAuthenticated,
           justConvertedFromAnonymous,
         });
@@ -57,7 +89,6 @@ export function useAuthBottomSheet({ onGoogleSignIn, onAppleSignIn }: UseAuthBot
       executePendingCallback();
     }
     
-    // Update refs for next render
     prevIsAuthenticatedRef.current = isAuthenticated;
     prevIsVisibleRef.current = isVisible;
     prevIsAnonymousRef.current = isAnonymous;
@@ -71,36 +102,43 @@ export function useAuthBottomSheet({ onGoogleSignIn, onAppleSignIn }: UseAuthBot
     setMode("login");
   }, [setMode]);
 
-  const handleGoogleSignIn = useCallback(async () => {
-    if (!onGoogleSignIn) return;
+  const handleGoogleSignInInternal = useCallback(async () => {
     setGoogleLoading(true);
     try {
-      await onGoogleSignIn();
+      if (onGoogleSignIn) {
+        await onGoogleSignIn();
+      } else if (signInWithGoogle) {
+        await signInWithGoogle();
+      }
     } finally {
       setGoogleLoading(false);
     }
-  }, [onGoogleSignIn]);
+  }, [onGoogleSignIn, signInWithGoogle]);
 
-  const handleAppleSignIn = useCallback(async () => {
-    if (!onAppleSignIn) return;
+  const handleAppleSignInInternal = useCallback(async () => {
     setAppleLoading(true);
     try {
-      await onAppleSignIn();
+      if (onAppleSignIn) {
+        await onAppleSignIn();
+      } else if (signInWithApple) {
+        await signInWithApple();
+      }
     } finally {
       setAppleLoading(false);
     }
-  }, [onAppleSignIn]);
+  }, [onAppleSignIn, signInWithApple]);
 
   return {
     modalRef,
     googleLoading,
     appleLoading,
     mode,
+    providers,
     handleDismiss,
     handleClose,
     handleNavigateToRegister,
     handleNavigateToLogin,
-    handleGoogleSignIn,
-    handleAppleSignIn,
+    handleGoogleSignIn: handleGoogleSignInInternal,
+    handleAppleSignIn: handleAppleSignInInternal,
   };
 }

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);
-    });
-  });
-});