Haruskah kita selalu menguji bug saat memperbaikinya?

Saat mengoreksi bug, disarankan di mana saya bekerja untuk pertama kali menulis tes yang gagal dengan bug yang diberikan, dan kemudian memperbaiki kode sampai tes berlalu. Ini mengikuti praktik TDD, dan seharusnya menjadi praktik yang baik, tetapi saya perhatikan cenderung menghasilkan tes samar yang mendekati implementasi.

Misalnya, kami memiliki masalah ketika pekerjaan dikirim, mencapai kondisi tertentu, dibatalkan, dan dicoba lagi. Untuk mereproduksi bug ini, tes besar-besaran ditulis dengan sinkronisasi utas di dalamnya, banyak ejekan dan semacamnya ... Itu berhasil, tapi sekarang saya refactoring kode, saya merasa sangat tergoda untuk hanya menghapus mammoth ini, karena itu benar-benar membutuhkan banyak pekerjaan (lagi) agar sesuai dengan desain baru. Dan itu hanya menguji satu fitur kecil dalam satu kasus spesifik.

Karena itu pertanyaan saya: bagaimana Anda menguji bug yang sulit direproduksi? Bagaimana Anda menghindari membuat hal-hal yang menguji implementasi, dan merusak refactoring dan keterbacaan?

Ya, secara umum Anda harus . Seperti halnya semua pedoman, Anda harus menggunakan penilaian terbaik Anda saat menjalankannya terhadap pedoman lain. Untuk skenario ini, tingkat keparahan bug perlu ditimbang terhadap pekerjaan yang diperlukan untuk mengimplementasikan tes dan kualitas tes yang ditargetkan untuk masalah bisnis dan menangkap regresi kondisi bug.

Saya cenderung lebih suka menulis tes daripada tidak, karena gangguan untuk menjalankan bug cenderung memiliki lebih banyak overhead daripada hanya mengembangkan dan mempertahankan unit test.

Saya pikir praktik terbaik - yang membuat saya malu untuk mengakui bahwa saya tidak sering mengikuti - adalah membuat tes sistem atau integrasi yang menunjukkan masalah yang diamati dalam produksi, kemudian penelitian untuk menemukan unit yang bertanggung jawab atas masalah tersebut, dan kemudian menulis tes unit untuk unit-unit yang menunjukkan masalah di tingkat unit . Setelah Anda memiliki unit test, perbaiki unit, dan jalankan semua tes. Pada titik ini, mungkin bijaksana untuk membuang tes asli - karena mungkin rapuh dan / atau lambat - tetapi simpan unit tes di suite otomatis Anda demi regresi dan cakupan.

Praktik menulis tes untuk mengidentifikasi cacat adalah ide yang baik, karena memungkinkan Anda untuk mengidentifikasi langkah-langkah apa yang diperlukan untuk mereproduksi cacat dan memverifikasi bahwa itu sudah diperbaiki. Selain itu, pengujian ini dapat dijalankan sebagai bagian dari pengujian asap atau pengujian regresi untuk memastikan bahwa perubahan di kemudian hari tidak memasukkan kembali cacat lama ke dalam sistem.

Hal pertama yang perlu dipertimbangkan adalah tingkat tes yang dibutuhkan. Mungkin tes untuk memverifikasi perbaikan akan lebih tepat di tingkat sistem, atau mungkin bahkan tes penerimaan yang dilakukan secara manual. Saya pikir lebih penting untuk memiliki tes yang didokumentasikan dan dikelola, terlepas dari bagaimana itu diterapkan secara khusus.

Sejauh bagaimana refactoring memengaruhi tes, itu tergantung pada karakteristik spesifik. Dalam beberapa kasus, refactoring (atau segala jenis pekerjaan, seperti fitur baru) dapat membuat tes tidak lagi diperlukan. Masalahnya, seperti yang awalnya terjadi, mungkin tidak lagi mungkin. Dalam hal ini, mungkin bijaksana untuk menghapus tes dari tes yang mungkin untuk membuat proses pengujian Anda (otomatis atau manual) lebih ramping. Dalam kasus lain, ada beberapa metode untuk melakukan pengujian dan memverifikasi fitur pada tingkat yang berbeda mungkin lebih tepat. Jika fitur ini kecil, mungkin pengujian tidak lagi diperlukan sama sekali.

Anda juga dapat mempertimbangkan tidak hanya mengandalkan pengujian, tetapi juga mencatat. Misalnya, menangkap informasi pada saat run-time (dengan berbagai tingkat verbositas tergantung pada lingkungan - lebih banyak bertele-tele selama pengujian, kurang bertele-tele selama penyebaran), membuat profil aplikasi, menangkap kesedihan dari kondisi sistem saat ini. Jika Anda dapat menemukan pemicu umum untuk masalah tersebut, Anda dapat menggunakannya untuk memandu pengujian di semua tingkatan.

Ya kamu harus.

Tulis tes unit untuk basis kode yang ada. Saat memperbaiki bug, Anda perlu memastikan bahwa unit test Anda gagal - ini akan memberi Anda keyakinan bahwa Anda memang sedang mengerjakan bug. Anda kemudian perlu faktor ulang dan lulus ujian dengan memperbaiki bug.

Namun ini bukan praktik TDD. Dalam tes TDD, buat desain Anda, tetapi dalam kasus Anda desainnya sudah diputuskan.