Fix Espresso tests failing on #4692

Author: TranceLove

app/src/androidTest/java/com/amaze/filemanager/ui/fragments/BackupPrefsFragmentTest.kt

@@ -27,13 +27,13 @@ import android.content.SharedPreferences
 import android.net.Uri
 import android.os.Build.VERSION.SDK_INT
 import android.os.Build.VERSION_CODES.TIRAMISU
+import android.os.Environment
 import androidx.lifecycle.Lifecycle
 import androidx.preference.PreferenceManager
 import androidx.test.core.app.ActivityScenario
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.espresso.Espresso.onView
 import androidx.test.espresso.action.ViewActions
-import androidx.test.espresso.matcher.ViewMatchers.withId
 import androidx.test.espresso.matcher.ViewMatchers.withText
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.rule.GrantPermissionRule
@@ -55,7 +55,7 @@ import java.io.File
 
 @RunWith(AndroidJUnit4::class)
 class BackupPrefsFragmentTest {
-    var storagePath = "/storage/emulated/0"
+    var storagePath = Environment.getExternalStorageDirectory().absolutePath
     var fileName = "amaze_backup.json"
 
     @Rule
@@ -93,6 +93,23 @@ class BackupPrefsFragmentTest {
         import(exportFile)
     }
 
+    /**
+     * Waits (with a timeout) for the given file to exist, since some writes to storage happen
+     * asynchronously on a background thread.
+     */
+    private fun waitForFile(
+        file: File,
+        timeoutMillis: Long = 5000L,
+    ) {
+        val startTime = System.currentTimeMillis()
+        while (!file.exists()) {
+            if (System.currentTimeMillis() - startTime > timeoutMillis) {
+                fail("Timed out waiting for file to be created: ${file.absolutePath}")
+            }
+            Thread.sleep(100L)
+        }
+    }
+
     /**
      * Test whether the exported file contains the expected preference values
      */
@@ -103,58 +120,67 @@ class BackupPrefsFragmentTest {
         val backupPrefsFragment = BackupPrefsFragment()
         val activityScenario = ActivityScenario.launch(PreferencesActivity::class.java)
 
-        activityScenario.moveToState(Lifecycle.State.STARTED)
+        // Espresso requires an activity to be RESUMED to dispatch view actions/clicks.
+        activityScenario.moveToState(Lifecycle.State.RESUMED)
+
+        lateinit var preferences: SharedPreferences
 
-        activityScenario.onActivity {
-            it.supportFragmentManager.beginTransaction()
+        activityScenario.onActivity { preferencesActivity ->
+            preferencesActivity.supportFragmentManager.beginTransaction()
                 .add(backupPrefsFragment, null)
                 .commitNow()
 
             backupPrefsFragment.exportPrefs()
-        }
 
-        val tempFile = File("${context.cacheDir.absolutePath}${File.separator}$fileName")
+            val tempFile = File("${context.cacheDir.absolutePath}${File.separator}$fileName")
 
-        assertTrue(tempFile.exists())
-
-        onView(withId(R.id.home)).perform(ViewActions.click())
-        onView(withText(R.string.save)).perform(ViewActions.click())
+            assertTrue(tempFile.exists())
 
-        assertTrue(exportFile.exists())
-
-        activityScenario.onActivity { preferencesActivity ->
-            val preferences = PreferenceManager.getDefaultSharedPreferences(preferencesActivity)
-            val preferenceMap: Map<String?, *> = preferences.all
-
-            val inputString =
-                exportFile
-                    .inputStream()
-                    .bufferedReader()
-                    .use {
-                        it.readText()
-                    }
-
-            val type = object : TypeToken<Map<String?, *>>() {}.type
+            preferences = PreferenceManager.getDefaultSharedPreferences(preferencesActivity)
+        }
 
-            val importMap: Map<String?, *> =
-                GsonBuilder()
-                    .create()
-                    .fromJson(
-                        inputString,
-                        type,
-                    )
-
-            for ((key, value) in preferenceMap) {
-                val importedValue = importMap[key]
-                val mapValue =
-                    if (importedValue != null && importedValue::class.simpleName.equals("Double")) {
-                        (importedValue as Double).toInt() // since Gson parses Integer as Double
-                    } else {
-                        importedValue
-                    }
+        // Espresso's onView().perform() must run on the instrumentation/test thread, never from
+        // inside onActivity {} or runOnUiThread {} (both of which run on the main/UI thread).
+        // Espresso internally synchronizes with the UI thread itself; calling it from the UI
+        // thread can deadlock or throw IllegalStateException.
+        // exportPrefs() launches MainActivity with an ACTION_SEND intent, which shows a Snackbar
+        // with a "Save" action; that is the only view action needed here.
+        onView(withText(R.string.save)).perform(ViewActions.click())
 
-                assertEquals("Difference found at key $key", value, mapValue)
-            }
+        // The actual write to storagePath happens asynchronously (RxJava) after the "Save" click
+        // and after MainActivity finishes, so poll for the file instead of asserting immediately.
+        waitForFile(exportFile)
+
+        val preferenceMap: Map<String?, *> = preferences.all
+
+        val inputString =
+            exportFile
+                .inputStream()
+                .bufferedReader()
+                .use {
+                    it.readText()
+                }
+
+        val type = object : TypeToken<Map<String?, *>>() {}.type
+
+        val importMap: Map<String?, *> =
+            GsonBuilder()
+                .create()
+                .fromJson(
+                    inputString,
+                    type,
+                )
+
+        for ((key, value) in preferenceMap) {
+            val importedValue = importMap[key]
+            val mapValue =
+                if (importedValue != null && importedValue::class.simpleName.equals("Double")) {
+                    (importedValue as Double).toInt() // since Gson parses Integer as Double
+                } else {
+                    importedValue
+                }
+
+            assertEquals("Difference found at key $key", value, mapValue)
         }
     }