Seorang kolega saya datang dengan ide yang menurut saya menarik.

Bukankah bermanfaat untuk menulis tes selama tinjauan kode, oleh orang yang melakukan tinjauan dengan asumsi bahwa kita tidak melakukan TDD?

Untuk pertanyaan ini asumsikan bahwa ini adalah proyek murni akademis sehingga tidak ada kehidupan yang dipertaruhkan. Apalagi timnya 4 orang. Semua orang tahu bahasa dan terbiasa dengan semua alat / perpustakaan / kerangka kerja yang digunakan dan dapat menulis tes. Jadi pada dasarnya orang-orang yang bukan senior fullstack memimpin insinyur ninja tetapi coders yang layak.

Pro saya temukan:

1. Dorong pemahaman kode yang lebih dalam selama ulasan untuk menulis tes yang bermakna.
2. Anda kemudian dapat menambahkan ulasan kode dari tes-tes yang dilakukan oleh penulis kode yang sedang diuji.

Kontra yang saya temukan:

1. Loop umpan balik antara penulisan kode dan pengujian bertambah.

EDIT: Saya tahu itu tidak akan berfungsi dengan baik pada aplikasi web "normal". Apa yang ada dalam pikiran saya adalah kasus sudut di mana Anda menerapkan algoritma yang kompleks dan ilmiah yang membutuhkan perhatian terhadap detail. Mari kita asumsikan sesuatu seperti mengimplementasikan pustaka grafik saya sendiri, NLP dll. Saya ingin tahu apakah kode yang kita tulis diisolasi dari basis data dan seperti itu tetapi sangat sulit untuk dipahami bukankah tingkat kontrol ditambahkan, orang lain yang perlu memahami sumbernya kode dan lakukan pengujian yang berarti, membuat seluruh proses lebih rentan terhadap bug yang kurang jelas yang tidak merusak aplikasi tetapi akhirnya membuat hasil Anda sampah?

Bukankah bermanfaat untuk menulis tes selama tinjauan kode, oleh orang yang melakukan tinjauan?

Saya telah menemukan bahwa waktu yang tepat untuk menulis tes adalah ketika Anda menyadari bahwa Anda perlu ujian untuk suatu situasi.

Pengalihan tugas untuk komputer itu mahal - bahkan lebih-lebih untuk manusia.

Pada titik waktu ini, Anda biasanya memiliki pemahaman yang baik tentang persyaratan dan dependensi untuk tes ini. Jadi, manfaatkan pencelupan tim Anda dalam masalah tersebut. Jika Anda perlu memperbaiki tes baru Anda di masa depan, bagus, Anda sudah memiliki kerangka uji / fixture di tempat, dan semua yang perlu Anda lakukan adalah mengubah bagian yang perlu diperbaiki.

Jika itu terjadi selama tinjauan kode, mengapa tidak melanjutkan dan melakukannya? Saya pernah melakukan itu sebelumnya. Saya telah menemukan bahwa itu lebih baik daripada tidak, terutama jika Anda dapat melakukannya dengan cepat, dan bahkan lebih baik jika Anda tidak melakukannya sebaliknya.

Dengan asumsi bahwa kita tidak melakukan TDD?

Bahkan jika Anda berlatih TDD, jika Anda menyadari bahwa Anda memerlukan tes saat melakukan review kode, yang tidak Anda miliki, mengapa tidak menulis tes saat itu juga?

Pro

• Anda meningkatkan fokus Anda pada kode yang sedang ditinjau.
• Terkadang review kode menjadi hang-out dan waktu obrolan ketika orang tidak menyukainya. Menulis tes mendorong semua orang untuk lebih aktif memikirkan kode yang ditinjau.
• Semakin banyak anggota tim junior yang akan memiliki kesempatan untuk belajar dari pengalaman menulis tes.
• Anda dapat mengidentifikasi bakat di tim Anda yang tidak Anda ketahui miliki.

