Menguji aktivitas aplikasi

Aktivitas berfungsi sebagai penampung untuk setiap interaksi pengguna dalam aplikasi, oleh karena itu, sebaiknya uji bagaimana aktivitas aplikasi Anda berperilaku selama peristiwa di tingkat perangkat, seperti berikut ini:

  • Aplikasi lain, seperti aplikasi ponsel perangkat, akan mengganggu aktivitas aplikasi Anda.
  • Sistem akan mengakhiri dan membuat ulang aktivitas Anda.
  • Pengguna menempatkan aktivitas Anda di lingkungan windowing baru, seperti picture-in-picture (PIP) atau multi-aplikasi.

Secara khusus, sebaiknya pastikan aktivitas Anda berperilaku dengan benar sebagai respons terhadap peristiwa yang dijelaskan dalam Siklus proses aktivitas.

Panduan ini menjelaskan cara mengevaluasi kemampuan aplikasi Anda untuk mempertahankan integritas data dan pengalaman pengguna yang baik saat aktivitas aplikasi Anda bertransisi melalui status yang berbeda dalam siklus prosesnya.

Menguji aktivitas di Compose

Saat menguji aplikasi yang dibangun dengan Jetpack Compose, Anda biasanya menggunakan createAndroidComposeRule untuk meluncurkan aktivitas dan berinteraksi dengan komponen UI.

Namun, pengujian peristiwa tingkat perangkat, seperti perubahan konfigurasi atau aktivitas yang dimasukkan ke latar belakang atau dihentikan oleh sistem, mengharuskan Anda memanipulasi siklus proses aktivitas secara langsung. Untuk melakukannya, Anda menggunakan framework ActivityScenario yang mendasarinya.

Aturan pengujian Compose otomatis membungkus dan mengelola skenario ini untuk Anda. Di sepanjang panduan ini, Anda akan melihat pola berikut yang digunakan untuk menjembatani kesenjangan antara pengujian UI modern dan pengelolaan siklus proses standar:

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

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

    // ...
}

Mendorong status aktivitas

Salah satu aspek utama pengujian aktivitas aplikasi Anda melibatkan penempatan aktivitas aplikasi dalam status tertentu. Untuk menentukan bagian "tersebut" pada pengujian Anda, gunakan instance ActivityScenario, bagian dari library AndroidX Test. Dengan menggunakan class ini, Anda dapat menempatkan aktivitas pada status yang menyimulasikan peristiwa tingkat perangkat.

ActivityScenario adalah API lintas platform yang dapat Anda gunakan dalam pengujian unit lokal dan pengujian integrasi pada perangkat. Pada perangkat sungguhan atau virtual, ActivityScenario memberikan keamanan thread, menyinkronkan peristiwa antara thread instrumentasi pengujian dan thread dalam pengujian yang menjalankan aktivitas Anda.

API ini sangat cocok untuk mengevaluasi bagaimana perilaku aktivitas yang sedang diuji saat aktivitas tersebut diakhiri atau dibuat. Bagian ini menunjukkan kasus penggunaan paling umum yang terkait dengan API ini.

Membuat aktivitas

Untuk membuat aktivitas yang sedang diuji, tambahkan kode yang ditampilkan dalam cuplikan berikut:

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

Setelah membuat aktivitas, ActivityScenario mentransisikan aktivitas ke status RESUMED. Status ini menunjukkan bahwa aktivitas Anda sedang berjalan dan dapat dilihat oleh pengguna. Dalam status ini, Anda bebas berinteraksi dengan composable aktivitas Anda menggunakan Compose testing API.

Google merekomendasikan agar Anda memanggil close di aktivitas saat pengujian selesai. Tindakan ini membersihkan resource terkait dan meningkatkan stabilitas pengujian Anda. ActivityScenario mengimplementasikan Closeable, sehingga Anda dapat menerapkan ekstensi use agar aktivitas ditutup secara otomatis.

Atau, Anda dapat menggunakan createAndroidComposeRule untuk otomatis meluncurkan aktivitas sebelum setiap pengujian, menangani penguraian, dan memberi Anda akses ke metode pengujian UI Compose dan ActivityScenario yang mendasarinya. Contoh berikut menunjukkan cara menentukan aturan dan mendapatkan instance skenario dari aturan tersebut:

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

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

Mendorong aktivitas ke status baru

Untuk mendorong aktivitas ke status yang berbeda, seperti CREATED atau STARTED, panggil moveToState. Tindakan ini menyimulasikan situasi saat aktivitas Anda dihentikan atau dijeda, karena terhenti oleh aplikasi lain atau tindakan sistem.

Contoh penggunaan moveToState akan ditampilkan dalam cuplikan kode berikut:

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

Menentukan status aktivitas saat ini

Untuk menentukan status aktivitas saat ini yang sedang diuji, dapatkan nilai kolom state dalam objek ActivityScenario Anda. Sebaiknya periksa status aktivitas yang sedang diuji jika aktivitas tersebut mengalihkan ke aktivitas lain atau diakhiri dengan sendirinya, seperti yang ditunjukkan dalam cuplikan kode berikut:

@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
        }
    }
}

Membuat ulang aktivitas

Jika perangkat kekurangan resource, sistem mungkin akan mengakhiri aktivitas, yang mengharuskan aplikasi Anda membuat ulang aktivitas tersebut saat pengguna kembali ke aplikasi Anda. Untuk menyimulasikan kondisi ini, panggil recreate:

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

Class ActivityScenario mempertahankan status instance tersimpan aktivitas dan objek apa pun yang dianotasikan menggunakan @NonConfigurationInstance. Objek ini dimuat ke dalam instance baru aktivitas Anda yang sedang diuji.

Mengambil hasil aktivitas

Untuk mendapatkan kode hasil atau data yang terkait dengan aktivitas yang sudah selesai, dapatkan nilai kolom result dalam objek ActivityScenario Anda. Dengan menggunakan createAndroidComposeRule, Anda dapat dengan mudah memicu tindakan UI yang menyelesaikan aktivitas, seperti yang ditunjukkan dalam cuplikan kode berikut:

@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
    }
}

Memicu tindakan dalam aktivitas

Semua metode dalam ActivityScenario akan memblokir panggilan, sehingga API mengharuskan Anda untuk menjalankannya di thread instrumentasi.

Untuk memicu tindakan dalam aktivitas yang sedang diuji, gunakan API pengujian Compose untuk berinteraksi dengan composable Anda:

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

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

Namun, jika perlu memanggil metode pada aktivitas itu sendiri, Anda dapat melakukannya secara aman dengan menggunakan onActivity:

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

Referensi lainnya

Untuk mengetahui informasi selengkapnya tentang pengujian, lihat referensi tambahan berikut:

Dokumentasi