Mengevaluasi apakah akan menulis tes unit atau tes integrasi terlebih dahulu pada proyek langit-biru / prototipe

Sesuatu yang saya perhatikan baru-baru ini adalah ketika saya melakukan jenis proyek berikut:

• Saat memulai proyek
• Bekerja pada MVP / prototipe
• Menambahkan fitur yang tidak sepenuhnya ditentukan
• Bekerja pada proyek skala kecil

Sebagai referensi, saya sedang mengerjakan proyek Python sekarang yang saat ini memiliki ~ 1k baris kode, termasuk beberapa komentar dan semua spasi putih.

Saya merasa lebih mudah untuk pertama-tama menulis tes integrasi, bekerja pada kode, dan kemudian setelah itu API agak mengeras benar-benar bekerja pada menambahkan tes unit. Jenis-jenis tes yang dapat saya jalankan pada mainfungsi saya , sehingga untuk berbicara, dan lebih "ujung ke ujung" daripada yang lain.

Ini karena unit test sangat menjengkelkan ketika API berubah cukup cepat, yang sering terjadi ketika mengerjakan proyek yang cocok dengan salah satu atau sebagian besar kriteria di atas.

Apakah pendekatan ini merupakan pendekatan yang baik dan kriteria apa yang harus dipertimbangkan ketika membuat keputusan apakah akan memulai dengan tes unit atau integrasi terlebih dahulu untuk jenis proyek ini? Apakah saya kehilangan nilai unit yang menguji proyek semacam ini sebelum API lebih solid?

Apakah saya kehilangan nilai unit yang menguji proyek semacam ini sebelum API lebih solid?

Tidak. Kamu baik-baik saja.

Dua tujuan besar TDD adalah:

• Mendefinisikan antarmuka dengan penggunaan aktual, bukan oleh implementasi internal ¹
• Memaksimalkan cakupan tes

Cakupan tes dapat dimaksimalkan dengan baik dengan cara apa pun yang Anda lakukan. Yaitu, terlepas dari apakah Anda pertama kali menguji unit kecil , terisolasi atau besar , "terintegrasi", Anda memiliki opsi untuk menulis tes Anda sebelum implementasi Anda.

Apa yang Anda peroleh secara tertulis dengan tes tingkat tinggi ("integrasi") pertama kali, seperti yang Anda lakukan, adalah kepastian bahwa antarmuka dan interaksi tingkat yang lebih tinggi juga ditentukan terutama berdasarkan penggunaannya, bukan oleh implementasi internal mereka.

Efek yang sama sebagian besar dapat dicapai dengan beberapa "arsitektur" dan diagram yang baik. Tetapi, tes-tes tingkat tinggi itu seringkali dapat mengungkapkan hal-hal yang Anda lewatkan dalam diagram Anda - atau bahwa Anda salah dalam pekerjaan "arsitektur" Anda.

Jika Anda tidak benar-benar melakukan TDD (atau yang sejenisnya), urutan yang Anda tuliskan tidak terlalu berarti. Antarmuka sudah ada pada saat Anda menguji, jadi jauh lebih kecil kemungkinannya bahwa tes Anda akan mengubah apa pun - mereka hanya akan berfungsi untuk melindungi terhadap perubahan tertentu yang melanggar.

Tetapi, jika Anda khawatir dengan membangun implementasi top-down versus buttom-up, poin pertama masih berlaku untuk tingkat yang besar. Kode tingkat tinggi membantu mendefinisikan antarmuka tingkat rendah. Sedangkan, jika antarmuka tingkat rendah ditulis terlebih dahulu (atau sudah ada), kode tingkat tinggi ada di tangan mereka ...

^{1. Yang ini juga berlaku bahkan jika Anda tidak melakukan TDD penuh. Bahkan jika Anda hanya menulis 1 atau 2 tes sebelum implementasi Anda, tes 1 atau 2 itu dapat membantu Anda mendefinisikan atau memperbaiki antarmuka Anda sebelum terlambat!}

Saya telah bekerja dengan cara Anda bekerja. Dan saya tidak akan memberi tahu Anda bahwa Anda tidak bisa. Saya akan memperingatkan Anda tentang sesuatu yang bisa Anda temui.

Ketika setiap unit tes hanyalah retrofit, sulit untuk belajar membuatnya fleksibel. Mereka cenderung tidak lebih dari tes regresi. Karena Anda belum pernah menggunakannya untuk membantu Anda refactor, sangat mudah untuk menulis jenis tes yang sebenarnya membuat refactoring lebih sulit. Ini cenderung lepas kendali sampai Anda kehilangan kepercayaan pada TDD.

Namun, Anda sudah mengerjakan sesuatu. Aku tidak akan memberitahumu untuk berhenti. Saya akan mengatakan itu mungkin layak untuk memulai sesuatu yang lain yang Anda punya waktu untuk mengeksplorasi dan mengikuti siklus refactor merah hijau dari awal. Pastikan Anda benar-benar menggunakan tes untuk membantu Anda refactor. Sampai Anda sudah menguasai cara kerja ini gunakan hemat pada sesuatu yang penting. Ini adalah cara yang sangat berbeda untuk kode dan perlu membiasakan diri. Melakukannya setengah jalan tidak akan ada gunanya bagi siapa pun.

Itu kata

Saya merasa lebih mudah untuk pertama-tama menulis tes integrasi, bekerja pada kode, dan kemudian setelah itu API agak mengeras benar-benar bekerja pada menambahkan tes unit. Jenis-jenis tes yang dapat saya jalankan pada fungsi utama saya, sehingga untuk berbicara, dan lebih "ujung ke ujung" daripada yang lain.

Memahami bahwa tes unit BUKAN hanya tes yang bekerja pada satu kelas. Selama API yang Anda kerjakan dapat diuji tanpa melakukan salah satu dari yang berikut ini, Anda melakukan pengujian unit dengan baik:

• Itu berbicara ke database
• Ini berkomunikasi di seluruh jaringan
• Menyentuh sistem file
• Itu tidak dapat berjalan pada saat yang sama dengan tes unit Anda yang lain
• Anda harus melakukan hal-hal khusus pada lingkungan Anda (seperti mengedit file konfigurasi) untuk menjalankannya.

Michael Feathers: Seperangkat Aturan Pengujian Unit

Jadi, jika tes ujung-ke-ujung Anda melibatkan lebih dari satu objek, itu tidak masalah. Ini adalah pengujian unit bukan pengujian objek.

Sama seperti metode pribadi tidak perlu diuji lagi maka mereka diuji melalui pengujian metode publik yang menggunakannya, objek tidak perlu awalnya dikembangkan di bawah memanfaatkan pengujian mereka sendiri. Hanya ketika objek dipertimbangkan untuk digunakan terlepas dari cerita ujung ke ujung, mereka benar-benar perlu diperlakukan seperti mereka memiliki antarmuka dan perilaku sendiri untuk mengonfirmasi. Jika Anda berhati-hati tentang hal ini, inilah saatnya Anda mempublikasikan objek-objek tersebut. Dengan cara ini Anda tidak membuat janji yang belum Anda uji.