Coba tangkap dalam tes JUnit

Karena Exception merupakan pengecualian yang dicentang, Anda juga:

• Harus menangkap pengecualian dalam pernyataan try...catch, atau
• Deklarasikan pengecualian yang akan diberikan pada metode itu sendiri.

Apa yang Anda miliki di sana berfungsi dengan baik, tetapi preferensi pribadi saya adalah menyatakan pengecualian yang akan diberikan. Dengan cara ini, jika pengecualian yang tidak saya harapkan muncul saat pengujian dijalankan, pengujian akan gagal.

@Test
public void someTest() throws Exception {
    // dodgy code here
}

Jika kami perlu melihat apakah pengecualian tertentu muncul, maka Anda memiliki opsi untuk menggunakan @Rule atau menambahkan nilai ke anotasi @Test secara langsung.

@Test(expected = FileNotFoundException.class)
public void someTest() throws Exception {
    // dodgy code here
}

Di JUnit 5, Anda dapat memanfaatkan Assertions.assertThrows untuk mencapai hal yang sama. Saya kurang paham dengan ini secara keseluruhan karena ini belum GA pada saat pengeditan, tetapi tampaknya menerima Executable yang berasal dari JUnit 5.

@Test
public void someTest() {
    assertThrows(FileNotFoundException.class, () ->
         { dodgyService.breakableMethod() };
}

@Test
public void someTest() {
   try {
     someMethod();
   }
   catch (Exception e) {
     Assert.fail("Exception " + e);
   }
}

Adalah apa yang dapat Anda lakukan, jika pengecualian tidak terjadi. Alternatifnya adalah dengan melemparkan pengecualian pada tanda tangan seperti ini:

@Test
public void someTest() throws Exception {
     someMethod();
}

Perbedaannya adalah, dalam satu kasus pengujian akan gagal dengan pengecualian pernyataan dan dalam kasus lain pengujian akan gagal karena pengujian gagal. (seperti di suatu tempat di kode Anda, Anda mendapatkan NPE dan tes akan terjadi karena itu)

Alasan Anda harus melakukan ini adalah karena Exception adalah pengecualian yang dicentang. Lihat Pengecualian yang dicentang versus tidak dicentang

@Test(expected=Exception.class) adalah untuk pengujian, yang ingin menguji apakah pengecualian akan dilempar.

@Test(expected=ArrayIndexOutOfBounds.class)
public void testIndex() {
   int[] array = new int[0];
   int var = array[0]; //exception will be thrown here, but test will be green, because we expect this exception

}

Jangan menangkap pengecualian aplikasi Anda dalam kode pengujian Anda. Sebaliknya, nyatakan untuk dilempar ke atas.

Karena, ketika TestRunner JUnit menemukan pengecualian yang dilemparkan, maka secara otomatis akan mencatatnya sebagai error untuk testcase.

Hanya jika Anda testcase mengharapkan metode tersebut menghasilkan Exception Anda harus menggunakan @Test(expected=Exception.class) atau menangkap pengecualian.

Dalam kasus lain, lempar saja ke atas dengan,

public void someTest() throws Exception {

Anda dapat menambahkan pengecualian pada tanda tangan metode pengujian. Kemudian, jika Anda menguji apakah pengecualian dilempar, Anda harus menggunakan @Test(expected=Exception.class). Dalam kasus pengujian di mana pengecualian tidak dilempar, pengujian akan berhasil.

@Test
public void testCaseWhereExceptionWontBeThrown() throws Exception {
    someMethod(); //Test pass
}

@Test(expected = Exception.class)
public void testCaseWhereExceptionWillBeThrown() throws Exception {
    someMethod(); //Test pass
}

Ada dua aturan utama tentang cara memproses pengecualian di penguji Junit:

1. Jika pengecualian berasal dari kode yang diuji:

   • If it was expected, declare it in the expected attribute of the Test annotation. Or, if further checks should be done on the exception object itself, catch it and ignore it. (In this case, there must be also a call to Assert.fail at the end of the try block, to indicate that the expected exception was not produced).
   • Jika tidak diharapkan, tangkap dan jalankan Assert.fail. (Panggilan sebelumnya ke Exception.printStackTrace juga berguna).

2. Jika pengecualian tidak berasal dari kode yang diuji atau tidak menarik untuk diuji (misalnya, sebagian besar IOException dihasilkan di tingkat jaringan, bahkan sebelum pengujian dapat diselesaikan), lemparkan kembali pengecualian tersebut pada klausa throws.

Mengapa Anda harus mengharapkan pengecualian pada penguji? Ingatkan: Anda harus mengkodekan satu metode pengujian untuk setiap kemungkinan hasil pada kode yang diuji (untuk mencapai cakupan kode yang tinggi): Dalam kasus Anda, satu metode harus berhasil kembali, dan setidaknya satu metode lainnya yang harus menghasilkan Pengecualian.

Tiga poin tentang JUnit:

• Pengujian harus tepat, lulus atau gagal dengan jelas hanya berdasarkan pada cara input pengujian disiapkan.

• Pengujian harus melaporkan kegagalannya kembali ke dalam kerangka kerja.

• Pengujian tidak boleh bergantung pada pembacaan keluarannya.

Contoh Anda gagal dalam ketiga hal tersebut. Jika pengecualian dilempar atau tidak, pengujian tetap lolos. Jika pengecualian diberikan, JUnit tidak akan pernah mengetahuinya dan tidak dapat memasukkannya ke dalam hasil pengujian. Satu-satunya cara untuk mengetahui ada yang tidak beres adalah dengan membaca apa yang ditulis tes ke stdout, yang membuat kesalahan terlalu mudah untuk diabaikan. Ini bukan cara yang berguna untuk menulis tes.

JUnit dirancang untuk mempermudah melakukan hal yang benar dan memberikan masukan yang berguna bagi pengembang. Jika pengecualian dilempar dari metode pengujian, pengecualian tersebut akan ditangkap oleh kerangka kerja. Jika pengujian dianotasi dengan pengecualian yang menunjukkan bahwa pengecualian memang diharapkan, maka kerangka kerja akan menandai pengujian tersebut sebagai lulus. Jika tidak, kerangka kerja akan gagal dalam pengujian dan mencatat pelacakan tumpukan untuk pelaporan. Kerangka kerja tersebut melaporkan pernyataan apa yang gagal dan pengecualian tak terduga apa yang terjadi sehingga semua orang mengetahui apakah pengujian berhasil atau tidak.

Jika Anda mengharapkan pengujian berhasil tanpa mengeluarkan pengecualian, maka jika ada sesuatu dalam pengujian yang dapat memunculkan pengecualian yang dicentang, tambahkan throws Exception ke tanda tangan metode pengujian. Menambahkan throws ke tanda tangan tidak berarti metode harus membuang apa pun, itu hanya membiarkan pengecualian apa pun yang terjadi dilempar sehingga kerangka pengujian dapat menangkapnya.

Satu-satunya contoh di mana Anda benar-benar menangkap pengecualian dalam pengujian adalah saat Anda ingin menguji pernyataan tentang pengecualian tersebut; misalnya, Anda dapat menguji apakah pesan pada pengecualian sesuai dengan yang Anda harapkan, atau apakah pengecualian tersebut memiliki penyebab tertentu. Dalam hal ini Anda akan menambahkan Assert.fail() di akhir blok percobaan sehingga tidak adanya pengecualian akan menyebabkan pengujian gagal.

Bukan adanya blok coba-tangkap yang buruk, yang buruk adalah tidak adanya apa pun yang akan menyebabkan pengujian gagal.

Saat Anda menulis tes pada awalnya, buatlah tes itu gagal. Dengan begitu Anda membuktikan pada diri sendiri bahwa Anda mengetahui apa yang dilakukan tes tersebut, dan Anda memastikan bahwa, ketika ada kegagalan, Anda akan disadarkan.

Pengecualian macam apa itu? Apakah itu

1. pengecualian dari melakukan sesuatu seperti menggunakan aliran yang tidak akan terjadi dalam pengujian unit Anda atau
2. pengecualian yang bisa terjadi karena beberapa masukan yang buruk?

Jika 1. Saya hanya akan meletakkannya di tingkat tanda tangan metode karena try-catch tidak memiliki tujuan nyata selain upacara.

@Test
public void testFoo() throws Exception {
    // ...
}

Jika 2. itu menjadi sedikit lebih rumit. Anda perlu bertanya pada diri sendiri apa yang seharusnya terjadi jika Pengecualian dilempar. Haruskah ujiannya gagal? Apakah itu diharapkan? Apakah itu tidak relevan? Contoh di bawah ini tentang cara menangani semua ini. HATI-HATI: Saya hanya menggunakan Exception karena Anda menggunakannya. Saya berharap hal ini tidak terjadi karena jika ada pengecualian lainnya yang mungkin terjadi selain yang diharapkan maka hal ini akan sangat tidak menguntungkan. Jika memungkinkan jangan gunakan Exception, gunakan yang lebih spesifik (pada kode dan junit).

// The below code assumes you've imported the org.junit.Assert class.

@Test
public void thisShouldFailIfExceptionCaught() {
    //Given...
    try {
        // When...
    } catch (Exception e) {
        Assert.fail();
    }
    // Then...
}

@Test
public void thisShouldPassOnlyIfTheExceptionIsCaught() {
    //Given...
    try {
        // When...
        Assert.fail();
    } catch (Exception expected) {}
    // No "then" needed, the fact that it didn't fail is enough.
}

@Test
public void irrelevantExceptionThatCouldBeThrown() {
    //Given...
    try {
        // When...
    } catch (Exception e) {}
    // Then...
}