Bagaimana Mengetahui Kapan Berhenti Pengujian?

Saya tahu ini adalah pertanyaan yang sangat mendasar. Untuk beberapa aplikasi perangkat lunak ada sejumlah besar kasus uji yang sangat tinggi untuk suatu aplikasi. Tidak praktis untuk menguji semua kasus uji tersebut. Bagaimana kami memutuskan kapan harus berhenti pengujian? (selain "ketika uang habis").

Buku Glenford Myers The Art of Software Testing memiliki aturan sederhana namun berprinsip baik untuk ini: Pengujian selesai ketika Anda telah berhenti menemukan bug. Atau, lebih praktisnya, ketika kecepatan Anda menemukan bug baru sangat melambat.

Bug cenderung "mengelompok" dalam modul-modul tertentu dan fungsi-fungsi tertentu: Saat Anda menemukan bug dalam satu, Anda tahu bahwa Anda harus mencari bug lebih lanjut di dalamnya. Untuk menemukan bug, Anda dapat menggunakan teknik pengujian blackbox, pengujian whitebox, dan pengujian mutasi. Selama Anda menemukan bug, Anda tahu bahwa proses pengujian Anda berhasil!

Untuk memvisualisasikan kemajuan Anda, buat grafik jumlah bug yang ditemukan tim Anda per hari. Jika grafik menurun, maka Anda tahu teknik yang digunakan tim Anda tidak akan menemukannya. Tentu saja, jika Anda yakin teknik Anda tidak sesuai, maka silakan baca buku Myers dan terapkan prinsip-prinsipnya.

Sekarang, ada kemungkinan Anda mungkin tidak memiliki patch bug baru, dan tingkat menemukan bug akan sangat meningkat jika Anda terus menguji sedikit lebih banyak. Namun, jika Anda yakin teknik Anda bagus, ini tidak mungkin.

Jawaban sederhana adalah itu tergantung pada sistem. Jika Anda menulis perangkat lunak tertanam untuk monitor jantung atau alat pemantauan keselamatan untuk reaktor nuklir maka standarnya jauh lebih tinggi daripada jika Anda menulis platform blogging.

Ini benar-benar pertanyaan untuk penguji sistem yang baik (dan saya bukan satu) tetapi saya akan mencobanya.

Ukuran dasar Anda akan menjadi cakupan uji: Berapa banyak aplikasi sebenarnya telah diuji (baik dengan uji unit dan secara fungsional).

Anda perlu menilai setiap kasus penggunaan potensial (dan parameter untuk kasus penggunaan itu) untuk kemungkinan penggunaan sebenarnya (sehingga Anda dapat menjatuhkan kasus tepi), kompleksitas (hal-hal sederhana yang cenderung mengandung bug, atau lebih cenderung mengandung keras untuk menemukan bug), biaya untuk menguji (dalam hal waktu) dan potensi dampak cacat jika ditemukan di daerah itu (di sinilah platform reaktor nuklir vs blogging).

Berdasarkan penilaian itu, Anda perlu menentukan yang mana yang akan diuji dan seberapa detail. Setelah Anda memiliki daftar seperti itu, tim (termasuk manajer produk / manajer proyek / perwakilan pengguna) dapat melalui daftar itu dan memprioritaskan berdasarkan kendala yang Anda miliki.

Salah satu teknik yang berguna untuk dipikirkan adalah Anda juga dapat memvariasikan use case yang diuji dengan setiap rilis. Misalnya, Anda mungkin memiliki daftar kasus uji non-kritis dan menguji setengah dari mereka dengan satu rilis dan setengah dengan yang berikutnya (kemudian bergantian). Dengan cara ini Anda meningkatkan cakupan tes total yang Anda dapatkan untuk upaya (meskipun dengan risiko bug regresi diperkenalkan).

Ini juga dapat diperluas ke pengujian platform - jika Anda mendukung dua ujung belakang basis data (atau beberapa browser) menguji setengah aplikasi pada satu, setengah lainnya pada yang lain dan kemudian menukar rilis berikutnya.

(Saya pikir ini disebut striping tetapi jangan mengutip saya tentang itu.)

