Merge remote-tracking branch 'GitLiveApp/increase_auth_coverage' into coroutine_cancellation_fix

Author: Daeda88

.github/workflows/publish.yml

@@ -24,8 +24,6 @@ jobs:
           arguments: :updateVersions
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
-      - name: Install Homebrew
-        run: ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
       - name: Install Carthage
         run: brew install carthage
       - name: Publish

.github/workflows/pull_request.yml

@@ -20,8 +20,6 @@ jobs:
         java-version: 1.8
     - name: Grant execute permission for gradlew
       run: chmod +x gradlew
-    - name: Install Homebrew
-      run: ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
     - name: Install Carthage
       run: brew install carthage
     - name: Assemble

firebase-auth/src/androidMain/kotlin/dev/gitlive/firebase/auth/auth.kt

@@ -101,7 +101,7 @@ actual class AuthResult internal constructor(val android: com.google.firebase.au
         get() = android.user?.let { FirebaseUser(it) }
 }
 
-private fun ActionCodeSettings.toAndroid() = com.google.firebase.auth.ActionCodeSettings.newBuilder()
+internal fun ActionCodeSettings.toAndroid() = com.google.firebase.auth.ActionCodeSettings.newBuilder()
     .setUrl(url)
     .also { androidPackageName?.run { it.setAndroidPackageName(packageName, installIfNotAvailable, minimumVersion) } }
     .also { dynamicLinkDomain?.run { it.setDynamicLinkDomain(this) } }

firebase-auth/src/androidMain/kotlin/dev/gitlive/firebase/auth/credentials.kt

@@ -6,6 +6,7 @@ package dev.gitlive.firebase.auth
 
 import android.app.Activity
 import com.google.firebase.FirebaseException
