test: PhoneAuthProvider unit tests, remove mockStatic usage

Author: demolaf

auth/src/main/java/com/firebase/ui/auth/compose/configuration/auth_provider/AuthProvider.kt

@@ -30,6 +30,7 @@ import com.firebase.ui.auth.util.data.PhoneNumberUtils
 import com.firebase.ui.auth.util.data.ProviderAvailability
 import com.google.firebase.FirebaseException
 import com.google.firebase.auth.ActionCodeSettings
+import com.google.firebase.auth.AuthCredential
 import com.google.firebase.auth.EmailAuthProvider
 import com.google.firebase.auth.FacebookAuthProvider
 import com.google.firebase.auth.FirebaseAuth
@@ -271,6 +272,24 @@ abstract class AuthProvider(open val providerId: String) {
 
         private fun continueUrl(continueUrl: String, block: ContinueUrlBuilder.() -> Unit) =
             ContinueUrlBuilder(continueUrl).apply(block).build()
+
+        /**
+         * An interface to wrap the static `EmailAuthProvider.getCredential` method to make it testable.
+         * @suppress
+         */
+        internal interface CredentialProvider {
+            fun getCredential(email: String, password: String): AuthCredential
+        }
+
+        /**
+         * The default implementation of [CredentialProvider] that calls the static method.
+         * @suppress
+         */
+        internal class DefaultCredentialProvider : CredentialProvider {
+            override fun getCredential(email: String, password: String): AuthCredential {
+                return EmailAuthProvider.getCredential(email, password)
+            }
+        }
     }
 
     /**
@@ -388,40 +407,99 @@ abstract class AuthProvider(open val providerId: String) {
             phoneNumber: String,
             multiFactorSession: MultiFactorSession? = null,
             forceResendingToken: PhoneAuthProvider.ForceResendingToken?,
-        ): VerifyPhoneNumberResult = suspendCoroutine { continuation ->
-            val options = PhoneAuthOptions.newBuilder(auth)
-                .setPhoneNumber(phoneNumber)
-                .requireSmsValidation(!isInstantVerificationEnabled)
-                .setTimeout(timeout, TimeUnit.SECONDS)
-                .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
-                    override fun onVerificationCompleted(credential: PhoneAuthCredential) {
-                        continuation.resume(VerifyPhoneNumberResult.AutoVerified(credential))
-                    }
+            verifier: Verifier = DefaultVerifier(),
+        ): VerifyPhoneNumberResult {
+            return verifier.verifyPhoneNumber(
+                auth,
+                phoneNumber,
+                timeout,
+                forceResendingToken,
+                multiFactorSession,
+                isInstantVerificationEnabled
+            )
+        }
 
-                    override fun onVerificationFailed(e: FirebaseException) {
-                        continuation.resumeWithException(e)
-                    }
+        /**
+         * @suppress
+         */
+        internal interface Verifier {
+            suspend fun verifyPhoneNumber(
+                auth: FirebaseAuth,
+                phoneNumber: String,
+                timeout: Long,
+                forceResendingToken: PhoneAuthProvider.ForceResendingToken?,
+                multiFactorSession: MultiFactorSession?,
+                isInstantVerificationEnabled: Boolean
+            ): VerifyPhoneNumberResult
+        }
 
-                    override fun onCodeSent(
-                        verificationId: String,
-                        token: PhoneAuthProvider.ForceResendingToken,
-                    ) {
-                        continuation.resume(
-                            VerifyPhoneNumberResult.NeedsManualVerification(
-                                verificationId,
-                                token
-                            )
-                        )
+        /**
+         * @suppress
+         */
+        internal class DefaultVerifier : Verifier {
+            override suspend fun verifyPhoneNumber(
+                auth: FirebaseAuth,
+                phoneNumber: String,
+                timeout: Long,
+                forceResendingToken: PhoneAuthProvider.ForceResendingToken?,
+                multiFactorSession: MultiFactorSession?,
+                isInstantVerificationEnabled: Boolean
+            ): VerifyPhoneNumberResult {
+                return suspendCoroutine { continuation ->
+                    val options = PhoneAuthOptions.newBuilder(auth)
+                        .setPhoneNumber(phoneNumber)
+                        .requireSmsValidation(!isInstantVerificationEnabled)
+                        .setTimeout(timeout, TimeUnit.SECONDS)
+                        .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
+                            override fun onVerificationCompleted(credential: PhoneAuthCredential) {
+                                continuation.resume(VerifyPhoneNumberResult.AutoVerified(credential))
+                            }
+
+                            override fun onVerificationFailed(e: FirebaseException) {
+                                continuation.resumeWithException(e)
+                            }
+
+                            override fun onCodeSent(
+                                verificationId: String,
+                                token: PhoneAuthProvider.ForceResendingToken,
+                            ) {
+                                continuation.resume(
+                                    VerifyPhoneNumberResult.NeedsManualVerification(
+                                        verificationId,
+                                        token
+                                    )
+                                )
+                            }
+                        })
+                    if (forceResendingToken != null) {
+                        options.setForceResendingToken(forceResendingToken)
                     }
-                })
-            if (forceResendingToken != null) {
-                options.setForceResendingToken(forceResendingToken)
+                    if (multiFactorSession != null) {
+                        options.setMultiFactorSession(multiFactorSession)
+                    }
+                    PhoneAuthProvider.verifyPhoneNumber(options.build())
+                }
             }
