Aktivitäten der App testen

Aktivitäten dienen als Container für jede Nutzerinteraktion in Ihrer App. Daher ist es wichtig zu testen, wie sich die Aktivitäten Ihrer App bei Ereignissen auf Geräteebene verhalten, z. B. bei folgenden:

  • Eine andere App, z. B. die Telefon-App des Geräts, unterbricht die Aktivität Ihrer App.
  • Das System zerstört und erstellt Ihre Aktivität neu.
  • Der Nutzer platziert Ihre Aktivität in einer neuen Fensterumgebung, z. B. im Bild-in-Bild-Modus oder im Multifenstermodus.

Insbesondere ist es wichtig, dass sich Ihre Aktivität korrekt verhält, wenn die in Der Aktivitätslebenszyklus beschriebenen Ereignisse auftreten.

In dieser Anleitung wird beschrieben, wie Sie die Fähigkeit Ihrer App bewerten können, die Datenintegrität und eine gute Nutzererfahrung aufrechtzuerhalten, während die Aktivitäten Ihrer App verschiedene Zustände in ihren Lebenszyklen durchlaufen.

Aktivitäten in Compose testen

Wenn Sie eine mit Jetpack Compose erstellte App testen, verwenden Sie in der Regel createAndroidComposeRule, um Ihre Aktivität zu starten und mit Ihren UI-Komponenten zu interagieren.

Für das Testen von Ereignissen auf Geräteebene, z. B. Konfigurationsänderungen oder das Versetzen der Aktivität in den Hintergrund oder das Zerstören durch das System, müssen Sie den Lebenszyklus der Aktivität direkt bearbeiten. Dazu verwenden Sie das zugrunde liegende ActivityScenario Framework.

Die Compose-Testregel umschließt und verwaltet dieses Szenario automatisch für Sie. In dieser Anleitung wird das folgende Muster verwendet, um die Lücke zwischen modernen UI-Tests und der Standardlebenszyklusverwaltung zu schließen:

@get:Rule
val composeTestRule = createAndroidComposeRule<MyActivity>()

@Test fun testEvent() {
    val scenario = composeTestRule.activityRule.scenario

    // ...
}

Status einer Activity steuern

Ein wichtiger Aspekt beim Testen der Aktivitäten Ihrer App ist das Versetzen der Aktivitäten Ihrer App in bestimmte Status. Um diesen Teil Ihrer Tests zu definieren, verwenden Sie Instanzen von ActivityScenario, das Teil der AndroidX-Testbibliothek ist. Mit dieser Klasse können Sie Ihre Aktivität in Status versetzen, die Ereignisse auf Geräteebene simulieren.

ActivityScenario ist eine plattformübergreifende API, die Sie sowohl in lokalen Unit-Tests als auch in Integrationstests auf dem Gerät verwenden können. Auf einem echten oder virtuellen Gerät bietet ActivityScenario Threadsicherheit und synchronisiert Ereignisse zwischen dem Instrumentationsthread Ihres Tests und dem Thread, in dem die zu testende Aktivität ausgeführt wird.

Die API eignet sich besonders gut, um zu bewerten, wie sich eine zu testende Aktivität verhält, wenn sie zerstört oder erstellt wird. In diesem Abschnitt werden die häufigsten Anwendungsfälle für diese API vorgestellt.

Aktivität erstellen

Fügen Sie den im folgenden Snippet gezeigten Code hinzu, um die zu testende Aktivität zu erstellen:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
       launchActivity<MyActivity>().use {
       }
    }
}

Nach dem Erstellen der Aktivität versetzt ActivityScenario die Aktivität in den Status RESUMED. Dieser Status gibt an, dass Ihre Aktivität ausgeführt wird und für Nutzer sichtbar ist. In diesem Status können Sie mit den Composables Ihrer Aktivität über die Compose-Test-APIs interagieren.

Google empfiehlt, close für die Aktivität aufzurufen, wenn der Test abgeschlossen ist. Dadurch werden die zugehörigen Ressourcen bereinigt und die Stabilität Ihrer Tests verbessert. ActivityScenario implementiert Closeable, sodass Sie die Erweiterung use anwenden können, damit die Aktivität automatisch geschlossen wird.

