Bug 1888249 - Adding Sync debug menu items for Fxa. r=lina,android-reviewers,boek

Connected the menu items to the existing app-services functions.

Changed FxaAccountManager to store a `FirefoxAccount`, rather than the
generic `OAuthAccount` from concept.sync. The alternative would be to
add these debug methods to `OAuthAccount`, but that it doesn't feel
right to me to add them to a generic interface.

Reworked the tests to generate mock `FirefoxAccount` objects rather than
`OAuthAccount` implementations.  The most difficult part was
`StatePersistenceTestableAccount`, which implemented OAuthAccount and
changing it to implement `FirefoxAccount` was not so easy.  Instead I
replaced the class with a function that generated a mock object.

Differential Revision: https://phabricator.services.mozilla.com/D205898

Author: bendk

mobile/android/android-components/components/feature/accounts/src/test/java/mozilla/components/feature/accounts/FirefoxAccountsAuthFeatureTest.kt

@@ -17,8 +17,8 @@ import mozilla.components.concept.sync.AuthType
 import mozilla.components.concept.sync.DeviceConfig
 import mozilla.components.concept.sync.DeviceType
 import mozilla.components.concept.sync.FxAEntryPoint
-import mozilla.components.concept.sync.OAuthAccount
 import mozilla.components.concept.sync.Profile
+import mozilla.components.service.fxa.FirefoxAccount
 import mozilla.components.service.fxa.FxaAuthData
 import mozilla.components.service.fxa.ServerConfig
 import mozilla.components.service.fxa.StorageWrapper
