Haruskah saya sengaja merusak build ketika bug ditemukan dalam produksi?

Tampaknya masuk akal bagi saya bahwa jika bug serius ditemukan dalam produksi oleh pengguna akhir, tes unit gagal harus ditambahkan untuk menutupi bug itu, sehingga dengan sengaja merusak build sampai bug diperbaiki. Alasan saya untuk ini adalah bahwa build seharusnya gagal selama ini , tetapi bukan karena tidak cukupnya cakupan tes otomatis.

Beberapa kolega saya tidak setuju mengatakan bahwa unit test yang gagal tidak boleh diperiksa. Saya setuju dengan sudut pandang ini dalam hal praktik TDD normal, tapi saya pikir bug produksi harus ditangani secara berbeda - setelah semua mengapa Anda ingin mengizinkan membangun untuk sukses dengan cacat yang dikenal?

Apakah ada orang lain yang memiliki strategi terbukti untuk menangani skenario ini? Saya mengerti bahwa dengan sengaja merusak bangunan bisa mengganggu anggota tim lainnya, tetapi itu sepenuhnya tergantung pada bagaimana Anda menggunakan cabang.

Strategi kami adalah:

Periksa dalam tes yang gagal, tetapi beri catatan dengan @Ignore("fails because of Bug #1234").

Dengan begitu, tes ada di sana, tetapi build tidak rusak.

Tentu saja Anda mencatat tes yang diabaikan dalam bug db, sehingga @Ignoredihapus setelah tes diperbaiki. Ini juga berfungsi sebagai pemeriksaan mudah untuk perbaikan bug.

Inti dari kegagalan dalam membangun tes yang gagal bukanlah untuk entah bagaimana membuat tim di bawah tekanan - itu untuk mengingatkan mereka akan masalah. Setelah masalah diidentifikasi dan diajukan dalam bug DB, tidak ada gunanya menjalankan tes untuk setiap build - Anda tahu bahwa itu akan gagal.

Tentu saja bug itu harus diperbaiki. Tetapi menjadwalkan perbaikan adalah keputusan bisnis, dan dengan demikian tidak benar-benar menjadi perhatian dev ... Bagi saya, sekali bug diajukan dalam bug DB, itu bukan lagi masalah saya, sampai pelanggan / pemilik produk memberi tahu saya bahwa mereka ingin memperbaikinya. .

Mengapa Anda ingin membiarkan bangunan berhasil dengan cacat yang diketahui?

Karena terkadang, Anda memiliki batasan waktu. Atau bug itu sangat kecil sehingga tidak layak menunda pengiriman produk selama beberapa hari yang dibutuhkan untuk unit test dan memperbaikinya.

Juga, apa gunanya melanggar build secara sengaja setiap kali Anda menemukan bug? Jika Anda menemukannya, perbaiki (atau berikan kepada orang yang akan memperbaikinya), tanpa mengganggu seluruh tim Anda. Jika Anda ingin mengingat untuk memperbaiki bug, maka Anda harus menandainya sebagai sangat penting dalam sistem pelacakan bug Anda.

Tes ada untuk memastikan bahwa Anda tidak (kembali) memperkenalkan masalah. Daftar tes yang gagal bukanlah pengganti sistem pelacakan bug. Ada beberapa validitas dalam POV bahwa tes gagal tidak hanya indikasi bug, mereka juga merupakan indikasi kegagalan proses pengembangan (dari kecerobohan hingga ketergantungan yang diidentifikasi dengan buruk).

"Break the build" berarti mencegah pembangunan agar tidak berhasil diselesaikan . Tes gagal tidak melakukan itu. Ini merupakan indikasi bahwa cacat bawaan telah diketahui, yang mana sebenarnya tepat.

Kebanyakan server membangun melacak status tes dari waktu ke waktu, dan akan menetapkan klasifikasi yang berbeda untuk tes yang telah gagal sejak ditambahkan vs regresi (tes yang digunakan untuk lulus dan tidak lagi melakukannya), dan juga mendeteksi revisi di mana regresi terjadi.

