Menulis pengujian otomatis

1. Sebelum memulai

Codelab ini mengajarkan pengujian otomatis di Android, dan cara pengujian tersebut memungkinkan Anda menulis aplikasi yang skalabel dan kuat. Anda juga akan semakin memahami perbedaan antara logika UI dan logika bisnis, serta cara menguji keduanya. Terakhir, Anda akan mempelajari cara menulis dan menjalankan pengujian otomatis di Android Studio.

Prasyarat

Kemampuan untuk menulis aplikasi Android dengan fungsi dan composable.

Yang akan Anda pelajari

Pengujian otomatis di Android.
Alasan pentingnya pengujian otomatis.
Pengertian pengujian lokal dan tujuan penggunaannya.
Pengertian uji instrumentasi dan kegunaannya.
Cara menulis pengujian lokal untuk kode Android.
Cara menulis uji instrumentasi untuk aplikasi Android.
Cara menjalankan pengujian otomatis.

Yang akan Anda build

Pengujian lokal
Uji instrumentasi

Yang akan Anda butuhkan

Versi terbaru Android Studio
Kode solusi untuk aplikasi Tip Time

2. Mendapatkan kode awal

Mendownload kode:

Atau, Anda dapat membuat clone repositori GitHub untuk kode tersebut:

$ git clone https://github.com/google-developer-training/basic-android-kotlin-compose-training-tip-calculator.git
$ cd basic-android-kotlin-compose-training-tip-calculator
$ git checkout main

3. Pengujian otomatis

Pengujian, dalam konteks software, adalah metode terstruktur dalam memeriksa software untuk memastikan software berfungsi seperti yang diharapkan. Pengujian otomatis merupakan kode untuk memeriksa sistem yang memastikan bahwa kode lain yang Anda tulis berfungsi dengan benar.

Pengujian adalah bagian penting dari proses pengembangan aplikasi. Dengan menjalankan pengujian terhadap aplikasi secara konsisten, Anda dapat memverifikasi ketepatan, perilaku fungsional, dan kegunaan aplikasi sebelum merilisnya ke publik.

Pengujian juga memungkinkan Anda untuk terus memeriksa kode yang ada saat perubahan diterapkan.

Meskipun pengujian manual hampir selalu ada, pengujian di Android sering kali dilakukan secara otomatis. Di sepanjang kursus ini, Anda akan berfokus pada pengujian otomatis untuk menguji kode aplikasi dan persyaratan fungsional aplikasi itu sendiri. Dalam codelab ini, Anda akan mempelajari dasar-dasar pengujian di Android. Dalam codelab berikutnya, Anda akan mempelajari praktik lanjutan pengujian aplikasi Android.

Ketika mulai terbiasa dengan pengembangan Android dan pengujian aplikasi Android, Anda juga harus membiasakan menulis pengujian serta kode aplikasi. Membuat pengujian setiap kali Anda membuat fitur baru di aplikasi nantinya akan mengurangi beban kerja Anda seiring dengan perkembangan aplikasi Anda. Selain itu, pengujian ini juga merupakan cara yang praktis bagi Anda untuk memastikan aplikasi berfungsi dengan baik tanpa menghabiskan terlalu banyak waktu untuk menguji aplikasi secara manual.

Pengujian otomatis adalah bagian penting dari semua pengembangan software, begitu pula dengan pengembangan Android. Oleh karena itu, sekarang adalah waktu yang paling tepat untuk memperkenalkannya.

Alasan pentingnya pengujian otomatis

Pada awalnya, Anda mungkin akan merasa tidak memerlukan pengujian di aplikasi, tetapi pengujian diperlukan di semua ukuran dan kompleksitas aplikasi.

Untuk mengembangkan codebase, Anda perlu menguji fungsi yang ada saat menambahkan bagian baru, yang hanya mungkin jika Anda memiliki pengujian yang sudah ada. Seiring perkembangan aplikasi Anda, pengujian manual akan memerlukan lebih banyak upaya daripada pengujian otomatis. Selain itu, setelah Anda mulai mengerjakan aplikasi dalam tahap produksi, pengujian menjadi sangat penting jika jumlah pengguna aplikasi Anda sangat banyak. Misalnya, Anda harus memperhitungkan berbagai jenis perangkat yang menjalankan berbagai versi Android.

