From f1238977d0ea4250eb90c43af3914a6bbaabfdfb Mon Sep 17 00:00:00 2001
From: Steve Soltys <steve@stevesoltys.com>
Date: Tue, 12 Sep 2023 22:17:39 +0000
Subject: [PATCH 1/5] Add end-to-end emulator test running on CI

---
 .cirrus.yml                                   |  53 +++++++
 .idea/runConfigurations/app_emulator.xml      |   6 +-
 app/build.gradle                              |  23 ++-
 app/development/scripts/clear_app_data.sh     |  22 +++
 app/development/scripts/provision_emulator.sh |   1 -
 .../seedvault/KoinInstrumentationTestApp.kt   |  35 +++++
 .../KoinInstrumentationTestRunner.kt          |  20 +++
 .../com/stevesoltys/seedvault/PluginTest.kt   |   2 +
 .../seedvault/e2e/BackupRestoreTest.kt        | 139 ++++++++++++++++++
 .../seedvault/e2e/LargeTestBase.kt            | 110 ++++++++++++++
 .../seedvault/e2e/screen/UiDeviceScreen.kt    |  20 +++
 .../seedvault/e2e/screen/impl/BackupScreen.kt |  12 ++
 .../e2e/screen/impl/DocumentPickerScreen.kt   |  17 +++
 .../e2e/screen/impl/RecoveryCodeScreen.kt     |  15 ++
 .../e2e/screen/impl/RestoreScreen.kt          |  12 ++
 .../plugins/saf/DocumentsStorageTest.kt       |   2 +
 .../transport/backup/PackageServiceTest.kt    |   2 +
 .../java/com/stevesoltys/seedvault/App.kt     |  26 ++--
 gradle.properties                             |   5 +-
 gradle/dependencies.gradle                    |   2 +-
 settings.gradle                               |  15 ++
 21 files changed, 519 insertions(+), 20 deletions(-)
 create mode 100644 .cirrus.yml
 create mode 100755 app/development/scripts/clear_app_data.sh
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestApp.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestRunner.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/BackupRestoreTest.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/UiDeviceScreen.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/BackupScreen.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/DocumentPickerScreen.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RecoveryCodeScreen.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RestoreScreen.kt

diff --git a/.cirrus.yml b/.cirrus.yml
new file mode 100644
index 00000000..d2f6c6c1
--- /dev/null
+++ b/.cirrus.yml
@@ -0,0 +1,53 @@
+container:
+  image: ghcr.io/cirruslabs/android-sdk:33
+  kvm: true
+  cpu: 8
+  memory: 16G
+
+check_android_task:
+  skip: "!changesInclude('.cirrus.yml', '*.gradle', '*.gradle.kts', '**/*.gradle', '**/*.gradle.kts', '*.properties', '**/*.properties', '**/*.kt', '**/*.xml')"
+  create_avd_script:
+  start_avd_background_script:
+    sdkmanager --install "system-images;android-33;google_apis;x86_64";
+    echo no | avdmanager create avd -n seedvault -k "system-images;android-33;google_apis;x86_64";
+    $ANDROID_HOME/emulator/emulator
+    -avd seedvault
+    -no-audio
+    -no-boot-anim
+    -gpu swiftshader_indirect
+    -no-snapshot
+    -no-window
+    -writable-system;
+  provision_avd_background_script:
+    adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;';
+    wget --output-document etar.apk https://f-droid.org/repo/ws.xsoh.etar_35.apk;
+    adb install etar.apk
+
+    adb root;
+    sleep 5;
+    adb remount;
+    adb reboot;
+    adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;';
+    adb root;
+    sleep 5;
+    adb remount;
+  assemble_release_script:
+    ./gradlew :app:assembleRelease :app:assembleAndroidTest
+  install_app_script:
+    timeout 180s bash -c 'while [[ -z $(adb shell mount | grep "/system " | grep "(rw,") ]]; do sleep 1; done;';
+    adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;';
+    adb shell mkdir -p /system/priv-app/Seedvault;
+    adb push app/build/outputs/apk/release/app-release.apk /system/priv-app/Seedvault/Seedvault.apk;
+    adb push permissions_com.stevesoltys.seedvault.xml /system/etc/permissions/privapp-permissions-seedvault.xml;
+    adb push allowlist_com.stevesoltys.seedvault.xml /system/etc/sysconfig/allowlist-seedvault.xml;
+    adb shell bmgr enable true;
+    adb shell bmgr transport com.stevesoltys.seedvault.transport.ConfigurableBackupTransport;
+    adb reboot;
+    adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;';
+  run_large_tests_script: ./gradlew -Pinstrumented_test_size=large :app:connectedAndroidTest
+  run_medium_tests_script: ./gradlew -Pinstrumented_test_size=medium :app:connectedAndroidTest
+  always:
+    pull_screenshots_script:
+      adb pull /sdcard/Documents/screenshots
+    screenshots_artifacts:
+      path: "screenshots/**/*.png"
diff --git a/.idea/runConfigurations/app_emulator.xml b/.idea/runConfigurations/app_emulator.xml
index 0579cb25..60f48b57 100644
--- a/.idea/runConfigurations/app_emulator.xml
+++ b/.idea/runConfigurations/app_emulator.xml
@@ -17,7 +17,7 @@
     <option name="TARGET_SELECTION_MODE" value="SHOW_DIALOG" />
     <option name="SELECTED_CLOUD_MATRIX_CONFIGURATION_ID" value="-1" />
     <option name="SELECTED_CLOUD_MATRIX_PROJECT_ID" value="" />
-    <option name="DEBUGGER_TYPE" value="Auto" />
+    <option name="DEBUGGER_TYPE" value="Java" />
     <Auto>
       <option name="USE_JAVA_AWARE_DEBUGGER" value="false" />
       <option name="SHOW_STATIC_VARS" value="true" />
@@ -37,7 +37,7 @@
       <option name="DEBUG_SANDBOX_SDK" value="false" />
     </Hybrid>
     <Java>
-      <option name="ATTACH_ON_WAIT_FOR_DEBUGGER" value="false" />
+      <option name="ATTACH_ON_WAIT_FOR_DEBUGGER" value="true" />
       <option name="DEBUG_SANDBOX_SDK" value="false" />
     </Java>
     <Native>
@@ -62,7 +62,7 @@
     <option name="SEARCH_ACTIVITY_IN_GLOBAL_SCOPE" value="false" />
     <option name="SKIP_ACTIVITY_VALIDATION" value="false" />
     <method v="2">
-      <option name="RunConfigurationTask" enabled="false" run_configuration_name="seedvault [installEmulatorRelease]" run_configuration_type="GradleRunConfiguration" />
+      <option name="Gradle.BeforeRunTask" enabled="false" tasks="installEmulatorRelease" externalProjectPath="$PROJECT_DIR$/app" vmOptions="" scriptParameters="" />
     </method>
   </configuration>
 </component>
\ No newline at end of file
diff --git a/app/build.gradle b/app/build.gradle
index d08c8286..6323ce3f 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -21,8 +21,15 @@ android {
         minSdk 32 // leave at 32 for robolectric tests
         targetSdk rootProject.ext.targetSdk
         versionNameSuffix "-$gitDescribe"
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        testInstrumentationRunner "com.stevesoltys.seedvault.KoinInstrumentationTestRunner"
         testInstrumentationRunnerArguments disableAnalytics: 'true'
+
+        if (project.hasProperty('instrumented_test_size')) {
+            final testSize = project.getProperty('instrumented_test_size')
+            println("Instrumented test size: $testSize")
+
+            testInstrumentationRunnerArguments size: testSize
+        }
     }
 
     buildTypes {
@@ -150,10 +157,13 @@ dependencies {
     testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:$junit5_version"
     testRuntimeOnly "org.junit.vintage:junit-vintage-engine:$junit5_version"
 
+    androidTestImplementation rootProject.ext.aosp_libs
     androidTestImplementation 'androidx.test:runner:1.4.0'
     androidTestImplementation 'androidx.test:rules:1.4.0'
     androidTestImplementation 'androidx.test.ext:junit:1.1.3'
     androidTestImplementation "io.mockk:mockk-android:$mockk_version"
+
+    androidTestImplementation 'com.kaspersky.android-components:kaspresso:1.5.3'
 }
 
 apply from: "${rootProject.rootDir}/gradle/ktlint.gradle"
@@ -210,3 +220,14 @@ tasks.register('installEmulatorRelease', Exec) {
         environment "JAVA_HOME", System.properties['java.home']
     }
 }
+
+tasks.register('clearEmulatorAppData', Exec) {
+    group("emulator")
+
+    doFirst {
+        commandLine "${project.projectDir}/development/scripts/clear_app_data.sh"
+
+        environment "ANDROID_SDK_HOME", android.sdkDirectory.absolutePath
+        environment "JAVA_HOME", System.properties['java.home']
+    }
+}
diff --git a/app/development/scripts/clear_app_data.sh b/app/development/scripts/clear_app_data.sh
new file mode 100755
index 00000000..fbde98b6
--- /dev/null
+++ b/app/development/scripts/clear_app_data.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+# assert ANDROID_HOME is set
+if [ -z "$ANDROID_SDK_HOME" ]; then
+  echo "ANDROID_SDK_HOME is not set"
+  exit 1
+fi
+
+SCRIPT_DIR=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
+DEVELOPMENT_DIR=$SCRIPT_DIR/..
+ROOT_PROJECT_DIR=$SCRIPT_DIR/../../..
+
+EMULATOR_DEVICE_NAME=$($ANDROID_SDK_HOME/platform-tools/adb devices | grep emulator | cut -f1)
+
+if [ -z "$EMULATOR_DEVICE_NAME" ]; then
+  echo "Emulator device name not found"
+  exit 1
+fi
+
+ADB="$ANDROID_SDK_HOME/platform-tools/adb -s $EMULATOR_DEVICE_NAME"
+
+$ADB shell pm clear com.stevesoltys.seedvault
diff --git a/app/development/scripts/provision_emulator.sh b/app/development/scripts/provision_emulator.sh
index 5c4bfd7f..b6c0623a 100755
--- a/app/development/scripts/provision_emulator.sh
+++ b/app/development/scripts/provision_emulator.sh
@@ -31,7 +31,6 @@ else
   sleep 1
 fi
 