Dan kemudian hal terakhir untuk dipikirkan bukanlah apa yang Anda uji tetapi apa yang sebenarnya Anda perbaiki ketika masalah ditemukan. Sudah umum untuk mengatakan "perbaiki semua bug" tetapi kenyataannya adalah bahwa ada tekanan waktu dan tidak semua bug sama. Sekali lagi, scrub bug reguler dengan semua pihak terkait adalah cara terbaik untuk maju. Ini sangat relevan di mana perbaikan bug mungkin sangat mengganggu karena pekerjaan tambahan dalam pengujian ulang dan pengujian regresi yang dihasilkannya mungkin lebih penting daripada manfaat perbaikannya.

Ketika risiko yang terkait dengan penggunaan perangkat lunak telah berkurang ke tingkat yang dapat diterima.

"Pengujian program dapat digunakan untuk menunjukkan keberadaan bug, tetapi tidak pernah menunjukkan ketidakhadiran mereka!" --Edsger Dijkstra

Sesuatu yang baik untuk diingat ketika melakukan pengujian apa pun, otomatis atau sebaliknya. Anda hanya dapat membuktikan bahwa Anda belum menemukan bug lagi, bukan berarti tidak ada lagi.

Tetapi semakin banyak mata yang Anda masukkan pada bagian kode, semakin yakin Anda bisa melakukan operasi yang benar. Ini sangat mirip dengan kutipan Knuth tentang optimasi dalam hal itu: Anda dapat menguji hal-hal yang salah dengan sangat mudah, dan Anda dapat menguji pada waktu yang salah dalam pengembangan Anda.

Intinya, Anda ingin diliput di dua tempat besar:

1. Apakah perangkat lunak tersebut lulus tes BDD yang menunjukkannya memenuhi persyaratan yang ditentukan. Perangkat lunak bahkan tidak bisa disebut selesai jika ini tidak benar.

2. Apakah segmen yang paling kritis, kompleks, dan tidak pasti memiliki tes yang memadai untuk memberikan kepercayaan diri? Jika itu adalah loop inti, atau sesuatu yang harus Anda optimalkan atau hack: uji di atasnya. Jika rumit dan memiliki banyak pemisahan logis: lakukan banyak tes di atasnya. Jika Anda tidak dapat mengujinya, atau tertanam terlalu dalam untuk secara langsung menguji: pastikan kode telah ditinjau, dan kode secara tidak langsung diuji dengan tangan.

Jika Anda menunggu sampai proyek selesai, Anda memang akan memiliki jumlah kasus uji yang sangat besar. Jika Anda melakukan pengiriman terus-menerus, dengan fokus pada pengiriman kecil, Anda akan memiliki lebih sedikit kasus uji pada setiap iterasi dan Anda akan dapat menguji semuanya. Jika Anda tidak dapat melakukan pengiriman kecil, prioritaskan dan mulai pengujian dari prioritas terbesar dan lakukan pengujian hingga Anda harus berhenti.

Jika Anda berbicara tentang pengujian unit dan Anda melakukan TDD (menulis tes terlebih dahulu) maka ini bukan masalah: Anda hanya berhenti menguji ketika fitur selesai.

Dalam TDD tambahan, Anda menulis tes yang gagal, lalu menerapkan jumlah kode terkecil yang dapat lulus, kemudian refactor. Terus tambahkan tes dengan cara ini sampai metode selesai fitur.

Ini contoh yang bagus.

Para ahli statistik juga telah melihat masalah ini - sebenarnya pada awal tahun 1970-80an. Dengan asumsi yang tepat tentang bagaimana bug ditemukan, mereka mencoba memperkirakan jumlah bug dari data pengujian. Ini kemudian digunakan untuk menentukan kapan harus berhenti berdasarkan pada mengoptimalkan fungsi kerugian. Lihat misalnya https://rpubs.com/hoehle/17920 ... untuk perawatan singkat dari salah satu makalah tentang masalah ini termasuk kode R tentang cara melakukan ini dalam praktik.