Pada akhirnya, Anda akan mencapai suatu titik ketika pengujian otomatis dapat menjalankan sebagian besar skenario penggunaan dalam waktu yang jauh lebih cepat daripada pengujian manual. Saat menjalankan pengujian sebelum merilis kode baru, Anda dapat membuat perubahan pada kode yang sudah ada sehingga dapat menghindari rilis aplikasi yang perilakunya tidak diharapkan.

Ingatlah bahwa pengujian otomatis adalah pengujian yang dijalankan melalui software, bukan pengujian manual, yang dilakukan oleh orang yang berinteraksi langsung dengan perangkat. Pengujian otomatis dan pengujian manual berperan penting dalam memastikan pengguna produk Anda mendapatkan pengalaman yang menyenangkan. Namun, pengujian otomatis bisa lebih akurat dan dapat mengoptimalkan produktivitas tim Anda karena tidak mengharuskan seseorang untuk menjalankannya dan dapat dijalankan lebih cepat daripada pengujian manual.

Jenis pengujian otomatis

Pengujian lokal

Pengujian lokal adalah jenis pengujian otomatis yang langsung menguji potongan kecil kode untuk memastikannya berfungsi dengan benar. Dengan pengujian lokal, Anda bisa menguji fungsi, class, dan properti. Pengujian lokal dijalankan di workstation Anda, yang berarti pengujian tersebut berjalan di lingkungan pengembangan tanpa memerlukan perangkat atau emulator. Dengan kata lain, pengujian lokal berjalan di komputer Anda. Dalam hal resource komputer, pengujian juga memiliki overhead yang sangat rendah sehingga dapat berjalan cepat bahkan dengan resource yang terbatas. Android Studio siap menjalankan pengujian lokal secara otomatis.

Pengujian instrumentasi

Untuk pengembangan Android, uji instrumentasi adalah pengujian UI. Dengan uji instrumentasi, Anda dapat menguji bagian aplikasi yang bergantung pada Android API, serta API dan layanan platformnya.

Tidak seperti pengujian lokal, pengujian UI meluncurkan aplikasi atau bagian dari aplikasi, menyimulasikan interaksi pengguna, dan memeriksa apakah aplikasi memberikan reaksi yang sesuai. Sepanjang kursus ini, pengujian UI dijalankan pada perangkat fisik atau emulator.

Saat Anda menjalankan uji instrumentasi di Android, kode pengujian tersebut memang dibuat dalam Paket Aplikasi Android (APK) sendiri, seperti aplikasi Android reguler. APK adalah file terkompresi yang berisi semua kode dan file yang diperlukan untuk menjalankan aplikasi di perangkat atau emulator. APK pengujian tersebut diinstal di perangkat atau emulator bersama dengan APK aplikasi reguler. APK pengujian kemudian menguji APK aplikasi.

4. Menulis pengujian lokal

Menyiapkan kode aplikasi

Pengujian lokal secara langsung menguji metode dari kode aplikasi, sehingga metode yang akan diuji harus tersedia untuk class dan metode pengujian. Pengujian lokal dalam cuplikan kode berikut memastikan bahwa metode calculateTip() berfungsi dengan benar, tetapi metode calculateTip() saat ini bersifat private sehingga tidak dapat diakses dari pengujian. Hapus pengelompokkan private lalu jadikan internal:

MainActivity.kt

internal fun calculateTip(amount: Double, tipPercent: Double = 15.0, roundUp: Boolean): String {
    var tip = tipPercent / 100 * amount
    if (roundUp) {
        tip = kotlin.math.ceil(tip)
    }
    return NumberFormat.getCurrencyInstance().format(tip)
}

Pada file MainActivity.kt di baris sebelum metode calculateTip(), tambahkan anotasi @VisibleForTesting:

@VisibleForTesting
internal fun calculateTip(amount: Double, tipPercent: Double = 15.0, roundUp: Boolean): String {
    var tip = tipPercent / 100 * amount
    if (roundUp) {
        tip = kotlin.math.ceil(tip)
    }
    return NumberFormat.getCurrencyInstance().format(tip)
}

Hal ini menjadikan metode bersifat publik, tetapi menunjukkan kepada orang lain bahwa metode tersebut hanya bersifat publik untuk tujuan pengujian.