@@ -45,13 +45,13 @@ internal class TestableStorageWrapper(
     manager: FxaAccountManager,
     accountEventObserverRegistry: ObserverRegistry<AccountEventsObserver>,
     serverConfig: ServerConfig,
-    private val block: () -> OAuthAccount = {
-        val account: OAuthAccount = mock()
+    private val block: () -> FirefoxAccount = {
+        val account: FirefoxAccount = mock()
         `when`(account.deviceConstellation()).thenReturn(mock())
         account
     },
 ) : StorageWrapper(manager, accountEventObserverRegistry, serverConfig) {
-    override fun obtainAccount(): OAuthAccount = block()
+    override fun obtainAccount(): FirefoxAccount = block()
 }
 
 // Same as the actual account manager, except we get to control how FirefoxAccountShaped instances
@@ -63,7 +63,7 @@ class TestableFxaAccountManager(
     config: ServerConfig,
     scopes: Set<String>,
     coroutineContext: CoroutineContext,
-    block: () -> OAuthAccount = { mock() },
+    block: () -> FirefoxAccount = { mock() },
 ) : FxaAccountManager(context, config, DeviceConfig("test", DeviceType.MOBILE, setOf()), null, scopes, null, coroutineContext) {
     private val testableStorageWrapper = TestableStorageWrapper(this, accountEventObserverRegistry, serverConfig, block)
     override fun getStorageWrapper(): StorageWrapper {
@@ -252,7 +252,7 @@ class FirefoxAccountsAuthFeatureTest {
     private suspend fun prepareAccountManagerForSuccessfulAuthentication(
         coroutineContext: CoroutineContext,
     ): TestableFxaAccountManager {
-        val mockAccount: OAuthAccount = mock()
+        val mockAccount: FirefoxAccount = mock()
         val profile = Profile(uid = "testUID", avatar = null, email = "[email protected]", displayName = "test profile")
 
         `when`(mockAccount.deviceConstellation()).thenReturn(mock())
@@ -279,7 +279,7 @@ class FirefoxAccountsAuthFeatureTest {
     private suspend fun prepareAccountManagerForFailedAuthentication(
         coroutineContext: CoroutineContext,
     ): TestableFxaAccountManager {
-        val mockAccount: OAuthAccount = mock()
+        val mockAccount: FirefoxAccount = mock()
         val profile = Profile(uid = "testUID", avatar = null, email = "[email protected]", displayName = "test profile")
 
         `when`(mockAccount.getProfile(anyBoolean())).thenReturn(profile)

mobile/android/android-components/components/service/firefox-accounts/src/main/java/mozilla/components/service/fxa/AccountStorage.kt

@@ -11,7 +11,6 @@ import mozilla.appservices.fxaclient.FxaRustAuthState
 import mozilla.components.concept.base.crash.CrashReporting
 import mozilla.components.concept.sync.AccountEvent
 import mozilla.components.concept.sync.AccountEventsObserver
-import mozilla.components.concept.sync.OAuthAccount
 import mozilla.components.concept.sync.StatePersistenceCallback
 import mozilla.components.lib.dataprotect.SecureAbove22Preferences
 import mozilla.components.service.fxa.manager.FxaAccountManager
@@ -26,16 +25,16 @@ const val FXA_STATE_KEY = "fxaState"
  * Represents state of our account on disk - is it new, or restored?
  */
 internal sealed class AccountOnDisk : WithAccount {
-    data class Restored(val account: OAuthAccount) : AccountOnDisk() {
+    data class Restored(val account: FirefoxAccount) : AccountOnDisk() {
         override fun account() = account
     }
-    data class New(val account: OAuthAccount) : AccountOnDisk() {
+    data class New(val account: FirefoxAccount) : AccountOnDisk() {
         override fun account() = account
     }
 }
 
 internal interface WithAccount {
-    fun account(): OAuthAccount
+    fun account(): FirefoxAccount
 }
 
 /**
@@ -80,16 +79,16 @@ open class StorageWrapper(
         }
     }
 
-    private fun watchAccount(account: OAuthAccount) {
+    private fun watchAccount(account: FirefoxAccount) {
         account.registerPersistenceCallback(statePersistenceCallback)
         account.deviceConstellation().register(accountEventsIntegration)
     }
 
     /**
-     * Exists strictly for testing purposes, allowing tests to specify their own implementation of [OAuthAccount].
+     * Exists strictly for testing purposes, allowing tests to specify their own implementation of [FirefoxAccount].
      */
     @VisibleForTesting
-    open fun obtainAccount(): OAuthAccount = FirefoxAccount(serverConfig, crashReporter)
+    open fun obtainAccount(): FirefoxAccount = FirefoxAccount(serverConfig, crashReporter)
 }
 
 /**
@@ -110,7 +109,7 @@ internal class AccountEventsIntegration(
 
 internal interface AccountStorage {
     @Throws(Exception::class)
-    fun read(): OAuthAccount?
+    fun read(): FirefoxAccount?
     fun write(accountState: String)
     fun clear()
 }
@@ -156,7 +155,7 @@ internal class SharedPrefAccountStorage(
      * @throws FxaException if JSON failed to parse into a [FirefoxAccount].
      */
     @Throws(FxaException::class)
-    override fun read(): OAuthAccount? {
+    override fun read(): FirefoxAccount? {
         val savedJSON = accountPreferences().getString(FXA_STATE_KEY, null)
             ?: return null
 
@@ -244,7 +243,7 @@ internal class SecureAbove22AccountStorage(
      * @throws FxaException if JSON failed to parse into a [FirefoxAccount].
      */
     @Throws(FxaException::class)
-    override fun read(): OAuthAccount? {
+    override fun read(): FirefoxAccount? {
         return store.getString(KEY_ACCOUNT_STATE).also {
             // If account state is missing, but we expected it to be present, report an exception.
             if (it == null && prefs.getBoolean(PREF_KEY_HAS_STATE, false)) {

mobile/android/android-components/components/service/firefox-accounts/src/main/java/mozilla/components/service/fxa/FirefoxAccount.kt

@@ -97,6 +97,10 @@ class FirefoxAccount internal constructor(
 
     internal fun getAuthState() = inner.getAuthState()
 
+    internal fun simulateNetworkError() = inner.simulateNetworkError()
+    internal fun simulateTemporaryAuthTokenIssue() = inner.simulateTemporaryAuthTokenIssue()
+    internal fun simulatePermanentAuthTokenIssue() = inner.simulatePermanentAuthTokenIssue()
+
     override suspend fun beginOAuthFlow(
         scopes: Set<String>,
         entryPoint: FxAEntryPoint,

mobile/android/android-components/components/service/firefox-accounts/src/main/java/mozilla/components/service/fxa/manager/FxaAccountManager.kt

@@ -8,9 +8,11 @@ import android.content.Context
 import androidx.annotation.GuardedBy
 import androidx.annotation.VisibleForTesting
 import androidx.lifecycle.LifecycleOwner
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.asCoroutineDispatcher
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import mozilla.appservices.fxaclient.FxaStateCheckerEvent
 import mozilla.appservices.fxaclient.FxaStateCheckerState
@@ -949,4 +951,60 @@ open class FxaAccountManager(
             accountManager.syncStatusObserverRegistry.notifyObservers { onError(error) }
         }
     }
+
+    /**
+     * Hook this up to the secret debug menu to simulate a network error
+     *
+     * Typical usage is:
+     *   - `adb logcat | grep fxa_client`
+     *   - Trigger this via the secret debug menu item.
+     *   - Watch the logs.  You should see the client perform a call to `get_profile', see a
+     *     network error, then recover.
+     *     - Note: the logs will be more clear once we switch the code to using the app-services state
+     *       machine.
+     *   - Check the UI, it should be in an authenticated state.
+     */
+    public fun simulateNetworkError() {
+        account.simulateNetworkError()
+        CoroutineScope(coroutineContext).launch {
+            refreshProfile(true)
+        }
+    }
+
+    /**
+     * Hook this up to the secret debug menu to simulate a temporary auth error
+     *
+     * Typical usage is:
+     *   - `adb logcat | grep fxa_client`
+     *   - Trigger this via the secret debug menu item.
+     *   - Watch the logs.  You should see the client perform a call to `get_profile', see an
+     *     auth error, then recover.
+     *   - Check the UI, it should be in an authenticated state.
+     */
+    public fun simulateTemporaryAuthTokenIssue() {
+        account.simulateTemporaryAuthTokenIssue()
+        SyncAuthInfoCache(context).clear()
+        CoroutineScope(coroutineContext).launch {
+            refreshProfile(true)
+        }
+    }
+
+    /**
+     * Hook this up to the secret debug menu to simulate an unrecoverable auth error
+     *
+     * Typical usage is:
+     *   - `adb logcat | grep fxa_client`
+     *   - Trigger this via the secret debug menu item.
+     *   - Initiaite a sync, or perform some other action that requires authentication.
+     *   - Watch the logs.  You should see the client perform a call to `get_profile', see an
+     *     auth error, then fail to recover.
+     *   - Check the UI, it should be in an authentication problems state.
+     */
+    public fun simulatePermanentAuthTokenIssue() {
+        account.simulatePermanentAuthTokenIssue()
+        SyncAuthInfoCache(context).clear()
+        CoroutineScope(coroutineContext).launch {
+            refreshProfile(true)
+        }
+    }
 }