Apakah ini benar-benar sebuah tipuan bahwa lebih banyak tes dapat menyebabkan lebih banyak kode? Jika tes diperlukan, dan kode diperlukan untuk tes, dan sekarang Anda memilikinya, maka itu hal yang baik .

Peringatan

Mungkin beberapa tim perlu fokus pada hal-hal lain. Jika itu menyebabkan gangguan dari prioritas, atau ulasan kode Anda melebihi jadwal, maka Anda perlu membatasi atau memotong penulisan tes yang sebenarnya. Namun, tinjauan kode tentu saja dapat mengidentifikasi tes yang perlu ditulis, dan mungkin mereka setidaknya dapat dihapuskan untuk diselesaikan penulis nanti.

Ini adalah ide bagus, dengan satu peringatan. Jangan mengganti tes tertulis pengembang dengan tes tertulis resensi. Mintalah pengulas Anda mencari kasing sudut dan input yang akan memecahkan kode. Dengan kata lain, minta mereka mencoba untuk menulis tes baru yang pengembang tidak berpikir untuk menulis.

Menulis tes karakterisasi adalah cara yang benar-benar luar biasa untuk mendapatkan pemahaman tentang sepotong kode yang tidak Anda tulis. Memiliki pengulas Anda mengendarai tes tambahan di kode memberi mereka pemahaman yang lebih baik tentang bagaimana kode bekerja, bagaimana kode itu dapat rusak, dan bagaimana itu dapat ditingkatkan. Sementara itu, tingkatkan cakupan kode Anda.

Ini semua adalah kemenangan dalam buku saya.

Saya tidak berpikir idenya sepenuhnya tanpa prestasi - namun, manfaat utama dari TDD et al adalah bahwa masalah ditemukan lebih awal . Pengembang juga paling baik ditempatkan untuk melihat kasus sudut mana yang mungkin memerlukan perhatian khusus. Jika ini dibiarkan hingga ulasan kode, maka ada risiko pengetahuan ini bisa hilang.

Tes penulisan selama tinjauan kode akan mengalami masalah yang sama dengan pengujian manual tradisional - pemahaman aturan bisnis dapat bervariasi dari pengembang ke pengembang seperti halnya ketekunan.

Ada juga diskusi lama yang akan berjalan dan berjalan tentang apakah pengembang akan menguji kode mereka dengan baik jika mereka tahu ada fungsi pengujian lebih lanjut di hulu yang seharusnya menangkap bug yang lebih serius.

Saya setuju dengan jawaban @ RobbieDee tapi saya punya sedikit lebih banyak untuk ditambahkan.

Jika Anda benar-benar menyukai ide ini, mengapa tidak meminta orang yang sama menulis tes sebelum kode sebagai kriteria penerimaan yang dapat dieksekusi untuk cerita pengguna?

Itu akan melakukan hal yang sama, tetap membuat umpan balik singkat dan membuat semua orang untuk berdiskusi tentang cerita, yang saya pikir akan lebih bernilai.