Membuat direktori pengujian

Dalam project Android, direktori test adalah tempat pengujian lokal ditulis.

Membuat direktori pengujian:

Di tab Project, ubah tampilan ke Project.

Klik kanan direktori src.

Pilih New > Directory

Di jendela New Directory, pilih test/java.

Ketik tombol return atau enter di keyboard Anda. Direktori test sekarang dapat dilihat di tab Project.

Direktori test memerlukan struktur paket yang sama dengan direktori main tempat kode aplikasi Anda berada. Dengan kata lain, sama seperti kode aplikasi yang ditulis dalam paket main > java > com > example > tiptime, pengujian lokal Anda akan ditulis dalam test > java > com > example > tiptime.

Buat struktur paket ini di direktori test:

Klik kanan direktori test/java, lalu pilih New > Package.

Di jendela New Package, ketik com.example.tiptime.

Membuat class pengujian

Setelah paket pengujian siap, saatnya menulis beberapa pengujian. Mulai dengan membuat class pengujian.

Di tab Project, klik app > src > test, lalu klik tanda panah peluas di samping direktori test.
Klik kanan direktori com.example.tiptime, lalu pilih New > Kotlin Class/File.

Masukkan TipCalculatorTests sebagai nama class.

Menulis pengujian

Seperti yang telah disebutkan sebelumnya, pengujian lokal digunakan untuk menguji potongan kecil kode dalam aplikasi. Fungsi utama Aplikasi Tip Time adalah menghitung tip, sehingga harus ada pengujian lokal yang memastikan bahwa logika penghitungan tip berfungsi dengan benar.

Untuk melakukannya, Anda harus langsung memanggil fungsi calculateTip() seperti yang dilakukan di kode aplikasi. Selanjutnya, pastikan nilai yang ditampilkan oleh fungsi cocok dengan nilai yang diharapkan berdasarkan nilai yang Anda teruskan ke fungsi.

Ada beberapa hal yang perlu Anda ketahui tentang penulisan pengujian otomatis. Daftar konsep berikut berlaku untuk uji lokal dan instrumentasi. Konsep ini mungkin tampak abstrak di awal, tetapi Anda akan semakin memahaminya pada akhir codelab ini.

Tulis pengujian otomatis dalam bentuk metode.
Anotasi metode dengan anotasi @Test. Hal ini memungkinkan compiler mengetahui bahwa metode tersebut adalah metode pengujian dan menjalankan metode yang sesuai.

Pastikan nama menjelaskan secara jelas tujuan pengujian dan hasil yang diharapkan.
Metode pengujian tidak menggunakan logika seperti metode aplikasi biasa. Cara implementasinya tidak menjadi masalah. Output yang diharapkan diperiksa secara ketat untuk input yang diberikan. Artinya, metode pengujian hanya mengeksekusi serangkaian petunjuk untuk menegaskan bahwa UI atau logika aplikasi berfungsi dengan benar. Anda belum perlu memahami maksudnya karena Anda akan melihat tampilannya nanti, tetapi ingat bahwa kode pengujian mungkin terlihat sangat berbeda dari kode aplikasi yang biasa Anda gunakan.
Pengujian biasanya diakhiri dengan pernyataan, yang digunakan untuk memastikan bahwa kondisi tertentu terpenuhi. Pernyataan muncul dalam bentuk panggilan metode yang memiliki assert dalam namanya. Misalnya: pernyataan assertTrue() biasanya digunakan dalam pengujian Android. Pernyataan digunakan dalam sebagian besar pengujian, tetapi jarang digunakan dalam kode aplikasi yang sebenarnya.

Menulis pengujian:

Buat metode untuk menguji penghitungan tip sebesar 20% untuk jumlah tagihan $10. Hasil penghitungan yang diharapkan adalah $2.

import org.junit.Test

class TipCalculatorTests {

   @Test
   fun calculateTip_20PercentNoRoundup() {

   }
}

Anda mungkin ingat bahwa metode calculateTip() dari file MainActivity.kt di kode aplikasi memerlukan tiga parameter. Jumlah tagihan, persentase tip, dan tanda untuk membulatkan hasil atau tidak.

fun calculateTip(amount: Double, tipPercent: Double, roundUp: Boolean)