-            if (multiFactorSession != null) {
-                options.setMultiFactorSession(multiFactorSession)
+        }
+
+        /**
+         * An interface to wrap the static `PhoneAuthProvider.getCredential` method to make it testable.
+         * @suppress
+         */
+        internal interface CredentialProvider {
+            fun getCredential(verificationId: String, smsCode: String): PhoneAuthCredential
+        }
+
+        /**
+         * The default implementation of [CredentialProvider] that calls the static method.
+         * @suppress
+         */
+        internal class DefaultCredentialProvider : CredentialProvider {
+            override fun getCredential(verificationId: String, smsCode: String): PhoneAuthCredential {
+                return PhoneAuthProvider.getCredential(verificationId, smsCode)
             }
-            PhoneAuthProvider.verifyPhoneNumber(options.build())
         }
+
     }
 
     /**
@@ -704,4 +782,4 @@ abstract class AuthProvider(open val providerId: String) {
             }
         }
     }
-}
+}

auth/src/main/java/com/firebase/ui/auth/compose/configuration/auth_provider/EmailAuthProvider+FirebaseAuthUI.kt

@@ -50,7 +50,7 @@ import kotlinx.coroutines.tasks.await
 internal class CredentialForLinking(
     val providerType: String,
     val idToken: String?,
-    val accessToken: String?
+    val accessToken: String?,
 )
 
 /**
@@ -130,11 +130,12 @@ internal suspend fun FirebaseAuthUI.createOrLinkUserWithEmailAndPassword(
     provider: AuthProvider.Email,
     name: String?,
     email: String,
-    password: String
+    password: String,
+    credentialProvider: AuthProvider.Email.CredentialProvider = AuthProvider.Email.DefaultCredentialProvider(),
 ): AuthResult? {
     val canUpgrade = canUpgradeAnonymous(config, auth)
     val pendingCredential =
-        if (canUpgrade) EmailAuthProvider.getCredential(email, password) else null
+        if (canUpgrade) credentialProvider.getCredential(email, password) else null
 
     try {
         // Check if new accounts are allowed (only for non-upgrade flows)
@@ -454,7 +455,7 @@ internal suspend fun FirebaseAuthUI.signInAndLinkWithCredential(
     config: AuthUIConfiguration,
     credential: AuthCredential,
     displayName: String? = null,
-    photoUrl: Uri? = null
+    photoUrl: Uri? = null,
 ): AuthResult? {
     try {
         updateAuthState(AuthState.Loading("Signing in user..."))
@@ -639,7 +640,7 @@ internal suspend fun FirebaseAuthUI.sendSignInLinkToEmail(
     config: AuthUIConfiguration,
     provider: AuthProvider.Email,
     email: String,
-    credentialForLinking: CredentialForLinking? = null
+    credentialForLinking: CredentialForLinking? = null,
 ) {
     try {
         updateAuthState(AuthState.Loading("Sending sign in email link..."))
@@ -938,7 +939,7 @@ suspend fun FirebaseAuthUI.signInWithEmailLink(
  */
 internal suspend fun FirebaseAuthUI.sendPasswordResetEmail(
     email: String,
-    actionCodeSettings: ActionCodeSettings? = null
+    actionCodeSettings: ActionCodeSettings? = null,
 ) {
     try {
         updateAuthState(AuthState.Loading("Sending password reset email..."))

auth/src/main/java/com/firebase/ui/auth/compose/configuration/auth_provider/PhoneAuthProvider+FirebaseAuthUI.kt

@@ -104,14 +104,16 @@ internal suspend fun FirebaseAuthUI.verifyPhoneNumber(
     phoneNumber: String,
     multiFactorSession: MultiFactorSession? = null,
     forceResendingToken: PhoneAuthProvider.ForceResendingToken? = null,
+    verifier: AuthProvider.Phone.Verifier = AuthProvider.Phone.DefaultVerifier(),
 ) {
     try {
         updateAuthState(AuthState.Loading("Verifying phone number..."))
         val result = provider.verifyPhoneNumberAwait(
             auth = auth,
             phoneNumber = phoneNumber,
             multiFactorSession = multiFactorSession,
-            forceResendingToken = forceResendingToken
+            forceResendingToken = forceResendingToken,
+            verifier = verifier
         )
         when (result) {
             is AuthProvider.Phone.VerifyPhoneNumberResult.AutoVerified -> {
@@ -195,10 +197,11 @@ internal suspend fun FirebaseAuthUI.submitVerificationCode(
     config: AuthUIConfiguration,
     verificationId: String,
     code: String,
+    credentialProvider: AuthProvider.Phone.CredentialProvider = AuthProvider.Phone.DefaultCredentialProvider(),
 ): AuthResult? {
     try {
         updateAuthState(AuthState.Loading("Submitting verification code..."))
-        val credential = PhoneAuthProvider.getCredential(verificationId, code)
+        val credential = credentialProvider.getCredential(verificationId, code)
         return signInWithPhoneAuthCredential(
             config = config,
             credential = credential