Kerugiannya adalah bahaya pertemuan kriteria penerimaan tanpa akhir :-( dan saya pikir Anda mencoba membuat orang-orang di ulasan kode untuk melihat kode implementasi tetapi saya menyarankan pemrograman pasangan dan pasangan berputar sebagai solusi yang lebih baik untuk masalah itu.

OP menambahkan edit di mana mereka tata letak rincian lebih lanjut dari ini menjadi fitur yang sulit atau algoritma berat.

Menanggapi hal itu saya akan menambahkan bahwa naluri Anda untuk lebih memperhatikan masalah dan solusinya adalah baik. Mungkin berpasangan dengan banyak orang satu lawan satu sampai semua orang telah melihat sedikit kode implementasi dan tes yang benar-benar sulit. Masing-masing membuang ide-ide baru dan menambahkan nilai lebih.

Ada ide yang kadang-kadang memanggil pemrograman-massa, seperti berpasangan tetapi dengan lebih banyak orang. Ini hampir apa yang Anda bicarakan tetapi mereka membantu pada saat penulisan daripada dalam tinjauan formal sesudahnya. Ini bukan untuk semua orang, dan dapat membutuhkan driver (pemimpin) yang kuat untuk membuatnya bekerja, atau tim yang sangat nyaman satu sama lain dan prosesnya.

Melakukan setelah pemrograman mob sebenarnya saya kira akan memiliki banyak keuntungan yang sama dari banyak mata melihat masalah dan dan menyarankan perbaikan dan jika itu adalah bagaimana tim Anda nyaman beroperasi maka itu dapat membantu tetapi saya benar-benar akan mencoba untuk tetap diperlukan kejadian ini turun seminimal mungkin karena saya pikir itu bisa memperlambat tim.

Seperti yang Anda katakan, jika Anda menjalankan tim TDD, maka ini bisa diperdebatkan karena kode harus sudah diuji.

Secara keseluruhan saya tidak berpikir ini adalah ide yang hebat, tetapi itu tergantung pada pendekatan Anda saat ini dan apa yang cocok untuk Anda. Pada dasarnya, masalah yang saya lihat adalah bahwa Anda kehilangan "loop umpan balik pendek" keuntungan dari tes. Mendapatkan pemberitahuan instan saat Anda memecahkan sesuatu bahkan ketika Anda sedang menulis kode baru adalah tempat ujian benar-benar bersinar. Jika Anda menunda pengujian hingga peninjauan kode, pada dasarnya Anda mengatakan, "Yah, kita BISA menyelesaikan masalah ini lebih awal dalam waktu yang lebih singkat dan dengan lebih sedikit orang yang terlibat, tetapi setidaknya kita semua belajar sesuatu (mungkin)". Saya lebih suka memastikan orang mengirimkan kode yang diuji untuk ditinjau, dan kemudian Anda menilai kebenaran dan perawatannya. Lagi pula, tinjauan kode adalah untuk meninjau, bukan untuk menulis kode.

Di sisi lain, saya TIDAK merekomendasikan Anda untuk FIDDLE dengan tes / kode selama peninjauan. Coba hancurkan sesuatu. Komentari kondisi jika. ganti boolean dengan literal true / false. Lihat apakah tes gagal.

Tapi ya, semuanya, saya sarankan Anda menulis tes Anda bersama-sama dengan kode Anda dan kemudian meninjau semuanya sekaligus.

Itu tergantung apa yang Anda lakukan dalam ulasan kode. Saya pikir ada dua alasan utama untuk menulis tes pada tahap itu:

• pertama, jika Anda juga melakukan refactoring selama peninjauan kode, dan Anda perhatikan tidak ada cukup unit test untuk mencakup jenis refactoring yang ingin Anda terapkan, tambahkan tes tersebut

• kedua, jika kode tersebut terlihat oleh Anda seolah-olah ia memiliki bug dan Anda ingin membuktikannya (atau membantah) ini, tulis tes untuk itu

Kedua kasus menyatakan perlunya tes yang tidak ada saat ini, tetapi seharusnya. Tentu saja, itu mungkin tergantung pada budaya tim Anda jika tes semacam ini harus ditulis oleh reviewer, atau oleh penulis asli, tetapi seseorang harus menulis tes.

Sebenarnya, saya tidak berpikir ini adalah "kasus sudut" hanya cocok untuk "algoritma ilmiah yang kompleks" - justru sebaliknya, ini cocok untuk semua jenis perangkat lunak yang Anda harapkan dari tingkat kualitas tertentu.

Tidak, jangan lakukan itu. Anda akan membuat mereka berpikir TDD mengerikan.

Saya pikir @ k3b sudah benar di komentar pada pertanyaan. Kode yang ditulis melalui proses gaya TDD cenderung terlihat, dan berinteraksi, sangat berbeda dengan kode yang ditulis tanpa tes. Menambahkan tes (baik) ke kode yang tidak diuji biasanya membutuhkan banyak refactoring kode untuk memperjelas maksud dan bagian yang bergerak.

Dengan menambahkan tes setelah menulis kode, Anda kehilangan aspek arsitektur dari manfaat TDD (yang menurut saya adalah salah satu manfaat utama). Tidak hanya itu, Anda meminta orang lain, yang hampir tidak begitu akrab dengan kode tersebut, untuk melakukan tes tambahan yang sudah sulit untuk ditambahkan.

Orang yang menambahkan tes harus memperbaiki kode secara signifikan, atau mereka harus bekerja sangat keras untuk menguji kode yang tidak dapat diuji. Bagaimanapun, mereka tidak akan menikmati pengalaman itu. Meskipun ini mungkin bukan TDD klasik, mereka tidak akan melihatnya seperti itu, dan Anda bisa menunda TDD sekali dan untuk semua.

(Jika Anda sudah mengikuti proses TDD, menulis tes tambahan selama tinjauan kode akan kurang berbahaya, meskipun menurut pengalaman saya, jika tes sudah ditulis dengan baik, sama mudahnya untuk menjelaskan tes tambahan kepada orang yang mengajukan kode untuk ditinjau dan minta mereka menulisnya.)

Tes unit selama tinjauan kode adalah pengganti yang buruk untuk tes unit selama pengembangan.

Apa yang Anda sarankan sangat masuk akal, secara intuitif. Untuk apa ulasannya? Untuk memeriksa apakah kodenya baik. Untuk apa tes? Untuk memeriksa apakah kodenya baik. Jadi mengapa tidak menggabungkan keduanya?

Inilah sebabnya.

Membawa kode yang sedang diuji adalah kerja keras. Menulis kode yang hanya berfungsi pada satu hal yang seharusnya dilakukan adalah satu hal; menulis kode yang dapat secara efektif dan efisien diuji adalah hal lain. Hanya fakta bahwa kode sekarang berjalan di bawah dua skenario - "pekerjaan nyata" dan "tes" - menuntut fleksibilitas yang jauh lebih besar, menuntut agar kode tersebut mampu berdiri sendiri dengan cara yang bermakna.

Menulis kode Anda sehingga dapat diuji merupakan pekerjaan dan keterampilan ekstra. Refactoring kode orang lain untuk testability, ketika itu tidak ditulis dengan testability dalam pikiran untuk memulai, bisa menjadi tugas utama.

Anda menggandakan upaya antara pengembang dan pengulas. Agaknya, pengembang Anda tidak menyerahkan kode di untuk diperiksa tanpa setidaknya beberapa tingkat kepercayaan bahwa itu bekerja. Dia sudah perlu menguji kodenya. Sekarang, ada berbagai tingkat dan cakupan pengujian. QA menguji kode setelah pengembang dan peninjau. Tetapi ruang lingkup apa pun yang Anda pikir sesuai untuk pengembang dan peninjau, tidak masuk akal bagi pengembang untuk mengetahui cara menguji kode ke tingkat itu sekali , tetapi membuat pengujiannya dibuang dan sulit untuk mereproduksi, dan kemudian membawa peninjau ke kembangkan tes lagi, kali ini yang otomatis dan direproduksi. Anda berdua hanya perlu menginvestasikan waktu dalam menulis tes yang sama - sekali buruk, sekali baik.

Anda mengubah ulasan menjadi langkah yang jauh lebih lama, lebih sulit. Jika pengujian adalah bagian utama dari proses peninjauan, apa yang terjadi ketika beberapa tes gagal ? Apakah pengulas bertanggung jawab untuk menjalankan semua tes, jadi ia perlu men-debug kode juga? Atau apakah akan bolak-balik, satu tes menulis, yang lain membuat mereka lulus?

Kadang-kadang Anda dapat menulis sejumlah besar tes yang semuanya ortogonal satu sama lain, sehingga Anda tidak perlu melakukan ping-pong. Reviewer menulis selusin tes, setengahnya gagal, pengembang memperbaiki bug dan semua tes tetap valid, dan lulus sekarang. Tapi ... sering kali, Anda memiliki bug pemblokir, atau bug yang membutuhkan desain ulang dan perubahan API, atau yang lainnya. Jika Anda melepaskan tanggung jawab untuk lulus tes bolak-balik antara peninjau dan pengembang, maka Anda sebenarnya tidak pada tahap peninjauan. Anda masih berkembang.

Perlu menulis tes tidak mendorong ulasan yang lebih menyeluruh. Ini pada dasarnya berarti bahwa semakin dalam Anda melangkah, semakin banyak tes yang harus Anda tulis, dan mungkin itu akan menjadi tes sulit yang perlu masuk jauh ke dalam sistem.

Bandingkan dengan pengembang yang menulis tes, di mana insentifnya adalah: jika saya tidak menulis tes penting, pengulas akan menunjukkan hal itu dalam ulasan.

Bahkan peninjau akan memiliki pemahaman yang jauh lebih baik tentang sistem jika dia perlu memeriksa tes kode secara menyeluruh , maka jika dia perlu memutuskan sendiri kapan dia bisa berhenti menulis tes penggalian yang dalam dan hanya OK tinjauan kode.

Jika pengembang tidak menulis unit test, reviewer tidak akan melakukannya. Ada banyak kendala untuk mengadopsi pengujian sebagai praktik umum. Mungkin Anda terlalu banyak mendapat tekanan, dan basis kode Anda sulit untuk diuji. Mungkin Anda tidak berpengalaman dalam pengujian, dan merasa seperti Anda tidak mampu membeli kurva belajar. Mungkin Anda punya pembunuh kapak yang mengirim catatan mengancam kepada orang-orang yang menulis tes. Saya tidak tahu!

Tapi apa pun penyebabnya, aman untuk bertaruh bahwa itu berlaku sama untuk pengulas dan pengembang. Jika tim sedang stres, resensi tidak memiliki waktu lebih banyak daripada pengembang (jika dia melakukannya, mendistribusikan kembali pekerjaan sehingga orang tidak begitu stres ). Jika tidak ada yang tahu cara menulis unit test dengan baik, pengulas mungkin juga tidak (jika dia melakukannya, dia harus duduk dan mengajar rekan satu timnya ).

Saran ini terdengar seperti mencoba meneruskan tanggung jawab dari satu kolega ke kolega lainnya. Dan saya tidak melihat cara apa pun untuk bekerja dengan baik, pertama dan terutama karena sangat sulit (dan tidak sehat) untuk menciptakan situasi di mana satu orang adalah satu-satunya yang dapat melakukan pengujian, dan orang lain tidak dapat melakukan semua pengujian sama sekali.

Apa yang dilakukannya kerja adalah memiliki tes tinjauan penutup juga. Jika pengembang telah menulis sepuluh tes, jauh lebih mungkin peninjau dapat membantu menyarankan sepuluh lainnya, daripada jika pengembang belum menulisnya.

Dan, jika menguji sudut-kasus adalah tugas utama, mungkin masuk akal untuk mendistribusikannya secara lebih luas di seluruh tim. ** Setelah kode diuji di tempat pertama, menulis lebih banyak tes menjadi jauh lebih mudah. **

Ulasan adalah waktu yang tepat untuk menemukan kasus sudut. Dan, jika peninjau dapat melompat dan menulis tes untuk kasus sudut yang dia temukan, maka hei - lebih baik! Tetapi secara umum, dengan asumsi bahwa resensi dapat menulis tes di mana pengembang tidak terdengar seperti ide yang sangat buruk.