Jika sudah waktunya untuk memanggil metode ini dari pengujian, parameter ini harus diteruskan seperti saat metode dipanggil dalam kode aplikasi.

Pada metode calculateTip_20PercentNoRoundup(), buat dua variabel konstan: variabel amount ditetapkan ke nilai 10.00 dan variabel tipPercent ditetapkan ke nilai 20.00.

val amount = 10.00
val tipPercent = 20.00

Dalam kode aplikasi, dalam file MainActivity.kt, amati kode berikut, jumlah tip diformat berdasarkan lokalitas perangkat.

MainActivity.kt

...
NumberFormat.getCurrencyInstance().format(tip)
...

Format yang sama harus digunakan saat memverifikasi jumlah tip yang diharapkan dalam pengujian.

Buat variabel expectedTip yang ditetapkan ke NumberFormat.getCurrencyInstance().format(2).

Variabel expectedTip dibandingkan dengan hasil metode calculateTip() nanti. Ini adalah cara pengujian memastikan bahwa metode tersebut berfungsi dengan benar. Pada langkah terakhir, Anda menetapkan variabel amount ke nilai 10.00 dan variabel tipPercent ke nilai 20.00. Dua puluh persen dari 10 adalah 2 sehingga variabel expectedTip ditetapkan ke mata uang berformat dengan nilai 2. Ingat, metode calculateTip() menampilkan nilai String yang diformat.

Panggil metode calculateTip() dengan variabel amount dan tipPercent, lalu teruskan argumen false untuk pembulatan.

Anda tidak perlu memperhitungkan pembulatan dalam kasus ini karena hasil yang diharapkan tidak memperhitungkan pembulatan ke atas.

Simpan hasil panggilan metode dalam variabel actualTip yang konstan.

Hingga saat ini, menulis pengujian ini tidak jauh berbeda dengan menulis metode biasa di kode aplikasi. Namun, setelah memiliki nilai yang ditampilkan dari metode yang ingin diuji, Anda harus menentukan apakah nilai tersebut merupakan nilai yang benar dengan pernyataan.

Membuat pernyataan biasanya merupakan tujuan akhir dari pengujian otomatis dan ini bukanlah sesuatu yang umum digunakan dalam kode aplikasi. Dalam hal ini, Anda ingin memastikan bahwa variabel actualTip sama dengan variabel expectedTip. Metode assertEquals() dari library JUnit dapat digunakan untuk ini.

Metode assertEquals() menggunakan dua parameter—nilai yang diharapkan dan nilai sebenarnya. Jika nilai tersebut sama, pernyataan dan pengujian lulus. Jika tidak sama, pernyataan dan pengujian akan gagal.

Panggil metode assertEquals() ini, lalu masukkan variabel expectedTip dan actualTip sebagai parameter:

import org.junit.Assert.assertEquals
import org.junit.Test
import java.text.NumberFormat

class TipCalculatorTests {

    @Test
    fun calculateTip_20PercentNoRoundup() {
        val amount = 10.00
        val tipPercent = 20.00
        val expectedTip = NumberFormat.getCurrencyInstance().format(2)
        val actualTip = calculateTip(amount = amount, tipPercent = tipPercent, false)
        assertEquals(expectedTip, actualTip)
    }
}

Menjalankan pengujian

Sekarang saatnya menjalankan pengujian.

Anda mungkin telah melihat tanda panah yang muncul di gutter bersama nomor baris nama kelas dan fungsi pengujian Anda. Anda dapat mengklik panah ini untuk menjalankan pengujian. Jika mengklik panah di samping metode, Anda hanya akan menjalankan metode pengujian tersebut. Jika memiliki beberapa metode pengujian di class, Anda dapat mengklik panah di samping class untuk menjalankan semua metode pengujian di class tersebut.

Jalankan pengujian:

Klik tanda panah di samping deklarasi class, lalu klik Run 'TipCalculatorTests'.

Anda akan melihat berikut ini:

Di bagian bawah panel Run, Anda akan melihat beberapa output.

5. Menulis uji instrumentasi

Membuat direktori instrumentasi

Direktori instrumentasi dibuat dengan cara yang serupa dengan direktori pengujian lokal.

Klik kanan direktori src, lalu pilih New > Directory.

