Kualitas Kode dalam pengujian unit?

Saat menulis tes unit, apakah ada baiknya menghabiskan waktu ekstra untuk membuat kode memiliki kualitas dan keterbacaan yang baik?

Saat menulis tes saya sering melanggar Hukum Demeter , untuk penulisan yang lebih cepat dan untuk menghindari menggunakan begitu banyak variabel. Secara teknis, tes unit tidak digunakan kembali secara langsung - mereka terikat dengan kode secara ketat sehingga saya tidak melihat alasan untuk menghabiskan banyak waktu untuk tes tersebut; mereka hanya perlu fungsional.

Anda pasti harus melakukan hal yang sama jika tidak lebih baik merawat unit test Anda daripada kode produksi Anda dalam hal kualitas dan keterbacaan. Tes unit sering merupakan hal pertama yang Anda lihat ketika mencoba memahami apa yang dilakukan oleh beberapa kode, dan pembaca harus dengan cepat memahami apa yang dipertaruhkan ketika melihat tes. Unit test juga cenderung banyak berubah dan akan banyak pecah jika desain mereka tidak kuat, yang mana membatalkan manfaat memiliki tes.

Pelanggaran Hukum Demeter jelas merupakan masalah dalam tes unit Anda karena alasan itu dan juga 2 orang lain yang muncul di benak saya:

• Jika tes Anda melanggar Hukum Demeter di bagian Atur atau Bertindak mereka , itu mungkin pertanda bahwa kode produksi Anda juga melakukannya, karena tes unit Anda hanyalah konsumen kode Anda dan mungkin akan memanggil dan mengoperasikan kelas yang diuji di dalam yang sama. cara yang dilakukan kode produksi lainnya.

• Jika tes Anda melanggar Hukum Demeter di bagian Tegasnya (yaitu Anda memverifikasi nilai sesuatu yang bersarang dalam grafik dependensi objek yang diuji), mungkin itu benar-benar tes integrasi daripada tes unit. Dengan kata lain, jika dalam TestA Anda menyatakan bahwa ABCD sama dengan sesuatu, mungkin Anda benar-benar mencoba menguji D dan A daripada hanya A.

Ngomong-ngomong, saat Anda mengatakannya

Saya sering melanggar Hukum Demeter, untuk menulis lebih cepat dan tidak menggunakan banyak variabel.

Anda harus menyadari tulisan itu

var grab = myDependency.Grab;
var something = grab.Something;
var very = something.Very;

very.Deep();

sebenarnya tidak lebih baik daripada Demeter bijaksana

myDependency.Grab.Something.Very.Deep();

jika itu yang Anda maksud.

Sangat berharga menghabiskan waktu menulis kode berkualitas baik untuk unit test:

• Mereka akan membutuhkan pemeliharaan seperti kode lainnya.
• Tes unit adalah salah satu sumber dokumentasi terbaik untuk sistem Anda, dan bisa dibilang bentuk yang paling dapat diandalkan. Mereka harus benar-benar menunjukkan:
  • Maksud: "apa perilaku yang diharapkan?".
  • Penggunaan: "bagaimana saya bisa menggunakan API ini?"
• Mereka akan membutuhkan debugging seperti kode lainnya.

Satu faktor yang mendukung pendekatan ad-hoc sedikit lebih adalah bahwa tes unit Anda tidak akan pernah menjadi API publik sehingga Anda tidak perlu khawatir tentang apa antarmuka / dll. Anda mengekspos.

Ya itu penting. Ada beberapa alasan mengapa unit test harus diadakan dengan standar yang sebanding dengan kode lainnya:

• Setiap tes unit juga berfungsi sebagai dokumentasi untuk peserta tes. Ketika tes bersifat komprehensif dan mencakup sebanyak mungkin kasus tepi dan kondisi kesalahan, mereka seringkali dapat menggantikan dokumentasi komentar dari suatu kelas atau fungsi. Mereka juga dapat berfungsi sebagai titik awal bagi orang-orang yang baru ke basis kode.

• Tes unit juga bisa buggy. Dan kesalahan lebih terlihat ketika kode ditulis dengan baik.

