Testowanie pod kątem zmian w konfiguracji ekranu za pomocą interfejsu Espresso Device API

Użyj interfejsu Espresso Device API, aby testować aplikację, gdy urządzenie przechodzi typowe zmiany konfiguracji, takie jak obrót i rozłożenie ekranu. Interfejs Espresso Device API to zalecane narzędzie do symulowania działań na poziomie urządzenia wraz z regułami testowania w Jetpack Compose. Jeśli dopiero zaczynasz pisać testy interfejsu użytkownika w Jetpack Compose, przeczytaj artykuł Testowanie układu Compose.

Interfejs Espresso Device API umożliwia symulowanie zmian konfiguracji na urządzeniu wirtualnym i synchroniczne wykonywanie testów, dzięki czemu w danym momencie wykonywane jest tylko jedno działanie lub asercja interfejsu użytkownika, a wyniki testów są bardziej wiarygodne. Jeśli dopiero zaczynasz pisać testy interfejsu użytkownika za pomocą Espresso, zapoznaj się z jego dokumentacją.

Aby korzystać z interfejsu Espresso Device API, potrzebujesz tych elementów:

  • Android Studio Iguana lub nowsze,
  • wtyczka Androida do obsługi Gradle w wersji 8.3 lub nowszej,
  • Android Emulator 33.1.10 lub nowszy
  • wirtualne urządzenie z Androidem z poziomem API 24 lub nowszym.

Konfigurowanie projektu pod kątem interfejsu Espresso Device API

Aby skonfigurować projekt tak, aby obsługiwał interfejs Espresso Device API:

  1. Aby test mógł przekazywać polecenia do urządzenia testowego, dodaj uprawnienia INTERNET i ACCESS_NETWORK_STATE do pliku manifestu w zbiorze źródeł androidTest:

      <uses-permission android:name="android.permission.INTERNET" />
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

  2. Włącz eksperymentalną flagę enableEmulatorControl w pliku gradle.properties:

      android.experimental.androidTest.enableEmulatorControl=true

  3. Włącz opcję emulatorControl w skrypcie kompilacji na poziomie modułu:

    Kotlin

      testOptions {
    emulatorControl {
      enable = true
    }
  }

    Dynamiczny

      testOptions {
    emulatorControl {
      enable = true
    }
  }

  4. W skrypcie kompilacji na poziomie modułu zaimportuj do projektu bibliotekę Espresso Device:

    Kotlin

    dependencies {
  androidTestImplementation("androidx.test.espresso:espresso-device:1.0.1")
}

    Dynamiczny

    dependencies {
  androidTestImplementation 'androidx.test.espresso:espresso-device:1.0.1'
}

Testowanie pod kątem typowych zmian konfiguracji

Interfejs Espresso Device API ma wiele stanów orientacji ekranu i składania, których możesz użyć do symulowania zmian konfiguracji urządzenia. Poniższe przykłady pokazują, jak wywołać te stany urządzenia i sprawdzić wynikowe zmiany interfejsu użytkownika za pomocą reguł testowania w Compose.

Testowanie pod kątem obrotu ekranu

Oto przykład testowania, co się stanie z aplikacją, gdy ekran urządzenia się obróci:

  1. Najpierw zdefiniuj regułę testowania w Compose i ustaw urządzenie w spójnym stanie początkowym (np. w trybie pionowym):

    import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.assertDoesNotExist
import androidx.compose.ui.test.junit4.createComposeRule
import androidx.compose.ui.test.onNodeWithTag
import androidx.test.espresso.device.EspressoDevice.onDevice
import androidx.test.espresso.device.action.ScreenOrientation
import androidx.test.espresso.device.rules.ScreenOrientationRule
import org.junit.Rule
import org.junit.Test

class MyConfigurationTest {

    // 1. Define the Compose test rule
    @get:Rule
    val composeTestRule = createComposeRule()

    // 2. Define the Espresso Device rule for a consistent starting state
    @get:Rule
    val screenOrientationRule = ScreenOrientationRule(ScreenOrientation.PORTRAIT)
}

  2. Utwórz test, który podczas jego wykonywania ustawia urządzenie w orientacji poziomej:

    @Test
fun myRotationTest() {
  ...
  // Sets the device to landscape orientation during test execution.
  onDevice().setScreenOrientation(ScreenOrientation.LANDSCAPE)
  ...
}

  3. Po obróceniu ekranu użyj composeTestRule, aby sprawdzić, czy elementy kompozycyjne dostosowują się do nowego stanu zgodnie z oczekiwaniami.

    @Test
fun myRotationTest() {
  ...
  // Sets the device to landscape orientation during test execution.
  onDevice().setScreenOrientation(ScreenOrientation.LANDSCAPE)
  composeTestRule.onNodeWithTag("NavRail").assertIsDisplayed()
  composeTestRule.onNodeWithTag("BottomBar").assertDoesNotExist()
}

Testowanie pod kątem rozłożenia ekranu

Oto przykład testowania, co się stanie z aplikacją, jeśli jest ona na urządzeniu składanym, a ekran się rozłoży:

  1. Najpierw przetestuj urządzenie w stanie złożonym, wywołując onDevice().setClosedMode(). Upewnij się, że elementy kompozycyjne dostosowują się do kompaktowej szerokości ekranu.

    @Test
fun myUnfoldedTest() {
  onDevice().setClosedMode()
  composeTestRule.onNodeWithTag("BottomBar").assertIsDisplayed()
  composeTestRule.onNodeWithTag("NavRail").assertDoesNotExist()
  ...
}

  2. Aby przejść do stanu całkowicie rozłożonego, wywołaj onDevice().setFlatMode(). Sprawdź, czy elementy kompozycyjne dostosowują się do rozszerzonej klasy rozmiaru.

    @Test
fun myUnfoldedTest() {
  onDevice().setClosedMode()
  ...
  onDevice().setFlatMode()
  composeTestRule.onNodeWithTag("NavRail").assertIsDisplayed()
  composeTestRule.onNodeWithTag("BottomBar").assertDoesNotExist()
}

Określanie, jakich urządzeń wymagają testy

Jeśli uruchomisz test, który wykonuje działania składania na urządzeniu, które nie jest składane, test prawdopodobnie się nie powiedzie. Aby wykonywać tylko testy odpowiednie dla uruchomionego urządzenia, użyj adnotacji @RequiresDeviceMode. Program do uruchamiania testów automatycznie pomija testy na urządzeniach, które nie obsługują testowanej konfiguracji. Regułę dotyczącą wymagań urządzenia możesz dodać do każdego testu lub całej klasy testowej.

Aby na przykład określić, że test ma być uruchamiany tylko na urządzeniach, które obsługują rozkładanie do konfiguracji płaskiej, dodaj do testu ten kod @RequiresDeviceMode:

@Test
@RequiresDeviceMode(mode = FLAT)
fun myUnfoldedTest() {
  ...
}