Di jendela New Directory, pilih androidTest/java.

Ketik tombol return atau enter di keyboard Anda. Direktori androidTest sekarang dapat dilihat di tab Project.

Sama seperti direktori main dan test yang memiliki struktur paket yang sama, direktori androidTest harus berisi struktur paket yang sama.

Klik kanan folder androidTest/java, lalu pilih New > Package.
Di jendela New Package, ketik com.example.tiptime.
Ketik tombol return atau enter di keyboard Anda. Struktur paket yang lengkap untuk direktori androidTest kini dapat dilihat di tab Project.

Membuat class pengujian

Dalam project Android, direktori uji instrumentasi ditetapkan sebagai direktori androidTest.

Untuk membuat uji instrumentasi, Anda harus mengulangi proses yang sama dengan yang digunakan untuk membuat pengujian lokal, tetapi kali ini, buat proses dalam direktori androidTest.

Buat class pengujian:

Buka direktori androidTest di panel project.
Klik panah peluas di samping setiap direktori hingga Anda melihat direktori tiptime.

Klik kanan direktori tiptime, lalu pilih New > Kotlin Class/File.
Masukkan TipUITests sebagai nama class.

Menulis pengujian

Kode uji instrumentasi sangat berbeda dari kode pengujian lokal.

Uji instrumentasi menguji instance aplikasi yang sebenarnya dan UI-nya, sehingga konten UI harus ditetapkan, mirip dengan cara konten ditetapkan di metode onCreate() file MainActivity.kt saat Anda menulis kode untuk aplikasi Tip Time. Anda harus melakukan hal ini sebelum menulis semua uji instrumentasi untuk aplikasi yang di-build dengan Compose.

Dalam kasus pengujian aplikasi Tip Time, Anda melanjutkan menulis petunjuk untuk berinteraksi dengan komponen UI sehingga proses penghitungan tip diuji melalui UI. Konsep uji instrumentasi di awal mungkin tampak abstrak, tetapi jangan khawatir. Prosesnya tercakup dalam langkah-langkah berikut.

Menulis pengujian:

Buat variabel composeTestRule yang ditetapkan ke hasil metode createComposeRule() dan anotasikan dengan anotasi Rule:

import androidx.compose.ui.test.junit4.createComposeRule
import org.junit.Rule

class TipUITests {

   @get:Rule
   val composeTestRule = createComposeRule()
}

Buat metode calculate_20_percent_tip() dan anotasikan dengan anotasi @Test:

import org.junit.Test

@Test
fun calculate_20_percent_tip() {
}

Compiler mengetahui bahwa metode yang dianotasi dengan anotasi @Test dalam direktori androidTest merujuk pada uji instrumentasi dan metode yang dianotasi dengan anotasi @Test dalam direktori test mengacu pada pengujian lokal.

Dalam isi fungsi, panggil fungsi composeTestRule.setContent(). Ini akan menetapkan konten UI composeTestRule.
Dalam isi lambda fungsi, panggil fungsi TipTimeTheme() dengan isi lambda yang memanggil fungsi TipTimeLayout().

import com.example.tiptime.ui.theme.TipTimeTheme

@Test
fun calculate_20_percent_tip() {
    composeTestRule.setContent {
        TipTimeTheme {
           TipTimeLayout()
        }
    }
}

Setelah selesai, kode akan terlihat mirip dengan kode yang ditulis untuk menetapkan konten dalam metode onCreate() di file MainActivity.kt. Setelah konten UI disiapkan, Anda dapat menulis petunjuk untuk berinteraksi dengan komponen UI aplikasi. Dalam aplikasi ini, Anda perlu menguji apakah aplikasi menampilkan nilai tip yang benar berdasarkan jumlah tagihan dan input persentase tip.

Komponen UI dapat diakses sebagai node melalui composeTestRule. Cara umum untuk melakukannya adalah dengan mengakses node yang berisi teks tertentu dengan metode onNodeWithText(). Gunakan metode onNodeWithText() untuk mengakses composable TextField untuk jumlah tagihan:

import androidx.compose.ui.test.onNodeWithText

@Test
fun calculate_20_percent_tip() {
    composeTestRule.setContent {
        TipTimeTheme {
            TipTimeLayout()
        }
    }
    composeTestRule.onNodeWithText("Bill Amount")
}