Tentu saja satu masalah akan selalu menjadi asumsi tentang proses penemuan bug. Misalnya, dalam perawatan di atas diasumsikan bahwa bug ditemukan secara independen satu sama lain. Dalam praktiknya, memperbaiki satu bug besar dapat, misalnya, menyebabkan bug baru, dll. Tetapi itu memberi permulaan dan menambah perasaan usus.

Ketika tanggal pengiriman telah tiba. Tidak ada akhir untuk pengujian perangkat lunak. Tetapi sekali lagi ada sesuatu yang dikenal sebagai jadwal. Anda harus menguji sebagian besar fungsi Anda dalam waktu yang dijadwalkan dan memperbaiki bug yang Anda temui. Tidak ada cara Anda dapat menjamin bahwa perangkat lunaknya sempurna.

Hal pertama yang akan diuji adalah "happy path", edge case, dan input yang tidak valid. Jika akan ada lebih dari satu pengguna secara bersamaan, Anda harus menguji masalah konkurensi seperti kondisi penguncian dan ras. Jika aplikasi menggunakan sumber daya eksternal, Anda harus menguji bagaimana aplikasi berperilaku ketika sumber daya tersebut tidak tersedia. Setelah itu, Anda dapat menggunakan kode untuk mencari hal-hal yang mungkin menyebabkannya rusak dan diuji untuk itu. Ketika semua tes lulus, rasio biaya / manfaat dari pengujian lebih lanjut mulai naik, jadi masuk akal untuk berhenti pada titik itu.

Semuanya bermuara pada kepercayaan diri. Apakah Anda merasa yakin bahwa sistem ini cukup teruji?

Jelas, "tingkat kepercayaan" sangat subyektif karena Anda tidak pernah bisa merasa benar-benar yakin, tetapi cukup yakin - dan itulah yang kami cari. Untuk itu, Anda perlu membuat daftar indikator, yang umumnya dikenal sebagai definisi selesai dan harus menjadi sesuatu yang disetujui seluruh tim Anda.

Berikut adalah beberapa tes terkait "Selesai-indikator":

• Apakah pembuatan dan pemasangan Anda sepenuhnya otomatis dan semua pengujian (unit, gui, integrasi) dijalankan secara otomatis?
• Apakah Anda menulis tes saat (atau sebaiknya sebelum) menulis kode, bukan setelahnya?
• Apakah Anda merasa cukup aman untuk membuat refactoring kode besar tanpa memperkenalkan bug?
• Apakah level cakupan kode Anda cukup tinggi?
• Apakah Anda memiliki penguji khusus di tim Anda? Apakah dia terlibat setiap hari sepanjang pengembangan dan tidak hanya pada akhirnya?
• Apakah penguji Anda secara manual (eksplorasi) mencoba memecahkannya tanpa hasil?

Jika Anda dapat memeriksa poin-poin ini, maka Anda mungkin dapat mengatakan bahwa Anda telah cukup menguji.

Tidak pernah, saya pikir Anda tidak akan pernah menyelesaikan pengujian dalam suatu sistem .. ada begitu banyak variabel yang tidak dapat Anda kelola.

Tapi, seperti yang kita tahu, Anda tidak dapat menguji "selamanya", jadi saya pikir batasnya pada dasarnya bergantung pada:

• Ketika risiko yang terkait dengan penggunaan perangkat lunak telah berkurang ke tingkat yang dapat diterima. (seperti yang dikatakan @Graham Lee)
• Siapa pengguna sistem? bisa jadi Anda atau presiden dari negara-negara bersatu. Dalam kasus pertama Anda tidak terlalu peduli jika bug muncul karena Anda menyelesaikannya dan selesai. Dalam kasus kedua Anda tidak ingin bug APA PUN muncul.
• Apa hubungan Anda dengan klien Anda? Mungkin kliennya ayahmu, jadi tidak terlalu buruk, atau mungkin itu perusahaan besar.
• Seberapa serius bagi pengguna sistem bug? Apakah ini akan menyebabkan perang dunia ketiga atau hanya pesan yang jelek?

Ketika orang-orang yang harus keluar pada penyebaran puas.

atau dalam beberapa kasus mayoritas pihak yang bertanggung jawab puas.