• Jika, karena alasan tertentu, nanti Anda perlu memisahkan modul, Anda mungkin perlu membagi tes unitnya juga. Ini lebih mudah jika tes ditulis sedemikian rupa sehingga memiliki ketergantungan yang mudah dilihat.

Yang mengatakan, selalu ada pertanyaan tentang kepraktisan. Bergantung pada bahasa dan sifat kode Anda, mungkin sulit untuk menulis tes unit "bersih" tanpa menghabiskan lebih banyak waktu pada tes daripada pada kode yang seharusnya mereka uji. Dalam hal ini, saya biasanya kembali menguji hal-hal yang mudah, cepat dan fungsionalitas paling kritis, tanpa terlalu mengkhawatirkan cakupan lengkap. Setiap kali bug muncul di kemudian hari, saya menulis tes untuk itu dan memeriksa apakah saya bisa memperbaiki tes baru dan yang sudah ada untuk membuatnya lebih baik.

jika Anda tidak dapat membaca unittest dan mencari tahu apa yang diuji di lain waktu gagal, Anda akan menghabiskan dua kali waktu debugging (satu kali untuk mencari tahu tentang tes apa dan sekali untuk memperbaiki kode yang sedang diuji)

Jujur unittests harus memiliki hasil yang diharapkan; melakukan prosedur; dapatkan hasil aktual; Tes diharapkan terhadap jenis struktur aktual yang mudah ditulis dan dipahami

Kode tes harus menerima cinta sebanyak kode produksi Anda. Untuk keterbacaan, bahkan mungkin lebih. Jika ada orang lain selain Anda (termasuk Anda dua minggu setelah meninggalkan kode) yang seharusnya memahami apa yang sedang terjadi, maka Anda harus membuat kode Anda bagus dan segar.

Ini berarti:

• Ekstrak bangunan data uji ke dalam kelas pembangun.
• Ekstraksi asersi multibel ke dalam metode asersi terpisah.
• Sangat tepat dalam penamaan Anda. Assert.That(x4, Is.EqualTo(y16*2*SOME_VALUE), ASS_ERR_TXT_56)membuat sangat sedikit perhatian bagi sebagian besar pembaca.

Secara ekstrem, tes dapat ditulis sehingga hampir mudah dibaca DAN dipahami sebagai prosa. Penguji ekstrem mungkin akan mengatakan bahwa tes unit lebih dari 10 baris panjang adalah yang buruk.

Alasan praktis yang paling penting adalah bahwa setiap kali Anda mengubah kode, Anda mengubah tes unit. Dan jika Anda melakukan TDD, Anda bahkan mengubah tes unit terlebih dahulu.

Lakukan salah satu dari hal-hal ini dalam tes Anda:

• Kode duplikat
• Mengurangi keterbacaan
• Kopling ketat
• Kopling temporal
• Kompleksitas siklomatik yang tinggi (banyak ketergantungan)

Dan Anda berada dalam banyak pekerjaan ketika perubahan diperlukan.

Perlakukan tes Anda seperti yang Anda sarankan, dan Anda akan menyesalinya. Anda bahkan mungkin akan mencapai kesimpulan yang salah bahwa "TDD tidak berfungsi".

Itu tergantung pada apakah unit test ini "sementara" atau tidak. Jika

1. Tes akan sering digunakan;

2. Pengembang harus bekerja dengan unit test yang ditulis oleh pengembang lain;

3. Sebagian besar pengujian dilakukan oleh unit test

maka tes harus ditulis dengan benar. Jika ada bug dalam tes itu sendiri, akan sulit untuk menemukan bug dan memperbaikinya, terutama jika beberapa waktu telah berlalu sejak tes ditulis.

Di sisi lain, jika tes ini hanya digunakan oleh pengembang sendiri saja, maka menurut saya tidak masalah. Tetapi tetap lebih disukai untuk menulis kode 'mudah dibaca'. Seperti yang dikatakan ratchet freak, Anda akan menghabiskan lebih banyak waktu memperbaiki tes daripada menghabiskan waktu untuk menuliskannya dengan benar.