Selanjutnya, Anda dapat memanggil metode performTextInput() dan meneruskan teks yang ingin dimasukkan untuk mengisi composable TextField.

Isi TextField untuk jumlah tagihan dengan nilai 10:

import androidx.compose.ui.test.performTextInput

@Test
fun calculate_20_percent_tip() {
    composeTestRule.setContent {
        TipTimeTheme {
            TipTimeLayout()
        }
    }
    composeTestRule.onNodeWithText("Bill Amount")
.performTextInput("10")
}

Gunakan pendekatan yang sama untuk mengisi OutlinedTextField untuk persentase tip dengan nilai 20:

@Test
fun calculate_20_percent_tip() {
    composeTestRule.setContent {
        TipTimeTheme {
            TipTimeLayout()
        }
    }
   composeTestRule.onNodeWithText("Bill Amount")
.performTextInput("10")
   composeTestRule.onNodeWithText("Tip Percentage").performTextInput("20")
}

Setelah semua composable TextField diisi, tip akan ditampilkan dalam composable Text di bagian bawah layar di aplikasi.

Setelah Anda menginstruksikan pengujian untuk mengisi composable TextField ini, Anda harus memastikan bahwa composable Text menampilkan tip yang benar dengan pernyataan.

Dalam uji instrumentasi dengan Compose, pernyataan dapat dipanggil langsung pada komponen UI. Ada sejumlah pernyataan yang tersedia, tetapi dalam hal ini Anda ingin menggunakan metode assertExists(). Composable Text yang menampilkan jumlah tip diharapkan untuk menampilkan: Tip Amount: $2.00.

Buat pernyataan bahwa node dengan teks tersebut ada:

import java.text.NumberFormat

@Test
fun calculate_20_percent_tip() {
    composeTestRule.setContent {
        TipTimeTheme {
            Surface (modifier = Modifier.fillMaxSize()){
                TipTimeLayout()
            }
        }
    }
   composeTestRule.onNodeWithText("Bill Amount")
      .performTextInput("10")
   composeTestRule.onNodeWithText("Tip Percentage").performTextInput("20")
   val expectedTip = NumberFormat.getCurrencyInstance().format(2)
   composeTestRule.onNodeWithText("Tip Amount: $expectedTip").assertExists(
      "No node with this text was found."
   )
}

Menjalankan pengujian

Proses menjalankan uji instrumentasi sama dengan proses untuk pengujian lokal. Anda mengklik panah di gutter di samping setiap deklarasi untuk menjalankan pengujian satu per satu atau seluruh class pengujian.

Klik tanda panah di samping deklarasi class. Anda dapat melihat pengujian berjalan pada perangkat atau emulator. Saat pengujian selesai, Anda akan melihat output seperti yang terlihat dalam gambar ini:

6. Mendapatkan kode solusi

Atau, Anda dapat membuat clone repositori GitHub untuk kode tersebut:

$ git clone https://github.com/google-developer-training/basic-android-kotlin-compose-training-tip-calculator.git
$ cd basic-android-kotlin-compose-training-tip-calculator
$ git checkout test_solution

7. Kesimpulan

Selamat! Anda telah menulis pengujian otomatis pertama di Android. Pengujian merupakan komponen penting dari kendali mutu software. Saat terus mem-build aplikasi Android, pastikan Anda menulis pengujian bersama fitur aplikasi untuk memastikan aplikasi Anda berfungsi dengan benar selama proses pengembangan.

Ringkasan

Pengertian pengujian otomatis.
Alasan pentingnya pengujian otomatis.
Perbedaan antara pengujian lokal dan uji instrumentasi
Praktik terbaik dasar untuk menulis pengujian otomatis.
Tempat menemukan dan menempatkan class pengujian lokal dan uji instrumentasi dalam project Android.
Cara membuat metode pengujian.
Cara membuat class pengujian lokal dan uji instrumentasi.
Cara membuat pernyataan dalam pengujian lokal dan uji instrumentasi.
Cara menggunakan aturan pengujian.
Cara menggunakan ComposeTestRule untuk meluncurkan aplikasi dengan pengujian.
Cara berinteraksi dengan composable dalam uji instrumentasi.
Cara menjalankan pengujian.