Saya berpendapat bahwa tes gagal harus ditambahkan, tetapi tidak secara eksplisit sebagai "tes gagal."

Seperti @BenVoigt tunjukkan dalam jawabannya , tes gagal tidak selalu "merusak build." Saya kira terminologinya dapat bervariasi dari satu tim ke tim lainnya, tetapi kodenya masih dikompilasi dan produk masih dapat dikirimkan dengan tes yang gagal.

Yang harus Anda tanyakan pada diri sendiri dalam situasi ini adalah,

Apa ujian yang ingin dicapai?

Jika tes ada di sana hanya untuk membuat semua orang merasa nyaman dengan kode tersebut, maka menambahkan tes gagal hanya untuk membuat semua orang merasa buruk tentang kode itu tidak produktif. Namun, seberapa produktifkah tes itu?

Pernyataan saya adalah bahwa tes harus mencerminkan persyaratan bisnis . Jadi, jika "bug" telah ditemukan yang menunjukkan persyaratan tidak terpenuhi dengan benar, maka itu juga merupakan indikasi bahwa tes tidak benar atau sepenuhnya mencerminkan persyaratan bisnis.

Itulah bug yang harus diperbaiki terlebih dahulu. Anda tidak "menambahkan tes yang gagal." Anda mengoreksi tes untuk menjadi refleksi yang lebih akurat dari persyaratan bisnis. Jika kode kemudian gagal lulus tes itu, itu hal yang baik. Itu berarti tes sedang melakukan pekerjaan mereka.

Prioritas memperbaiki kode harus ditentukan oleh bisnis. Tetapi sampai tes diperbaiki, dapatkah prioritas itu benar-benar ditentukan? Bisnis harus dipersenjatai dengan pengetahuan tentang apa sebenarnya yang gagal, bagaimana itu gagal, dan mengapa ia gagal untuk membuat keputusan berdasarkan prioritas. Tes harus menunjukkan ini.

Memiliki tes yang tidak sepenuhnya lulus bukanlah hal yang buruk. Ini menciptakan artefak besar dari masalah yang diketahui untuk diprioritaskan dan ditangani sesuai. Namun, memiliki tes yang tidak sepenuhnya diuji adalah masalah. Ini mempertanyakan nilai dari tes itu sendiri.

Untuk mengatakannya dengan cara lain ... Bangunannya sudah rusak. Yang Anda putuskan adalah apakah akan memperhatikan fakta itu atau tidak.

Di tim otomasi pengujian kami, kami memeriksa tes yang gagal asalkan gagal karena cacat pada produk alih-alih cacat dalam pengujian. Dengan begitu kita punya bukti untuk tim dev bahwa hei, mereka melanggarnya. Breaking build sangat disukai, tetapi itu tidak sama dengan memeriksa dalam tes yang dapat dikompilasi tetapi gagal.

Menulis tes yang Anda tahu akan gagal sampai bug diperbaiki adalah ide yang baik, itu dasar dari TDD.

Menghancurkan bangunan adalah ide yang buruk. Mengapa? Karena itu berarti tidak ada yang bisa bergerak sampai diperbaiki. Ini pada dasarnya memblokir semua aspek pembangunan lainnya.

Contoh 1
Bagaimana jika aplikasi Anda sangat besar, dengan banyak komponen? Bagaimana jika komponen-komponen itu dikerjakan oleh tim lain dengan siklus rilis mereka sendiri? Sulit! Mereka harus menunggu untuk memperbaiki bug Anda!

Contoh 2
Bagaimana jika bug pertama sulit untuk diperbaiki dan Anda menemukan bug lain dengan prioritas lebih tinggi? Apakah Anda juga merusak build untuk bug kedua? Sekarang Anda tidak dapat membangun sampai keduanya diperbaiki. Anda telah membuat ketergantungan buatan.