-echo "Starting emulator..."
 $SCRIPT_DIR/start_emulator.sh "$EMULATOR_NAME"
 sleep 3
 
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestApp.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestApp.kt
new file mode 100644
index 00000000..8335c720
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestApp.kt
@@ -0,0 +1,35 @@
+package com.stevesoltys.seedvault
+
+import androidx.test.platform.app.InstrumentationRegistry
+import com.stevesoltys.seedvault.restore.RestoreViewModel
+import com.stevesoltys.seedvault.ui.notification.BackupNotificationManager
+import io.mockk.spyk
+import org.koin.core.module.Module
+import org.koin.dsl.module
+
+private val spyBackupNotificationManager = spyk(
+    BackupNotificationManager(
+        InstrumentationRegistry.getInstrumentation()
+            .targetContext.applicationContext
+    )
+)
+
+class KoinInstrumentationTestApp : App() {
+
+    override fun appModules(): List<Module> {
+        val testModule = module {
+            single { spyBackupNotificationManager }
+
+            single {
+                spyk(
+                    RestoreViewModel(
+                        this@KoinInstrumentationTestApp,
+                        get(), get(), get(), get(), get(), get()
+                    )
+                )
+            }
+        }
+
+        return super.appModules().plus(testModule)
+    }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestRunner.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestRunner.kt
new file mode 100644
index 00000000..1ee3fe99
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestRunner.kt
@@ -0,0 +1,20 @@
+package com.stevesoltys.seedvault
+
+import android.app.Application
+import android.content.Context
+import androidx.test.runner.AndroidJUnitRunner
+
+class KoinInstrumentationTestRunner : AndroidJUnitRunner() {
+
+    override fun newApplication(
+        classLoader: ClassLoader?,
+        className: String?,
+        context: Context?,
+    ): Application {
+        return super.newApplication(
+            classLoader,
+            KoinInstrumentationTestApp::class.java.name,
+            context
+        )
+    }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/PluginTest.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/PluginTest.kt
index 3188686b..f5dddd70 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/PluginTest.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/PluginTest.kt
@@ -2,6 +2,7 @@ package com.stevesoltys.seedvault
 
 import androidx.test.core.content.pm.PackageInfoBuilder
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.MediumTest
 import androidx.test.platform.app.InstrumentationRegistry
 import com.stevesoltys.seedvault.plugins.LegacyStoragePlugin
 import com.stevesoltys.seedvault.plugins.StoragePlugin
@@ -28,6 +29,7 @@ import org.koin.core.component.inject
 
 @RunWith(AndroidJUnit4::class)
 @Suppress("BlockingMethodInNonBlockingContext")
+@MediumTest
 class PluginTest : KoinComponent {
 
     private val context = InstrumentationRegistry.getInstrumentation().targetContext
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/BackupRestoreTest.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/BackupRestoreTest.kt
new file mode 100644
index 00000000..1542cafb
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/BackupRestoreTest.kt
@@ -0,0 +1,139 @@
+package com.stevesoltys.seedvault.e2e
+
+import androidx.test.filters.LargeTest
+import com.stevesoltys.seedvault.e2e.screen.impl.RestoreScreen
+import com.stevesoltys.seedvault.restore.RestoreViewModel
+import com.stevesoltys.seedvault.transport.backup.PackageService
+import com.stevesoltys.seedvault.ui.notification.BackupNotificationManager
+import io.mockk.every
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.junit.Test
+import org.koin.core.component.inject
+import java.util.concurrent.atomic.AtomicBoolean
+
+@LargeTest
+class BackupRestoreTest : LargeTestBase() {
+
+    private val packageService: PackageService by inject()
+
+    private val spyBackupNotificationManager: BackupNotificationManager by inject()
+
+    private val restoreViewModel: RestoreViewModel by inject()
+
+    companion object {
+        private const val BACKUP_TIMEOUT = 360 * 1000L
+        private const val RESTORE_TIMEOUT = 360 * 1000L
+    }
+
+    @Test
+    fun `backup and restore applications`() = run {
+        launchBackupActivity()
+        verifyCode()
+        chooseBackupLocation()
+
+        val eligiblePackages = launchAllEligibleApps()
+        performBackup(eligiblePackages)
+        uninstallPackages(eligiblePackages)
+        performRestore()
+
+        val packagesAfterRestore = getEligibleApps()
+        assert(eligiblePackages == packagesAfterRestore)
+    }
+
+    private fun getEligibleApps() = packageService.userApps
+        .map { it.packageName }.toSet()
+
+    private fun launchAllEligibleApps(): Set<String> {
+        return getEligibleApps().onEach {
+            val intent = device.targetContext.packageManager.getLaunchIntentForPackage(it)
+
+            device.targetContext.startActivity(intent)
+            waitUntilIdle()
+        }
+    }
+
+    private fun performBackup(expectedPackages: Set<String>) = run {
+        val backupResult = spyOnBackup(expectedPackages)
+        startBackup()
+        waitForBackupResult(backupResult)
+        screenshot("backup result")
+    }
+
+    private fun spyOnBackup(expectedPackages: Set<String>): AtomicBoolean {
+        val finishedBackup = AtomicBoolean(false)
+
+        every {
+            spyBackupNotificationManager.onBackupFinished(any(), any())
+        } answers {
+            val success = firstArg<Boolean>()
+            assert(success) { "Backup failed." }
+
+            val packageCount = secondArg<Int>()
+            assert(packageCount == expectedPackages.size) {
+                "Expected ${expectedPackages.size} apps, got $packageCount."
+            }
+
+            this.callOriginal()
+            finishedBackup.set(true)
+        }
+
+        return finishedBackup
+    }
+
+    private fun waitForBackupResult(finishedBackup: AtomicBoolean) = run {
+        step("Wait for backup completion") {
+            runBlocking {
+                withTimeout(BACKUP_TIMEOUT) {
+                    while (!finishedBackup.get()) {
+                        delay(100)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun performRestore() = run {
+        step("Start restore and await completion") {
+            RestoreScreen {
+                startRestore()
+                waitForInstallResult()
+                screenshot("restore app apks result")
+
+                nextButton.click()
+                waitForRestoreResult()
+                screenshot("restore app data result")
+
+                finishButton.click()
+            }
+        }
+    }
+
+    private fun waitForInstallResult() = runBlocking {
+        withTimeout(RESTORE_TIMEOUT) {
+
+            while (restoreViewModel.installResult.value == null) {
+                delay(100)
+            }
+
+            val restoreResultValue = restoreViewModel.installResult.value!!
+            assert(!restoreResultValue.hasFailed) { "Failed to install packages" }
+        }
+    }
+
+    private fun waitForRestoreResult() = runBlocking {
+        withTimeout(RESTORE_TIMEOUT) {
+
+            while (restoreViewModel.restoreBackupResult.value == null) {
+                delay(100)
+            }
+
+            val restoreResultValue = restoreViewModel.restoreBackupResult.value!!
+
+            assert(!restoreResultValue.hasError()) {
+                "Restore failed: ${restoreResultValue.errorMsg}"
+            }
+        }
+    }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
new file mode 100644
index 00000000..fc0c01ed
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
@@ -0,0 +1,110 @@
+package com.stevesoltys.seedvault.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.kaspersky.kaspresso.testcases.api.testcase.TestCase
+import com.stevesoltys.seedvault.e2e.screen.impl.BackupScreen
+import com.stevesoltys.seedvault.e2e.screen.impl.DocumentPickerScreen
+import com.stevesoltys.seedvault.e2e.screen.impl.RecoveryCodeScreen
+import com.stevesoltys.seedvault.e2e.screen.impl.RestoreScreen
+import org.junit.After
+import org.junit.Before
+import org.junit.runner.RunWith
+import org.koin.core.component.KoinComponent
+import java.lang.Thread.sleep
+
+@RunWith(AndroidJUnit4::class)
+abstract class LargeTestBase : TestCase(), KoinComponent {
+
+    @Before
+    open fun setUp() {
+        // reset document picker state, and delete old backups
+        runCommand("pm clear com.google.android.documentsui")
+        runCommand("rm -Rf /sdcard/seedvault")
+    }
+
+    @After
+    open fun tearDown() {
+        screenshot("end")
+    }
+
+    protected fun launchBackupActivity() = run {
+        runCommand("am start -n ${device.targetContext.packageName}/.settings.SettingsActivity")
+        waitUntilIdle()
+    }
+
+    protected fun launchRestoreActivity() = run {
+        runCommand("am start -n ${device.targetContext.packageName}/.restore.RestoreActivity")
+        waitUntilIdle()
+    }
+
+    protected fun waitUntilIdle() {
+        device.uiDevice.waitForIdle()
+        sleep(3000)
+    }
+
+    protected fun verifyCode() = run {
+        RecoveryCodeScreen {
+            step("Confirm code") {
+                screenshot("confirm code")
+                confirmCodeButton.click()
+            }
+            step("Verify code") {
+                screenshot("verify code")
+                verifyCodeButton.scrollTo()
+                verifyCodeButton.click()
+            }
+        }
+    }
+
+    protected fun chooseBackupLocation() = run {
+        step("Choose backup location") {
+            waitUntilIdle()
+            screenshot("choose backup location")
+
+            DocumentPickerScreen {
+                createNewFolderButton.click()
+                textBox.text = "seedvault"
+                okButton.click()
+                useThisFolderButton.click()
+                allowButton.click()
+            }
+        }
+    }
+
+    protected fun startBackup() = run {
+        launchBackupActivity()
+
+        step("Run backup") {
+            BackupScreen {
+                backupMenu.clickAndWaitForNewWindow()
+                backupNowButton.clickAndWaitForNewWindow()
+                backupStatusButton.clickAndWaitForNewWindow()
+            }
+        }
+    }
+
+    protected fun startRestore() = run {
+        launchRestoreActivity()
+
+        step("Restore backup") {
+            RestoreScreen {
+                backupListItem.clickAndWaitForNewWindow()
+            }
+        }
+    }
+
+    protected fun uninstallPackages(packages: Set<String>) {
+        packages.forEach { runCommand("pm uninstall $it") }
+    }
+
+    protected fun runCommand(command: String) {
+        InstrumentationRegistry.getInstrumentation().uiAutomation
+            .executeShellCommand(command)
+            .close()
+    }
+
+    protected fun screenshot(name: String) {
+        device.screenshots.take(name.replace(" ", "_"))
+    }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/UiDeviceScreen.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/UiDeviceScreen.kt
new file mode 100644
index 00000000..bddc428a
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/UiDeviceScreen.kt
@@ -0,0 +1,20 @@
+package com.stevesoltys.seedvault.e2e.screen
+
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.UiDevice
+import androidx.test.uiautomator.UiObject
+import androidx.test.uiautomator.UiSelector
+
+abstract class UiDeviceScreen<T> {
+
+    operator fun invoke(function: T.() -> Unit) {
+        function.invoke(this as T)
+    }
+
+    protected fun findObject(
+        block: UiSelector.() -> UiSelector,
+    ): UiObject = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
+        .findObject(
+            UiSelector().let { it.block() }
+        )
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/BackupScreen.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/BackupScreen.kt
new file mode 100644
index 00000000..a9ce5c5e
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/BackupScreen.kt
@@ -0,0 +1,12 @@
+package com.stevesoltys.seedvault.e2e.screen.impl
+
+import com.stevesoltys.seedvault.e2e.screen.UiDeviceScreen
+
+object BackupScreen : UiDeviceScreen<BackupScreen>() {
+
+    val backupMenu = findObject { description("More options") }
+
+    val backupNowButton = findObject { text("Backup now") }
+
+    val backupStatusButton = findObject { text("Backup status") }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/DocumentPickerScreen.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/DocumentPickerScreen.kt
new file mode 100644
index 00000000..f6f101e4
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/DocumentPickerScreen.kt
@@ -0,0 +1,17 @@
+package com.stevesoltys.seedvault.e2e.screen.impl
+
+import android.widget.EditText
+import com.stevesoltys.seedvault.e2e.screen.UiDeviceScreen
+
+object DocumentPickerScreen : UiDeviceScreen<DocumentPickerScreen>() {
+
+    val createNewFolderButton = findObject { text("CREATE NEW FOLDER") }
+
+    val useThisFolderButton = findObject { text("USE THIS FOLDER") }
+
+    val textBox = findObject { className(EditText::class.java) }
+
+    val okButton = findObject { text("OK") }
+
+    val allowButton = findObject { text("ALLOW") }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RecoveryCodeScreen.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RecoveryCodeScreen.kt
new file mode 100644
index 00000000..3ce61511
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RecoveryCodeScreen.kt
@@ -0,0 +1,15 @@
+package com.stevesoltys.seedvault.e2e.screen.impl
+
+import com.kaspersky.kaspresso.screens.KScreen
+import com.stevesoltys.seedvault.R
+import io.github.kakaocup.kakao.text.KButton
+
+object RecoveryCodeScreen : KScreen<RecoveryCodeScreen>() {
+
+    override val layoutId: Int? = null
+    override val viewClass: Class<*>? = null
+
+    val confirmCodeButton = KButton { withId(R.id.confirmCodeButton) }
+
+    val verifyCodeButton = KButton { withId(R.id.doneButton) }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RestoreScreen.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RestoreScreen.kt
new file mode 100644
index 00000000..706fc7bf
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RestoreScreen.kt
@@ -0,0 +1,12 @@
+package com.stevesoltys.seedvault.e2e.screen.impl
+
+import com.stevesoltys.seedvault.e2e.screen.UiDeviceScreen
+
+object RestoreScreen : UiDeviceScreen<RestoreScreen>() {
+
+    val backupListItem = findObject { textContains("Last backup 0 hr") }
+
+    val nextButton = findObject { text("Next") }
+
+    val finishButton = findObject { text("Finish") }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/plugins/saf/DocumentsStorageTest.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/plugins/saf/DocumentsStorageTest.kt
index d6bdf680..353d7680 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/plugins/saf/DocumentsStorageTest.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/plugins/saf/DocumentsStorageTest.kt
@@ -7,6 +7,7 @@ import android.os.Bundle
 import android.provider.DocumentsContract.EXTRA_LOADING
 import androidx.documentfile.provider.DocumentFile
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.MediumTest
 import androidx.test.platform.app.InstrumentationRegistry
 import com.stevesoltys.seedvault.assertReadEquals
 import com.stevesoltys.seedvault.coAssertThrows
@@ -39,6 +40,7 @@ import kotlin.random.Random
 
 @RunWith(AndroidJUnit4::class)
 @Suppress("BlockingMethodInNonBlockingContext")
+@MediumTest
 class DocumentsStorageTest : KoinComponent {
 
     private val context = InstrumentationRegistry.getInstrumentation().targetContext
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/transport/backup/PackageServiceTest.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/transport/backup/PackageServiceTest.kt
index 64ea9c40..f140eb22 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/transport/backup/PackageServiceTest.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/transport/backup/PackageServiceTest.kt
@@ -2,12 +2,14 @@ package com.stevesoltys.seedvault.transport.backup
 
 import android.util.Log
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.MediumTest
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
 
 @RunWith(AndroidJUnit4::class)
+@MediumTest
 class PackageServiceTest : KoinComponent {
 
     private val packageService: PackageService by inject()
diff --git a/app/src/main/java/com/stevesoltys/seedvault/App.kt b/app/src/main/java/com/stevesoltys/seedvault/App.kt
index 69d3b6dc..c0354815 100644
--- a/app/src/main/java/com/stevesoltys/seedvault/App.kt
+++ b/app/src/main/java/com/stevesoltys/seedvault/App.kt
@@ -84,21 +84,21 @@ open class App : Application() {
     protected open fun startKoin() = startKoin {
         androidLogger(Level.ERROR)
         androidContext(this@App)
-        modules(
-            listOf(
-                cryptoModule,
-                headerModule,
-                metadataModule,
-                documentsProviderModule, // storage plugin
-                backupModule,
-                restoreModule,
-                installModule,
-                storageModule,
-                appModule
-            )
-        )
+        modules(appModules())
     }
 
+    open fun appModules() = listOf(
+        cryptoModule,
+        headerModule,
+        metadataModule,
+        documentsProviderModule, // storage plugin
+        backupModule,
+        restoreModule,
+        installModule,
+        storageModule,
+        appModule
+    )
+
     private val settingsManager: SettingsManager by inject()
     private val metadataManager: MetadataManager by inject()
 
diff --git a/gradle.properties b/gradle.properties
index c6adc6da..8af1ea32 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,5 +1,8 @@
-org.gradle.jvmargs=-Xmx1g
+org.gradle.jvmargs=-Xmx4g
 org.gradle.configureondemand=true
+org.gradle.caching=true
+org.gradle.parallel=true
+org.gradle.daemon=true
 android.useAndroidX=true
 android.enableJetifier=false
 kotlin.code.style=official
diff --git a/gradle/dependencies.gradle b/gradle/dependencies.gradle
index cb1f6a1e..e1323412 100644
--- a/gradle/dependencies.gradle
+++ b/gradle/dependencies.gradle
@@ -23,7 +23,7 @@ ext.aosp_libs = fileTree(include: [
     'android.jar',
     // out/target/common/obj/JAVA_LIBRARIES/core-libart.com.android.art_intermediates/classes.jar
     'libcore.jar',
-], dir: "$projectDir/app/libs")
+], dir: "${rootProject.projectDir}/app/libs")
 
 ext.kotlin_libs = [
     std: [
diff --git a/settings.gradle b/settings.gradle
index ae995566..07243914 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -18,3 +18,18 @@ include ':app'
 include ':contactsbackup'
 include ':storage:lib'
 include ':storage:demo'
+
+ext.isCiServer = System.getenv().containsKey("CIRRUS_CI")
+ext.isMasterBranch = System.getenv().getOrDefault("CIRRUS_BRANCH", "").matches("android[0-9]+")
+ext.buildCacheHost = System.getenv().getOrDefault("CIRRUS_HTTP_CACHE_HOST", "localhost:12321")
+
+buildCache {
+    local {
+        enabled = !isCiServer
+    }
+    remote(HttpBuildCache) {
+        url = "http://${buildCacheHost}/"
+        enabled = isCiServer
+        push = isMasterBranch
+    }
+}

From 59cef31183400d60a26f9ca69fe21aa6b7bbf5b6 Mon Sep 17 00:00:00 2001
From: Steve Soltys <steve@stevesoltys.com>
Date: Thu, 14 Sep 2023 06:37:38 +0000
Subject: [PATCH 2/5] Address review comments, add screen recording, use test
 backup data

---
 .cirrus.yml                                   |  21 ++-
 app/build.gradle                              |   3 +-
 app/development/scripts/provision_emulator.sh |   9 ++
 app/src/androidTest/AndroidManifest.xml       |   1 -
 .../seedvault/e2e/BackupRestoreTest.kt        | 139 ----------------
 .../seedvault/e2e/LargeBackupTestBase.kt      |  71 +++++++++
 .../seedvault/e2e/LargeRestoreTestBase.kt     |  86 ++++++++++
 .../seedvault/e2e/LargeTestBase.kt            | 150 ++++++++----------
 .../seedvault/e2e/SeedvaultLargeTest.kt       |  73 +++++++++
 .../seedvault/e2e/impl/BackupRestoreTest.kt   |  41 +++++
 .../seedvault/e2e/screen/UiDeviceScreen.kt    |  23 ++-
 .../e2e/screen/impl/DocumentPickerScreen.kt   |   2 +
 .../e2e/screen/impl/RecoveryCodeScreen.kt     |  13 +-
 .../e2e/screen/impl/RestoreScreen.kt          |   4 +-
 14 files changed, 392 insertions(+), 244 deletions(-)
 delete mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/BackupRestoreTest.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeBackupTestBase.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeRestoreTestBase.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/impl/BackupRestoreTest.kt

diff --git a/.cirrus.yml b/.cirrus.yml
index d2f6c6c1..896a6a4b 100644
--- a/.cirrus.yml
+++ b/.cirrus.yml
@@ -4,9 +4,9 @@ container:
   cpu: 8
   memory: 16G
 
-check_android_task:
+instrumentation_tests_task:
+  name: "Cirrus CI Instrumentation Tests"
   skip: "!changesInclude('.cirrus.yml', '*.gradle', '*.gradle.kts', '**/*.gradle', '**/*.gradle.kts', '*.properties', '**/*.properties', '**/*.kt', '**/*.xml')"
-  create_avd_script:
   start_avd_background_script:
     sdkmanager --install "system-images;android-33;google_apis;x86_64";
     echo no | avdmanager create avd -n seedvault -k "system-images;android-33;google_apis;x86_64";
@@ -19,10 +19,9 @@ check_android_task:
     -no-window
     -writable-system;
   provision_avd_background_script:
-    adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;';
-    wget --output-document etar.apk https://f-droid.org/repo/ws.xsoh.etar_35.apk;
-    adb install etar.apk
+    wget https://github.com/seedvault-app/seedvault-test-data/releases/download/1/backup.tar.gz;
 
+    adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;';
     adb root;
     sleep 5;
     adb remount;
@@ -31,11 +30,17 @@ check_android_task:
     adb root;
     sleep 5;
     adb remount;
-  assemble_release_script:
+    sleep 5;
+  assemble_script:
     ./gradlew :app:assembleRelease :app:assembleAndroidTest
   install_app_script:
     timeout 180s bash -c 'while [[ -z $(adb shell mount | grep "/system " | grep "(rw,") ]]; do sleep 1; done;';
     adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;';
+
+    adb shell mkdir -p /sdcard/seedvault_baseline;
+    adb push backup.tar.gz /sdcard/seedvault_baseline/backup.tar.gz;
+    adb shell tar xzf /sdcard/seedvault_baseline/backup.tar.gz --directory=/sdcard/seedvault_baseline;
+
     adb shell mkdir -p /system/priv-app/Seedvault;
     adb push app/build/outputs/apk/release/app-release.apk /system/priv-app/Seedvault/Seedvault.apk;
     adb push permissions_com.stevesoltys.seedvault.xml /system/etc/permissions/privapp-permissions-seedvault.xml;
@@ -48,6 +53,6 @@ check_android_task:
   run_medium_tests_script: ./gradlew -Pinstrumented_test_size=medium :app:connectedAndroidTest
   always:
     pull_screenshots_script:
-      adb pull /sdcard/Documents/screenshots
+      adb pull /sdcard/seedvault_test_videos
     screenshots_artifacts:
-      path: "screenshots/**/*.png"
+      path: "seedvault_test_videos/**/*.mp4"
diff --git a/app/build.gradle b/app/build.gradle
index 6323ce3f..06327965 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -162,8 +162,7 @@ dependencies {
     androidTestImplementation 'androidx.test:rules:1.4.0'
     androidTestImplementation 'androidx.test.ext:junit:1.1.3'
     androidTestImplementation "io.mockk:mockk-android:$mockk_version"
-
-    androidTestImplementation 'com.kaspersky.android-components:kaspresso:1.5.3'
+    androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.2.0'
 }
 
 apply from: "${rootProject.rootDir}/gradle/ktlint.gradle"
diff --git a/app/development/scripts/provision_emulator.sh b/app/development/scripts/provision_emulator.sh
index b6c0623a..8af6504f 100755
--- a/app/development/scripts/provision_emulator.sh
+++ b/app/development/scripts/provision_emulator.sh
@@ -67,4 +67,13 @@ echo "Rebooting emulator..."
 $ADB reboot
 $ADB wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;'
 
+echo "Downloading and extracting test backup to '/sdcard/seedvault'..."
+wget https://github.com/seedvault-app/seedvault-test-data/releases/download/1/backup.tar.gz
+$ADB push backup.tar.gz /sdcard/
+rm backup.tar.gz
+
+$ADB shell mkdir -p /sdcard/seedvault_baseline
+$ADB shell tar xzf /sdcard/backup.tar.gz --directory=/sdcard/seedvault_baseline
+$ADB shell rm /sdcard/backup.tar.gz
+
 echo "Emulator '$EMULATOR_NAME' has been provisioned with Seedvault!"
diff --git a/app/src/androidTest/AndroidManifest.xml b/app/src/androidTest/AndroidManifest.xml
index 7770cfb2..00f58f96 100644
--- a/app/src/androidTest/AndroidManifest.xml
+++ b/app/src/androidTest/AndroidManifest.xml
@@ -1,5 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
     <application android:extractNativeLibs="true" />
 </manifest>
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/BackupRestoreTest.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/BackupRestoreTest.kt
deleted file mode 100644
index 1542cafb..00000000
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/BackupRestoreTest.kt
+++ /dev/null
@@ -1,139 +0,0 @@
-package com.stevesoltys.seedvault.e2e
-
-import androidx.test.filters.LargeTest
-import com.stevesoltys.seedvault.e2e.screen.impl.RestoreScreen
-import com.stevesoltys.seedvault.restore.RestoreViewModel
-import com.stevesoltys.seedvault.transport.backup.PackageService
-import com.stevesoltys.seedvault.ui.notification.BackupNotificationManager
-import io.mockk.every
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.withTimeout
-import org.junit.Test
-import org.koin.core.component.inject
-import java.util.concurrent.atomic.AtomicBoolean
-
-@LargeTest
-class BackupRestoreTest : LargeTestBase() {
-
-    private val packageService: PackageService by inject()
-
-    private val spyBackupNotificationManager: BackupNotificationManager by inject()
-
-    private val restoreViewModel: RestoreViewModel by inject()
-
-    companion object {
-        private const val BACKUP_TIMEOUT = 360 * 1000L
-        private const val RESTORE_TIMEOUT = 360 * 1000L
-    }
-
-    @Test
-    fun `backup and restore applications`() = run {
-        launchBackupActivity()
-        verifyCode()
-        chooseBackupLocation()
-
-        val eligiblePackages = launchAllEligibleApps()
-        performBackup(eligiblePackages)
-        uninstallPackages(eligiblePackages)
-        performRestore()
-
-        val packagesAfterRestore = getEligibleApps()
-        assert(eligiblePackages == packagesAfterRestore)
-    }
-
-    private fun getEligibleApps() = packageService.userApps
-        .map { it.packageName }.toSet()
-
-    private fun launchAllEligibleApps(): Set<String> {
-        return getEligibleApps().onEach {
-            val intent = device.targetContext.packageManager.getLaunchIntentForPackage(it)
-
-            device.targetContext.startActivity(intent)
-            waitUntilIdle()
-        }
-    }
-
-    private fun performBackup(expectedPackages: Set<String>) = run {
-        val backupResult = spyOnBackup(expectedPackages)
-        startBackup()
-        waitForBackupResult(backupResult)
-        screenshot("backup result")
-    }
-
-    private fun spyOnBackup(expectedPackages: Set<String>): AtomicBoolean {
-        val finishedBackup = AtomicBoolean(false)
-
-        every {
-            spyBackupNotificationManager.onBackupFinished(any(), any())
-        } answers {
-            val success = firstArg<Boolean>()
-            assert(success) { "Backup failed." }
-
-            val packageCount = secondArg<Int>()
-            assert(packageCount == expectedPackages.size) {
-                "Expected ${expectedPackages.size} apps, got $packageCount."
-            }
-
-            this.callOriginal()
-            finishedBackup.set(true)
-        }
-
-        return finishedBackup
-    }
-
-    private fun waitForBackupResult(finishedBackup: AtomicBoolean) = run {
-        step("Wait for backup completion") {
-            runBlocking {
-                withTimeout(BACKUP_TIMEOUT) {
-                    while (!finishedBackup.get()) {
-                        delay(100)
-                    }
-                }
-            }
-        }
-    }
-
-    private fun performRestore() = run {
-        step("Start restore and await completion") {
-            RestoreScreen {
-                startRestore()
-                waitForInstallResult()
-                screenshot("restore app apks result")
-
-                nextButton.click()
-                waitForRestoreResult()
-                screenshot("restore app data result")
-
-                finishButton.click()
-            }
-        }
-    }
-
-    private fun waitForInstallResult() = runBlocking {
-        withTimeout(RESTORE_TIMEOUT) {
-
-            while (restoreViewModel.installResult.value == null) {
-                delay(100)
-            }
-
-            val restoreResultValue = restoreViewModel.installResult.value!!
-            assert(!restoreResultValue.hasFailed) { "Failed to install packages" }
-        }
-    }
-
-    private fun waitForRestoreResult() = runBlocking {
-        withTimeout(RESTORE_TIMEOUT) {
-
-            while (restoreViewModel.restoreBackupResult.value == null) {
-                delay(100)
-            }
-
-            val restoreResultValue = restoreViewModel.restoreBackupResult.value!!
-
-            assert(!restoreResultValue.hasError()) {
-                "Restore failed: ${restoreResultValue.errorMsg}"
-            }
-        }
-    }
-}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeBackupTestBase.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeBackupTestBase.kt
new file mode 100644
index 00000000..c3695931
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeBackupTestBase.kt
@@ -0,0 +1,71 @@
+package com.stevesoltys.seedvault.e2e
+
+import com.stevesoltys.seedvault.e2e.screen.impl.BackupScreen
+import com.stevesoltys.seedvault.ui.notification.BackupNotificationManager
+import io.mockk.clearMocks
+import io.mockk.every
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import java.util.concurrent.atomic.AtomicBoolean
+
+internal interface LargeBackupTestBase : LargeTestBase {
+
+    companion object {
+        private const val BACKUP_TIMEOUT = 360 * 1000L
+    }
+
+    val spyBackupNotificationManager: BackupNotificationManager
+
+    fun launchBackupActivity() {
+        runCommand("am start -n ${targetContext.packageName}/.settings.SettingsActivity")
+        waitUntilIdle()
+    }
+
+    fun startBackup() {
+        BackupScreen {
+            backupMenu.clickAndWaitForNewWindow()
+            waitUntilIdle()
+
+            backupNowButton.clickAndWaitForNewWindow()
+            waitUntilIdle()
+
+            backupStatusButton.clickAndWaitForNewWindow()
+            waitUntilIdle()
+        }
+    }
+
+    fun performBackup(expectedPackages: Set<String>) {
+        val backupResult = spyOnBackup(expectedPackages)
+        startBackup()
+        waitForBackupResult(backupResult)
+    }
+
+    private fun spyOnBackup(expectedPackages: Set<String>): AtomicBoolean {
+        val finishedBackup = AtomicBoolean(false)
+
+        clearMocks(spyBackupNotificationManager)
+
+        every {
+            spyBackupNotificationManager.onBackupFinished(any(), any())
+        } answers {
+            val success = firstArg<Boolean>()
+            assert(success) { "Backup failed." }
+
+            this.callOriginal()
+            finishedBackup.set(true)
+        }
+
+        return finishedBackup
+    }
+
+    private fun waitForBackupResult(finishedBackup: AtomicBoolean) {
+        runBlocking {
+            withTimeout(BACKUP_TIMEOUT) {
+                while (!finishedBackup.get()) {
+                    delay(100)
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeRestoreTestBase.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeRestoreTestBase.kt
new file mode 100644
index 00000000..1ba2b288
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeRestoreTestBase.kt
@@ -0,0 +1,86 @@
+package com.stevesoltys.seedvault.e2e
+
+import com.stevesoltys.seedvault.e2e.screen.impl.RecoveryCodeScreen
+import com.stevesoltys.seedvault.e2e.screen.impl.RestoreScreen
+import com.stevesoltys.seedvault.restore.RestoreViewModel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+
+internal interface LargeRestoreTestBase : LargeTestBase {
+
+    companion object {
+        private const val RESTORE_TIMEOUT = 360 * 1000L
+    }
+
+    val spyRestoreViewModel: RestoreViewModel
+
+    fun launchRestoreActivity() {
+        runCommand("am start -n ${targetContext.packageName}/.restore.RestoreActivity")
+        waitUntilIdle()
+    }
+
+    fun typeInRestoreCode(code: List<String>) {
+        assert(code.size == 12) { "Code must have 12 words." }
+
+        RecoveryCodeScreen {
+            waitUntilIdle()
+
+            code.forEachIndexed { index, word ->
+                wordTextField(index).text = word
+            }
+
+            waitUntilIdle()
+            verifyCodeButton.scrollTo().click()
+        }
+    }
+
+    fun performRestore() {
+        RestoreScreen {
+            backupListItem.clickAndWaitForNewWindow()
+            waitUntilIdle()
+
+            waitForInstallResult()
+            nextButton.clickAndWaitForNewWindow()
+
+            waitForRestoreDataResult()
+            finishButton.clickAndWaitForNewWindow()
+            skipButton.clickAndWaitForNewWindow()
+            waitUntilIdle()
+        }
+    }
+
+    private fun waitForInstallResult() = runBlocking {
+        withTimeout(RESTORE_TIMEOUT) {
+            while (spyRestoreViewModel.installResult.value == null ||
+                spyRestoreViewModel.nextButtonEnabled.value == false
+            ) {
+                delay(100)
+            }
+        }
+
+        val restoreResultValue = spyRestoreViewModel.installResult.value
+            ?: error("Restore APKs timed out")
+
+        assert(!restoreResultValue.hasFailed) { "Failed to install packages" }
+        waitUntilIdle()
+    }
+
+    private fun waitForRestoreDataResult() = runBlocking {
+        withTimeout(RESTORE_TIMEOUT) {
+            while (spyRestoreViewModel.restoreBackupResult.value == null) {
+                delay(100)
+            }
+        }
+
+        val restoreResultValue = spyRestoreViewModel.restoreBackupResult.value
+            ?: error("Restore app data timed out")
+
+        assert(!restoreResultValue.hasError()) {
+            "Restore failed: ${restoreResultValue.errorMsg}"
+        }
+
+        waitUntilIdle()
+    }
+
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
index fc0c01ed..89ebbb9d 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
@@ -1,110 +1,100 @@
 package com.stevesoltys.seedvault.e2e
 
-import androidx.test.ext.junit.runners.AndroidJUnit4
+import android.app.UiAutomation
+import android.content.Context
+import android.os.Environment
+import androidx.annotation.WorkerThread
 import androidx.test.platform.app.InstrumentationRegistry
-import com.kaspersky.kaspresso.testcases.api.testcase.TestCase
-import com.stevesoltys.seedvault.e2e.screen.impl.BackupScreen
+import androidx.test.uiautomator.UiDevice
 import com.stevesoltys.seedvault.e2e.screen.impl.DocumentPickerScreen
 import com.stevesoltys.seedvault.e2e.screen.impl.RecoveryCodeScreen
-import com.stevesoltys.seedvault.e2e.screen.impl.RestoreScreen
-import org.junit.After
-import org.junit.Before
-import org.junit.runner.RunWith
-import org.koin.core.component.KoinComponent
 import java.lang.Thread.sleep
+import java.text.SimpleDateFormat
+import java.util.Calendar
 
-@RunWith(AndroidJUnit4::class)
-abstract class LargeTestBase : TestCase(), KoinComponent {
+interface LargeTestBase {
 
-    @Before
-    open fun setUp() {
-        // reset document picker state, and delete old backups
-        runCommand("pm clear com.google.android.documentsui")
-        runCommand("rm -Rf /sdcard/seedvault")
+    companion object {
+        private const val TEST_STORAGE_FOLDER = "seedvault_test"
+        private const val TEST_VIDEO_FOLDER = "seedvault_test_videos"
     }
 
-    @After
-    open fun tearDown() {
-        screenshot("end")
-    }
+    fun externalStorageDir(): String = Environment.getExternalStorageDirectory().absolutePath
 
-    protected fun launchBackupActivity() = run {
-        runCommand("am start -n ${device.targetContext.packageName}/.settings.SettingsActivity")
-        waitUntilIdle()
-    }
+    fun testStoragePath(): String = "${externalStorageDir()}/$TEST_STORAGE_FOLDER"
 
-    protected fun launchRestoreActivity() = run {
-        runCommand("am start -n ${device.targetContext.packageName}/.restore.RestoreActivity")
-        waitUntilIdle()
-    }
+    fun testVideoPath(): String = "${externalStorageDir()}/$TEST_VIDEO_FOLDER"
 
-    protected fun waitUntilIdle() {
-        device.uiDevice.waitForIdle()
+    val targetContext: Context
+        get() = InstrumentationRegistry.getInstrumentation().targetContext
+
+    val uiAutomation: UiAutomation
+        get() = InstrumentationRegistry.getInstrumentation().uiAutomation
+
+    val device: UiDevice
+        get() = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
+
+    fun waitUntilIdle() {
+        device.waitForIdle()
         sleep(3000)
     }
 
-    protected fun verifyCode() = run {
-        RecoveryCodeScreen {
-            step("Confirm code") {
-                screenshot("confirm code")
-                confirmCodeButton.click()
-            }
-            step("Verify code") {
-                screenshot("verify code")
-                verifyCodeButton.scrollTo()
-                verifyCodeButton.click()
-            }
-        }
+    fun runCommand(command: String) {
+        uiAutomation.executeShellCommand(command).close()
     }
 
-    protected fun chooseBackupLocation() = run {
-        step("Choose backup location") {
-            waitUntilIdle()
-            screenshot("choose backup location")
+    @WorkerThread
+    fun startScreenRecord(testName: String) {
+        val simpleDateFormat = SimpleDateFormat("yyyyMMdd_hhmmss")
+        val timeStamp = simpleDateFormat.format(Calendar.getInstance().time)
+        val fileName = "${timeStamp}_${testName.replace(" ", "_")}"
 
-            DocumentPickerScreen {
-                createNewFolderButton.click()
-                textBox.text = "seedvault"
-                okButton.click()
-                useThisFolderButton.click()
-                allowButton.click()
-            }
-        }
+        val folder = testVideoPath()
+        runCommand("mkdir -p $folder")
+        runCommand("screenrecord $folder/$fileName.mp4")
     }
 
-    protected fun startBackup() = run {
-        launchBackupActivity()
-
-        step("Run backup") {
-            BackupScreen {
-                backupMenu.clickAndWaitForNewWindow()
-                backupNowButton.clickAndWaitForNewWindow()
-                backupStatusButton.clickAndWaitForNewWindow()
-            }
-        }
+    @WorkerThread
+    fun stopScreenRecord() {
+        runCommand("pkill -2 screenrecord")
     }
 
-    protected fun startRestore() = run {
-        launchRestoreActivity()
-
-        step("Restore backup") {
-            RestoreScreen {
-                backupListItem.clickAndWaitForNewWindow()
-            }
-        }
-    }
-
-    protected fun uninstallPackages(packages: Set<String>) {
+    fun uninstallPackages(packages: Set<String>) {
         packages.forEach { runCommand("pm uninstall $it") }
     }
 
-    protected fun runCommand(command: String) {
-        InstrumentationRegistry.getInstrumentation().uiAutomation
-            .executeShellCommand(command)
-            .close()
+    fun clearDocumentPickerAppData() {
+        runCommand("pm clear com.google.android.documentsui")
     }
 
-    protected fun screenshot(name: String) {
-        device.screenshots.take(name.replace(" ", "_"))
+    fun clearTestBackups() {
+        runCommand("rm -Rf ${testStoragePath()}")
+    }
+
+    fun chooseStorageLocation(
+        folderName: String = TEST_STORAGE_FOLDER,
+        exists: Boolean = false,
+    ) {
+        DocumentPickerScreen {
+            if (exists) {
+                existingFolder(folderName).scrollTo().clickAndWaitForNewWindow()
+
+            } else {
+                createNewFolderButton.clickAndWaitForNewWindow()
+                textBox.text = folderName
+                okButton.clickAndWaitForNewWindow()
+            }
+
+            useThisFolderButton.clickAndWaitForNewWindow()
+            allowButton.clickAndWaitForNewWindow()
+        }
+    }
+
+    fun confirmCode() {
+        RecoveryCodeScreen {
+            confirmCodeButton.click()
+
+            verifyCodeButton.scrollTo().click()
+        }
     }
 }
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt
new file mode 100644
index 00000000..eff53014
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt
@@ -0,0 +1,73 @@
+package com.stevesoltys.seedvault.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.stevesoltys.seedvault.restore.RestoreViewModel
+import com.stevesoltys.seedvault.ui.notification.BackupNotificationManager
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.rules.TestName
+import org.junit.runner.RunWith
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+internal abstract class SeedvaultLargeTest :
+    LargeBackupTestBase, LargeRestoreTestBase, KoinComponent {
+
+    @JvmField
+    @Rule
+    var name = TestName()
+
+    companion object {
+        private const val BASELINE_BACKUP_FOLDER = "seedvault_baseline"
+        private const val RECOVERY_CODE_FILE = "recovery-code.txt"
+    }
+
+    override val spyBackupNotificationManager: BackupNotificationManager by inject()
+
+    override val spyRestoreViewModel: RestoreViewModel by inject()
+
+    private val baselineBackupFolderPath = "${this.externalStorageDir()}/$BASELINE_BACKUP_FOLDER"
+
+    private val baselineRecoveryCodePath = "$baselineBackupFolderPath/$RECOVERY_CODE_FILE"
+
+    @Before
+    open fun setUp() {
+        clearDocumentPickerAppData()
+        clearTestBackups()
+
+        startScreenRecord(name.methodName)
+        restoreBaselineBackup()
+    }
+
+    @After
+    open fun tearDown() {
+        stopScreenRecord()
+    }
+
+    /**
+     * Restore the baseline backup, if it exists.
+     *
+     * This is a hand-crafted backup containing various apps and app data that we use for
+     * provisioning tests: https://github.com/seedvault-app/seedvault-test-data
+     */
+    private fun restoreBaselineBackup() {
+        if (File(baselineBackupFolderPath).exists()) {
+            launchRestoreActivity()
+            chooseStorageLocation(folderName = BASELINE_BACKUP_FOLDER, exists = true)
+            typeInRestoreCode(baselineBackupRecoveryCode())
+            performRestore()
+        }
+    }
+
+    private fun baselineBackupRecoveryCode(): List<String> {
+        val recoveryCodeFile = File(baselineRecoveryCodePath)
+
+        return recoveryCodeFile.readLines()
+            .filter { it.isNotBlank() }
+            .joinToString(separator = " ") { it.trim() }
+            .split(" ")
+    }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/impl/BackupRestoreTest.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/impl/BackupRestoreTest.kt
new file mode 100644
index 00000000..bc85ff54
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/impl/BackupRestoreTest.kt
@@ -0,0 +1,41 @@
+package com.stevesoltys.seedvault.e2e.impl
+
+import androidx.test.filters.LargeTest
+import com.stevesoltys.seedvault.e2e.SeedvaultLargeTest
+import com.stevesoltys.seedvault.settings.SettingsManager
+import com.stevesoltys.seedvault.transport.backup.PackageService
+import org.junit.Test
+import org.koin.core.component.inject
+
+@LargeTest
+internal class BackupRestoreTest : SeedvaultLargeTest() {
+
+    private val packageService: PackageService by inject()
+
+    private val settingsManager: SettingsManager by inject()
+
+    @Test
+    fun `backup and restore applications`() {
+        launchBackupActivity()
+
+        if (settingsManager.getStorage() == null) {
+            confirmCode()
+            chooseStorageLocation()
+        }
+
+        val eligiblePackages = getEligibleApps()
+        performBackup(eligiblePackages)
+        uninstallPackages(eligiblePackages)
+
+        launchRestoreActivity()
+        performRestore()
+
+        // TODO: Get some real assertions in here..
+        // val packagesAfterRestore = getEligibleApps()
+        // assert(eligiblePackages == packagesAfterRestore)
+    }
+
+    private fun getEligibleApps() = packageService.userApps
+        .map { it.packageName }.toSet()
+
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/UiDeviceScreen.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/UiDeviceScreen.kt
index bddc428a..7a826216 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/UiDeviceScreen.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/UiDeviceScreen.kt
@@ -1,9 +1,12 @@
 package com.stevesoltys.seedvault.e2e.screen
 
+import android.widget.ScrollView
 import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.uiautomator.UiDevice
 import androidx.test.uiautomator.UiObject
+import androidx.test.uiautomator.UiScrollable
 import androidx.test.uiautomator.UiSelector
+import java.lang.Thread.sleep
 
 abstract class UiDeviceScreen<T> {
 
@@ -11,10 +14,20 @@ abstract class UiDeviceScreen<T> {
         function.invoke(this as T)
     }
 
-    protected fun findObject(
+    fun UiObject.scrollTo(
+        scrollSelector: UiSelector = UiSelector().className(ScrollView::class.java),
+    ): UiObject {
+        UiScrollable(scrollSelector).scrollIntoView(this)
+        waitForExists(15000)
+        sleep(2000)
+        return this
+    }
+
+    fun findObject(
         block: UiSelector.() -> UiSelector,
-    ): UiObject = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
-        .findObject(
-            UiSelector().let { it.block() }
-        )
+    ): UiObject = device().findObject(
+        UiSelector().let { it.block() }
+    )
+
+    private fun device() = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
 }
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/DocumentPickerScreen.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/DocumentPickerScreen.kt
index f6f101e4..050e57b2 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/DocumentPickerScreen.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/DocumentPickerScreen.kt
@@ -14,4 +14,6 @@ object DocumentPickerScreen : UiDeviceScreen<DocumentPickerScreen>() {
     val okButton = findObject { text("OK") }
 
     val allowButton = findObject { text("ALLOW") }
+
+    fun existingFolder(folderName: String) = findObject { text(folderName) }
 }
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RecoveryCodeScreen.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RecoveryCodeScreen.kt
index 3ce61511..6804c5c7 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RecoveryCodeScreen.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RecoveryCodeScreen.kt
@@ -1,15 +1,12 @@
 package com.stevesoltys.seedvault.e2e.screen.impl
 
-import com.kaspersky.kaspresso.screens.KScreen
-import com.stevesoltys.seedvault.R
-import io.github.kakaocup.kakao.text.KButton
+import com.stevesoltys.seedvault.e2e.screen.UiDeviceScreen
 
-object RecoveryCodeScreen : KScreen<RecoveryCodeScreen>() {
+object RecoveryCodeScreen : UiDeviceScreen<RecoveryCodeScreen>() {
 
-    override val layoutId: Int? = null
-    override val viewClass: Class<*>? = null
+    val confirmCodeButton = findObject { text("Confirm code") }
 
-    val confirmCodeButton = KButton { withId(R.id.confirmCodeButton) }
+    val verifyCodeButton = findObject { text("Verify") }
 
-    val verifyCodeButton = KButton { withId(R.id.doneButton) }
+    fun wordTextField(index: Int) = findObject { text("Word ${index + 1}") }
 }
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RestoreScreen.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RestoreScreen.kt
index 706fc7bf..20914755 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RestoreScreen.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/RestoreScreen.kt
@@ -4,9 +4,11 @@ import com.stevesoltys.seedvault.e2e.screen.UiDeviceScreen
 
 object RestoreScreen : UiDeviceScreen<RestoreScreen>() {
 
-    val backupListItem = findObject { textContains("Last backup 0 hr") }
+    val backupListItem = findObject { textContains("Last backup") }
 
     val nextButton = findObject { text("Next") }
 
     val finishButton = findObject { text("Finish") }
+
+    val skipButton = findObject { text("Skip restoring files") }
 }

From 04c50891138d3562eeb5e94ecbb19f1a4d22f351 Mon Sep 17 00:00:00 2001
From: Steve Soltys <steve@stevesoltys.com>
Date: Thu, 14 Sep 2023 18:42:22 +0000
Subject: [PATCH 3/5] Start recording screen again if we get cut off after 3
 minutes

---
 .../seedvault/e2e/LargeTestBase.kt            | 27 ++++++++++++++++---
 .../seedvault/e2e/SeedvaultLargeTest.kt       | 13 ++++++---
 2 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
index 89ebbb9d..40395c72 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
@@ -8,9 +8,14 @@ import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.uiautomator.UiDevice
 import com.stevesoltys.seedvault.e2e.screen.impl.DocumentPickerScreen
 import com.stevesoltys.seedvault.e2e.screen.impl.RecoveryCodeScreen
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
 import java.lang.Thread.sleep
 import java.text.SimpleDateFormat
 import java.util.Calendar
+import java.util.concurrent.atomic.AtomicBoolean
 
 interface LargeTestBase {
 
@@ -43,19 +48,35 @@ interface LargeTestBase {
         uiAutomation.executeShellCommand(command).close()
     }
 
+    @OptIn(DelicateCoroutinesApi::class)
     @WorkerThread
-    fun startScreenRecord(testName: String) {
+    suspend fun startScreenRecord(
+        keepRecordingScreen: AtomicBoolean,
+        testName: String,
+    ) {
         val simpleDateFormat = SimpleDateFormat("yyyyMMdd_hhmmss")
         val timeStamp = simpleDateFormat.format(Calendar.getInstance().time)
         val fileName = "${timeStamp}_${testName.replace(" ", "_")}"
 
         val folder = testVideoPath()
+
         runCommand("mkdir -p $folder")
-        runCommand("screenrecord $folder/$fileName.mp4")
+
+        // screen record automatically stops after 3 minutes
+        // we need to block on a loop and split it into multiple files
+        GlobalScope.launch(Dispatchers.IO) {
+            var index = 0
+
+            while (keepRecordingScreen.get()) {
+                device.executeShellCommand("screenrecord $folder/$fileName-${index++}.mp4")
+            }
+        }
     }
 
     @WorkerThread
-    fun stopScreenRecord() {
+    fun stopScreenRecord(keepRecordingScreen: AtomicBoolean) {
+        keepRecordingScreen.set(false)
+
         runCommand("pkill -2 screenrecord")
     }
 
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt
index eff53014..6a896467 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt
@@ -3,6 +3,7 @@ package com.stevesoltys.seedvault.e2e
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.stevesoltys.seedvault.restore.RestoreViewModel
 import com.stevesoltys.seedvault.ui.notification.BackupNotificationManager
+import kotlinx.coroutines.runBlocking
 import org.junit.After
 import org.junit.Before
 import org.junit.Rule
@@ -11,6 +12,7 @@ import org.junit.runner.RunWith
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
 import java.io.File
+import java.util.concurrent.atomic.AtomicBoolean
 
 @RunWith(AndroidJUnit4::class)
 internal abstract class SeedvaultLargeTest :
@@ -33,18 +35,20 @@ internal abstract class SeedvaultLargeTest :
 
     private val baselineRecoveryCodePath = "$baselineBackupFolderPath/$RECOVERY_CODE_FILE"
 
+    private val keepRecordingScreen = AtomicBoolean(true)
+
     @Before
-    open fun setUp() {
+    open fun setUp() = runBlocking {
         clearDocumentPickerAppData()
         clearTestBackups()
 
-        startScreenRecord(name.methodName)
+        startScreenRecord(keepRecordingScreen, name.methodName)
         restoreBaselineBackup()
     }
 
     @After
     open fun tearDown() {
-        stopScreenRecord()
+        stopScreenRecord(keepRecordingScreen)
     }
 
     /**
@@ -59,6 +63,9 @@ internal abstract class SeedvaultLargeTest :
             chooseStorageLocation(folderName = BASELINE_BACKUP_FOLDER, exists = true)
             typeInRestoreCode(baselineBackupRecoveryCode())
             performRestore()
+
+            // remove baseline backup after restore
+            runCommand("rm -Rf $baselineBackupFolderPath/*")
         }
     }
 

From 29bd71bcc9340a9f81cd6553285d7dcf1c5b9aab Mon Sep 17 00:00:00 2001
From: Steve Soltys <steve@stevesoltys.com>
Date: Thu, 21 Sep 2023 06:51:43 +0000
Subject: [PATCH 4/5] Intercept and assert on application data in e2e test

---
 .../seedvault/KoinInstrumentationTestApp.kt   |  37 ++--
 .../seedvault/e2e/LargeBackupTestBase.kt      | 142 +++++++++++++---
 .../seedvault/e2e/LargeRestoreTestBase.kt     | 159 +++++++++++++++---
 .../seedvault/e2e/LargeTestBase.kt            |  86 +++++++++-
 .../seedvault/e2e/SeedvaultLargeTest.kt       |  18 +-
 .../seedvault/e2e/SeedvaultLargeTestResult.kt |  23 +++
 .../seedvault/e2e/impl/BackupRestoreTest.kt   | 135 +++++++++++++--
 .../e2e/io/BackupDataInputIntercept.kt        |  24 +++
 .../e2e/io/BackupDataOutputIntercept.kt       |  23 +++
 .../seedvault/e2e/io/InputStreamIntercept.kt  |  26 +++
 .../seedvault/e2e/io/OutputStreamIntercept.kt |  20 +++
 .../seedvault/e2e/screen/impl/BackupScreen.kt |   2 +
 .../seedvault/crypto/CryptoModule.kt          |   2 +-
 .../seedvault/crypto/KeyManager.kt            |   4 +-
 .../seedvault/settings/SettingsManager.kt     |  13 +-
 15 files changed, 613 insertions(+), 101 deletions(-)
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTestResult.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/BackupDataInputIntercept.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/BackupDataOutputIntercept.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/InputStreamIntercept.kt
 create mode 100644 app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/OutputStreamIntercept.kt

diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestApp.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestApp.kt
index 8335c720..338a426b 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestApp.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/KoinInstrumentationTestApp.kt
@@ -1,32 +1,39 @@
 package com.stevesoltys.seedvault
 
-import androidx.test.platform.app.InstrumentationRegistry
 import com.stevesoltys.seedvault.restore.RestoreViewModel
+import com.stevesoltys.seedvault.transport.backup.FullBackup
+import com.stevesoltys.seedvault.transport.backup.InputFactory
+import com.stevesoltys.seedvault.transport.backup.KVBackup
+import com.stevesoltys.seedvault.transport.restore.FullRestore
+import com.stevesoltys.seedvault.transport.restore.KVRestore
+import com.stevesoltys.seedvault.transport.restore.OutputFactory
 import com.stevesoltys.seedvault.ui.notification.BackupNotificationManager
 import io.mockk.spyk
+import org.koin.androidx.viewmodel.dsl.viewModel
 import org.koin.core.module.Module
 import org.koin.dsl.module
 
-private val spyBackupNotificationManager = spyk(
-    BackupNotificationManager(
-        InstrumentationRegistry.getInstrumentation()
-            .targetContext.applicationContext
-    )
-)
+internal var currentRestoreViewModel: RestoreViewModel? = null
 
 class KoinInstrumentationTestApp : App() {
 
     override fun appModules(): List<Module> {
         val testModule = module {
-            single { spyBackupNotificationManager }
+            val context = this@KoinInstrumentationTestApp
 
-            single {
-                spyk(
-                    RestoreViewModel(
-                        this@KoinInstrumentationTestApp,
-                        get(), get(), get(), get(), get(), get()
-                    )
-                )
+            single { spyk(BackupNotificationManager(context)) }
+            single { spyk(FullBackup(get(), get(), get(), get())) }
+            single { spyk(KVBackup(get(), get(), get(), get(), get())) }
+            single { spyk(InputFactory()) }
+
+            single { spyk(FullRestore(get(), get(), get(), get(), get())) }
+            single { spyk(KVRestore(get(), get(), get(), get(), get(), get())) }
+            single { spyk(OutputFactory()) }
+
+            viewModel {
+                currentRestoreViewModel =
+                    spyk(RestoreViewModel(context, get(), get(), get(), get(), get(), get()))
+                currentRestoreViewModel!!
             }
         }
 
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeBackupTestBase.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeBackupTestBase.kt
index c3695931..0533eeaa 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeBackupTestBase.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeBackupTestBase.kt
@@ -1,12 +1,22 @@
 package com.stevesoltys.seedvault.e2e
 
+import android.content.pm.PackageInfo
+import android.os.ParcelFileDescriptor
+import com.stevesoltys.seedvault.e2e.io.BackupDataInputIntercept
+import com.stevesoltys.seedvault.e2e.io.InputStreamIntercept
 import com.stevesoltys.seedvault.e2e.screen.impl.BackupScreen
+import com.stevesoltys.seedvault.transport.backup.FullBackup
+import com.stevesoltys.seedvault.transport.backup.InputFactory
+import com.stevesoltys.seedvault.transport.backup.KVBackup
 import com.stevesoltys.seedvault.ui.notification.BackupNotificationManager
 import io.mockk.clearMocks
+import io.mockk.coEvery
 import io.mockk.every
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withTimeout
+import org.koin.core.component.get
+import java.io.ByteArrayOutputStream
 import java.util.concurrent.atomic.AtomicBoolean
 
 internal interface LargeBackupTestBase : LargeTestBase {
@@ -15,7 +25,13 @@ internal interface LargeBackupTestBase : LargeTestBase {
         private const val BACKUP_TIMEOUT = 360 * 1000L
     }
 
-    val spyBackupNotificationManager: BackupNotificationManager
+    val spyBackupNotificationManager: BackupNotificationManager get() = get()
+
+    val spyFullBackup: FullBackup get() = get()
+
+    val spyKVBackup: KVBackup get() = get()
+
+    val spyInputFactory: InputFactory get() = get()
 
     fun launchBackupActivity() {
         runCommand("am start -n ${targetContext.packageName}/.settings.SettingsActivity")
@@ -35,14 +51,112 @@ internal interface LargeBackupTestBase : LargeTestBase {
         }
     }
 
-    fun performBackup(expectedPackages: Set<String>) {
-        val backupResult = spyOnBackup(expectedPackages)
+    fun performBackup(): SeedvaultLargeTestResult {
+
+        val backupResult = SeedvaultLargeTestResult(
+            full = mutableMapOf(),
+            kv = mutableMapOf(),
+            userApps = packageService.userApps,
+            userNotAllowedApps = packageService.userNotAllowedApps
+        )
+
+        val completed = spyOnBackup(backupResult)
         startBackup()
-        waitForBackupResult(backupResult)
+        waitForBackupResult(completed)
+
+        return backupResult.copy(
+            backupResults = backupResult.allUserApps().associate {
+                it.packageName to spyMetadataManager.getPackageMetadata(it.packageName)
+            }.toMutableMap()
+        )
     }
 
-    private fun spyOnBackup(expectedPackages: Set<String>): AtomicBoolean {
-        val finishedBackup = AtomicBoolean(false)
+    private fun waitForBackupResult(completed: AtomicBoolean) {
+        runBlocking {
+            withTimeout(BACKUP_TIMEOUT) {
+                while (!completed.get()) {
+                    delay(100)
+                }
+            }
+        }
+    }
+
+    private fun spyOnBackup(backupResult: SeedvaultLargeTestResult): AtomicBoolean {
+        clearMocks(spyInputFactory, spyKVBackup, spyFullBackup)
+        spyOnFullBackupData(backupResult)
+        spyOnKVBackupData(backupResult)
+
+        return spyOnBackupCompletion()
+    }
+
+    private fun spyOnKVBackupData(backupResult: SeedvaultLargeTestResult) {
+        var packageName: String? = null
+        var data = mutableMapOf<String, ByteArray>()
+
+        coEvery {
+            spyKVBackup.performBackup(any(), any(), any(), any(), any())
+        } answers {
+            packageName = firstArg<PackageInfo>().packageName
+            callOriginal()
+        }
+
+        every {
+            spyInputFactory.getBackupDataInput(any())
+        } answers {
+            val fd = firstArg<ParcelFileDescriptor>().fileDescriptor
+
+            BackupDataInputIntercept(fd) { key, value ->
+                data[key] = value
+            }
+        }
+
+        coEvery {
+            spyKVBackup.finishBackup()
+        } answers {
+            backupResult.kv[packageName!!] = data
+                .mapValues { entry -> entry.value.sha256() }
+                .toMutableMap()
+
+            packageName = null
+            data = mutableMapOf()
+            callOriginal()
+        }
+    }
+
+    private fun spyOnFullBackupData(backupResult: SeedvaultLargeTestResult) {
+        var packageName: String? = null
+        var dataIntercept = ByteArrayOutputStream()
+
+        coEvery {
+            spyFullBackup.performFullBackup(any(), any(), any(), any(), any())
+        } answers {
+            packageName = firstArg<PackageInfo>().packageName
+            callOriginal()
+        }
+
+        every {
+            spyInputFactory.getInputStream(any())
+        } answers {
+            InputStreamIntercept(
+                inputStream = callOriginal(),
+                intercept = dataIntercept
+            )
+        }
+
+        every {
+            spyFullBackup.finishBackup()
+        } answers {
+            val result = callOriginal()
+            backupResult.full[packageName!!] = dataIntercept.toByteArray().sha256()
+
+            packageName = null
+            dataIntercept = ByteArrayOutputStream()
+            result
+        }
+    }
+
+    private fun spyOnBackupCompletion(): AtomicBoolean {
+        val completed = AtomicBoolean(false)
 
         clearMocks(spyBackupNotificationManager)
 
@@ -52,20 +166,10 @@ internal interface LargeBackupTestBase : LargeTestBase {
             val success = firstArg<Boolean>()
             assert(success) { "Backup failed." }
 
-            this.callOriginal()
-            finishedBackup.set(true)
+            callOriginal()
+            completed.set(true)
         }
 
-        return finishedBackup
-    }
-
-    private fun waitForBackupResult(finishedBackup: AtomicBoolean) {
-        runBlocking {
-            withTimeout(BACKUP_TIMEOUT) {
-                while (!finishedBackup.get()) {
-                    delay(100)
-                }
-            }
-        }
+        return completed
     }
 }
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeRestoreTestBase.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeRestoreTestBase.kt
index 1ba2b288..5458ae28 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeRestoreTestBase.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeRestoreTestBase.kt
@@ -1,11 +1,24 @@
 package com.stevesoltys.seedvault.e2e
 
+import android.content.pm.PackageInfo
+import android.os.ParcelFileDescriptor
+import com.stevesoltys.seedvault.e2e.io.BackupDataOutputIntercept
+import com.stevesoltys.seedvault.e2e.io.OutputStreamIntercept
 import com.stevesoltys.seedvault.e2e.screen.impl.RecoveryCodeScreen
 import com.stevesoltys.seedvault.e2e.screen.impl.RestoreScreen
-import com.stevesoltys.seedvault.restore.RestoreViewModel
+import com.stevesoltys.seedvault.transport.restore.FullRestore
+import com.stevesoltys.seedvault.transport.restore.KVRestore
+import com.stevesoltys.seedvault.transport.restore.OutputFactory
+import io.mockk.clearMocks
+import io.mockk.coEvery
+import io.mockk.every
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
+import org.koin.core.component.get
+import java.io.ByteArrayOutputStream
 
 internal interface LargeRestoreTestBase : LargeTestBase {
 
@@ -13,7 +26,11 @@ internal interface LargeRestoreTestBase : LargeTestBase {
         private const val RESTORE_TIMEOUT = 360 * 1000L
     }
 
-    val spyRestoreViewModel: RestoreViewModel
+    val spyFullRestore: FullRestore get() = get()
+
+    val spyKVRestore: KVRestore get() = get()
+
+    val spyOutputFactory: OutputFactory get() = get()
 
     fun launchRestoreActivity() {
         runCommand("am start -n ${targetContext.packageName}/.restore.RestoreActivity")
@@ -35,7 +52,17 @@ internal interface LargeRestoreTestBase : LargeTestBase {
         }
     }
 
-    fun performRestore() {
+    fun performRestore(): SeedvaultLargeTestResult {
+
+        val result = SeedvaultLargeTestResult(
+            full = mutableMapOf(),
+            kv = mutableMapOf(),
+            userApps = emptyList(), // will update everything below this after restore
+            userNotAllowedApps = emptyList()
+        )
+
+        spyOnRestoreData(result)
+
         RestoreScreen {
             backupListItem.clickAndWaitForNewWindow()
             waitUntilIdle()
@@ -48,39 +75,123 @@ internal interface LargeRestoreTestBase : LargeTestBase {
             skipButton.clickAndWaitForNewWindow()
             waitUntilIdle()
         }
+
+        return result.copy(
+            userApps = packageService.userApps,
+            userNotAllowedApps = packageService.userNotAllowedApps
+        )
+    }
+
+    private fun spyOnRestoreData(result: SeedvaultLargeTestResult) {
+        clearMocks(spyOutputFactory)
+
+        spyOnFullRestoreData(result)
+        spyOnKVRestoreData(result)
     }
 
     private fun waitForInstallResult() = runBlocking {
-        withTimeout(RESTORE_TIMEOUT) {
-            while (spyRestoreViewModel.installResult.value == null ||
-                spyRestoreViewModel.nextButtonEnabled.value == false
-            ) {
-                delay(100)
+
+        withContext(Dispatchers.Main) {
+            withTimeout(RESTORE_TIMEOUT) {
+                while (spyRestoreViewModel.installResult.value == null ||
+                    spyRestoreViewModel.nextButtonEnabled.value == false
+                ) {
+                    delay(100)
+                }
             }
+
+            val restoreResultValue = spyRestoreViewModel.installResult.value
+                ?: error("Restore APKs timed out")
+
+            assert(!restoreResultValue.hasFailed) { "Failed to install packages" }
         }
 
-        val restoreResultValue = spyRestoreViewModel.installResult.value
-            ?: error("Restore APKs timed out")
-
-        assert(!restoreResultValue.hasFailed) { "Failed to install packages" }
         waitUntilIdle()
     }
 
     private fun waitForRestoreDataResult() = runBlocking {
-        withTimeout(RESTORE_TIMEOUT) {
-            while (spyRestoreViewModel.restoreBackupResult.value == null) {
-                delay(100)
+        withContext(Dispatchers.Main) {
+            withTimeout(RESTORE_TIMEOUT) {
+                while (spyRestoreViewModel.restoreBackupResult.value == null) {
+                    delay(100)
+                }
             }
+
+            val restoreResultValue = spyRestoreViewModel.restoreBackupResult.value
+                ?: error("Restore app data timed out")
+
+            assert(!restoreResultValue.hasError()) {
+                "Restore failed: ${restoreResultValue.errorMsg}"
+            }
+
+            waitUntilIdle()
         }
-
-        val restoreResultValue = spyRestoreViewModel.restoreBackupResult.value
-            ?: error("Restore app data timed out")
-
-        assert(!restoreResultValue.hasError()) {
-            "Restore failed: ${restoreResultValue.errorMsg}"
-        }
-
-        waitUntilIdle()
     }
 
+    private fun spyOnKVRestoreData(restoreResult: SeedvaultLargeTestResult) {
+        var packageName: String? = null
+
+        clearMocks(spyKVRestore)
+
+        coEvery {
+            spyKVRestore.initializeState(any(), any(), any(), any(), any())
+        } answers {
+            packageName = arg<PackageInfo>(3).packageName
+            restoreResult.kv[packageName!!] = mutableMapOf()
+            callOriginal()
+        }
+
+        every {
+            spyOutputFactory.getBackupDataOutput(any())
+        } answers {
+            val fd = firstArg<ParcelFileDescriptor>().fileDescriptor
+
+            BackupDataOutputIntercept(fd) { key, value ->
+                restoreResult.kv[packageName!!]!![key] = value.sha256()
+            }
+        }
+    }
+
+    private fun spyOnFullRestoreData(restoreResult: SeedvaultLargeTestResult) {
+        var packageName: String? = null
+        var dataIntercept = ByteArrayOutputStream()
+
+        clearMocks(spyFullRestore)
+
+        coEvery {
+            spyFullRestore.initializeState(any(), any(), any(), any())
+        } answers {
+            packageName = arg<PackageInfo>(3).packageName
+            dataIntercept = ByteArrayOutputStream()
+
+            callOriginal()
+        }
+
+        every {
+            spyOutputFactory.getOutputStream(any())
+        } answers {
+            OutputStreamIntercept(
+                outputStream = callOriginal(),
+                intercept = dataIntercept
+            )
+        }
+
+        every {
+            spyFullRestore.abortFullRestore()
+        } answers {
+            packageName = null
+            dataIntercept = ByteArrayOutputStream()
+            callOriginal()
+        }
+
+        every {
+            spyFullRestore.finishRestore()
+        } answers {
+            restoreResult.full[packageName!!] = dataIntercept.toByteArray().sha256()
+
+            packageName = null
+            dataIntercept = ByteArrayOutputStream()
+            callOriginal()
+        }
+    }
 }
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
index 40395c72..31aa0e07 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/LargeTestBase.kt
@@ -2,33 +2,52 @@ package com.stevesoltys.seedvault.e2e
 
 import android.app.UiAutomation
 import android.content.Context
+import android.content.pm.PackageInfo
 import android.os.Environment
 import androidx.annotation.WorkerThread
+import androidx.preference.PreferenceManager
 import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.uiautomator.UiDevice
+import com.stevesoltys.seedvault.crypto.ANDROID_KEY_STORE
+import com.stevesoltys.seedvault.crypto.KEY_ALIAS_BACKUP
+import com.stevesoltys.seedvault.crypto.KEY_ALIAS_MAIN
+import com.stevesoltys.seedvault.crypto.KeyManager
+import com.stevesoltys.seedvault.currentRestoreViewModel
+import com.stevesoltys.seedvault.e2e.screen.impl.BackupScreen
 import com.stevesoltys.seedvault.e2e.screen.impl.DocumentPickerScreen
 import com.stevesoltys.seedvault.e2e.screen.impl.RecoveryCodeScreen
+import com.stevesoltys.seedvault.metadata.MetadataManager
+import com.stevesoltys.seedvault.permitDiskReads
+import com.stevesoltys.seedvault.plugins.saf.DocumentsStorage
+import com.stevesoltys.seedvault.restore.RestoreViewModel
+import com.stevesoltys.seedvault.settings.SettingsManager
+import com.stevesoltys.seedvault.transport.backup.PackageService
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
+import java.io.File
 import java.lang.Thread.sleep
+import java.security.KeyStore
+import java.security.MessageDigest
 import java.text.SimpleDateFormat
 import java.util.Calendar
 import java.util.concurrent.atomic.AtomicBoolean
 
-interface LargeTestBase {
+internal interface LargeTestBase : KoinComponent {
 
     companion object {
         private const val TEST_STORAGE_FOLDER = "seedvault_test"
         private const val TEST_VIDEO_FOLDER = "seedvault_test_videos"
     }
 
-    fun externalStorageDir(): String = Environment.getExternalStorageDirectory().absolutePath
+    val externalStorageDir: String get() = Environment.getExternalStorageDirectory().absolutePath
 
-    fun testStoragePath(): String = "${externalStorageDir()}/$TEST_STORAGE_FOLDER"
+    val testStoragePath get() = "$externalStorageDir/$TEST_STORAGE_FOLDER"
 
-    fun testVideoPath(): String = "${externalStorageDir()}/$TEST_VIDEO_FOLDER"
+    val testVideoPath get() = "$externalStorageDir/$TEST_VIDEO_FOLDER"
 
     val targetContext: Context
         get() = InstrumentationRegistry.getInstrumentation().targetContext
@@ -39,6 +58,38 @@ interface LargeTestBase {
     val device: UiDevice
         get() = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
 
+    val packageService: PackageService get() = get()
+
+    val settingsManager: SettingsManager get() = get()
+
+    val keyManager: KeyManager get() = get()
+
+    val documentsStorage: DocumentsStorage get() = get()
+
+    val spyMetadataManager: MetadataManager get() = get()
+
+    val spyRestoreViewModel: RestoreViewModel
+        get() = currentRestoreViewModel ?: error("currentRestoreViewModel is null")
+
+    fun resetApplicationState() {
+        settingsManager.setNewToken(null)
+        documentsStorage.reset(null)
+
+        val sharedPreferences = permitDiskReads {
+            PreferenceManager.getDefaultSharedPreferences(targetContext)
+        }
+        sharedPreferences.edit().clear().apply()
+
+        KeyStore.getInstance(ANDROID_KEY_STORE).apply {
+            load(null)
+        }.apply {
+            deleteEntry(KEY_ALIAS_MAIN)
+            deleteEntry(KEY_ALIAS_BACKUP)
+        }
+
+        clearDocumentPickerAppData()
+    }
+
     fun waitUntilIdle() {
         device.waitForIdle()
         sleep(3000)
@@ -58,8 +109,7 @@ interface LargeTestBase {
         val timeStamp = simpleDateFormat.format(Calendar.getInstance().time)
         val fileName = "${timeStamp}_${testName.replace(" ", "_")}"
 
-        val folder = testVideoPath()
-
+        val folder = testVideoPath
         runCommand("mkdir -p $folder")
 
         // screen record automatically stops after 3 minutes
@@ -80,8 +130,8 @@ interface LargeTestBase {
         runCommand("pkill -2 screenrecord")
     }
 
-    fun uninstallPackages(packages: Set<String>) {
-        packages.forEach { runCommand("pm uninstall $it") }
+    fun uninstallPackages(packages: Collection<PackageInfo>) {
+        packages.forEach { runCommand("pm uninstall ${it.packageName}") }
     }
 
     fun clearDocumentPickerAppData() {
@@ -89,7 +139,19 @@ interface LargeTestBase {
     }
 
     fun clearTestBackups() {
-        runCommand("rm -Rf ${testStoragePath()}")
+        File(testStoragePath).deleteRecursively()
+    }
+
+    fun changeBackupLocation(
+        folderName: String = TEST_STORAGE_FOLDER,
+        exists: Boolean = false,
+    ) {
+        BackupScreen {
+            clearDocumentPickerAppData()
+            backupLocationButton.clickAndWaitForNewWindow()
+
+            chooseStorageLocation(folderName, exists)
+        }
     }
 
     fun chooseStorageLocation(
@@ -118,4 +180,10 @@ interface LargeTestBase {
             verifyCodeButton.scrollTo().click()
         }
     }
+
+    fun ByteArray.sha256(): String {
+        val data = MessageDigest.getInstance("SHA-256").digest(this)
+
+        return data.joinToString("") { "%02x".format(it) }
+    }
 }
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt
index 6a896467..af68a664 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTest.kt
@@ -1,8 +1,6 @@
 package com.stevesoltys.seedvault.e2e
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.stevesoltys.seedvault.restore.RestoreViewModel
-import com.stevesoltys.seedvault.ui.notification.BackupNotificationManager
 import kotlinx.coroutines.runBlocking
 import org.junit.After
 import org.junit.Before
@@ -10,7 +8,6 @@ import org.junit.Rule
 import org.junit.rules.TestName
 import org.junit.runner.RunWith
 import org.koin.core.component.KoinComponent
-import org.koin.core.component.inject
 import java.io.File
 import java.util.concurrent.atomic.AtomicBoolean
 
@@ -27,11 +24,9 @@ internal abstract class SeedvaultLargeTest :
         private const val RECOVERY_CODE_FILE = "recovery-code.txt"
     }
 
-    override val spyBackupNotificationManager: BackupNotificationManager by inject()
+    private val baselineBackupFolderPath get() = "$externalStorageDir/$BASELINE_BACKUP_FOLDER"
 
-    override val spyRestoreViewModel: RestoreViewModel by inject()
-
-    private val baselineBackupFolderPath = "${this.externalStorageDir()}/$BASELINE_BACKUP_FOLDER"
+    private val baselineBackupPath get() = "$baselineBackupFolderPath/.SeedVaultAndroidBackup"
 
     private val baselineRecoveryCodePath = "$baselineBackupFolderPath/$RECOVERY_CODE_FILE"
 
@@ -39,7 +34,7 @@ internal abstract class SeedvaultLargeTest :
 
     @Before
     open fun setUp() = runBlocking {
-        clearDocumentPickerAppData()
+        resetApplicationState()
         clearTestBackups()
 
         startScreenRecord(keepRecordingScreen, name.methodName)
@@ -58,14 +53,15 @@ internal abstract class SeedvaultLargeTest :
      * provisioning tests: https://github.com/seedvault-app/seedvault-test-data
      */
     private fun restoreBaselineBackup() {
-        if (File(baselineBackupFolderPath).exists()) {
+        val backupFile = File(baselineBackupPath)
+
+        if (backupFile.exists()) {
             launchRestoreActivity()
             chooseStorageLocation(folderName = BASELINE_BACKUP_FOLDER, exists = true)
             typeInRestoreCode(baselineBackupRecoveryCode())
             performRestore()
 
-            // remove baseline backup after restore
-            runCommand("rm -Rf $baselineBackupFolderPath/*")
+            resetApplicationState()
         }
     }
 
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTestResult.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTestResult.kt
new file mode 100644
index 00000000..3223aa52
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/SeedvaultLargeTestResult.kt
@@ -0,0 +1,23 @@
+package com.stevesoltys.seedvault.e2e
+
+import android.content.pm.PackageInfo
+import com.stevesoltys.seedvault.metadata.PackageMetadata
+
+/**
+ * Contains maps of (package name -> SHA-256 hashes) of application data.
+ *
+ * During backups and restores, we intercept the package data and store the result here.
+ * We can use this to validate that the restored app data actually matches the backed up data.
+ *
+ * For full backups, the mapping is: Map<PackageName, SHA-256>
+ * For K/V backups, the mapping is: Map<PackageName, Map<Key, SHA-256>>
+ */
+data class SeedvaultLargeTestResult(
+    val backupResults: Map<String, PackageMetadata?> = emptyMap(),
+    val full: MutableMap<String, String>,
+    val kv: MutableMap<String, MutableMap<String, String>>,
+    val userApps: List<PackageInfo>,
+    val userNotAllowedApps: List<PackageInfo>,
+) {
+    fun allUserApps() = userApps + userNotAllowedApps
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/impl/BackupRestoreTest.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/impl/BackupRestoreTest.kt
index bc85ff54..83e638b6 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/impl/BackupRestoreTest.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/impl/BackupRestoreTest.kt
@@ -2,40 +2,139 @@ package com.stevesoltys.seedvault.e2e.impl
 
 import androidx.test.filters.LargeTest
 import com.stevesoltys.seedvault.e2e.SeedvaultLargeTest
-import com.stevesoltys.seedvault.settings.SettingsManager
-import com.stevesoltys.seedvault.transport.backup.PackageService
+import com.stevesoltys.seedvault.e2e.SeedvaultLargeTestResult
+import com.stevesoltys.seedvault.metadata.PackageState
 import org.junit.Test
-import org.koin.core.component.inject
 
 @LargeTest
 internal class BackupRestoreTest : SeedvaultLargeTest() {
 
-    private val packageService: PackageService by inject()
-
-    private val settingsManager: SettingsManager by inject()
-
     @Test
     fun `backup and restore applications`() {
         launchBackupActivity()
 
-        if (settingsManager.getStorage() == null) {
+        if (!keyManager.hasBackupKey()) {
             confirmCode()
-            chooseStorageLocation()
         }
 
-        val eligiblePackages = getEligibleApps()
-        performBackup(eligiblePackages)
-        uninstallPackages(eligiblePackages)
+        if (settingsManager.getStorage() == null) {
+            chooseStorageLocation()
+        } else {
+            changeBackupLocation()
+        }
+
+        val backupResult = performBackup()
+        assertValidBackupMetadata(backupResult)
+
+        uninstallPackages(backupResult.allUserApps())
 
         launchRestoreActivity()
-        performRestore()
+        val restoreResult = performRestore()
 
-        // TODO: Get some real assertions in here..
-        // val packagesAfterRestore = getEligibleApps()
-        // assert(eligiblePackages == packagesAfterRestore)
+        assertValidResults(backupResult, restoreResult)
     }
 
-    private fun getEligibleApps() = packageService.userApps
-        .map { it.packageName }.toSet()
+    private fun assertValidBackupMetadata(backup: SeedvaultLargeTestResult) {
+        // Assert all user apps have metadata.
+        backup.allUserApps().forEach { app ->
+            assert(backup.backupResults.containsKey(app.packageName)) {
+                "Metadata for $app missing from backup."
+            }
+        }
 
+        // Assert all metadata has a valid state.
+        backup.backupResults.forEach { (pkg, metadata) ->
+            assert(metadata != null) { "Metadata for $pkg is null." }
+
+            assert(metadata!!.state != PackageState.UNKNOWN_ERROR) {
+                "Metadata for $pkg has an unknown state."
+            }
+        }
+    }
+
+    private fun assertValidResults(
+        backup: SeedvaultLargeTestResult,
+        restore: SeedvaultLargeTestResult,
+    ) {
+        assertAllUserAppsWereRestored(backup, restore)
+        assertValidFullData(backup, restore)
+        assertValidKeyValueData(backup, restore)
+    }
+
+    private fun assertAllUserAppsWereRestored(
+        backup: SeedvaultLargeTestResult,
+        restore: SeedvaultLargeTestResult,
+    ) {
+        val backupUserApps = backup.allUserApps()
+            .map { it.packageName }.toSet()
+
+        val restoreUserApps = restore.allUserApps()
+            .map { it.packageName }.toSet()
+
+        // Assert we re-installed all user apps.
+        assert(restoreUserApps.containsAll(backupUserApps)) {
+            val missingApps = backupUserApps
+                .minus(restoreUserApps)
+                .joinToString(", ")
+
+            "Not all user apps were restored. Missing: $missingApps"
+        }
+
+        // Assert we restored data for all user apps that had successful backups.
+        // This is expected to succeed because we are uninstalling the apps before restoring.
+        val missingFromRestore = backup.userApps
+            .map { it.packageName }
+            .filter { backup.backupResults[it]?.state == PackageState.APK_AND_DATA }
+            .filter { !restore.kv.containsKey(it) && !restore.full.containsKey(it) }
+
+        if (missingFromRestore.isNotEmpty()) {
+            val failedApps = missingFromRestore.joinToString(", ")
+
+            error("Not all user apps had their data restored. Missing: $failedApps")
+        }
+    }
+
+    private fun assertValidFullData(
+        backup: SeedvaultLargeTestResult,
+        restore: SeedvaultLargeTestResult,
+    ) {
+        // Assert all "full" restored data matches the backup data.
+        val allUserPkgs = backup.allUserApps().map { it.packageName }
+
+        restore.full.forEach { (pkg, fullData) ->
+            if (allUserPkgs.contains(pkg)) {
+                assert(backup.full.containsKey(pkg)) {
+                    "Full data for $pkg missing from restore."
+                }
+
+                if (backup.backupResults[pkg]!!.state == PackageState.APK_AND_DATA) {
+                    assert(fullData == backup.full[pkg]!!) {
+                        "Full data for $pkg does not match."
+                    }
+                }
+            }
+        }
+    }
+
+    private fun assertValidKeyValueData(
+        backup: SeedvaultLargeTestResult,
+        restore: SeedvaultLargeTestResult,
+    ) {
+        // Assert all "key/value" restored data matches the backup data.
+        restore.kv.forEach { (pkg, kvData) ->
+            assert(backup.kv.containsKey(pkg)) {
+                "KV data for $pkg missing from backup."
+            }
+
+            kvData.forEach { (key, value) ->
+                assert(backup.kv[pkg]!!.containsKey(key)) {
+                    "KV data for $pkg/$key exists in restore but is missing from backup."
+                }
+
+                assert(value.contentEquals(backup.kv[pkg]!![key]!!)) {
+                    "KV data for $pkg/$key does not match."
+                }
+            }
+        }
+    }
 }
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/BackupDataInputIntercept.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/BackupDataInputIntercept.kt
new file mode 100644
index 00000000..2277fff5
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/BackupDataInputIntercept.kt
@@ -0,0 +1,24 @@
+package com.stevesoltys.seedvault.e2e.io
+
+import android.app.backup.BackupDataInput
+import java.io.FileDescriptor
+
+class BackupDataInputIntercept(
+    fileDescriptor: FileDescriptor,
+    private val callback: (String, ByteArray) -> Unit,
+) : BackupDataInput(fileDescriptor) {
+
+    var currentKey: String? = null
+
+    override fun getKey(): String? {
+        currentKey = super.getKey()
+        return currentKey
+    }
+
+    override fun readEntityData(data: ByteArray, offset: Int, size: Int): Int {
+        val result = super.readEntityData(data, offset, size)
+
+        callback(currentKey!!, data.copyOf(result))
+        return result
+    }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/BackupDataOutputIntercept.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/BackupDataOutputIntercept.kt
new file mode 100644
index 00000000..0da58800
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/BackupDataOutputIntercept.kt
@@ -0,0 +1,23 @@
+package com.stevesoltys.seedvault.e2e.io
+
+import android.app.backup.BackupDataOutput
+import java.io.FileDescriptor
+
+class BackupDataOutputIntercept(
+    fileDescriptor: FileDescriptor,
+    private val callback: (String, ByteArray) -> Unit,
+) : BackupDataOutput(fileDescriptor) {
+
+    private var currentKey: String? = null
+
+    override fun writeEntityHeader(key: String, dataSize: Int): Int {
+        currentKey = key
+        return super.writeEntityHeader(key, dataSize)
+    }
+
+    override fun writeEntityData(data: ByteArray, size: Int): Int {
+        callback(currentKey!!, data.copyOf())
+
+        return super.writeEntityData(data, size)
+    }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/InputStreamIntercept.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/InputStreamIntercept.kt
new file mode 100644
index 00000000..876c10b4
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/InputStreamIntercept.kt
@@ -0,0 +1,26 @@
+package com.stevesoltys.seedvault.e2e.io
+
+import java.io.ByteArrayOutputStream
+import java.io.InputStream
+
+class InputStreamIntercept(
+    private val inputStream: InputStream,
+    private val intercept: ByteArrayOutputStream
+) : InputStream() {
+
+    override fun read(): Int {
+        val byte = inputStream.read()
+        if (byte != -1) {
+            intercept.write(byte)
+        }
+        return byte
+    }
+
+    override fun read(buffer: ByteArray, offset: Int, length: Int): Int {
+        val bytesRead = inputStream.read(buffer, offset, length)
+        if (bytesRead != -1) {
+            intercept.write(buffer, offset, bytesRead)
+        }
+        return bytesRead
+    }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/OutputStreamIntercept.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/OutputStreamIntercept.kt
new file mode 100644
index 00000000..601b8337
--- /dev/null
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/io/OutputStreamIntercept.kt
@@ -0,0 +1,20 @@
+package com.stevesoltys.seedvault.e2e.io
+
+import java.io.ByteArrayOutputStream
+import java.io.OutputStream
+
+class OutputStreamIntercept(
+    private val outputStream: OutputStream,
+    private val intercept: ByteArrayOutputStream
+) : OutputStream() {
+
+    override fun write(byte: Int) {
+        intercept.write(byte)
+        outputStream.write(byte)
+    }
+
+    override fun write(buffer: ByteArray, offset: Int, length: Int) {
+        intercept.write(buffer, offset, length)
+        outputStream.write(buffer, offset, length)
+    }
+}
diff --git a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/BackupScreen.kt b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/BackupScreen.kt
index a9ce5c5e..dc33be7b 100644
--- a/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/BackupScreen.kt
+++ b/app/src/androidTest/java/com/stevesoltys/seedvault/e2e/screen/impl/BackupScreen.kt
@@ -9,4 +9,6 @@ object BackupScreen : UiDeviceScreen<BackupScreen>() {
     val backupNowButton = findObject { text("Backup now") }
 
     val backupStatusButton = findObject { text("Backup status") }
+
+    val backupLocationButton = findObject { text("Backup location") }
 }
diff --git a/app/src/main/java/com/stevesoltys/seedvault/crypto/CryptoModule.kt b/app/src/main/java/com/stevesoltys/seedvault/crypto/CryptoModule.kt
index d15c9606..f484bf6d 100644
--- a/app/src/main/java/com/stevesoltys/seedvault/crypto/CryptoModule.kt
+++ b/app/src/main/java/com/stevesoltys/seedvault/crypto/CryptoModule.kt
@@ -3,7 +3,7 @@ package com.stevesoltys.seedvault.crypto
 import org.koin.dsl.module
 import java.security.KeyStore
 
-private const val ANDROID_KEY_STORE = "AndroidKeyStore"
+const val ANDROID_KEY_STORE = "AndroidKeyStore"
 
 val cryptoModule = module {
     factory<CipherFactory> { CipherFactoryImpl(get()) }
diff --git a/app/src/main/java/com/stevesoltys/seedvault/crypto/KeyManager.kt b/app/src/main/java/com/stevesoltys/seedvault/crypto/KeyManager.kt
index eded4cef..4b605fec 100644
--- a/app/src/main/java/com/stevesoltys/seedvault/crypto/KeyManager.kt
+++ b/app/src/main/java/com/stevesoltys/seedvault/crypto/KeyManager.kt
@@ -14,8 +14,8 @@ import javax.crypto.spec.SecretKeySpec
 
 internal const val KEY_SIZE = 256
 internal const val KEY_SIZE_BYTES = KEY_SIZE / 8
-private const val KEY_ALIAS_BACKUP = "com.stevesoltys.seedvault"
-private const val KEY_ALIAS_MAIN = "com.stevesoltys.seedvault.main"
+internal const val KEY_ALIAS_BACKUP = "com.stevesoltys.seedvault"
+internal const val KEY_ALIAS_MAIN = "com.stevesoltys.seedvault.main"
 private const val KEY_ALGORITHM_BACKUP = "AES"
 private const val KEY_ALGORITHM_MAIN = "HmacSHA256"
 
diff --git a/app/src/main/java/com/stevesoltys/seedvault/settings/SettingsManager.kt b/app/src/main/java/com/stevesoltys/seedvault/settings/SettingsManager.kt
index a1fa0ca6..e26e61d3 100644
--- a/app/src/main/java/com/stevesoltys/seedvault/settings/SettingsManager.kt
+++ b/app/src/main/java/com/stevesoltys/seedvault/settings/SettingsManager.kt
@@ -60,8 +60,17 @@ class SettingsManager(private val context: Context) {
      * Should only be called by the [BackupCoordinator]
      * to ensure that related work is performed after moving to a new token.
      */
-    fun setNewToken(newToken: Long) {
-        prefs.edit().putLong(PREF_KEY_TOKEN, newToken).apply()
+    fun setNewToken(newToken: Long?) {
+        if (newToken == null) {
+            prefs.edit()
+                .remove(PREF_KEY_TOKEN)
+                .apply()
+        } else {
+            prefs.edit()
+                .putLong(PREF_KEY_TOKEN, newToken)
+                .apply()
+        }
+
         token = newToken
     }
 

From ced8803761226e988fad40ae0f19d8d0e0d0506a Mon Sep 17 00:00:00 2001
From: Steve Soltys <steve@stevesoltys.com>
Date: Fri, 22 Sep 2023 04:12:53 +0000
Subject: [PATCH 5/5] Switch ANDROID_SDK_HOME to ANDROID_HOME

---
 app/build.gradle                              |  8 ++++----
 app/development/scripts/clear_app_data.sh     |  8 ++++----
 app/development/scripts/install_app.sh        |  8 ++++----
 app/development/scripts/provision_emulator.sh | 14 +++++++-------
 app/development/scripts/start_emulator.sh     |  6 +++---
 5 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/app/build.gradle b/app/build.gradle
index 06327965..6f2c7dff 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -191,7 +191,7 @@ tasks.register('provisionEmulator', Exec) {
                 "seedvault",
                 "system-images;android-33;google_apis;x86_64"
 
-        environment "ANDROID_SDK_HOME", android.sdkDirectory.absolutePath
+        environment "ANDROID_HOME", android.sdkDirectory.absolutePath
         environment "JAVA_HOME", System.properties['java.home']
     }
 }
@@ -202,7 +202,7 @@ tasks.register('startEmulator', Exec) {
     doFirst {
         commandLine "${project.projectDir}/development/scripts/start_emulator.sh", "seedvault"
 
-        environment "ANDROID_SDK_HOME", android.sdkDirectory.absolutePath
+        environment "ANDROID_HOME", android.sdkDirectory.absolutePath
         environment "JAVA_HOME", System.properties['java.home']
     }
 }
@@ -215,7 +215,7 @@ tasks.register('installEmulatorRelease', Exec) {
     doFirst {
         commandLine "${project.projectDir}/development/scripts/install_app.sh"
 
-        environment "ANDROID_SDK_HOME", android.sdkDirectory.absolutePath
+        environment "ANDROID_HOME", android.sdkDirectory.absolutePath
         environment "JAVA_HOME", System.properties['java.home']
     }
 }
@@ -226,7 +226,7 @@ tasks.register('clearEmulatorAppData', Exec) {
     doFirst {
         commandLine "${project.projectDir}/development/scripts/clear_app_data.sh"
 
-        environment "ANDROID_SDK_HOME", android.sdkDirectory.absolutePath
+        environment "ANDROID_HOME", android.sdkDirectory.absolutePath
         environment "JAVA_HOME", System.properties['java.home']
     }
 }
diff --git a/app/development/scripts/clear_app_data.sh b/app/development/scripts/clear_app_data.sh
index fbde98b6..8bf4b978 100755
--- a/app/development/scripts/clear_app_data.sh
+++ b/app/development/scripts/clear_app_data.sh
@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 
 # assert ANDROID_HOME is set
-if [ -z "$ANDROID_SDK_HOME" ]; then
-  echo "ANDROID_SDK_HOME is not set"
+if [ -z "$ANDROID_HOME" ]; then
+  echo "ANDROID_HOME is not set"
   exit 1
 fi
 
@@ -10,13 +10,13 @@ SCRIPT_DIR=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
 DEVELOPMENT_DIR=$SCRIPT_DIR/..
 ROOT_PROJECT_DIR=$SCRIPT_DIR/../../..
 
-EMULATOR_DEVICE_NAME=$($ANDROID_SDK_HOME/platform-tools/adb devices | grep emulator | cut -f1)
+EMULATOR_DEVICE_NAME=$($ANDROID_HOME/platform-tools/adb devices | grep emulator | cut -f1)
 
 if [ -z "$EMULATOR_DEVICE_NAME" ]; then
   echo "Emulator device name not found"
   exit 1
 fi
 
-ADB="$ANDROID_SDK_HOME/platform-tools/adb -s $EMULATOR_DEVICE_NAME"
+ADB="$ANDROID_HOME/platform-tools/adb -s $EMULATOR_DEVICE_NAME"
 
 $ADB shell pm clear com.stevesoltys.seedvault
diff --git a/app/development/scripts/install_app.sh b/app/development/scripts/install_app.sh
index 05bd3ee1..6891cad5 100755
--- a/app/development/scripts/install_app.sh
+++ b/app/development/scripts/install_app.sh
@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 
 # assert ANDROID_HOME is set
-if [ -z "$ANDROID_SDK_HOME" ]; then
-  echo "ANDROID_SDK_HOME is not set"
+if [ -z "$ANDROID_HOME" ]; then
+  echo "ANDROID_HOME is not set"
   exit 1
 fi
 
@@ -10,14 +10,14 @@ SCRIPT_DIR=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)
 DEVELOPMENT_DIR=$SCRIPT_DIR/..
 ROOT_PROJECT_DIR=$SCRIPT_DIR/../../..
 
-EMULATOR_DEVICE_NAME=$($ANDROID_SDK_HOME/platform-tools/adb devices | grep emulator | cut -f1)
+EMULATOR_DEVICE_NAME=$($ANDROID_HOME/platform-tools/adb devices | grep emulator | cut -f1)
 
 if [ -z "$EMULATOR_DEVICE_NAME" ]; then
   echo "Emulator device name not found"
   exit 1
 fi
 
-ADB="$ANDROID_SDK_HOME/platform-tools/adb -s $EMULATOR_DEVICE_NAME"
+ADB="$ANDROID_HOME/platform-tools/adb -s $EMULATOR_DEVICE_NAME"
 
 $ADB root
 sleep 3      # wait for adb to restart
diff --git a/app/development/scripts/provision_emulator.sh b/app/development/scripts/provision_emulator.sh
index 8af6504f..e8d45917 100755
--- a/app/development/scripts/provision_emulator.sh
+++ b/app/development/scripts/provision_emulator.sh
@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 
 # assert ANDROID_HOME is set
-if [ -z "$ANDROID_SDK_HOME" ]; then
-  echo "ANDROID_SDK_HOME is not set"
+if [ -z "$ANDROID_HOME" ]; then
+  echo "ANDROID_HOME is not set"
   exit 1
 fi
 
@@ -20,14 +20,14 @@ DEVELOPMENT_DIR=$SCRIPT_DIR/..
 ROOT_PROJECT_DIR=$SCRIPT_DIR/../../..
 
 echo "Downloading system image..."
-$ANDROID_SDK_HOME/cmdline-tools/latest/bin/sdkmanager --install "$SYSTEM_IMAGE"
+$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --install "$SYSTEM_IMAGE"
 
 # create AVD if it doesn't exist
-if $ANDROID_SDK_HOME/cmdline-tools/latest/bin/avdmanager list avd | grep -q "$EMULATOR_NAME"; then
+if $ANDROID_HOME/cmdline-tools/latest/bin/avdmanager list avd | grep -q "$EMULATOR_NAME"; then
   echo "AVD already exists. Skipping creation."
 else
   echo "Creating AVD..."
-  echo 'no' | $ANDROID_SDK_HOME/cmdline-tools/latest/bin/avdmanager create avd -n "$EMULATOR_NAME" -k "$SYSTEM_IMAGE"
+  echo 'no' | $ANDROID_HOME/cmdline-tools/latest/bin/avdmanager create avd -n "$EMULATOR_NAME" -k "$SYSTEM_IMAGE"
   sleep 1
 fi
 
@@ -35,14 +35,14 @@ $SCRIPT_DIR/start_emulator.sh "$EMULATOR_NAME"
 sleep 3
 
 # get emulator device name from ADB
-EMULATOR_DEVICE_NAME=$($ANDROID_SDK_HOME/platform-tools/adb devices | grep emulator | cut -f1)
+EMULATOR_DEVICE_NAME=$($ANDROID_HOME/platform-tools/adb devices | grep emulator | cut -f1)
 
 if [ -z "$EMULATOR_DEVICE_NAME" ]; then
   echo "Emulator device name not found"
   exit 1
 fi
 
-ADB="$ANDROID_SDK_HOME/platform-tools/adb -s $EMULATOR_DEVICE_NAME"
+ADB="$ANDROID_HOME/platform-tools/adb -s $EMULATOR_DEVICE_NAME"
 
 echo "Waiting for emulator to boot..."
 $ADB wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;'
diff --git a/app/development/scripts/start_emulator.sh b/app/development/scripts/start_emulator.sh
index 387388df..616a538b 100755
--- a/app/development/scripts/start_emulator.sh
+++ b/app/development/scripts/start_emulator.sh
@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 
 # assert ANDROID_HOME is set
-if [ -z "$ANDROID_SDK_HOME" ]; then
-  echo "ANDROID_SDK_HOME is not set"
+if [ -z "$ANDROID_HOME" ]; then
+  echo "ANDROID_HOME is not set"
   exit 1
 fi
 
@@ -19,4 +19,4 @@ DEVELOPMENT_DIR=$SCRIPT_DIR/..
 ROOT_PROJECT_DIR=$SCRIPT_DIR/../../..
 
 echo "Starting emulator..."
-nohup $ANDROID_SDK_HOME/emulator/emulator -avd "$EMULATOR_NAME" -gpu swiftshader_indirect -writable-system -no-snapshot-load >/dev/null 2>&1 &
+nohup $ANDROID_HOME/emulator/emulator -avd "$EMULATOR_NAME" -gpu swiftshader_indirect -writable-system -no-snapshot-load >/dev/null 2>&1 &