+import com.google.firebase.auth.OAuthProvider
 import com.google.firebase.auth.PhoneAuthProvider
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.coroutineScope
@@ -23,48 +24,34 @@ actual class PhoneAuthCredential(override val android: com.google.firebase.auth.
 actual class OAuthCredential(override val android: com.google.firebase.auth.OAuthCredential) : AuthCredential(android)
 
 actual object EmailAuthProvider {
-    actual fun credentialWithEmail(
+    actual fun credential(
         email: String,
         password: String
     ): AuthCredential = AuthCredential(com.google.firebase.auth.EmailAuthProvider.getCredential(email, password))
 }
 
 actual object FacebookAuthProvider {
-    actual fun credentialWithAccessToken(accessToken: String): AuthCredential = AuthCredential(com.google.firebase.auth.FacebookAuthProvider.getCredential(accessToken))
+    actual fun credential(accessToken: String): AuthCredential = AuthCredential(com.google.firebase.auth.FacebookAuthProvider.getCredential(accessToken))
 }
 
 actual object GithubAuthProvider {
-    actual fun credentialWithToken(token: String): AuthCredential = AuthCredential(com.google.firebase.auth.GithubAuthProvider.getCredential(token))
+    actual fun credential(token: String): AuthCredential = AuthCredential(com.google.firebase.auth.GithubAuthProvider.getCredential(token))
 }
 
 actual object GoogleAuthProvider {
-    actual fun credentialWithIDAndAccessToken(idToken: String, accessToken: String): AuthCredential = AuthCredential(com.google.firebase.auth.GoogleAuthProvider.getCredential(idToken, accessToken))
+    actual fun credential(idToken: String, accessToken: String): AuthCredential = AuthCredential(com.google.firebase.auth.GoogleAuthProvider.getCredential(idToken, accessToken))
 }
 
 actual class OAuthProvider(val android: com.google.firebase.auth.OAuthProvider.Builder, private val auth: FirebaseAuth) {
     actual constructor(provider: String, auth: FirebaseAuth) : this(com.google.firebase.auth.OAuthProvider.newBuilder(provider, auth.android), auth)
 
     actual companion object {
-        actual fun credentialsWithAccessToken(providerId: String, accessToken: String): AuthCredential = createCredentials(providerId) {
-            this.accessToken = accessToken
-        }
-        actual fun credentialsWithIDAndAccessToken(providerId: String, idToken: String, accessToken: String): AuthCredential = createCredentials(providerId) {
-            setIdToken(idToken)
-            this.accessToken = accessToken
-        }
-        actual fun credentialsWithIDRawNonceAndAccessToken(providerId: String, idToken: String, rawNonce: String, accessToken: String): AuthCredential = createCredentials(providerId) {
-            setIdTokenWithRawNonce(idToken, rawNonce)
-            this.accessToken = accessToken
-        }
-        actual fun credentialsWithIDAndRawNonce(providerId: String, idToken: String, rawNonce: String): AuthCredential = createCredentials(providerId) {
-            setIdTokenWithRawNonce(idToken, rawNonce)
-        }
-
-        private fun createCredentials(providerId: String, block: com.google.firebase.auth.OAuthProvider.CredentialBuilder.() -> Unit): AuthCredential {
-            val credential = com.google.firebase.auth.OAuthProvider.newCredentialBuilder(providerId).apply {
-                block()
-            }.build()
-            return (credential as? com.google.firebase.auth.OAuthCredential)?.let { OAuthCredential(it) } ?: AuthCredential(credential)
+        actual fun credential(providerId: String, accessToken: String?, idToken: String?, rawNonce: String?): OAuthCredential {
+            val builder = OAuthProvider.newCredentialBuilder(providerId)
+            accessToken?.let { builder.accessToken = it }
+            idToken?.let { builder.idToken = it }
+            rawNonce?.let { builder.setIdTokenWithRawNonce(idToken!!, it)  }
+            return OAuthCredential(builder.build() as com.google.firebase.auth.OAuthCredential)
         }
     }
 
@@ -87,7 +74,7 @@ actual class PhoneAuthProvider(val android: com.google.firebase.auth.PhoneAuthPr
 
     actual constructor(auth: FirebaseAuth) : this(com.google.firebase.auth.PhoneAuthProvider.getInstance(auth.android))
 
-    actual fun credentialWithVerificationIdAndSmsCode(verificationId: String, smsCode: String): PhoneAuthCredential = PhoneAuthCredential(com.google.firebase.auth.PhoneAuthProvider.getCredential(verificationId, smsCode))
+    actual fun credential(verificationId: String, smsCode: String): PhoneAuthCredential = PhoneAuthCredential(com.google.firebase.auth.PhoneAuthProvider.getCredential(verificationId, smsCode))
     actual suspend fun verifyPhoneNumber(phoneNumber: String, verificationProvider: PhoneVerificationProvider): AuthCredential = coroutineScope {
         val response = CompletableDeferred<Result<AuthCredential>>()
         val callback = object :
@@ -101,9 +88,7 @@ actual class PhoneAuthProvider(val android: com.google.firebase.auth.PhoneAuthPr
                 launch {
                     val code = verificationProvider.getVerificationCode()
                     try {
-                        val credentials =
-                            credentialWithVerificationIdAndSmsCode(verificationId, code)
-                        response.complete(Result.success(credentials))
+                        response.complete(Result.success(credential(verificationId, code)))
                     } catch (e: Exception) {
                         response.complete(Result.failure(e))
                     }
@@ -134,5 +119,5 @@ actual interface PhoneVerificationProvider {
 }
 
 actual object TwitterAuthProvider {
-    actual fun credentialWithTokenAndSecret(token: String, secret: String): AuthCredential = AuthCredential(com.google.firebase.auth.TwitterAuthProvider.getCredential(token, secret))
+    actual fun credential(token: String, secret: String): AuthCredential = AuthCredential(com.google.firebase.auth.TwitterAuthProvider.getCredential(token, secret))
 }

firebase-auth/src/androidMain/kotlin/dev/gitlive/firebase/auth/user.kt

@@ -38,8 +38,8 @@ actual class FirebaseUser internal constructor(val android: com.google.firebase.
     actual suspend fun reauthenticate(credential: AuthCredential) = android.reauthenticate(credential.android).await().run { Unit }
     actual suspend fun reauthenticateAndRetrieveData(credential: AuthCredential): AuthResult = AuthResult(android.reauthenticateAndRetrieveData(credential.android).await())
     actual suspend fun sendEmailVerification(actionCodeSettings: ActionCodeSettings?) {
-        val request = actionCodeSettings?.android?.let { android.sendEmailVerification(it) } ?: android.sendEmailVerification()
-        request.await().run { Unit }
+        val request = actionCodeSettings?.let { android.sendEmailVerification(it.toAndroid()) } ?: android.sendEmailVerification()
+        request.await()
     }
     actual suspend fun unlink(provider: String): FirebaseUser? = android.unlink(provider).await().user?.let { FirebaseUser(it) }
     actual suspend fun updateEmail(email: String) = android.updateEmail(email).await().run { Unit }
@@ -52,7 +52,8 @@ actual class FirebaseUser internal constructor(val android: com.google.firebase.
         }.build()
         android.updateProfile(request).await()
     }
-    actual suspend fun verifyBeforeUpdateEmail(newEmail: String, actionCodeSettings: ActionCodeSettings?) = android.verifyBeforeUpdateEmail(newEmail, actionCodeSettings?.android).await().run { Unit }
+    actual suspend fun verifyBeforeUpdateEmail(newEmail: String, actionCodeSettings: ActionCodeSettings?) =
+        android.verifyBeforeUpdateEmail(newEmail, actionCodeSettings?.toAndroid()).await().run { Unit }
 }
 
 actual class UserInfo(val android: com.google.firebase.auth.UserInfo) {

firebase-auth/src/commonMain/kotlin/dev/gitlive/firebase/auth/credentials.kt

@@ -14,27 +14,24 @@ expect class PhoneAuthCredential : AuthCredential
 expect class OAuthCredential : AuthCredential
 
 expect object EmailAuthProvider {
-    fun credentialWithEmail(email: String, password: String): AuthCredential
+    fun credential(email: String, password: String): AuthCredential
 }
 
 expect object FacebookAuthProvider {
-    fun credentialWithAccessToken(accessToken: String): AuthCredential
+    fun credential(accessToken: String): AuthCredential
 }
 
 expect object GithubAuthProvider {
-    fun credentialWithToken(token: String): AuthCredential
+    fun credential(token: String): AuthCredential
 }
 
 expect object GoogleAuthProvider {
-    fun credentialWithIDAndAccessToken(idToken: String, accessToken: String): AuthCredential
+    fun credential(idToken: String, accessToken: String): AuthCredential
 }
 
 expect class OAuthProvider constructor(provider: String, auth: FirebaseAuth = Firebase.auth) {
     companion object {
-        fun credentialsWithAccessToken(providerId: String, accessToken: String): AuthCredential
-        fun credentialsWithIDAndAccessToken(providerId: String, idToken: String, accessToken: String): AuthCredential
-        fun credentialsWithIDRawNonceAndAccessToken(providerId: String, idToken: String, rawNonce: String, accessToken: String): AuthCredential
-        fun credentialsWithIDAndRawNonce(providerId: String, idToken: String, rawNonce: String): AuthCredential
+        fun credential(providerId: String, accessToken: String? = null, idToken: String? = null, rawNonce: String? = null): OAuthCredential
     }
 
     fun addScope(vararg scope: String)
@@ -46,13 +43,12 @@ expect class OAuthProvider constructor(provider: String, auth: FirebaseAuth = Fi
 expect class SignInProvider
 
 expect class PhoneAuthProvider constructor(auth: FirebaseAuth = Firebase.auth) {
-    fun credentialWithVerificationIdAndSmsCode(verificationId: String, smsCode: String): PhoneAuthCredential
+    fun credential(verificationId: String, smsCode: String): PhoneAuthCredential
     suspend fun verifyPhoneNumber(phoneNumber: String, verificationProvider: PhoneVerificationProvider): AuthCredential
-
 }
 
 expect interface PhoneVerificationProvider
 
 expect object TwitterAuthProvider {
-    fun credentialWithTokenAndSecret(token: String, secret: String): AuthCredential
+    fun credential(token: String, secret: String): AuthCredential
 }

firebase-auth/src/commonTest/kotlin/dev/gitlive/firebase/auth/auth.kt

@@ -54,10 +54,10 @@ class FirebaseAuthTest {
     fun testFetchSignInMethods() = runTest {
         val email = "test+${Random.nextInt(100000)}@test.com"
         var signInMethodResult = Firebase.auth.fetchSignInMethodsForEmail(email)
-        assertEquals(emptyList(), signInMethodResult.signInMethods)
+        assertEquals(emptyList(), signInMethodResult)
         Firebase.auth.createUserWithEmailAndPassword(email, "test123")
         signInMethodResult = Firebase.auth.fetchSignInMethodsForEmail(email)
-        assertEquals(listOf("password"), signInMethodResult.signInMethods)
+        assertEquals(listOf("password"), signInMethodResult)
 
         Firebase.auth.signInWithEmailAndPassword(email, "test123").user!!.delete()
     }
@@ -85,7 +85,7 @@ class FirebaseAuthTest {
 
     @Test
     fun testSignInWithCredential() = runTest {
-        val credential = EmailAuthProvider.credentialWithEmail("[email protected]", "test123")
+        val credential = EmailAuthProvider.credential("[email protected]", "test123")
         val result = Firebase.auth.signInWithCredential(credential)
         assertEquals("mn8kgIFnxLO7il8GpTa5g0ObP6I2", result.user!!.uid)
 

firebase-auth/src/iosMain/kotlin/dev/gitlive/firebase/auth/auth.kt

@@ -45,9 +45,9 @@ actual class FirebaseAuth internal constructor(val ios: FIRAuth) {
     actual suspend fun confirmPasswordReset(code: String, newPassword: String) = ios.await { confirmPasswordResetWithCode(code, newPassword, it) }.run { Unit }
 
     actual suspend fun createUserWithEmailAndPassword(email: String, password: String) =
-        AuthResult(ios.awaitExpectedResult { createUserWithEmail(email = email, password = password, completion = it) })
+        AuthResult(ios.awaitResult { createUserWithEmail(email = email, password = password, completion = it) })
 
-    actual suspend fun fetchSignInMethodsForEmail(email: String) = ios.awaitResult { fetchSignInMethodsForEmail(email, it) }.orEmpty()
+    actual suspend fun fetchSignInMethodsForEmail(email: String) = ios.awaitResult { fetchSignInMethodsForEmail(email, it) } as List<String>
 
     actual suspend fun sendPasswordResetEmail(email: String, actionCodeSettings: ActionCodeSettings?) {
         ios.await { actionCodeSettings?.let { actionSettings -> sendPasswordResetWithEmail(email, actionSettings.toIos(), it) } ?: sendPasswordResetWithEmail(email = email, completion = it) }
@@ -56,24 +56,24 @@ actual class FirebaseAuth internal constructor(val ios: FIRAuth) {
     actual suspend fun sendSignInLinkToEmail(email: String, actionCodeSettings: ActionCodeSettings) = ios.await { sendSignInLinkToEmail(email, actionCodeSettings.toIos(), it) }.run { Unit }
 
     actual suspend fun signInWithEmailAndPassword(email: String, password: String) =
-        AuthResult(ios.awaitExpectedResult { signInWithEmail(email = email, password = password, completion = it) })
+        AuthResult(ios.awaitResult { signInWithEmail(email = email, password = password, completion = it) })
 
     actual suspend fun signInWithCustomToken(token: String) =
-        AuthResult(ios.awaitExpectedResult { signInWithCustomToken(token, it) })
+        AuthResult(ios.awaitResult { signInWithCustomToken(token, it) })
 
     actual suspend fun signInAnonymously() =
-        AuthResult(ios.awaitExpectedResult { signInAnonymouslyWithCompletion(it) })
+        AuthResult(ios.awaitResult { signInAnonymouslyWithCompletion(it) })
 
     actual suspend fun signInWithCredential(authCredential: AuthCredential) =
-        AuthResult(ios.awaitExpectedResult { signInWithCredential(authCredential.ios, it) })
+        AuthResult(ios.awaitResult { signInWithCredential(authCredential.ios, it) })
 
     actual suspend fun signOut() = ios.throwError { signOut(it) }.run { Unit }
 
     actual suspend fun updateCurrentUser(user: FirebaseUser) = ios.await { updateCurrentUser(user.ios, it) }.run { Unit }
-    actual suspend fun verifyPasswordResetCode(code: String): String = ios.awaitExpectedResult { verifyPasswordResetCode(code, it) }
+    actual suspend fun verifyPasswordResetCode(code: String): String = ios.awaitResult { verifyPasswordResetCode(code, it) }
 
     actual suspend fun <T : ActionCodeResult> checkActionCode(code: String): T {
-        val result = ios.awaitExpectedResult { checkActionCode(code, it) }
+        val result = ios.awaitResult { checkActionCode(code, it) }
         @Suppress("UNCHECKED_CAST")
         return when(result.operation) {
             FIRActionCodeOperationUnknown -> Error
@@ -93,7 +93,7 @@ actual class AuthResult internal constructor(val ios: FIRAuthDataResult) {
         get() = FirebaseUser(ios.user)
 }
 
-private fun ActionCodeSettings.toIos() = FIRActionCodeSettings().let {
+internal fun ActionCodeSettings.toIos() = FIRActionCodeSettings().also {
     it.URL =  NSURL.URLWithString(url)
     androidPackageName?.run { it.setAndroidPackageName(androidPackageName, installIfNotAvailable, minimumVersion) }
     it.dynamicLinkDomain = dynamicLinkDomain
@@ -127,41 +127,13 @@ internal fun <T, R> T.throwError(block: T.(errorPointer: CPointer<ObjCObjectVar<
     }
 }
 
-internal suspend fun <T, R> T.awaitResult(function: T.(callback: (R?, NSError?) -> Unit) -> Unit): R? {
-    val job = CompletableDeferred<R?>()
-    function { result, error ->
-        if(error != null) {
-            job.completeExceptionally(error.toException())
-        } else {
-            job.complete(result)
-        }
-    }
-    return job.await()
-}
-
-internal suspend fun <T, R> T.awaitResult(default: R, function: T.(callback: (R?, NSError?) -> Unit) -> Unit): R {
+internal suspend fun <T, R> T.awaitResult(function: T.(callback: (R, NSError?) -> Unit) -> Unit): R {
     val job = CompletableDeferred<R>()
     function { result, error ->
-        if(result != null) {
+        if(error == null) {
             job.complete(result)
-        } else if(error != null) {
-            job.completeExceptionally(error.toException())
         } else {
-            job.complete(default)
-        }
-    }
-    return job.await()
-}
-
-internal suspend fun <T, R> T.awaitExpectedResult(function: T.(callback: (R?, NSError?) -> Unit) -> Unit): R {
-    val job = CompletableDeferred<R>()
-    function { result, error ->
-        if(result != null) {
-            job.complete(result)
-        } else if(error != null) {
             job.completeExceptionally(error.toException())
-        } else {
-            job.completeExceptionally(UnexpectedNullResultException())
         }
     }
     return job.await()