Tidak ada alasan logis mengapa gagal dalam ujian harus menghentikan pembangunan. Ini adalah keputusan yang perlu dibuat oleh tim pengembang (mungkin dengan diskusi manajemen) yang mempertimbangkan pro dan kontra dari merilis build dengan bug yang diketahui. Ini sangat umum dalam pengembangan perangkat lunak, hampir semua perangkat lunak utama dirilis dengan setidaknya beberapa masalah yang diketahui.

Itu tergantung pada peran tes yang seharusnya dimainkan dan bagaimana hasil mereka seharusnya mempengaruhi sistem pembangunan / proses yang diadopsi. Pemahaman saya tentang melanggar build adalah sama dengan Ben, dan pada saat yang sama kita seharusnya tidak secara sengaja memeriksa kode yang merusak tes yang ada. Jika tes-tes itu masuk "nanti", mungkin "oke" untuk mengabaikannya hanya untuk membuatnya tidak terlalu mengganggu bagi orang lain, tetapi saya menemukan praktik mengabaikan tes gagal (sehingga tampaknya lulus) agak mengganggu (terutama begitu untuk tes unit), kecuali ada cara untuk menunjukkan tes seperti tidak merah atau hijau.

Itu tergantung pada bug, tentu saja, tetapi umumnya jika ada kesalahan yang tidak teridentifikasi selama pengujian manual atau otomatis, maka itu menyiratkan ada kesenjangan dalam cakupan Anda. Saya pasti akan mendorong mencari tahu penyebab utama dan menampar kasus uji unit di atas masalah.

Jika ini merupakan masalah produksi yang direncanakan untuk perbaikan terbaru dari cabang pemeliharaan, Anda juga perlu memastikan bahwa perbaikan tersebut bekerja pada jalur utama, dan bahwa pengembang tidak dapat secara salah menerbangkan perbaikan dengan resolusi konflik penggabungan yang terlalu bersemangat. .

Selain itu, tergantung pada kebijakan rilis Anda, keberadaan tes unit yang baru diperbarui dapat membantu mengonfirmasi bahwa pengembang telah benar-benar menyelesaikan masalah, bukan hanya mengubahnya [(masalah atau tes?)], Meskipun ini tergantung pada penyandian kode. persyaratan yang benar dalam pengujian unit baru.

Satu masalah dengan menambahkan tes tahu-gagal ke build adalah bahwa tim Anda mungkin terbiasa mengabaikan tes gagal karena mereka berharap build gagal. Itu tergantung pada sistem build Anda, tetapi jika tes gagal tidak selalu berarti "sesuatu yang baru saja rusak" maka mudah untuk kurang memperhatikan tes gagal.

Anda tidak ingin membantu tim Anda masuk ke dalam pola pikir itu.

Jadi saya setuju dengan sleske bahwa Anda harus menambahkan tes, tetapi tandai sebagai 'diabaikan' untuk tujuan pembuatan otomatis, sampai bug diperbaiki.

Meskipun saya pikir Anda harus dengan cara tertentu 'memeriksa' bug sebagai tes, sehingga ketika Anda memperbaikinya tidak terjadi lagi, dan dalam beberapa cara memprioritaskannya, saya pikir yang terbaik adalah tidak merusak build (/ tes) . Alasannya adalah bahwa selanjutnya komitmen membangun akan disembunyikan di balik tes Anda yang rusak. Jadi dengan memeriksa tes yang rusak untuk bug ini Anda menuntut agar seluruh tim mengesampingkan pekerjaan mereka untuk memperbaiki bug ini. Jika itu tidak terjadi, Anda mungkin berakhir dengan melanggar komitmen yang tidak dapat dilacak seperti itu.

Karena itu saya akan mengatakan lebih baik untuk menjadikannya sebagai tes yang tertunda, dan menjadikannya prioritas dalam tim Anda untuk tidak memiliki tes yang tertunda.

Pilihan lain adalah memeriksa tes gagal ke cabang terpisah di sistem kontrol sumber Anda. Tergantung pada praktik Anda, ini mungkin layak atau tidak. Kami terkadang membuka cabang baru untuk pekerjaan yang sedang berlangsung, seperti memperbaiki bug yang tidak sepele.