Alternativ können Sie createAndroidComposeRule verwenden, um die Activity vor jedem Test automatisch zu starten, die Bereinigung zu verarbeiten und Zugriff auf die Compose-UI-Testmethoden und das zugrunde liegende ActivityScenario zu erhalten. Im folgenden Beispiel wird gezeigt, wie Sie eine Regel definieren und eine Instanz eines Szenarios daraus abrufen:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @get:Rule
    val composeTestRule = createAndroidComposeRule<MyActivity>()

    @Test fun testEvent() {
        val scenario = composeTestRule.activityRule.scenario
    }
}

Aktivität in einen neuen Status versetzen

Rufen Sie moveToState auf, um die Aktivität in einen anderen Status zu versetzen, z. B. CREATED oder STARTED. Diese Aktion simuliert eine Situation, in der Ihre Aktivität beendet oder pausiert wird, weil sie von einer anderen App oder einer Systemaktion unterbrochen wird.

Ein Beispiel für die Verwendung von moveToState finden Sie im folgenden Code-Snippet:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.moveToState(State.CREATED)
        }
    }
}

Aktuellen Aktivitätsstatus ermitteln

Um den aktuellen Zustand einer zu testenden Activity zu ermitteln, rufen Sie den Wert des Felds state in Ihrem ActivityScenario-Objekt ab. Es ist besonders hilfreich, den Status einer zu testenden Aktivität zu prüfen, wenn die Aktivität zu einer anderen Aktivität weiterleitet oder sich selbst beendet, wie im folgenden Code-Snippet gezeigt:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.onActivity { activity ->
              startActivity(Intent(activity, MyOtherActivity::class.java))
            }

            val originalActivityState = scenario.state
        }
    }
}

Aktivität neu erstellen

Wenn auf einem Gerät nur noch wenige Ressourcen verfügbar sind, kann das System eine Aktivität zerstören. Ihre App muss diese Aktivität dann neu erstellen, wenn der Nutzer zu Ihrer App zurückkehrt. Rufen Sie recreate auf, um diese Bedingungen zu simulieren:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.recreate()
        }
    }
}

Die Klasse ActivityScenario behält den gespeicherten Instanzstatus der Aktivität und alle mit @NonConfigurationInstance annotierten Objekte bei. Diese Objekte werden in die neue Instanz der zu testenden Aktivität geladen.

Aktivitätsergebnisse abrufen

Um den Ergebniscode oder die Daten abzurufen, die mit einer abgeschlossenen Aktivität verknüpft sind, rufen Sie den Wert des Felds result in Ihrem ActivityScenario-Objekt ab. Mit createAndroidComposeRule können Sie ganz einfach die UI-Aktion auslösen, die die Aktivität beendet, wie im folgenden Code-Snippet gezeigt:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @get:Rule
    val composeTestRule = createAndroidComposeRule<MyActivity>()

    @Test fun testResult() {
        composeTestRule.onNodeWithTag("finish_button").performClick()

        val scenario = composeTestRule.activityRule.scenario
        val resultCode = scenario.result.resultCode
        val resultData = scenario.result.resultData
    }
}

Aktionen in der Aktivität auslösen

Alle Methoden in ActivityScenario sind blockierende Aufrufe. Daher müssen Sie sie im Instrumentationsthread ausführen.

Verwenden Sie die Compose-Test-APIs, um mit den Composables zu interagieren und Aktionen in der zu testenden Aktivität auszulösen:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @get:Rule
    val composeTestRule = createAndroidComposeRule<MyActivity>()

    @Test fun testEvent() {
        composeTestRule.onNodeWithText("Refresh").performClick()
    }
}

Wenn Sie jedoch eine Methode für die Aktivität selbst aufrufen müssen, können Sie das sicher mit onActivity tun:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.onActivity { activity ->
              activity.handleSwipeToRefresh()
            }
        }
    }
}

Zusätzliche Ressourcen

Weitere Informationen zum Testen finden Sie in den folgenden zusätzlichen Ressourcen:

Dokumentation